activity_notification 0.0.8

data/lib/activity_notification/common.rb

@@ -0,0 +1,86 @@
+module ActivityNotification
+
+  # Used to transform value from metadata to data.
+  # Accepts Symbols, which it will send against context.
+  # Accepts Procs, which it will execute with controller and context.
+  # Both Symbols and Procs will be passed arguments of this method.
+  def self.resolve_value(context, thing, *args)
+    case thing
+    when Symbol
+      begin
+        context.__send__(thing, *args)
+      rescue ArgumentError => e
+        context.__send__(thing)
+      end
+    when Proc
+      begin
+        thing.call(ActivityNotification.get_controller, context, *args)
+      rescue ArgumentError => e
+        thing.call(ActivityNotification.get_controller, context)
+      end
+    when Hash
+      thing.dup.tap do |hash|
+        hash.each do |key, value|
+          hash[key] = ActivityNotification.resolve_value(context, value, *args)
+        end
+      end
+    else
+      thing
+    end
+  end
+
+  module Common
+
+    # Used to transform value from metadata to data which belongs model instance.
+    # Accepts Symbols, which it will send against this instance.
+    # Accepts Procs, which it will execute with this instance.
+    # Both Symbols and Procs will be passed arguments of this method.
+    def resolve_value(thing, *args)
+      case thing
+      when Symbol
+        begin
+          __send__(thing, *args)
+        rescue ArgumentError => e
+          __send__(thing)
+        end
+      when Proc
+        begin
+          thing.call(self, *args)
+        rescue ArgumentError => e
+          thing.call(self)
+        end
+      when Hash
+        thing.dup.tap do |hash|
+          hash.each do |key, value|
+            hash[key] = resolve_value(value, *args)
+          end
+        end
+      else
+        thing
+      end
+    end
+
+    def to_class_name
+      self.class.name
+    end
+
+    def to_resource_name
+      self.class.name.demodulize.singularize.underscore
+    end
+
+    def to_resources_name
+      self.class.name.demodulize.pluralize.underscore
+    end
+
+    #TODO Is it the best solution?
+    def printable_type
+      "#{self.class.name.demodulize.humanize}"
+    end
+
+    #TODO Is it the best solution?
+    def printable_name
+      "#{self.printable_type} (#{id})"
+    end
+
+  end
+end

data/lib/activity_notification/config.rb

@@ -0,0 +1,23 @@
+module ActivityNotification
+  # Class used to initialize configuration object.
+  class Config
+    attr_accessor :enabled,
+                  :table_name,
+                  :mailer_sender,
+                  :mailer,
+                  :parent_mailer,
+                  :parent_controller,
+                  :opened_limit
+
+    def initialize
+      @enabled           = true
+      @table_name        = "notifications"
+      @mailer_sender     = nil
+      @mailer            = "ActivityNotification::Mailer"
+      @parent_mailer     = 'ActionMailer::Base'
+      @parent_controller = 'ApplicationController'
+      @opened_limit      = 10
+    end
+
+  end
+end

data/lib/activity_notification/controllers/store_controller.rb

@@ -0,0 +1,30 @@
+module ActivityNotification
+  class << self
+    # Setter for remembering controller instance
+    def set_controller(controller)
+      Thread.current[:activity_notification_controller] = controller
+    end
+
+    # Getter for accessing the controller instance
+    def get_controller
+      Thread.current[:activity_notification_controller]
+    end
+  end
+
+  # Module included in controllers to allow p_a access to controller instance
+  module StoreController
+    extend ActiveSupport::Concern
+
+    included do
+      around_action :store_controller_for_activity_notification if     respond_to?(:around_action)
+      around_filter :store_controller_for_activity_notification unless respond_to?(:around_action)
+    end
+
+    def store_controller_for_activity_notification
+      ActivityNotification.set_controller(self)
+      yield
+    ensure
+      ActivityNotification.set_controller(nil)
+    end
+  end
+end

data/lib/activity_notification/helpers/polymorphic_helpers.rb

