eventifier 0.0.7 → 0.0.8

data/app/models/eventifier/event.rb

@@ -0,0 +1,22 @@
+module Eventifier
+  class Event < ActiveRecord::Base
+    attr_accessible :user, :eventable, :verb, :change_data, :groupable
+
+    belongs_to  :user
+    belongs_to  :eventable,     polymorphic: true
+    belongs_to  :groupable,     polymorphic: true
+    has_many    :notifications, class_name: 'Eventifier::Notification',
+      dependent: :destroy
+
+    validates :user,      presence: true
+    validates :eventable, presence: true
+    validates :verb,      presence: true
+    validates :groupable, presence: true
+
+    serialize :change_data
+
+    def self.find_all_by_eventable object
+      where :eventable_id => object.id, :eventable_type => object.class.name
+    end
+  end
+end

data/app/models/eventifier/ghost.rb

@@ -0,0 +1,21 @@
+module Eventifier
+  class Ghost < ActiveRecord::Base
+    validates :ghost_class, :presence => true
+    validates :ghost_id,    :presence => true
+    validates :data_hash,   :presence => true
+
+    serialize :data_hash
+
+    def self.create_from_object object
+      create :ghost_class => object.class.name, :ghost_id => object.id, :data_hash => object.serializable_hash
+    end
+
+    def ghost
+      klass = Object.const_get(ghost_class)
+      ghost_object = klass.new data_hash
+      ghost_object.id = ghost_id
+
+      ghost_object
+    end
+  end
+end

data/app/models/eventifier/notification.rb

@@ -0,0 +1,38 @@
+module Eventifier
+  class Notification < ActiveRecord::Base
+    attr_accessible :event, :user, :relations, :event_id, :user_id
+
+    belongs_to :event, :class_name => 'Eventifier::Event'
+    belongs_to :user
+
+    serialize :relations, MultiJson
+
+    validates :event, :presence => true
+    validates :user, :presence => true
+    validates :event_id, :uniqueness => { :scope => :user_id }
+
+    default_scope order("notifications.created_at DESC")
+    scope :for_events,  -> ids { where(event_id: ids) }
+    scope :for_user,    -> user { where(user_id: user.id) }
+    scope :since,       -> date { where("created_at > ?", date) }
+    scope :latest,      order('notifications.created_at DESC').limit(5)
+    scope :unsent,      -> { where(sent: false) }
+
+    def self.expire_for_past_events!(time_limit = 1.day.ago)
+      self.for_events(Event.expired_ids(time_limit)).each &:expire!
+    end
+
+    def self.unread_for(user)
+      if user.notifications_last_read_at
+        for_user(user).since(user.notifications_last_read_at)
+      else
+        for_user(user)
+      end
+    end
+
+    def unread_for?(user)
+      return true if user.notifications_last_read_at.nil?
+      created_at > user.notifications_last_read_at
+    end
+  end
+end

data/app/models/eventifier/notification_setting.rb

@@ -0,0 +1,14 @@
+class Eventifier::NotificationSetting < ActiveRecord::Base
+  belongs_to :user
+
+  serialize :preferences, MultiJson
+
+  attr_accessible :user
+
+  validates :user,    :presence   => true
+  validates :user_id, :uniqueness => true
+
+  def self.for_user(user)
+    where(:user_id => user.id).first || create!(:user => user)
+  end
+end

data/app/views/eventifier/_notification.haml

@@ -0,0 +1 @@
+#{event.user.try :to_s} #{pastize(event.verb)} a #{event.eventable_type.titleize}

data/app/views/eventifier/email/_notification.haml

@@ -0,0 +1,2 @@
+%a{ href: root_url }
+  #{event.user.try :to_s} #{pastize(event.verb)} a #{event.eventable_type.titleize}

data/app/views/eventifier/mailer/notifications.haml

@@ -0,0 +1,5 @@
+%p You have new notifications
+
+%ul.notifications
+  - @notifications.each do |notification|
+    %li= render_partial_view(notification, :email)

data/app/views/eventifier/notifications/index.jbuilder

