rails-alerter 0.0.5

data/lib/alerter/models/notifiable.rb

@@ -0,0 +1,174 @@
+module Alerter
+  module Models
+    module Notifiable
+      extend ActiveSupport::Concern
+
+      module ActiveRecordExtension
+        #Converts the model into messageable allowing it to interchange messages and
+        #receive notifications
+        def acts_as_notifiable
+          include Notifiable
+        end
+      end
+
+
+      included do
+        has_many :messages, :class_name => "Alerter::Message", :as => :sender
+        has_many :preferences, :class_name => "Alerter::Preference", :as => :notifiable, dependent: :destroy
+        if Rails::VERSION::MAJOR == 4
+          has_many :receipts, -> { order 'created_at DESC' }, :class_name => "Alerter::Receipt", dependent: :destroy, as: :receiver
+        else
+          # Rails 3 does it this way
+          has_many :receipts, :order => 'created_at DESC',    :class_name => "Alerter::Receipt", :dependent => :destroy, :as => :receiver
+        end
+      end
+
+      # unless defined?(Alerter.name_method)
+      #   # Returning any kind of identification you want for the model
+      #   define_method Alerter.name_method do
+      #     begin
+      #       super
+      #     rescue NameError
+      #       return "You should add method :#{Alerter.name_method} in your Notifiable model"
+      #     end
+      #   end
+      # end
+      #
+      # unless defined?(Alerter.email_method)
+      #   #Returning the email address of the model if an email should be sent for this Message.
+      #   #If no mail has to be sent, return nil.
+      #   define_method Alerter.email_method do |object|
+      #     begin
+      #       super
+      #     rescue NameError
+      #       return "You should add method :#{Alerter.email_method} in your Notifiable model"
+      #     end
+      #   end
+      # end
+
+      #Gets the mailbox of the notifiable
+      def mailbox
+        @mailbox ||= Alerter::Mailbox.new(self)
+      end
+
+      # Get number of unread messages
+      def unread_inbox_count
+        mailbox.inbox(unread: true).count
+      end
+
+
+      #Sends a notification
+      #as originator
+      def send_message(short_msg, long_msg, notification_type_name, sanitize_text = true)
+        message = Alerter::MessageBuilder.new({
+                                                    :recipients        => self,
+                                                    :short_msg         => short_msg,
+                                                    :long_msg          => long_msg,
+                                                    :notification_type => NotificationType.find_or_create_by(name: notification_type_name),
+                                                }).build
+        message.save!
+        message.deliver sanitize_text
+      end
+
+
+
+      #Mark the object as read for notifiable.
+      #Object can be:
+      #* A Receipt
+      #* A Message
+      #* An Array of these
+      #Optionally pass in details of the read receipt as String
+      def mark_as_read(obj, details = nil)
+        case obj
+          when Alerter::Receipt
+            obj.mark_as_read if obj.receiver == self
+          when Alerter::Message
+            obj.mark_as_read(self)
+          when Array
+            obj.map{ |sub_obj| mark_as_read(sub_obj) }
+        end
+
+      end
+
+      #Mark the object as unread for notifiable.
+      #
+      #Object can be:
+      #* A Receipt
+      #* A Message
+      #* An Array of these
+      #Optionally pass in details of the un-read receipt as String
+      def mark_as_unread(obj, details = nil)
+        case obj
+          when Alerter::Receipt
+            obj.mark_as_unread if obj.receiver == self
+          when Alerter::Message
+            obj.mark_as_unread(self)
+          when Array
+            obj.map{ |sub_obj| mark_as_unread(sub_obj) }
+        end
+      end
+
+      #Mark the object as deleted for notifiable.
+      #
+      #Object can be:
+      #* A Receipt
+      #* A Message
+      #* An Array of these
+      #Optionally pass in details of the deletion as String
+      def mark_as_deleted(obj, details = nil)
+        case obj
+          when Receipt
+            return obj.mark_as_deleted if obj.receiver == self
+          when Message
+            obj.mark_as_deleted(self)
+          when Array
+            obj.map{ |sub_obj| mark_as_deleted(sub_obj) }
+          else
+            return nil
+        end
+      end
+
+      #Mark the object as not deleted for notifiable.
+      #
+      #Object can be:
+      #* A Receipt
+      #* A Message
+      #* An Array of these
+      #Optionally pass in details of the deletion as String
+      def mark_as_not_deleted(obj, details = nil)
+        case obj
+          when Receipt
+            return obj.mark_as_not_deleted if obj.receiver == self
+          when Message
+            obj.mark_as_not_deleted(self)
+          when Array
+            obj.map{ |sub_obj| mark_as_not_deleted(sub_obj) }
+          else
+            return nil
+        end
+      end
+
+      # Get the notification preferences for a given notification_type
+      def notification_methods(notification_type)
+        return [] unless notification_type.is_a?(Alerter::NotificationType)
+        prefs = preferences.find_by(notification_type: notification_type).try(:alert_methods)
+        prefs ||= []
+      end
+
+      # configure methods for a given notification type
+      # methods can be an array of methods, a single method, or nil
+      def configure_notification_methods(notification_type, methods)
+        preference = preferences.find_or_create_by(notification_type: notification_type)
+        if methods.is_a?(Array)
+          preference.alert_methods = methods
+        elsif methods.is_a?(String)
+          preference.alert_methods = [ methods ]
+        elsif methods.nil?
+          preference.alert_methods = [ ]
+        end
+        preference.save
+      end
+
+    end
+  end
+end

