rails-alerter 0.0.5

data/app/models/alerter/message.rb

@@ -0,0 +1,171 @@
+class Alerter::Message < ActiveRecord::Base
+  self.table_name = :alerter_messages
+
+  attr_accessor :recipients
+  attr_accessible :message, :subject, :global, :expires if Alerter.protected_attributes?
+
+  belongs_to :sender, :polymorphic => :true
+  belongs_to :notified_object, :polymorphic => :true
+  belongs_to :notification_type
+  has_many :receipts, :dependent => :destroy, :class_name => "Alerter::Receipt"
+
+  validates :notification_type, :presence => true
+  validates :short_msg,    :presence => true,
+            :length => { :maximum => Alerter.short_msg_length }
+  validates :long_msg,    :presence => true,
+            :length => { :maximum => Alerter.long_msg_length }
+
+  scope :receipts, lambda { |recipient|
+                    joins(:receipts).where('Alerter_receipts.receiver_id' => recipient.id,'Alerter_receipts.receiver_type' => recipient.class.base_class.to_s)
+                  }
+
+  scope :inbox, lambda {|recipient|
+                receipts(recipient).merge(Alerter::Receipt.inbox.not_deleted)
+              }
+
+  scope :trash, lambda {|recipient|
+                receipts(recipient).merge(Alerter::Receipt.deleted)
+              }
+
+  scope :unread,  lambda {
+                 joins(:receipts).where('Alerter_receipts.is_read' => false)
+               }
+  scope :read,  lambda {
+                 joins(:receipts).where('Alerter_receipts.is_read' => true)
+               }
+  scope :global, lambda {
+                 where(:global => true)
+               }
+  scope :expired, lambda {
+                  where("Alerter_messages.expires < ?", Time.now)
+                }
+  scope :unexpired, lambda {
+                    where("Alerter_messages.expires is NULL OR Alerter_messages.expires > ?", Time.now)
+                  }
+
+  class << self
+    def message_all(recipients, short_msg, long_msg, notification_type_name, sanitize_text = true)
+      message = Alerter::MessageBuilder.new({
+                                                :recipients        => recipients,
+                                                :short_msg         => short_msg,
+                                                :long_msg          => long_msg,
+                                                :notification_type => Alerter::NotificationType.find_or_create_by(name: notification_type_name),
+                                            }).build
+      message.save!
+      message.deliver sanitize_text
+    end
+  end
+
+  def expired?
+    expires.present? && (expires < Time.now)
+  end
+
+  def expire!
+    unless expired?
+      expire
+      save
+    end
+  end
+
+  def expire
+    unless expired?
+      self.expires = Time.now - 1.second
+    end
+  end
+
+  #Delivers a Notification. USE NOT RECOMENDED.
+  #Use Alerter::Models::Message.notify and Notification.notify_all instead.
+  def deliver(should_clean = true)
+    clean if should_clean
+    temp_receipts = recipients.map { |r| build_receipt(r, 'inbox', false) }
+    if temp_receipts.all?(&:valid?)
+      temp_receipts.each(&:save!)   #Save receipts
+      Alerter::MessageDispatcher.new(self, recipients).call
+      #self.recipients = nil
+    end
+
+    return temp_receipts if temp_receipts.size > 1
+    temp_receipts.first
+  end
+
+  #Returns the recipients of the Notification
+  def recipients
+    return Array.wrap(@recipients) unless @recipients.blank?
+    @recipients = receipts.map { |receipt| receipt.receiver }
+  end
+
+  #Returns the receipt for the participant
+  def receipt_for(participant)
+    #Alerter::Receipt.notification(self).recipient(participant)
+    self.receipts.recipient(participant)
+  end
+
+  #Returns the receipt for the participant. Alias for receipt_for(participant)
+  def receipts_for(participant)
+    receipt_for(participant)
+  end
+
+  #Returns if the participant have read the Notification
+  def is_unread?(participant)
+    return false if participant.nil?
+    !receipt_for(participant).first.is_read
+  end
+
+  def is_read?(participant)
+    !is_unread?(participant)
+  end
+
+  #Returns if the participant have deleted the Notification
+  def is_deleted?(participant)
+    return false if participant.nil?
+    return receipt_for(participant).first.deleted
+  end
+
+  #Mark the notification as read
+  def mark_as_read(participant)
+    return if participant.nil?
+    receipt_for(participant).mark_as_read
+  end
+
+  #Mark the notification as unread
+  def mark_as_unread(participant)
+    return if participant.nil?
+    receipt_for(participant).mark_as_unread
+  end
+
+
+  #Mark the notification as deleted for one of the participant
+  def mark_as_deleted(participant)
+    return if participant.nil?
+    return receipt_for(participant).mark_as_deleted
+  end
+
+  #Mark the notification as not deleted for one of the participant
+  def mark_as_not_deleted(participant)
+    return if participant.nil?
+    return receipt_for(participant).mark_as_not_deleted
+  end
+
+  #Sanitizes the body and subject
+  def clean
+    self.short_msg = sanitize(short_msg)
+    self.long_msg = sanitize(long_msg)
+  end
+
+
+  def sanitize(text)
+    ::Alerter::Cleaner.instance.sanitize(text)
+  end
+
+  private
+
+  def build_receipt(receiver, mailbox_type, is_read = false)
+    Alerter::ReceiptBuilder.new({
+                                      :message => self,
+                                      :mailbox_type => mailbox_type,
+                                      :receiver     => receiver,
+                                      :is_read      => is_read
+                                  }).build
+  end
+
+end

