activity_notification 0.0.8

data/lib/activity_notification/models/notification.rb

@@ -0,0 +1,50 @@
+module ActivityNotification
+  class Notification < ActiveRecord::Base
+    include Renderable
+    include Common
+    include NotificationApi
+    self.table_name = ActivityNotification.config.table_name
+  
+    belongs_to :target,        polymorphic: true
+    belongs_to :notifiable,    polymorphic: true
+    belongs_to :group,         polymorphic: true
+    belongs_to :group_owner,   class_name: :Notification
+    has_many   :group_members,
+      class_name: "::ActivityNotification::Notification",
+      foreign_key: :group_owner_id
+    belongs_to :notifier,      polymorphic: true
+
+    # Serialize parameters Hash
+    serialize  :parameters, Hash
+
+    validates  :target,        presence: true
+    validates  :notifiable,    presence: true
+    validates  :key,           presence: true
+
+    scope :group_owners_only,                 ->        { where(group_owner_id: nil) }
+    scope :group_members_only,                ->        { where.not(group_owner_id: nil) }
+    scope :unopened_only,                     ->        { where(opened_at: nil) }
+    scope :unopened_index,                    ->        { unopened_only.group_owners_only.latest_order }
+    scope :opened_only!,                      ->        { where.not(opened_at: nil) }
+    scope :opened_only,                       ->(limit) { opened_only!.limit(limit) }
+    scope :opened_index,                      ->(limit) { opened_only(limit).group_owners_only.latest_order }
+    scope :unopened_index_group_members_only, ->        { where(group_owner_id: unopened_index.pluck(:id)) }
+    scope :opened_index_group_members_only,   ->(limit) { where(group_owner_id: opened_index(limit).pluck(:id)) }
+
+    scope :filtered_by_target,   ->(target)             { where(target: target) }
+    scope :filtered_by_instance, ->(notifiable)         { where(notifiable: notifiable) }
+    scope :filtered_by_type,     ->(notifiable_type)    { where(notifiable_type: notifiable_type) }
+    scope :filtered_by_group,    ->(group)              { where(group: group) }
+    scope :filtered_by_key,      ->(key)                { where(key: key) }
+
+    scope :with_target,                       ->        { includes(:target) }
+    scope :with_notifiable,                   ->        { includes(:notifiable) }
+    scope :with_group,                        ->        { includes(:group) }
+    scope :with_notifier,                     ->        { includes(:notifier) }
+
+    scope :latest_order,                      ->        { order(created_at: :desc) }
+    scope :earliest_order,                    ->        { order(created_at: :asc) }
+    scope :latest,                            ->        { latest_order.first }
+    scope :earliest,                          ->        { earliest_order.first }
+  end
+end

data/lib/activity_notification/models/notifier.rb

@@ -0,0 +1,11 @@
+module ActivityNotification
+  module Notifier
+    extend ActiveSupport::Concern
+    included do
+      include Common
+      has_many :sent_notifications,
+        class_name: "::ActivityNotification::Notification",
+        as: :notifier
+    end
+  end
+end

data/lib/activity_notification/models/target.rb

