activity_notification 0.0.8

data/Rakefile

@@ -0,0 +1,19 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActivityNotification'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+Bundler::GemHelper.install_tasks
+

data/activity_notification.gemspec

@@ -0,0 +1,33 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+# Maintain your gem's version:
+require "activity_notification/version"
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name          = "activity_notification"
+  s.version       = ActivityNotification::VERSION
+  s.platform      = Gem::Platform::RUBY
+  s.authors       = ["Shota Yamazaki"]
+  s.email         = ["shota.yamazaki.8@gmail.com"]
+  s.homepage      = "https://github.com/simukappu/activity_notification"
+  s.summary       = "Integrated user activity notifications for Rails"
+  s.description   = "Integrated user activity notifications for Rails. Provides functions to configure multiple notification targets and make activity notifications with notifiable models, like adding comments, responding etc."
+  s.license       = "MIT"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ["lib"]
+  s.required_ruby_version = '>= 2.1.0'
+
+  s.add_dependency 'rails', '~> 4.2'
+  #s.add_dependency 'railties', '>= 3.0.0'
+  s.add_dependency 'i18n', '>= 0.5.0'
+  s.add_dependency 'activerecord', '>= 3.0'
+
+  s.add_development_dependency 'sqlite3', '~> 1.3.11'
+  s.add_development_dependency "rspec-rails", '~> 3.5.1'
+  s.add_development_dependency "factory_girl_rails", '~> 4.7.0'
+  s.add_development_dependency 'simplecov', '~> 0.12.0'
+  s.add_development_dependency "devise", '~> 4.2.0'
+end

data/app/controllers/activity_notification/notifications_controller.rb

@@ -0,0 +1,119 @@
+module ActivityNotification
+  class NotificationsController < ActivityNotification.config.parent_controller.constantize
+    include ActivityNotification::StoreController
+    include ActivityNotification::PolymorphicHelpers
+    prepend_before_action :set_target
+    before_action :set_notification, except: [:index, :open_all]
+    before_action :set_view_prefixes, except: [:move]
+  
+    DEFAULT_VIEW_DIRECTORY = "default"
+  
+    # GET /:target_type/:target_id/notifcations
+    def index
+      @notifications = load_notification_index(params[:filter], params[:limit]) if params[:reload].to_s.to_boolean(true)
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @notifications.to_json(include: [:target, :notifiable, :group]) }
+      end
+    end
+
+    # POST /:target_type/:target_id/notifcations/open_all
+    def open_all
+      @target.open_all_notifications
+      @notifications = load_notification_index(params[:filter], params[:limit]) if params[:reload].to_s.to_boolean(true)
+      return_back_or_ajax(params[:filter], params[:limit])
+    end
+  
+    # GET /:target_type/:target_id/notifcations/:id
+    def show
+    end
+  
+    # DELETE /:target_type/:target_id/notifcations/:id
+    def destroy
+      @notification.destroy
+      @notifications = load_notification_index(params[:filter], params[:limit]) if params[:reload].to_s.to_boolean(true)
+      return_back_or_ajax(params[:filter], params[:limit])
+    end
+  
+    # POST /:target_type/:target_id/notifcations/:id/open
+    def open
+      @notification.open!
+      @notifications = load_notification_index(params[:filter], params[:limit]) if params[:reload].to_s.to_boolean(true)
+      params[:move].to_s.to_boolean(false) ? 
+        move : 
+        return_back_or_ajax(params[:filter], params[:limit])
+    end
+
+    # GET /:target_type/:target_id/notifcations/:id/move
+    def move
+      @notification.open! if params[:open].to_s.to_boolean(false)
+      redirect_to @notification.notifiale_path
+    end
+  
+    # No action routing
+    # This method is called from target_view_path method
+    # This method can be overriden
+    def controller_path
+      "activity_notification/notifications"
+    end
+
+    # No action routing
+    # This method needs to be public since it is called from view helper
+    def target_view_path
+      target_type = @target.to_resources_name
+      view_path = [controller_path, target_type].join('/')
+      lookup_context.exists?(action_name, view_path) ?
+        view_path :
+        [controller_path, DEFAULT_VIEW_DIRECTORY].join('/')
+    end
+
+    protected
+
+      def set_target
+        if (target_type = params[:target_type]).present?
+          target_class = target_type.to_model_class
+          @target = params[:target_id].present? ?
+            target_class.find_by_id!(params[:target_id]) : 
+            target_class.find_by_id!(params["#{target_type.to_resource_name}_id"])
+        else
+          render text: "400 Bad Request: Missing parameter", status: 400
+        end
+      end
+  
+      def set_notification
+        @notification = Notification.find_by_id!(params[:id])
+        if @target.present? and @notification.target != @target
+          render text: "403 Forbidden: Wrong target", status: 403
+        end
+      end
+
+      def load_notification_index(filter, limit)
+        limit = nil unless limit.to_i > 0
+        case filter
+        when 'opened'
+          @target.opened_notification_index_with_attributes(limit)
+        when 'unopened'
+          @target.unopened_notification_index_with_attributes(limit)
+        else
+          @target.notification_index_with_attributes(limit)
+        end
+      end
+
+      def set_view_prefixes
+        lookup_context.prefixes.prepend(target_view_path)
+      end
+  
+      def return_back_or_ajax(filter, limit)
+        respond_to do |format|
+          if request.xhr?
+            format.js
+          elsif request.referer
+            redirect_to :back, filter: filter, limit: limit and return
+          else
+            redirect_to action: :index, filter: filter, limit: limit and return
+          end
+        end
+      end
+
+  end
+end