@@ -0,0 +1,6 @@
+json.last_read_at current_user.notifications_last_read_at.to_i
+json.notifications @notifications do |notification|
+  json.(notification, :id)
+  json.created_at notification.created_at.to_i
+  json.html render_partial_view(notification, :dropdown)
+end

data/config/routes.rb

@@ -0,0 +1,7 @@
+Eventifier::Engine.routes.draw do
+  resources :notifications, module: 'eventifier' do
+    collection { post :touch }
+  end
+
+  resource :preferences, module: 'eventifier'
+end

data/config.ru

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+Combustion.initialize!
+run Combustion::Application

data/{lib/generators/eventifier/install/templates/migration.rb → db/migrate/1_eventifier_setup.rb}

@@ -9,7 +9,7 @@ class EventifierSetup < ActiveRecord::Migration
 
       t.timestamps
     end
-    
+
     add_index :events, :user_id
     add_index :events, [:eventable_id, :eventable_type]
 
@@ -23,8 +23,7 @@ class EventifierSetup < ActiveRecord::Migration
     add_index :notifications, :event_id
     add_index :notifications, :user_id
     add_index :notifications, :parent_id
-    
+
     add_column :users, :notifications_last_read_at, :datetime
   end
-
 end

data/db/migrate/2_eventifier_notification_settings.rb

@@ -0,0 +1,11 @@
+class EventifierNotificationSettings < ActiveRecord::Migration
+  def change
+    create_table :notification_settings do |t|
+      t.integer :user_id,     :null => false
+      t.text    :preferences, :null => false, :default => '{}'
+      t.timestamps
+    end
+
+    add_index :notification_settings, :user_id, :unique => true
+  end
+end

data/db/migrate/3_notification_sent_status.rb

@@ -0,0 +1,15 @@
+class NotificationSentStatus < ActiveRecord::Migration
+  def up
+    add_column :notifications, :sent,      :boolean, :default => false
+    add_column :notifications, :relations, :text,    :default => '[]'
+    add_index  :notifications, :sent
+
+    Eventifier::Notification.reset_column_information
+    Eventifier::Notification.update_all :sent => true
+  end
+
+  def down
+    remove_column :notifications, :sent
+    remove_column :notifications, :relations
+  end
+end

data/db/migrate/4_event_groupable.rb

@@ -0,0 +1,19 @@
+class EventGroupable < ActiveRecord::Migration
+  def up
+    add_column :events, :groupable_id,   :integer
+    add_column :events, :groupable_type, :string
+
+    Eventifier::Event.reset_column_information
+    Eventifier::Event.update_all(
+      'groupable_id = eventable_id, groupable_type = eventable_type'
+    )
+
+    change_column :events, :groupable_id,   :integer, :null => false
+    change_column :events, :groupable_type, :string,  :null => false
+  end
+
+  def down
+    remove_column :events, :groupable_id
+    remove_column :events, :groupable_type
+  end
+end

data/eventifier.gemspec

@@ -1,10 +1,7 @@
 # -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "eventifier/version"
-
 Gem::Specification.new do |s|
   s.name        = "eventifier"
-  s.version     = Eventifier::VERSION
+  s.version     = '0.0.8'
   s.authors     = ["Nathan Sampimon", "Peter Murray"]
   s.email       = ["nathan@inspire9.com"]
   s.homepage    = "http://github.com/inspire9/eventifier"
@@ -18,16 +15,16 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency  "activerecord"
-  s.add_development_dependency  "mongoid"
-  s.add_runtime_dependency      "actionmailer"
-  s.add_development_dependency  "fabrication"
-  s.add_development_dependency  "database_cleaner"
-  s.add_development_dependency  "pg"
-  s.add_development_dependency  "rspec"
-
-  s.add_runtime_dependency "activerecord"
+  s.add_runtime_dependency 'rails',           '~> 3.2.0'
   s.add_runtime_dependency "bson_ext"