@@ -0,0 +1,104 @@
+module ActivityNotification
+  module Target
+    extend ActiveSupport::Concern
+    included do
+      include Common
+      include ActsAsTarget
+      has_many :notifications,
+        class_name: "::ActivityNotification::Notification",
+        as: :target
+      class_attribute :_notification_email, :_notification_email_allowed
+      set_target_class_defaults
+    end
+
+    class_methods do
+      def set_target_class_defaults
+        self._notification_email          = nil
+        self._notification_email_allowed  = false
+      end
+    end
+
+    def mailer_to
+      resolve_value(_notification_email)
+    end
+
+    def notification_email_allowed?(notifiable, key)
+      resolve_value(_notification_email_allowed, notifiable, key)
+    end
+
+    def unopened_notification_count
+      unopened_notification_index.count
+    end
+
+    def has_unopened_notifications?
+      unopened_notification_index.exists?
+    end
+
+    #TODO is this switching the best solution?
+    def notification_index(limit = nil)
+      # When the target have unopened notifications
+      notifications.unopened_index.exists? ?
+        # Return unopened notifications
+        unopened_notification_index(limit) :
+        # Otherwise, return opened notifications
+        limit.present? ?
+          opened_notification_index(limit) :
+          opened_notification_index
+    end
+
+    def unopened_notification_index(limit = nil)
+      limit.present? ?
+        notifications.unopened_index.limit(limit) :
+        notifications.unopened_index
+    end
+
+    def opened_notification_index(limit = ActivityNotification.config.opened_limit)
+      notifications.opened_index(limit)
+    end
+
+
+    # Wrapper methods of SimpleNotify class methods
+  
+    def notify_to(notifiable, options = {})
+      Notification.notify_to(self, notifiable, options)
+    end
+  
+    def open_all_notifications(opened_at = nil)
+      Notification.open_all_of(self, opened_at)
+    end
+
+    # Methods to be overriden
+
+    # Typical method to get notifications index
+    def notification_index_with_attributes(limit = nil)
+      # When the target have unopened notifications
+      unopened_notification_index.exists? ?
+        # Return unopened notifications
+        unopened_notification_index_with_attributes(limit) :
+        # Otherwise, return opened notifications
+        limit.present? ?
+          opened_notification_index_with_attributes(limit) :
+          opened_notification_index_with_attributes
+    end
+
+    def unopened_notification_index_with_attributes(limit = nil)
+      Notification.group_member_exists?(unopened_notification_index(limit)) ?
+        unopened_notification_index(limit).with_target.with_notifiable.with_group.with_notifier :
+        unopened_notification_index(limit).with_target.with_notifiable.with_notifier
+    end
+
+    def opened_notification_index_with_attributes(limit = ActivityNotification.config.opened_limit)
+      Notification.group_member_exists?(opened_notification_index(limit)) ?
+        opened_notification_index(limit).with_target.with_notifiable.with_group.with_notifier :
+        opened_notification_index(limit).with_target.with_notifiable.with_notifier
+    end
+
+    def authenticate_with_devise?(current_resource)
+      unless current_resource.instance_of? self.class
+        raise TypeError, "Defferent type of devise resource #{current_resource.class.to_s} has been passed to #{self.class}##{__method__}. You have to override #{self.class}##{__method__} method."
+      end
+      current_resource == self
+    end
+
+  end
+end

data/lib/activity_notification/rails.rb

@@ -0,0 +1,6 @@
+require 'activity_notification/rails/routes'
+
+module ActivityNotification #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/activity_notification/rails/routes.rb