data/lib/alerter/version.rb

@@ -0,0 +1,3 @@
+module Alerter
+  VERSION = "0.0.5"
+end

data/lib/generators/alerter/install_generator.rb

@@ -0,0 +1,37 @@
+module Alerter
+  class InstallGenerator < Rails::Generators::Base #:nodoc:
+    include Rails::Generators::Migration
+    source_root File.expand_path('../templates', __FILE__)
+    require 'rails/generators/migration'
+
+    def self.next_migration_number path
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+      @prev_migration_nr.to_s
+    end
+
+    def create_initializer_file
+      template 'initializer.rb', 'config/initializers/alerter.rb'
+    end
+
+    def copy_migrations
+      if Rails.version < "3.1"
+        migrations = [
+            %w[20150821000000_create_alerter.rb create_alerter.rb]
+        ]
+        migrations.each do |migration|
+          migration_template "../../../../db/migrate/" + migration[0], "db/migrate/" + migration[1]
+        end
+      # Rails 4 is handled by a initializer
+      # else
+      #   require 'rake'
+      #   Rails.application.load_tasks
+      #   Rake::Task['railties:install:migrations'].reenable
+      #   Rake::Task['rails-alerter_engine:install:migrations'].invoke
+      end
+    end
+  end
+end

data/lib/generators/alerter/namespacing_compatibility_generator.rb

@@ -0,0 +1,24 @@
+module Alerter
+  class NamespacingCompatibilityGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+    source_root File.expand_path('../templates', __FILE__)
+    require 'rails/generators/migration'
+
+    FILENAME = 'alerter_namespacing_compatibility.rb'
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    def create_model_file
+      migration_template FILENAME, "db/migrate/#{FILENAME}"
+    end
+
+    def self.next_migration_number path
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+      @prev_migration_nr.to_s
+    end
+  end
+end

data/lib/generators/alerter/templates/initializer.rb

@@ -0,0 +1,29 @@
+Alerter.setup do |config|
+
+  #Configures the default from for emails sent for Messages
+  config.default_from = "no-reply@alert.com"
+
+  #Configures the default subject line (only used in emails)
+  config.default_subject = "Alerter: you have a new message!"
+
+  #Configures the methods needed by alerter to get information about the model its attached to
+  #config.email_method = :email
+  #config.name_method = :name
+
+  #Configures the array of available (supported) notification methods
+  # Available choices are: none email push sms twitter
+  config.available_notification_methods = %w( none email ios_push android_push sms twitter )
+
+  config.notification_method = %w( none email ios_push android_push sms twitter )
+
+  #Configures maximum length of the message
+  config.short_msg_length = 144 # twitter support
+  config.long_msg_length = 2048
+
+  # Base application URL - to be used in messages
+  config.root_url = 'www.alert.com'
+end
+
+if Alerter::NotificationType.all.count == 0
+  Alerter::NotificationType.create(name: 'Default')
+end

data/lib/generators/alerter/views_generator.rb

@@ -0,0 +1,11 @@
+module Alerter
+  class ViewsGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../../../app/views/alerter", __FILE__)
+
+    desc "Copy Alerter views into your app"
+
+    def copy_views
+      directory('message_mailer', 'app/views/alerter/message_mailer')
+    end
+  end
+end

data/lib/rails-alerter.rb