data/app/models/alerter/notification_type.rb

@@ -0,0 +1,20 @@
+class Alerter::NotificationType < ActiveRecord::Base
+  self.table_name = :alerter_notification_types
+
+
+  attr_accessible :name if Alerter.protected_attributes?
+
+  #belongs_to :message
+  has_many :preferences
+  has_many :messages
+  before_save :check_notification_type
+
+
+  validates_uniqueness_of :name
+
+  protected
+  def check_notification_type
+    Alerter.available_notification_types.include?(self.name)
+  end
+
+end

data/app/models/alerter/preference.rb

@@ -0,0 +1,19 @@
+class Alerter::Preference < ActiveRecord::Base
+  self.table_name = :alerter_preferences
+  attr_accessible :alert_methods if Alerter.protected_attributes?
+
+  belongs_to :notifiable, :polymorphic => :true
+  belongs_to :notification_type
+
+  validates :notification_type_id, uniqueness: { scope: :notifiable_id }
+
+  serialize :alert_methods, Array
+
+  validate :alert_methods do
+    unless self.methods.nil? || self.alert_methods.count == 0 || (self.alert_methods - Alerter::available_notification_methods).empty?
+      errors.add(:alert_methods, "Must be only: #{Alerter::available_notification_methods.join(", ")}")
+    end
+  end
+
+
+end

data/app/models/alerter/receipt.rb