data/app/controllers/activity_notification/notifications_with_devise_controller.rb

@@ -0,0 +1,29 @@
+module ActivityNotification
+  class NotificationsWithDeviseController < NotificationsController
+    prepend_before_action :authenticate_devise_resource!
+    before_action :authenticate_target!
+    
+    protected
+
+      def authenticate_devise_resource!
+        authenticate_method_name = "authenticate_#{params[:devise_type].to_resource_name}!"
+        if respond_to?(authenticate_method_name)
+          send(authenticate_method_name)
+        else
+          render text: "403 Forbidden: Unauthenticated", status: 403
+        end
+      end
+
+      def authenticate_target!
+        current_resource_method_name = "current_#{params[:devise_type].to_resource_name}"
+        if respond_to?(current_resource_method_name)
+          unless @target.authenticate_with_devise?(send(current_resource_method_name))
+            render text: "403 Forbidden: Unauthorized target", status: 403
+          end
+        else
+          render text: "403 Forbidden: Unauthenticated", status: 403
+        end
+      end
+
+  end
+end

data/app/mailers/activity_notification/mailer.rb

@@ -0,0 +1,13 @@
+if defined?(ActionMailer)
+  class ActivityNotification::Mailer < ActivityNotification.config.parent_mailer.constantize
+    include ActivityNotification::Mailers::Helpers
+
+    def send_notification_email(notification)
+      if notification.target.notification_email_allowed?(notification.notifiable, notification.key) and 
+         notification.notifiable.notification_email_allowed?(notification.target, notification.key)
+        notification_mail(notification)
+      end
+    end
+  
+  end
+end

data/app/views/activity_notification/mailer/default/default.html.erb

@@ -0,0 +1,7 @@
+<p>Dear <%= @target.mailer_to %></p>
+
+<p>This is a notification of <%= @notifiable.printable_name %> for you.</p>
+
+<p><%= link_to "Move to #{@notifiable.printable_name}", move_notification_url_for(@notification, open: true) %></p>
+
+<p>Thank you!</p>

data/app/views/activity_notification/notifications/default/_default.html.erb

@@ -0,0 +1,36 @@
+<li>
+  <div>
+  	<%= notification.notifier.present? ? notification.notifier.printable_name : 'Someone' %>
+    <% if notification.group_member_exists? %>
+       <%= " and other #{notification.group_member_count} people" %>
+    <% end %>
+    notified you of <%= notification.notifiable.printable_name %>
+  	<%= "in #{notification.group.printable_name}" if notification.group.present? %>
+  </div>
+  <div>
+    <%= notification.opened? ? "Opened" : "Unopened" %>
+  </div>
+  <div>
+    <%= link_to "Move", move_notification_path_for(notification) %>
+  </div>
+  <% if notification.unopened? %>
+    <div>
+      <%= link_to "Open and move (GET)", move_notification_path_for(notification, open: true) %>
+    </div>
+    <div>
+      <%= link_to "Open and move (POST)", open_notification_path_for(notification, move: true), method: :post %>
+    </div>
+    <div>
+      <%= link_to "Open", open_notification_path_for(notification, filter: params[:filter], limit: params[:limit]), method: :post %>
+    </div>
+    <div>
+      <%= link_to "Open (Ajax)", open_notification_path_for(notification, filter: params[:filter], limit: params[:limit]), method: :post, remote: true %>
+    </div>
+  <% end %>
+  <div>
+    <%= link_to "Destroy", notification_path_for(notification, filter: params[:filter], limit: params[:limit]), method: :delete %>
+  </div>
+  <div>
+    <%= link_to "Destroy (Ajax)", notification_path_for(notification, filter: params[:filter], limit: params[:limit]), method: :delete, remote: true %>
+  </div>
+</li>