-  s.add_runtime_dependency "mongoid"
-  s.add_runtime_dependency "actionmailer"
+  s.add_runtime_dependency 'haml-rails',      '~> 0.4'
+  s.add_runtime_dependency 'haml_coffee_assets'
+  s.add_runtime_dependency 'coffee-rails',    '~> 3.2.1'
+  s.add_runtime_dependency 'compass-rails'
+  s.add_runtime_dependency 'multi_json',      '~> 1.7.4'
+
+  s.add_development_dependency 'combustion',  '~> 0.5.0'
+  s.add_development_dependency 'fabrication', '~> 2.7.1'
+  s.add_development_dependency "pg"
+  s.add_development_dependency 'rspec-rails', '~> 2.13.2'
 end

data/lib/eventifier/delivery.rb

@@ -0,0 +1,59 @@
+class Eventifier::Delivery
+  def self.deliver
+    unsent = Eventifier::Notification.unsent
+    unsent.group_by(&:user).each do |user, notifications|
+      new(user, notifications).deliver
+    end
+  end
+
+  def initialize(user, notifications)
+    @user, @notifications = user, notifications
+  end
+
+  def deliver
+    if anything_to_send?
+      Eventifier.mailer.notifications(user, notifications_to_send).deliver
+    end
+
+    notifications.each do |notification|
+      notification.update_attribute :sent, true
+    end
+  end
+
+  private
+
+  attr_reader :user, :notifications
+
+  def anything_to_send?
+    !notifications_to_send.empty?
+  end
+
+  def notifications_to_send
+    @notifications_to_send ||= notifications.select { |notification|
+      include_notification? notification
+    }
+  end
+
+  def settings
+    @settings ||= Eventifier::NotificationSetting.for_user user
+  end
+
+  def include_notification?(notification)
+    return true if settings.preferences['email'].nil?
+
+    specifics = notification.relations.collect { |relation|
+      key = [
+        notification.event.verb,
+        notification.event.eventable_type.underscore.pluralize,
+        'notify',
+        Eventifier::Relationship.new(self, relation).key
+      ].join('_')
+      settings.preferences['email'][key]
+    }.compact
+
+    return specifics.any? unless specifics.empty?
+
+    default  = settings.preferences['email']['default']
+    default.nil? || default
+  end
+end

data/lib/eventifier/{railtie.rb → engine.rb}

@@ -1,7 +1,9 @@
 module Eventifier
-  class Railtie < Rails::Railtie
+  class Engine < Rails::Engine
+    engine_name :eventifier
+
     config.after_initialize do
       ::EventTracking.new
     end
   end
-end
+end

data/lib/eventifier/event_subscriber.rb

@@ -0,0 +1,44 @@
+class Eventifier::EventSubscriber
+  def self.subscribe_to_all klass, names
+    names.each do |method_name|
+      new.subscribe_to_method klass, method_name
+    end
+  end
+
+  def subscribe_to_method klass, method_name
+    name = "#{method_name}.#{klass.name.tableize}.event.eventifier"
+
+    return if ActiveSupport::Notifications.notifier.listening?(name)
+
+    ActiveSupport::Notifications.subscribe name do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      event_user = if event.payload[:user]
+        Eventifier::Relationship.new(event.payload[:object], event.payload[:user]).users.first
+      else
+        event.payload[:object].user
+      end
+      groupable = event.payload[:object]
+      groupable = Eventifier::Relationship.new(groupable, event.payload[:group_by]).users.first if event.payload[:group_by]
+
+      eventifier_event = Eventifier::Event.create(
+        user:         event_user,
+        eventable:    event.payload[:object],
+        groupable:    groupable,
+        verb:         event.payload[:event],
+        change_data:  change_data(event.payload[:object], event.payload[:options])
+      )
+
+      ActiveSupport::Notifications.instrument("#{method_name}.#{klass.name.tableize}.notification.eventifier", verb: :create, event: eventifier_event, object: event.payload[:object])
+    end
+  end
+
+  private
+  def change_data object, options
+    change_data = object.changes.stringify_keys
+
+    change_data = change_data.reject { |attribute, value| options[:except].include?(attribute) } if options[:except]
+    change_data = change_data.select { |attribute, value| options[:only].include?(attribute) } if options[:only]
+
+    change_data.symbolize_keys
+  end
+end

data/lib/eventifier/event_tracking.rb