@@ -0,0 +1,32 @@
+module ActivityNotification
+  module PolymorphicHelpers
+    extend ActiveSupport::Concern
+
+    included do
+      class ::String
+        def to_model_name
+          singularize.camelize
+        end
+      
+        def to_model_class
+          to_model_name.classify.constantize
+        end
+      
+        def to_resource_name
+          singularize.underscore
+        end
+      
+        def to_resources_name
+          pluralize.underscore
+        end
+
+        def to_boolean(default = nil)
+          return true if ['true', '1', 'yes', 'on', 't'].include? self
+          return false if ['false', '0', 'no', 'off', 'f'].include? self
+          return default
+        end
+      end
+    end
+
+  end
+end

data/lib/activity_notification/helpers/view_helpers.rb

@@ -0,0 +1,108 @@
+# Provides a shortcut from views to the rendering method.
+module ActivityNotification
+  # Module extending ActionView::Base and adding `render_notification` helper.
+  module ViewHelpers
+    # View helper for rendering an notification, calls {ActivityNotification::Notification#render} internally.
+    def render_notification notifications, options = {}
+      if notifications.is_a? ActivityNotification::Notification
+        notifications.render self, options
+      elsif notifications.respond_to?(:map)
+        return nil if notifications.empty?
+        notifications.map {|notification| notification.render self, options.dup }.join.html_safe
+      end
+    end
+    alias_method :render_notifications, :render_notification
+
+    # View helper for rendering embedded partial template of target's notifications
+    def render_notification_of target, options = {}
+      return unless target.is_a? ActivityNotification::Target
+
+      partial_path = options.delete(:partial) || "index"
+      partial_root = options[:partial_root] ||
+                         "activity_notification/notifications/#{target.to_resources_name}"
+      partial      = select_path(partial_path, partial_root)
+      layout       = options[:layout].present? ?
+                       select_path(options.delete(:layout), (options[:layout_root] || "layouts")) :
+                       nil
+      locals       = (options[:locals] || {}).merge(target: target)
+
+      # Prepare content for notifications index
+      notification_options = options.merge\
+                               target:  target.to_resources_name, 
+                               partial: options[:notification_partial], 
+                               layout:  options[:notification_layout]
+      case options[:index_content]
+      when :simple
+        notification_index = target.notification_index
+      when :none
+      else
+        notification_index = target.notification_index_with_attributes
+      end
+
+      if notification_index.present?
+        content_for :notification_index do
+          begin
+            render_notifications notification_index, notification_options
+          rescue ActionView::MissingTemplate => e
+            notification_options.delete(:target)
+            render_notifications notification_index, notification_options
+          end
+        end
+      end
+
+      # Render partial index
+      begin
+        render options.merge(partial: partial, layout: layout, locals: locals)
+      rescue ActionView::MissingTemplate => e
+        partial_root = "activity_notification/notifications/default"
+        partial      = select_path(partial_path, partial_root)
+        render options.merge(partial: partial, layout: layout, locals: locals)
+      end
+    end
+    alias_method :render_notifications_of, :render_notification_of
+
+    # Url helper methods
+    #TODO Is there any other better solution?
+    #TODO Must handle devise namespace
+    def notification_path_for(notification, params = {})
+      send("#{notification.target.to_resource_name}_notification_path", notification.target, notification, params)
+    end
+
+    def move_notification_path_for(notification, params = {})
+      send("move_#{notification.target.to_resource_name}_notification_path", notification.target, notification, params)
+    end
+
+    def open_notification_path_for(notification, params = {})
+      send("open_#{notification.target.to_resource_name}_notification_path", notification.target, notification, params)
+    end
+
+    def open_all_notifications_path_for(target, params = {})
+      send("open_all_#{target.to_resource_name}_notifications_path", target, params)
+    end
+
+    def notification_url_for(notification, params = {})
+      send("#{notification.target.to_resource_name}_notification_url", notification.target, notification, params)
+    end
+
+    def move_notification_url_for(notification, params = {})
+      send("move_#{notification.target.to_resource_name}_notification_url", notification.target, notification, params)
+    end
+
+    def open_notification_url_for(notification, params = {})
+      send("open_#{notification.target.to_resource_name}_notification_url", notification.target, notification, params)
+    end
+
+    def open_all_notifications_url_for(target, params = {})
+      send("open_all_#{target.to_resource_name}_notifications_url", target, params)
+    end
+
+    private
+
+      def select_path(path, root)
+        [root, path].map(&:to_s).join('/')
+      end
+
+  end
+
+  ActionView::Base.class_eval { include ViewHelpers }
+end