@@ -0,0 +1,71 @@
+require "alerter/version"
+
+module Alerter
+  module Models
+    autoload :Notifiable, 'alerter/models/notifiable'
+  end
+
+  # Default from address for email notifications
+  mattr_accessor :default_from
+  @@default_from = "no-reply@alerter.com"
+
+  # default subject to use on emails only
+  mattr_accessor :default_subject
+  @@default_from = "Alerter: you have a new message!"
+
+  # method used to retrieve the recipient's name
+  mattr_accessor :name_method
+  @@name_method = :name
+
+  # method used to retrieve the recipient's email
+  mattr_accessor :email_method
+  @@email_method = :email
+
+  mattr_accessor :short_msg_length
+  @@short_msg_length = 144
+
+  mattr_accessor :long_msg_length
+  @@long_msg_length = 512
+
+  mattr_accessor :mailer_wants_array
+  @@mailer_wants_array = false
+
+  # array of available (supported) notification types
+  mattr_accessor :available_notification_types
+  @@available_notification_types = %w( info warning error action )
+
+  # array of available (supported) notification methods
+  mattr_accessor :available_notification_methods
+  @@available_notification_methods = %w( none email ios_push android_push sms twitter )
+
+  # the chosen notification method for this object
+  mattr_accessor :notification_method
+  @@notification_method = %w( none )
+
+  # Base url to use in messages
+  @@root_url = 'www.alerter.com'
+
+  mattr_accessor :email_message_mailer
+  mattr_accessor :custom_email_delivery_proc
+  mattr_accessor :sms_message_mailer
+  mattr_accessor :custom_sms_delivery_proc
+  mattr_accessor :push_message_mailer
+  mattr_accessor :custom_push_delivery_proc
+  mattr_accessor :root_url
+
+  class << self
+    def setup
+      yield self
+    end
+
+    def protected_attributes?
+      Rails.version < '4' || defined?(ProtectedAttributes)
+    end
+  end
+end
+
+# reopen ActiveRecord and include all the above to make
+# them available to all our models if they want it
+require 'alerter/engine'
+require 'alerter/cleaner'
+require 'alerter/message_dispatcher'

data/spec/alerter/message_dispatcher_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Alerter::MessageDispatcher do
+
+  subject(:instance) { described_class.new(message, recipients) }
+
+  let(:message)   { FactoryGirl.create :message }
+  let(:recipient1) { FactoryGirl.create :user_with_email_pref, email: nil  }
+  let(:recipient2) { FactoryGirl.create :user_with_email_pref  }
+  let(:recipients) { [ recipient1, recipient2 ] }
+
+  describe "call" do
+    context "supported methods" do
+      before { Alerter.notification_method = %w( bad ) }
+      after  { Alerter.notification_method = %w( none email ios_push android_push sms twitter )}
+      its(:call) { should be false }
+    end
+
+    context "mailer wants array" do
+      before { Alerter.mailer_wants_array = true  }
+      after  { Alerter.mailer_wants_array = false }
+      it 'sends collection' do
+        expect(subject).to receive(:send_email).with(recipients)
+        subject.call
+      end
+    end
+
+    context "mailer doesnt want array" do
+      it 'sends collection' do
+        expect(subject).not_to receive(:send_email).with(recipient1) #email is blank
+        expect(subject).to receive(:send_email).with(recipient2)
+        subject.call
+      end
+    end
+  end
+
+  describe "send_email" do
+
+    let(:mailer) { double 'mailer' }
+
+    before(:each) do
+      allow(subject).to receive(:mailer).and_return mailer
+    end
+
+    context "with custom_deliver_proc" do
+      let(:my_proc) { double 'proc' }
+
+      before { Alerter.custom_email_delivery_proc = my_proc }
+      after  { Alerter.custom_email_delivery_proc = nil     }
+      it "triggers proc" do
+        expect(my_proc).to receive(:call).with(mailer, message, recipient1)
+        subject.send :send_email, recipient1
+      end
+    end
+
+    context "without custom_deliver_proc" do
+      let(:email) { double :email }
+
+      it "triggers standard deliver chain" do
+        expect(mailer).to receive(:send_email).with(message, recipient1).and_return email
+        expect(email).to receive :deliver
+
+        subject.send :send_email, recipient1
+      end
+    end
+  end
+
+  describe "send_push_notification" do
+
+    pending 'test push notifications'
+    # let(:mailer) { double 'mailer' }
+    #
+    # before(:each) do
+    #   allow(subject).to receive(:mailer).and_return mailer
+    # end
+    #
+    # context "with custom_deliver_proc" do
+    #   let(:my_proc) { double 'proc' }
+    #
+    #   before { Alerter.custom_deliver_proc = my_proc }
+    #   after  { Alerter.custom_deliver_proc = nil     }
+    #   it "triggers proc" do
+    #     expect(my_proc).to receive(:call).with(mailer, mailable, recipient1)
+    #     subject.send :send_email, recipient1
+    #   end
+    # end
+    #
+    # context "without custom_deliver_proc" do
+    #   let(:email) { double :email }
+    #
+    #   it "triggers standard deliver chain" do
+    #     expect(mailer).to receive(:send_email).with(mailable, recipient1).and_return email
+    #     expect(email).to receive :deliver
+    #
+    #     subject.send :send_email, recipient1
+    #   end
+    # end
+  end
+
+
+end