@@ -8,74 +8,22 @@ module Eventifier
       methods    = options.delete(:track_on)
       attributes = options.delete(:attributes)
 
-      create_observers
-
       if block.nil?
         track_on methods, :attributes => attributes
       else
         instance_eval(&block)
       end
-    end
-
-    def create_observers
-      # Create all the observer classes
-      @klasses.each do |target_klass|
 
-        # If the observer doesn't exist, create the class
-        unless self.class.const_defined?("#{target_klass}Observer")
-          constant_name = "#{target_klass}Observer"
-          klass         = Class.new(OBSERVER_CLASS)
-          self.class.qualified_const_set(constant_name, klass)
-        end
-      end
+      @klasses.each { |klass| Eventifier.tracked_classes << klass }
+      Eventifier.tracked_classes.uniq!
     end
 
-    def track_on methods, options = { }
-      methods    = methods.kind_of?(Array) ? methods : [methods]
-      attributes = options.delete(:attributes) || {}
-      raise 'No events defined to track' if methods.compact.empty?
-      User.class_eval { has_many :notifications, :class_name => 'Eventifier::Notification' } unless User.respond_to?(:notifications)
-      Eventifier::EventObserver.instance
-
-      # set up each class with an observer and relationships
-      @klasses.each do |target_klass|
-        # Add relations to class
-        target_klass.class_eval { has_many :events, :as => :eventable, :class_name => 'Eventifier::Event', :dependent => :destroy }
-        add_notification_association(target_klass)
-
-        # create an observer and have it observe the class
-        klass = self.class.const_get("#{target_klass}Observer")
-        klass.observe target_klass
-
-        # create a callback for the methods we want to track
-        klass.class_eval do
-          methods.each do |event|
-            define_method "after_#{event}" do |object|
-              # create an event when the callback is fired
-              Eventifier::Event.create_event(event.to_sym, object, attributes) if object.changed?
-            end
-          end
-        end
-        # instantiate the observer
-        klass.instance
-      end
+    def track_on methods, options = {}
+      Eventifier::Tracker.new @klasses, methods, options
     end
 
     def notify *args
-      # args will either be [:relation, {:on => :create}] or [{:relation => :second_relation, :on => :create}]
-      # if its the first one, relation is the first in the array, otherwise treat the whole thing like a hash
-      relation = args.delete_at(0) if args.length == 2
-      args = args.first
-
-      methods  = args.delete(:on)
-      methods  = methods.kind_of?(Array) ? methods : [methods]
-      relation ||= args
-
-      @klasses.each do |target_klass|
-        methods.each do |method|
-          Eventifier::Event.add_notification target_klass, relation, method
-        end
-      end
+      Eventifier::Notifier.new @klasses, *args
     end
 
     def url url_proc
@@ -87,6 +35,5 @@ module Eventifier
     def self.url_mappings
       @url_mapppings ||= {}
     end
-
   end
 end

data/lib/eventifier/mailers/helpers.rb

@@ -0,0 +1,70 @@
+module Eventifier
+  module Mailers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :scope_name, :resource
+      end
+
+      protected
+
+      # Configure default email options
+      def eventifier_mail(user, records, action)
+        initialize_from_record(user, records)
+        mail headers_for(action)
+      end
+
+      def initialize_from_record(user, records)
+        @user, @notifications = user, records
+      end
+
+      def headers_for(action)
+        headers = {
+          :subject       => I18n.t(:email_subject, :scope => [:notifications]),
+          :from          => mailer_sender,
+          :to            => @user.email,
+          :template_path => template_paths
+        }
+
+        headers[:reply_to] = headers[:from] unless headers.key?(:reply_to)
+
+        headers
+      end
+
+      def mailer_sender
+        if default_params[:from].present?
+          default_params[:from]
+        else
+          Eventifier.mailer_sender
+        end
+      end
+
+      def template_paths
+        self.class.mailer_name
+      end
+
+      # Setup a subject doing an I18n lookup. At first, it attemps to set a subject
+      # based on the current mapping:
+      #
+      #   en:
+      #     devise:
+      #       mailer:
+      #         confirmation_instructions:
+      #           user_subject: '...'
+      #
+      # If one does not exist, it fallbacks to ActionMailer default:
+      #
+      #   en:
+      #     devise:
+      #       mailer:
+      #         confirmation_instructions:
+      #           subject: '...'
+      #
+      def translate(mapping, key)
+        I18n.t(:"notifications_subject", :scope => [:eventifier, :notifications, key],
+          :default => [:subject, key.to_s.humanize])
+      end
+    end
+  end
+end