data/lib/activity_notification/mailers/helpers.rb

@@ -0,0 +1,97 @@
+module ActivityNotification
+  module Mailers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      protected
+
+      # Configure default email options
+      def notification_mail(notification, options = {})
+        initialize_from_notification(notification)
+        headers = headers_for(notification.key, options)
+        begin
+          mail headers
+        rescue ActionView::MissingTemplate => e
+          mail headers.merge(template_name: 'default')
+        end
+      end
+
+      def initialize_from_notification(notification)
+        @notification, @target, @notifiable = notification, notification.target, notification.notifiable
+      end
+
+      def headers_for(key, options)
+        if @notifiable.respond_to?(:overriding_notification_email_key) and 
+           @notifiable.overriding_notification_email_key(@target, key).present?
+          key = @notifiable.overriding_notification_email_key(@target, key)
+        end
+        headers = {
+          subject: subject_for(key),
+          to: mailer_to(@target),
+          from: mailer_sender(@target.to_resource_name),
+          reply_to: mailer_reply_to(@target.to_resource_name),
+          template_path: template_paths,
+          template_name: template_name(key)
+        }.merge(options)
+
+        @email = headers[:to]
+        headers
+      end
+
+      def mailer_to(target)
+        target.mailer_to
+      end
+
+      def mailer_reply_to(target_type)
+        mailer_sender(target_type, :reply_to)
+      end
+
+      def mailer_from(target_type)
+        mailer_sender(target_type, :from)
+      end
+
+      def mailer_sender(target_type, sender = :from)
+        default_sender = default_params[sender]
+        if default_sender.present?
+          default_sender.respond_to?(:to_proc) ? instance_eval(&default_sender) : default_sender
+        elsif ActivityNotification.config.mailer_sender.is_a?(Proc)
+          ActivityNotification.config.mailer_sender.call(target_type)
+        else
+          ActivityNotification.config.mailer_sender
+        end
+      end
+
+      def template_paths
+        paths = ['activity_notification/mailer/default']
+        paths.unshift("activity_notification/mailer/#{@target.to_resources_name}") if @target.present?
+        paths
+      end
+
+      def template_name(key)
+        key.gsub('.', '/')
+      end
+
+
+      # Set up a subject doing an I18n lookup.
+      # At first, it attempts to set a subject based on the current mapping:
+      #   en:
+      #     notification:
+      #       {target}:
+      #         {key}:
+      #           mail_subject: '...'
+      #
+      # If one does not exist, it fallbacks to default:
+      #   Notification for #{notification.printable_type}
+      #
+      def subject_for(key)
+        k = key.split('.')
+        k.unshift('notification') if k.first != 'notification'
+        k.insert(1, @target.to_resource_name)
+        k = k.join('.')
+        I18n.t(:mail_subject, scope: k,
+          default: ["Notification of #{@notifiable.printable_type}"])
+      end
+
+    end
+  end
+end

data/lib/activity_notification/models/notifiable.rb