@@ -0,0 +1,89 @@
+class Alerter::Receipt < ActiveRecord::Base
+  self.table_name = :alerter_receipts
+  attr_accessible :is_read, :deleted if Alerter.protected_attributes?
+
+  belongs_to :receiver, :polymorphic => :true
+  belongs_to :message, :class_name => "Alerter::Message", :foreign_key => "message_id"
+
+  validates_presence_of :receiver
+
+  scope :recipient, lambda { |recipient|
+                    where(:receiver_id => recipient.id, :receiver_type => recipient.class.base_class.to_s)
+                  }
+
+  scope :inbox, lambda {
+                where(:mailbox_type => "inbox")
+              }
+  scope :deleted, lambda {
+                  where(:deleted => true)
+                }
+  scope :not_deleted, lambda {
+                      where(:deleted => false)
+                    }
+  scope :is_read, lambda {
+                  where(:is_read => true)
+                }
+  scope :is_unread, lambda {
+                    where(:is_read => false)
+                  }
+
+
+  class << self
+    #Marks all the receipts from the relation as read
+    def mark_as_read(options={})
+      update_receipts({:is_read => true}, options)
+    end
+
+    #Marks all the receipts from the relation as unread
+    def mark_as_unread(options={})
+      update_receipts({:is_read => false}, options)
+    end
+
+    #Marks the receipt as deleted
+    def mark_as_deleted(options={})
+      update_receipts({:deleted => true}, options)
+    end
+
+    #Marks the receipt as not deleted
+    def mark_as_not_deleted(options={})
+      update_receipts({:deleted => false}, options)
+    end
+
+
+    def update_receipts(updates, options={})
+      ids = where(options).map { |rcp| rcp.id }
+      unless ids.empty?
+        sql = ids.map { "#{table_name}.id = ? " }.join(' OR ')
+        conditions = [sql].concat(ids)
+        Alerter::Receipt.where(conditions).update_all(updates)
+      end
+    end
+  end
+
+
+  #Marks the receipt as deleted
+  def mark_as_deleted
+    update_attributes(:deleted => true)
+  end
+
+  #Marks the receipt as not deleted
+  def mark_as_not_deleted
+    update_attributes(:deleted => false)
+  end
+
+  #Marks the receipt as read
+  def mark_as_read
+    update_attributes(:is_read => true)
+  end
+
+  #Marks the receipt as unread
+  def mark_as_unread
+    update_attributes(:is_read => false)
+  end
+
+  #Returns if the participant has read the Notification
+  def is_unread?
+    !is_read
+  end
+
+end

data/app/views/alerter/message_mailer/new_message_email.html.erb

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta content="text/html; charset=UTF-8" http-equiv="Content-Type" />
+</head>
+<body>
+<h1>You have been alerted!</h1>
+<p>
+  You have received a new message:
+</p>
+<blockquote>
+  <p>
+    <%= raw @message.long_msg %>
+  </p>
+</blockquote>
+<p>
+  Visit <%= link_to Alerter.root_url, Alerter.root_url %> and go to your inbox for more info.
+</p>
+</body>
+</html>

data/app/views/alerter/message_mailer/new_message_email.text.erb

@@ -0,0 +1,10 @@
+You have been alerted!
+===============================================
+
+You have received a new message:
+
+-----------------------------------------------
+<%= @message.long_msg.html_safe? ? @message.long_msg : strip_tags(@message.long_msg) %>
+-----------------------------------------------
+
+Visit <%= Alerter.root_url %> and go to your inbox for more info.

data/db/migrate/20150821000000_create_alerter.rb

@@ -0,0 +1,65 @@
+class CreateAlerter < ActiveRecord::Migration
+  def self.up
+    #Tables
+
+    #Receipts
+    create_table :alerter_receipts do |t|
+      t.references :receiver, :polymorphic => true
+      t.column :message_id, :integer, :null => false
+      t.column :is_read, :boolean, :default => false
+      t.column :deleted, :boolean, :default => false
+      t.column :mailbox_type, :string, :limit => 25
+      t.column :created_at, :datetime, :null => false
+      t.column :updated_at, :datetime, :null => false
+    end
+    #Messages
+    create_table :alerter_messages do |t|
+      t.column :type, :string
+      t.column :short_msg, :string, :default => ""
+      t.column :long_msg, :text, :default => ""
+      t.column :draft, :boolean, :default => false
+      t.string :notification_code, :default => nil
+      t.references :notified_object, :polymorphic => true
+      t.references :notification_type
+      t.column :attachment, :string
+      t.column :updated_at, :datetime, :null => false
+      t.column :created_at, :datetime, :null => false
+      t.boolean :global, default: false
+      t.datetime :expires
+    end
+
+    #preferences
+    create_table :alerter_preferences do |t|
+      t.references :notification_type
+      t.references :notifiable, :polymorphic => true
+      t.column :alert_methods, :text
+    end
+
+    #Notification Types
+    create_table :alerter_notification_types do |t|
+      t.column :name, :string, :null => :false
+    end
+
+    #Indexes
+    #Receipts
+    add_index "alerter_receipts","message_id"
+
+    #Foreign keys
+    #Conversations
+    #Receipts
+    add_foreign_key "alerter_receipts", "alerter_messages", :name => "receipts_on_message_id", :column => "message_id"
+
+  end
+
+  def self.down
+    #Tables
+    remove_foreign_key "alerter_receipts", :name => "receipts_on_message_id"
+
+    #Indexes
+    drop_table :alerter_receipts
+    drop_table :alerter_messages
+    drop_table :alerter_notification_types
+    drop_table :alerter_preferences
+
+  end
+end