data/app/views/activity_notification/notifications/default/_index.html.erb

@@ -0,0 +1,9 @@
+<div>
+  <%= link_to open_all_notifications_path_for(@target), method: :post, remote: true do %>
+    <div id="notification_count"><%= @target.unopened_notification_count %></div>
+  <% end %>
+
+  <div id="notification_index">
+    <%= yield :notification_index %>
+  </div>
+</div>

data/app/views/activity_notification/notifications/default/destroy.js.erb

@@ -0,0 +1,2 @@
+$("#notification_count").html("<%= @target.unopened_notification_count %>");
+$("#notifications").html("<%= escape_javascript( render_notification(@notifications, fallback: "default") ) %>");

data/app/views/activity_notification/notifications/default/index.html.erb

@@ -0,0 +1,17 @@
+<h1>Notifications for <%= @target.printable_name %></h1>
+<div id="notification_count"><%= @target.unopened_notification_count %></div>
+
+<div>
+  <%= link_to "Open all", open_all_notifications_path_for(@target), method: :post %>
+</div>
+<div>
+  <%= link_to "Open all (ajax)", open_all_notifications_path_for(@target), method: :post, remote: true %>
+</div>
+<ul>
+  <div id="notifications">
+    <%= render_notification(@notifications, fallback: :default) %>
+    <%#= render_notification(@notifications, fallback: :text) %>
+  </div>
+</ul>
+
+<%#= render_notifications_of @target, fallback: :default, index_content: :with_attributes %>

data/app/views/activity_notification/notifications/default/open.js.erb

@@ -0,0 +1,2 @@
+$("#notification_count").html("<%= @target.unopened_notification_count %>");
+$("#notifications").html("<%= escape_javascript( render_notification(@notifications, fallback: "default") ) %>");

data/app/views/activity_notification/notifications/default/open_all.js.erb

@@ -0,0 +1,2 @@
+$("#notification_count").html("<%= @target.unopened_notification_count %>");
+$("#notifications").html("<%= escape_javascript( render_notification(@notifications, fallback: "default") ) %>");

data/app/views/activity_notification/notifications/default/show.html.erb

@@ -0,0 +1,2 @@
+<h1>Notification for <%= "#{@target.class.to_s.underscore} (#{@target.id})" %></h1>
+<%= render_notification(@notification, fallback: "default") %>

data/config/locales/en.yml

@@ -0,0 +1,8 @@
+# Additional translations of ActivityNotification
+
+en:
+  notification:
+    default:
+      your_notifiable:
+        default:
+          mail_subject:

data/lib/activity_notification.rb

@@ -0,0 +1,52 @@
+require 'rails'
+require 'active_support'
+require 'action_view'
+
+module ActivityNotification
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+
+  autoload :Notification,     'activity_notification/models/notification'
+  autoload :Target,           'activity_notification/models/target'
+  autoload :Notifiable,       'activity_notification/models/notifiable'
+  autoload :ActsAsTarget,     'activity_notification/roles/acts_as_target'
+  autoload :ActsAsNotifiable, 'activity_notification/roles/acts_as_notifiable'
+  autoload :StoreController,  'activity_notification/controllers/store_controller'
+  autoload :NotificationApi,  'activity_notification/apis/notification_api'
+  autoload :Common
+  autoload :Config
+  autoload :Renderable
+  autoload :VERSION
+
+
+  module Mailers
+    autoload :Helpers,        'activity_notification/mailers/helpers'
+  end
+
+  # Returns ActivityNotification's configuration object.
+  def self.config
+    @config ||= ActivityNotification::Config.new
+  end
+
+  # Lets you set global configuration options.
+  #
+  # All available options and their defaults are in the example below:
+  # @example Initializer for Rails
+  #   ActivityNotification.configure do |config|
+  #     config.enabled       = false
+  #     config.table_name    = "notifications"
+  #     ...
+  #   end
+  def self.configure(&block)
+    yield(config) if block_given?
+  end
+
+end
+
+# Load ActivityNotification helpers
+require 'activity_notification/helpers/polymorphic_helpers'
+require 'activity_notification/helpers/view_helpers'
+
+# Define Rails::Engine
+require 'activity_notification/rails'
+

data/lib/activity_notification/apis/notification_api.rb