@@ -0,0 +1,105 @@
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/hash/slice"
+
+module ActionDispatch::Routing
+  class Mapper
+    # Includes notify_to method for routes.
+    # This method is responsible to generate all needed routes for activity_notification
+    #
+    # ==== Examples
+    #
+    #   notify_to :users
+    #   notify_to :users, with_devise: :users
+    #   notify_to :users, with_devise: :users, only: [:open, :open_all, :move]
+    #
+    # When you have an User model configured as a target (e.g. defined acts_as_target),
+    # you can creat this inside your routes:
+    #
+    #   notify_to :users
+    #
+    # This method creates the needed routes:
+    #
+    #  # Notification routes
+    #          user_notifications GET    /users/:user_id/notifications(.:format)
+    #                                    {controller:"activity_notification/notifications", action:"index", target_type:"users"}
+    #           user_notification GET    /users/:user_id/notifications/:id(.:format)
+    #                                    {controller:"activity_notification/notifications", action:"show", target_type:"users"}
+    #           user_notification DELETE /users/:user_id/notifications/:id(.:format)
+    #                                    {controller:"activity_notification/notifications", action:"destroy", target_type:"users"}
+    # open_all_user_notifications POST   /users/:user_id/notifications/open_all(.:format)
+    #                                      {controller:"activity_notification/notifications", action:"open_all", target_type:"users"}
+    #      move_user_notification POST   /users/:user_id/notifications/:id/move(.:format)
+    #                                      {controller:"activity_notification/notifications", action:"move", target_type:"users"}
+    #      open_user_notification POST   /users/:user_id/notifications/:id/open(.:format)
+    #                                      {controller:"activity_notification/notifications", action:"open", target_type:"users"}
+    #
+    # When you use devise for authentication and you want make notification target assciated with devise,
+    # you can creat this inside your routes:
+    #
+    #   notify_to :users, with_devise: true
+    #
+    # This with_devise option creates the needed routes assciated with devise authentication:
+    #
+    #  # Notification with devise routes
+    #          user_notifications GET    /users/:user_id/notifications(.:format)
+    #                                    {controller:"activity_notification/notifications_with_devise", action:"index", devise_type:"users", target_type:"users"}
+    #           user_notification GET    /users/:user_id/notifications/:id(.:format)
+    #                                    {controller:"activity_notification/notifications_with_devise", action:"show", devise_type:"users", target_type:"users"}
+    #           user_notification DELETE /users/:user_id/notifications/:id(.:format)
+    #                                    {controller:"activity_notification/notifications_with_devise", action:"destroy", devise_type:"users", target_type:"users"}
+    # open_all_user_notifications POST   /users/:user_id/notifications/open_all(.:format)
+    #                                      {controller:"activity_notification/notifications_with_devise", action:"open_all", devise_type:"users", target_type:"users"}
+    #      move_user_notification POST   /users/:user_id/notifications/:id/move(.:format)
+    #                                      {controller:"activity_notification/notifications_with_devise", action:"move", devise_type:"users", target_type:"users"}
+    #      open_user_notification POST   /users/:user_id/notifications/:id/open(.:format)
+    #                                      {controller:"activity_notification/notifications_with_devise", action:"open", devise_type:"users", target_type:"users"}
+    #
+    # ==== Options
+    #TODO add document for options
+    #
+    def notify_to(*resources)
+      options = resources.extract_options!
+      
+      #TODO check resources if it includes target module
+
+      if (with_devise = options.delete(:with_devise)).present?
+        options[:controller] ||= "activity_notification/notifications_with_devise"
+        options[:as]         ||= "notifications"
+        #TODO check device configuration in model
+        devise_defaults        = { devise_type: with_devise.to_s }
+      else
+        options[:controller] ||= "activity_notification/notifications"
+      end
+      options[:except]       ||= []
+      options[:except].concat( [:new, :create, :edit, :update] )
+
+      #TODO other options
+      # :as, :path_prefix, :path_names ...
+
+      resources.each do |resource|
+        self.resources resource, only: :none do
+          options[:defaults] = (devise_defaults || {}).merge({ target_type: resource.to_s })
+          self.resources :notifications, options do
+            collection do
+              post :open_all unless ignore_path?(:open_all, options)
+            end
+            member do
+              get  :move     unless ignore_path?(:move, options)
+              post :open     unless ignore_path?(:open, options)
+            end
+          end
+        end
+      end
+
+    end
+
+    private
+
+      def ignore_path?(action, options)
+        return true if options[:except].present? and     options[:except].include?(action)
+        return true if options[:only].present?   and not options[:only].include?(action)
+        false
+      end
+
+  end
+end

data/lib/activity_notification/renderable.rb