data/lib/eventifier/notifier/notification_mapping.rb

@@ -0,0 +1,34 @@
+class Eventifier::NotificationMapping
+  def self.add(key, relation)
+    notification_mappings[key] << relation
+  end
+
+  def self.find(key)
+    notification_mappings[key]
+  end
+
+  def self.all
+    notification_mappings
+  end
+
+  def self.users_and_relations(event, key, &block)
+    users = Hash.new { |hash, key| hash[key] = [] }
+
+    find(key).each do |relation|
+      Eventifier::Relationship.new(event.eventable, relation).users.each do |user|
+        users[user] << relation
+        users[user].uniq!
+      end
+    end
+
+    users.each(&block)
+  end
+
+  private
+
+  def self.notification_mappings
+    @notification_mapppings ||= Hash.new { |hash, key|
+      hash[key] = []
+    }
+  end
+end

data/lib/eventifier/notifier/notification_subscriber.rb

@@ -0,0 +1,23 @@
+class Eventifier::NotificationSubscriber
+  def self.subscribe_to_method klass, method_name
+    key = "#{method_name}.#{klass.name.tableize}"
+    name = "#{key}.notification.eventifier"
+
+    return if ActiveSupport::Notifications.notifier.listening?(name)
+
+    ActiveSupport::Notifications.subscribe name do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      eventifier_event = event.payload[:event]
+
+      Eventifier::NotificationMapping.users_and_relations(eventifier_event, key) do |user, relations|
+        next if user == eventifier_event.user
+
+        Eventifier::Notification.create(
+          event:     eventifier_event,
+          user:      user,
+          relations: relations
+        )
+      end
+    end
+  end
+end

data/lib/eventifier/notifier/notifier.rb

@@ -0,0 +1,21 @@
+class Eventifier::Notifier
+  def initialize klasses, *args
+    # args will either be [:relation, {:on => :create}] or [{:relation => :second_relation, :on => :create}]
+    # if its the first one, relation is the first in the array, otherwise treat the whole thing like a hash
+
+    @klasses = klasses
+    relation = args.delete_at(0) if args.length == 2
+    args = args.first || {}
+
+    methods  = args.delete(:on)
+    methods  = methods.kind_of?(Array) ? methods : [methods]
+    relation ||= args
+
+    @klasses.each do |target_klass|
+      methods.each do |method_name|
+        Eventifier::NotificationMapping.add "#{method_name}.#{target_klass.name.tableize}", relation
+        Eventifier::NotificationSubscriber.subscribe_to_method target_klass, method_name
+      end
+    end
+  end
+end

data/lib/eventifier/preferences.rb

@@ -0,0 +1,44 @@
+class Eventifier::Preferences
+  def initialize(user)
+    @user = user
+  end
+
+  def to_hashes
+    keys.collect do |key|
+      {
+        :key   => key,
+        :label => label_for(key),
+        :value => value_for(key)
+      }
+    end
+  end
+
+  private
+
+  attr_reader :user
+
+  def keys
+    @keys ||= begin
+      hash = Eventifier::NotificationMapping.notification_mappings
+      ['default'] + hash.keys.collect { |key|
+        hash[key].collect { |value|
+          (key.split('.') + ['notify', Eventifier::Relationship.new(user, value).key]).join('_')
+        }
+      }.flatten
+    end
+  end
+
+  def label_for(key)
+    I18n.translate :"events.labels.preferences.#{key}", default: key
+  end
+
+  def settings
+    @settings ||= Eventifier::NotificationSetting.for_user user
+  end
+
+  def value_for(key)
+    settings.preferences['email'].nil?      ||
+    settings.preferences['email'][key].nil? ||
+    settings.preferences['email'][key]
+  end
+end