@@ -0,0 +1,147 @@
+module ActivityNotification
+  module NotificationApi
+    extend ActiveSupport::Concern
+
+    # Define store_notification as private clas method
+    included do
+      private_class_method :store_notification
+    end
+
+    # For notification API
+    class_methods do
+      def notify(target_type, notifiable, options = {})
+        targets = notifiable.notification_targets(target_type, options[:key])
+        unless targets.blank?
+          notify_all(targets, notifiable, options)
+        end
+      end
+    
+      def notify_all(targets, notifiable, options = {})
+        targets.each do |target|
+          notify_to(target, notifiable, options)
+        end
+      end
+    
+      def notify_to(target, notifiable, options = {})
+        send_email = options.has_key?(:send_email) ? options[:send_email] : true
+        send_later = options.has_key?(:send_later) ? options[:send_later] : true
+        # Store notification
+        notification = store_notification(target, notifiable, options)
+        # Send notification email
+        notification.send_notification_email(send_later) if send_email
+        notification
+      end
+  
+      # Open all notifications of specified target
+      def open_all_of(target, opened_at = nil)
+        opened_at = DateTime.now if opened_at.blank?
+        Notification.where(target: target, opened_at: nil).update_all(opened_at: opened_at)
+      end
+  
+      #TODO description
+      # Call from controllers or views to avoid N+1
+      def group_member_exists?(notifications)
+        Notification.where(group_owner_id: notifications.pluck(:id)).exists?
+      end
+    
+      def available_options
+        [:key, :group, :parameters, :notifier, :send_email, :send_later].freeze
+      end
+
+      # Private class methods
+  
+      def store_notification(target, notifiable, options = {})
+        target_type = target.to_class_name
+        key         = options[:key]        || notifiable.default_notification_key
+        group       = options[:group]      || notifiable.notification_group(target_type, key)
+        notifier    = options[:notifier]   || notifiable.notifier(target_type, key)
+        parameters  = options[:parameters] || {}
+        parameters.merge!(options.except(*available_options))
+        parameters.merge!(notifiable.notification_parameters(target_type, key))
+  
+        # Bundle notification group by target, notifiable_type, group and key
+        # Defferent notifiable.id can be made in a same group
+        group_owner = Notification.where(target: target, notifiable_type: notifiable.to_class_name, key: key, group: group)
+                                  .where(group_owner_id: nil, opened_at: nil).earliest
+        if group.present? and group_owner.present?
+          create(target: target, notifiable: notifiable, key: key, group: group, group_owner: group_owner, parameters: parameters, notifier: notifier)
+        else
+          create(target: target, notifiable: notifiable, key: key, group: group, parameters: parameters, notifier: notifier)
+        end
+      end
+    end
+
+
+    # Public instance methods
+
+    def send_notification_email(send_later = true)
+      if send_later
+        Mailer.send_notification_email(self).deliver_later
+      else
+        Mailer.send_notification_email(self).deliver_now
+      end
+    end
+
+    def open!(opened_at = nil)
+      opened_at = DateTime.now if opened_at.blank?
+      update(opened_at: opened_at)
+      group_members.update_all(opened_at: opened_at)
+    end
+
+    def unopened?
+      !opened?
+    end
+
+    def opened?
+      opened_at.present?
+    end
+
+    def group_owner?
+      group_owner_id.blank?
+    end
+
+    def group_member?
+      group_owner_id.present?
+    end
+  
+    # Cache group-by query result to avoid N+1 call
+    def group_member_exists?(limit = ActivityNotification.config.opened_limit)
+      group_member_count(limit) > 0
+    end
+
+    # Cache group-by query result to avoid N+1 call
+    def group_member_count(limit = ActivityNotification.config.opened_limit)
+      notification = group_member? ? group_owner : self
+      notification.opened? ?
+        notification.opened_group_member_count(limit) :
+        notification.unopened_group_member_count
+    end
+
+    def notifiale_path
+      notifiable.notifiable_path(target_type)
+    end
+
+
+    # Protected instance methods
+    protected
+
+      def unopened_group_member_count
+        # Cache group-by query result to avoid N+1 call
+        unopened_group_member_counts = target.notifications
+                                              .unopened_index_group_members_only
+                                              .group(:group_owner_id)
+                                              .count
+        unopened_group_member_counts[id] || 0
+      end
+    
+      def opened_group_member_count(limit = ActivityNotification.config.opened_limit)
+        # Cache group-by query result to avoid N+1 call
+        opened_group_member_counts   = target.notifications
+                                              .opened_index_group_members_only(limit)
+                                              .group(:group_owner_id)
+                                              .count
+        opened_group_member_counts[id] || 0
+      end
+
+  end
+end