@@ -0,0 +1,136 @@
+module ActivityNotification
+  module Notifiable
+    extend ActiveSupport::Concern
+
+    included do
+      include Common
+      include ActsAsNotifiable
+      include ActionDispatch::Routing::PolymorphicRoutes
+      include Rails.application.routes.url_helpers
+      class_attribute  :_notification_targets,
+                       :_notification_group,
+                       :_notifier,
+                       :_notification_parameters,
+                       :_notification_email_allowed,
+                       :_notifiable_path
+      set_notifiable_class_defaults
+    end
+  
+    def default_url_options
+      Rails.application.routes.default_url_options
+    end
+    
+    class_methods do
+      def set_notifiable_class_defaults
+        self._notification_targets        = {}
+        self._notification_group          = {}
+        self._notifier                    = {}
+        self._notification_parameters     = {}
+        self._notification_email_allowed  = {}
+        self._notifiable_path             = {}
+      end
+    end
+
+    # Methods to be overriden
+
+    def notification_targets(target_type, key)
+      plural_target_type       = target_type.to_s.underscore.pluralize
+      plural_target_type_sym   = plural_target_type.to_sym
+      target_typed_method_name = "notification_#{plural_target_type}"
+      if respond_to?(target_typed_method_name)
+        send(target_typed_method_name, key)
+      else
+        if _notification_targets[plural_target_type_sym]
+          resolve_value(_notification_targets[plural_target_type_sym], key)
+        else
+          raise NotImplementedError, "You have to implement #{self.class}##{target_typed_method_name} or set :targets in acts_as_notifiable"
+        end
+      end
+    end
+
+    def notification_group(target_type, key)
+      plural_target_type       = target_type.to_s.underscore.pluralize
+      plural_target_type_sym   = plural_target_type.to_sym
+      target_typed_method_name = "notification_group_for_#{plural_target_type}"
+      if respond_to?(target_typed_method_name)
+        send(target_typed_method_name, key)
+      else
+        resolve_value(_notification_group[plural_target_type_sym])
+      end
+    end
+
+    def notification_parameters(target_type, key)
+      plural_target_type       = target_type.to_s.underscore.pluralize
+      plural_target_type_sym   = plural_target_type.to_sym
+      target_typed_method_name = "notification_parameters_for_#{plural_target_type}"
+      if respond_to?(target_typed_method_name)
+        send(target_typed_method_name, key)
+      else
+        resolve_value(_notification_parameters[plural_target_type_sym], key) || {}
+      end
+    end
+
+    def notifier(target_type, key)
+      plural_target_type       = target_type.to_s.underscore.pluralize
+      plural_target_type_sym   = plural_target_type.to_sym
+      target_typed_method_name = "notifier_for_#{plural_target_type}"
+      if respond_to?(target_typed_method_name)
+        send(target_typed_method_name, key)
+      else
+        resolve_value(_notifier[plural_target_type_sym])
+      end
+    end
+
+    def notification_email_allowed?(target, key)
+      plural_target_type_sym   = target.to_resources_name.to_sym
+      if _notification_email_allowed[plural_target_type_sym]
+        resolve_value(_notification_email_allowed[plural_target_type_sym], target, key)
+      else
+        true
+      end
+    end
+
+    def notifiable_path(target_type, key = nil)
+      plural_target_type       = target_type.to_s.underscore.pluralize
+      plural_target_type_sym   = plural_target_type.to_sym
+      target_typed_method_name = "notifiable_path_for_#{plural_target_type}"
+      if respond_to?(target_typed_method_name)
+        send(target_typed_method_name, key)
+      elsif _notifiable_path[plural_target_type_sym]
+        resolve_value(_notifiable_path[plural_target_type_sym])
+      else
+        begin
+          polymorphic_path(self)
+        rescue NoMethodError => e
+          raise NotImplementedError, "You have to implement #{self.class}##{__method__}, set :notifiable_path in acts_as_notifiable or set polymorphic_path routing for #{self.class}"
+        rescue ActionController::UrlGenerationError => e
+          raise NotImplementedError, "You have to implement #{self.class}##{__method__}, set :notifiable_path in acts_as_notifiable or set polymorphic_path routing for #{self.class}"
+        end
+      end
+    end
+
+    # TODO docs
+    # overriding_notification_render_key(target, key)
+
+    # TODO docs
+    # overriding_notification_email_key(target, key)
+
+    # Wrapper methods of SimpleNotify class methods
+  
+    def notify(target_type, options = {})
+      Notification.notify(target_type, self, options)
+    end
+  
+    def notify_to(target, options = {})
+      Notification.notify_to(target, self, options)
+    end
+  
+    def notify_all(targets, options = {})
+      Notification.notify_all(targets, self, options)
+    end
+
+    def default_notification_key
+      "#{to_resource_name}.default"
+    end
+  end
+end