data/lib/alerter/cleaner.rb

@@ -0,0 +1,9 @@
+require 'singleton'
+
+module Alerter
+  class Cleaner
+    include Singleton
+    include ActionView::Helpers::SanitizeHelper
+
+  end
+end

data/lib/alerter/engine.rb

@@ -0,0 +1,31 @@
+# Database foreign keys
+require 'foreigner' if Rails.version < "4.2.0"
+begin
+  require 'sunspot_rails'
+rescue LoadError
+end
+
+module Alerter
+  class Engine < Rails::Engine
+    isolate_namespace Alerter
+
+    # config.generators do |g|
+    #   g.test_framework :rspec
+    #   g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+    # end
+
+    initializer "alerter.models.notifiable" do
+      ActiveSupport.on_load(:active_record) do
+        extend Alerter::Models::Notifiable::ActiveRecordExtension
+      end
+    end
+
+    initializer :append_migrations do |app|
+      unless app.root.to_s.match root.to_s
+        config.paths["db/migrate"].expanded.each do |expanded_path|
+          app.config.paths["db/migrate"] << expanded_path
+        end
+      end
+    end
+  end
+end

data/lib/alerter/message_dispatcher.rb

@@ -0,0 +1,62 @@
+module Alerter
+  class MethodNotImplemented < StandardError
+    def initialize(data)
+      @data = data
+    end
+  end
+
+  class MessageDispatcher
+
+    attr_reader :message, :recipients
+
+    def initialize(message, recipients)
+      @message, @recipients = message, recipients
+    end
+
+    def call
+      return false unless (Alerter.notification_method - Alerter.available_notification_methods).empty? # array subtraction to see if notification methods are in the available list
+      Alerter.notification_method.each do |method|
+        case method
+          when 'email'
+            if Alerter.mailer_wants_array
+              send_email(filtered_recipients(method))
+            else
+              filtered_recipients(method).each do |recipient|
+                send_email(recipient) if recipient.notification_methods(message.notification_type).include?(method) && recipient.email.present?
+              end
+            end
+          when 'none', 'ios_push', 'android_push', 'sms', 'twitter'
+
+          else
+            raise MethodNotImplemented.new(method)
+        end
+      end
+    end
+
+    private
+
+    def mailer
+      klass = message.class.name.demodulize
+      method = "#{klass.downcase}_mailer".to_sym
+      Alerter.methods.include?(method) ? Alerter.send(method) : "#{message.class}Mailer".constantize
+    end
+
+    # recipients can be filtered on a notification type basis
+    def filtered_recipients(method)
+      recipients.each_with_object([]) do |recipient, array|
+        pref = recipient.preferences.find_by(notification_type: message.notification_type)
+        array << recipient if pref && recipient.notification_methods(message.notification_type).include?(method)
+      end
+    end
+
+
+    def send_email(recipient)
+      if Alerter.custom_email_delivery_proc
+        Alerter.custom_email_delivery_proc.call(mailer, message, recipient)
+      else
+        email = mailer.send_email(message, recipient)
+        email.respond_to?(:deliver_now) ? email.deliver_now : email.deliver
+      end
+    end
+  end
+end