@@ -0,0 +1,142 @@
+module ActivityNotification
+  # Provides logic for rendering notifications.
+  # Handles both i18n strings support and smart partials rendering (different templates per notification key).
+  # Deeply uses PublicActivity as reference
+  module Renderable
+    # Virtual attribute returning text description of the notification
+    # using the notification's key to translate using i18n.
+    def text(params = {})
+      k = key.split('.')
+      k.unshift('notification') if k.first != 'notification'
+      if params.has_key?(:target)
+        k.insert(1, params[:target])
+      else
+        k.insert(1, target.to_resource_name)
+      end
+      k = k.join('.')
+
+      I18n.t(k, parameters.merge(params) || {})
+    end
+
+    # Renders notification from views.
+    #
+    # @param [ActionView::Base] context
+    # @return [nil] nil
+    #
+    # The preferred way of rendering notifications is
+    # to provide a template specifying how the rendering should be happening.
+    # However, you can choose using _I18n_ based approach when developing
+    # an application that supports plenty of languages.
+    #
+    # If partial view exists that matches the "key" attribute
+    # renders that partial with local variables set to contain both
+    # Activity and activity_parameters (hash with indifferent access).
+    #
+    # If the partial view does not exist and you wish to fallback to rendering
+    # through the I18n translation, you can do so by passing in a :fallback
+    # parameter whose value equals :text.
+    #
+    # If you do not want to define a partial view, and instead want to have
+    # all missing views fallback to a default, you can define the :fallback
+    # value equal to the partial you wish to use when the partial defined
+    # by the notification key does not exist.
+    #
+    # @example Render a list of all @target's notifications of from a view (erb)
+    #   <ul>
+    #     <% @target.notifications.each do |notification|  %>
+    #       <li><%= render_notification(notification) %></li>
+    #     <% end %>
+    #   </ul>
+    #
+    # @example Fallback to the I18n text translation if the view is missing 
+    #   <ul>
+    #     <% @target.notifications.each do |notification|  %>
+    #       <li><%= render_notification(notification, fallback: :text) %></li>
+    #     <% end %>
+    #   </ul>
+    #
+    # @example Fallback to a default view if the view for the current notification key is missing.
+    # The string is the partial name you wish to use.
+    #   <ul>
+    #     <% @target.notifications.each do |notification|  %>
+    #       <li><%= render_notification(notification, fallback: 'default') %></li>
+    #     <% end %>
+    #   </ul>
+    #
+    # # Layouts
+    #TODO
+    #
+    # # Creating a template
+    #
+    # To use templates for formatting how the notification should render,
+    # create a template based on target type and notification key, for example:
+    #
+    # Given a target type users and key _notification.article.create_, create directory tree
+    # _app/views/activity_notifications/users/article/_ and create the _create_ partial there
+    #
+    # Note that if a key consists of more than three parts splitted by commas, your
+    # directory structure will have to be deeper, for example:
+    #   notification.article.comments.destroy => app/views/activity_notifications/users/articles/comments/_destroy.html.erb
+    #
+    # ## Custom Directory
+    #TODO
+    #
+    # ## Variables in templates
+    #TODO
+    def render(context, params = {})
+      params[:i18n] and return context.render text: self.text(params)
+
+      partial = partial_path(*params.values_at(:partial, :partial_root, :target))
+      layout  = layout_path(*params.values_at(:layout, :layout_root))
+      locals  = prepare_locals(params)
+
+      begin
+        context.render params.merge(partial: partial, layout: layout, locals: locals)
+      rescue ActionView::MissingTemplate => e
+        if params[:fallback] == :text
+          context.render text: self.text(params)
+        elsif params[:fallback].present?
+          partial = partial_path(*params.values_at(:fallback, :partial_root, :target))
+          context.render params.merge(partial: partial, layout: layout, locals: locals)
+        else
+          raise e
+        end
+      end
+    end
+
+    def partial_path(path = nil, root = nil, target = nil)
+      controller = ActivityNotification.get_controller         if ActivityNotification.respond_to?(:get_controller)
+      root ||= "activity_notification/notifications/#{target}" if target.present?
+      root ||= controller.target_view_path                     if controller.present? and controller.respond_to?(:target_view_path)
+      root ||= 'activity_notification/notifications/default'
+      path ||= self.key.gsub('.', '/')
+      select_path(path, root)
+    end
+
+    def layout_path(path = nil, root = nil)
+      path.nil? and return
+      root ||= 'layouts'
+      select_path(path, root)
+    end
+
+    def prepare_locals(params)
+      locals = params.delete(:locals) || {}
+
+      prepared_parameters = prepare_parameters(params)
+      locals.merge\
+        notification: self,
+        parameters:   prepared_parameters
+    end
+
+    def prepare_parameters(params)
+      @prepared_params ||= self.parameters.with_indifferent_access.merge(params)
+    end
+
+    private
+
+      def select_path(path, root)
+        [root, path].map(&:to_s).join('/')
+      end
+
+  end
+end

data/lib/activity_notification/roles/acts_as_notifiable.rb

@@ -0,0 +1,37 @@
+module ActivityNotification
+  module ActsAsNotifiable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Adds required callbacks for creating and updating
+      # notifiable models.
+      #
+      # == Parameters:
+      # [:targets]
+      #TODO
+      def acts_as_notifiable(target_type, opts = {})
+        options = opts.clone
+        assign_globals       target_type, options
+        nil
+      end
+
+      def available_options
+        [:targets, :group, :notifier, :parameters, :email_allowed, :notifiable_path].freeze
+      end
+
+      def assign_globals(target_type, options)
+        [:targets, :group, :parameters, :email_allowed].each do |key|
+          if options[key]
+            self.send("_notification_#{key}".to_sym).store(target_type.to_sym, options.delete(key))
+          end
+        end
+        [:notifier, :notifiable_path].each do |key|
+          if options[key]
+            self.send("_#{key}".to_sym).store(target_type.to_sym, options.delete(key))
+          end
+        end
+      end
+
+    end
+  end
+end