notifun 1.6

data/app/views/notifun/message_templates/index.html.haml

@@ -0,0 +1,29 @@
+%h1 Message Templates
+
+%table.notifun-table
+  %thead
+    %tr
+      %th
+      %th Sent via
+      %th
+
+  %tbody
+    - @message_templates.where(category: nil).each do |message_template|
+      %tr
+        %td= message_template.description
+        %td= message_template.sent_via
+        - if message_template.editable
+          %td= link_to "Edit", edit_notifun_message_template_path(message_template)
+        - else
+          %td
+    - @message_templates.order(:category).pluck(:category).uniq.compact.each do |category|
+      %tr
+        %td.notifun-category.notifun-center{colspan: 3}= category.capitalize
+      - @message_templates.order(:description).where(category: category).each do |message_template|
+        %tr
+          %td= message_template.description
+          %td= message_template.sent_via
+          - if message_template.editable
+            %td= link_to "Edit", edit_notifun_message_template_path(message_template)
+          - else
+            %td

data/app/views/notifun/messages/index.haml

@@ -0,0 +1,47 @@
+%h1 Messages
+
+%table.table
+  %thead
+    %tr
+      %th User
+      %th Recipient
+      %th Sent via
+      %th Message Template
+      %th Success
+      %th Sent At
+      %th
+
+  %tbody
+    - @messages.each do |message|
+      - user = User.where(uuid: message.uuid).first
+      %tr
+        - if user.try(:display_name)
+          %td= user.display_name
+        - else
+          %td= message.uuid
+        %td= message.recipient
+        %td= message.notification_method
+        - if message.message_template
+          %td= link_to message.message_template_key.humanize, edit_notifun_message_template_path(message.message_template)
+        - else
+          %td= message.message_template_key.humanize
+        %td= message.success ? "Yes" : "No"
+        %td= message.created_at.in_time_zone(Notifun.configuration.time_zone).strftime("%D %l:%M %Z")
+        %td= link_to "View", message
+
+.notifun-center
+  - if @page == 1
+    %span ← Previous
+  - else
+    = link_to '← Previous', { page: @page - 1 }
+
+  - (1..@pages).each do |p|
+    - if p == @page
+      %em= @page
+    - else
+      = link_to p, { page: p }
+
+  - if @page == @pages
+    %span Next →
+  - else
+    = link_to 'Next →', { page: @page + 1 }

data/app/views/notifun/messages/show.haml

@@ -0,0 +1,47 @@
+%h1 Message Details
+
+.notifun-detail
+  .notifun-detail-title UUID
+  .notifun-detail-value= @message.uuid
+
+.notifun-detail
+  .notifun-detail-title Recipient
+  .notifun-detail-value= @message.recipient
+
+.notifun-detail
+  .notifun-detail-title Sent Via
+  .notifun-detail-value= @message.notification_method
+
+.notifun-detail
+  .notifun-detail-title Template
+  .notifun-detail-value
+    - if @message.message_template.editable
+      = link_to @message.message_template_key.humanize, edit_notifun_message_template_path(@message.message_template)
+    - else
+      = @message.message_template_key.humanize
+
+.notifun-detail
+  .notifun-detail-title Sent At
+  .notifun-detail-value= @message.created_at.in_time_zone(Notifun.configuration.time_zone).strftime("%D %l:%M %Z")
+
+.notifun-detail
+  .notifun-detail-title Success
+  .notifun-detail-value= @message.success ? "Yes" : "No"
+
+- if @message.error_message.present?
+  .notifun-detail
+    .notifun-detail-title Error Message
+    .notifun-detail-value= @message.error_message
+
+- if @message.data.present?
+  .notifun-detail
+    .notifun-detail-title Data
+    .notifun-detail-value= @message.data
+
+.notifun-detail
+  .notifun-detail-title Title
+  .notifun-detail-value= @message.message_title || "N/A"
+
+.notifun-detail
+  .notifun-detail-title Text
+  .notifun-detail-value= @message.message_text

data/app/views/notifun/preferences/index.haml

@@ -0,0 +1,45 @@
+%h1 Notification Preferences
+
+= form_tag save_notifun_preferences_path, class: "notifun-form" do
+  - @models.each do |model|
+    - index = 0
+    %h2 #{model.class.name} Preferences
+    %table.notifun-table
+      %thead
+        %tr
+          %th
+          - @notification_methods.each do |notification_method|
+            %th.notifun-center= notification_method.capitalize
+      %tbody
+        - message_templates = Notifun::MessageTemplate.where("models @> Array[?]::varchar[]", model.class.name).where("category IS NOT NULL")
+        - message_templates.pluck(:category).uniq.each do |category|
+          - prefix = "preferences[#{index}]"
+          - index += 1
+          - preference = Notifun::Preference.where(preferable: model, category: category).first_or_initialize
+          = hidden_field_tag "#{prefix}[preferable_type]", model.class.name
+          = hidden_field_tag "#{prefix}[preferable_id]", model.id
+          = hidden_field_tag "#{prefix}[preference_type]", "category"
+          = hidden_field_tag "#{prefix}[category]", category
+          %tr
+            %td.notifun-category #{category.capitalize} Category
+            - @notification_methods.each do |notification_method|
+              = hidden_field_tag "#{prefix}[#{notification_method}]", "0"
+              %td.notifun-center= check_box_tag "#{prefix}[#{notification_method}]", "1", preference.send(notification_method)
+          - message_templates.where(category: category).each do |message_template|
+            - prefix = "preferences[#{index}]"
+            - index += 1
+            - preference = Notifun::Preference.where(preferable: model, message_template_key: message_template.key).first_or_initialize
+            = hidden_field_tag "#{prefix}[preferable_type]", model.class.name
+            = hidden_field_tag "#{prefix}[preferable_id]", model.id
+            = hidden_field_tag "#{prefix}[preference_type]", "message_template_key"
+            = hidden_field_tag "#{prefix}[message_template_key]", message_template.key
+            %tr
+              %td.notifun-indent= message_template.description
+              - @notification_methods.each do |notification_method|
+                = hidden_field_tag "#{prefix}[#{notification_method}]", "0"
+                - checked = preference.persisted? ? preference.send(notification_method) : message_template.notification_methods.include?(notification_method)
+                - if message_template.possible_notification_methods.include?(notification_method)
+                  %td.notifun-center= check_box_tag "#{prefix}[#{notification_method}]", "1", checked
+                - else
+                  %td.notifun-center
+  = submit_tag "Save Preferences"

data/config/routes.rb

@@ -0,0 +1,16 @@
+# notifun/config/routes.rb
+Rails.application.routes.draw do
+  namespace :notifun do
+    resources :message_templates, param: :key do
+      member do
+        get :preview
+      end
+    end
+    resources :messages, only: [:index, :show]
+    resources :preferences, only: [:index] do
+      collection do
+        post :save
+      end
+    end
+  end
+end

data/lib/generators/notifun/install_generator.rb

@@ -0,0 +1,50 @@
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+require_relative '../../../app/models/notifun/message_template'
+
+class Notifun::InstallGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  source_root File.expand_path("../templates", __FILE__)
+
+  def copy_notifun_migration
+    if !ActiveRecord::Base.connection.table_exists?('notifun_message_templates')
+      migration_template "migration.rb", "db/migrate/notifun_create_tables.rb"
+    else
+      puts "Skipping db/migrate/notifun_create_tables.rb"
+      Notifun::MessageTemplate.reset_column_information
+      if !Notifun::MessageTemplate.column_names.include?("push_title")
+        migration_template "notifun_add_push_title.rb", "db/migrate/notifun_add_push_title.rb"
+      end
+    end
+  end
+
+  def copy_config_file
+    if File.exists?("config/initializers/notifun.rb")
+      puts "Skipping config/initializers/notifun.rb"
+    else
+      copy_file "notifun.rb", "config/initializers/notifun.rb"
+    end
+  end
+
+  def copy_json_file
+    if File.exists?("config/notifun_templates.json")
+      puts "Skipping config/notifun_templates.json"
+    else
+      copy_file "notifun_templates.json", "config/notifun_templates.json"
+    end
+  end
+
+  def rails5?
+    Rails.version.start_with? '5'
+  end
+
+  def migration_version
+    if rails5?
+      "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+    end
+  end
+
+  def self.next_migration_number(dirname)
+    ActiveRecord::Generators::Base.next_migration_number(dirname)
+  end
+end

data/lib/generators/notifun/templates/migration.rb

@@ -0,0 +1,48 @@
+class NotifunCreateTables < ActiveRecord::Migration<%= migration_version %>
+  def change
+    create_table :notifun_message_templates do |t|
+      t.string :key
+      t.string :models, array: true, default: [], null: false
+      t.text :description
+      t.string :category
+      t.string :default_notification_methods, array: true, default: [], null: false
+      t.string :backup_notification_methods, array: true, default: [], null: false
+      t.jsonb :merge_fields, null: false, default: {}
+      t.text :push_title
+      t.text :push_body
+      t.text :text_body
+      t.string :email_subject
+      t.text :email_html
+      t.text :email_text
+      t.boolean :preferences, default: false, null: false
+      t.boolean :editable, default: true, null: false
+
+      t.timestamps
+    end
+
+    create_table :notifun_messages do |t|
+      t.string :message_template_key
+      t.string :uuid
+      t.string :recipient
+      t.string :notification_method
+      t.text :message_title
+      t.text :message_text
+      t.jsonb :data, null: false, default: {}
+      t.boolean :success, default: false, null: false
+      t.text :error_message
+
+      t.timestamps
+    end
+
+    create_table :notifun_preferences do |t|
+      t.references :preferable, polymorphic: true
+      t.string :message_template_key
+      t.string :category
+      t.boolean :email, default: false, null: false
+      t.boolean :push, default: false, null: false
+      t.boolean :text, default: false, null: false
+
+      t.timestamps
+    end
+  end
+end

data/lib/generators/notifun/templates/notifun.rb

@@ -0,0 +1,39 @@
+Notifun.configure do |config|
+  # Configure which types of notifications can be sent
+  # "email", "push", "text"
+  config.notification_methods = ["email"]
+
+  # Configure the parent class responsible to send e-mails.
+  config.parent_mailer = 'ApplicationMailer'
+
+  # Configure how to send push notifications
+  # "CloudFive", "Empty"
+  # config.push_notifier = "CloudFive"
+  # config.push_config = { api_key: ENV["CLOUD_FIVE_API_KEY"] }
+
+  # Configure how to send text notifications
+  # "Twilio", "Empty"
+  # config.text_notifier = "Twilio"
+  # config.text_config = { account_sid: ENV["TWILIO_ACCOUNT_SID"], auth_token: ENV["TWILIO_AUTH_TOKEN"], from: "+14159341234" }
+
+  # Configure how to edit html fields
+  # "froala", timymce", "none"
+  # config.wysiwyg = "timymce"
+
+  # Configure parent class for Notifun controllers for admin actions like editing message templates
+  config.admin_parent_controller = 'ApplicationController'
+
+  # Configure parent class for Notifun controllers for user actions like editing preferences
+  config.user_parent_controller = 'ApplicationController'
+
+  # Configure controller helper method to use to get the model
+  # notifun should use for the currently logged in person for the preferences page
+  # should correspond to the 'models' attribute on message template
+  # this must be set for preferences to work
+  # can return an array of models
+  # config.controller_method = "current_user"
+
+  # If you have the premailer gem installed and you want to use it to automatically
+  # convert your html to plain text, set this to true
+  config.premailer_html_to_text = false
+end

data/lib/generators/notifun/templates/notifun_add_push_title.rb

@@ -0,0 +1,8 @@
+class NotifunAddPushTitle < ActiveRecord::Migration<%= migration_version %>
+  def change
+    add_column :notifun_message_templates, :push_title, :text
+    add_column :notifun_messages, :message_title, :text
+    add_column :notifun_messages, :error_message, :text
+    add_column :notifun_messages, :data, :jsonb, null: false, default: {}
+  end
+end

data/lib/generators/notifun/templates/notifun_templates.json

@@ -0,0 +1,29 @@
+// {
+//   "message_template_key" : {
+//     "models" : ["User"], // used for preferences, must match models returned by config.controller_method
+//     "description" : "Description Text.", // seen by admin for editing and users for preferences
+//     "category" : "reminders", // categories for admin organization and user preferences
+//     "editable" : false, // indicates whether admin should be able to change the text via the web
+//     // methods not in default or backup can be chosen by user preferences if the related text is present
+//     // if users have edited their preferences, those will always take precedence over these defaults
+//     "default_notification_methods" : ["push"], // tries to send to all of these methods
+//     "backup_notification_methods" : ["email"], // if all default methods fail, will try all of backup until one succeeds
+//     "preferences" : false, // whether users should be allowed to change preferences or not
+//     // display of fields that can be used to show real data; this should match what you pass into Notifun::Notification.notify
+//     "merge_fields" : {
+//       "full_name" : {
+//         "description" : "Full Name of first user",
+//         "preview" : "William Riker"
+//       },
+//       "application_name" : {
+//         "description" : "Name of application",
+//         "preview" : "Awesome App Name"
+//       }
+//     },
+//     "push_body" : "Hello, {full_name}. Welcome to {application_name}.",
+//     "email_subject" : "Welcome to {application_name}.",
+//     "email_html" : "<h3>Hello, {full_name},</h3><p>Welcome to {application_name}.</p>",
+//     "email_text" : "Hello, {full_name}, Welcome to {application_name}.",
+//     "text_body" : "Hello, {full_name}, Welcome to {application_name}."
+//   }
+// }

data/lib/notifun.rb

@@ -0,0 +1,27 @@
+require 'notifun/version'
+require 'notifun/configuration'
+require 'notifun/engine'
+require 'notifun/notifiers/notifier'
+require 'notifun/notification'
+
+module Notifun
+  require 'notifun/railtie' if defined?(Rails)
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  module NotificationMethods
+    EMAIL = 'email'
+    PUSH = 'push'
+    TEXT = 'text'
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/notifun/configuration.rb

@@ -0,0 +1,19 @@
+class Notifun::Configuration
+  attr_accessor :notification_methods, :parent_mailer, :push_notifier, :push_config, :text_notifier, :text_config,
+    :wysiwyg, :admin_parent_controller, :user_parent_controller, :controller_method, :time_zone, :premailer_html_to_text
+
+  def initialize
+    @notification_methods = []
+    @parent_mailer = 'ActionMailer::Base'
+    @push_notifier = "Empty"
+    @push_config = {}
+    @text_notifier = "Empty"
+    @text_config = {}
+    @wysiwyg = "none"
+    @admin_parent_controller = "ActionController::Base"
+    @user_parent_controller = "ActionController::Base"
+    @controller_method = "current_user"
+    @time_zone = "Etc/UTC"
+    @premailer_html_to_text = false
+  end
+end

data/lib/notifun/engine.rb

@@ -0,0 +1,5 @@
+class Notifun::Engine < Rails::Engine
+  initializer 'notifun.engine', :group => :all do |app|
+    app.config.assets.paths << root.join('assets', 'stylesheets')
+  end
+end

data/lib/notifun/notification.rb

@@ -0,0 +1,166 @@
+class Notifun::Notification
+  # model passed in must have following methods:
+  # notifun_uuid or uuid: unique identifier
+  # notifun_email or email: email to send to
+  # notifun_notify_via or notify_via(method) returns if it should send message using one of the message types: ["email", "push", "text"]
+  def self.notify(models, key, merge_hash={}, options={})
+    message_template = Notifun::MessageTemplate.find_by_key(key)
+    raise "Unable to find message_template with key #{key}" if message_template.nil?
+    models = [models].flatten
+    status = true
+    models.each do |model|
+      primary_sent = false
+      backup_sent = false
+      preference = Notifun::Preference.where(preferable: model).where(message_template_key: key).first
+      if message_template.category.present?
+        preference ||= Notifun::Preference.where(preferable: model).where(category: message_template.category).first
+      end
+      if preference
+        sent = false
+        preference.notification_methods.each do |notification_method|
+          next if options[:notification_methods] && !options[:notification_methods].include?(notification_method)
+          sent = self.send("send_via_#{notification_method}", message_template, model, merge_hash, options)
+        end
+
+        return sent
+      else
+        message_template.default_notification_methods.each do |notification_method|
+          next if options[:notification_methods] && !options[:notification_methods].include?(notification_method)
+          notify_via = model.try(:notifun_notify_via, notification_method)
+          notify_via = model.notify_via(notification_method) if notify_via.nil?
+          if notify_via
+            if self.send("send_via_#{notification_method}", message_template, model, merge_hash, options)
+              primary_sent = true
+            end
+          end
+        end
+        if !primary_sent
+          message_template.backup_notification_methods.each do |notification_method|
+            next if options[:notification_methods] && !options[:notification_methods].include?(notification_method)
+            notify_via = model.try(:notifun_notify_via, notification_method)
+            notify_via = model.notify_via(notification_method) if notify_via.nil?
+            if notify_via
+              if self.send("send_via_#{notification_method}", message_template, model, merge_hash, options)
+                backup_sent = true
+                break
+              end
+            end
+          end
+        end
+
+        if status == true
+          status = primary_sent || backup_sent
+        end
+      end
+    end
+
+    return status
+  end
+
+  def self.send_via_text(message_template, model, merge_hash, options)
+    if options[:message].present?
+      text = options[:message]
+    else
+      text = message_template.merged_text_body(merge_hash)
+    end
+    phone = model.try(:notifun_phone).presence || model.try(:phone).presence
+    if phone
+      text_notifier = Notifun::Notifier.text_notifier.new
+      text_notifier.notify!(text, phone, options)
+      success = text_notifier.success
+      error_message = text_notifier.error_message
+    else
+      success = false
+      error_message = "No phone number."
+    end
+    uuid = model.try(:notifun_uuid).presence || model.try(:uuid).presence
+
+    Notifun::Message.create({
+      message_template_key: message_template.key,
+      uuid: uuid,
+      recipient: phone,
+      notification_method: "text",
+      message_text: text,
+      success: success,
+      error_message: error_message
+    })
+
+    return success
+  end
+
+  def self.send_via_push(message_template, model, merge_hash, options)
+    if options[:message].present?
+      text = options[:message]
+    else
+      text = message_template.merged_push_body(merge_hash)
+    end
+    if options[:title].present?
+      title = options[:title]
+    else
+      title = message_template.merged_push_title(merge_hash)
+    end
+    uuid = model.try(:notifun_uuid).presence || model.try(:uuid).presence
+    if uuid
+      push_notifier = Notifun::Notifier.push_notifier.new
+      push_notifier.notify!(text, title, uuid, options)
+      success = push_notifier.success
+      error_message = push_notifier.error_message
+    else
+      success = false
+      error_message = "No uuid."
+    end
+    data = options[:push_data].presence || {}
+    Notifun::Message.create({
+      message_template_key: message_template.key,
+      uuid: uuid,
+      recipient: uuid,
+      notification_method: "push",
+      message_text: text,
+      success: success,
+      message_title: title,
+      data: data,
+      error_message: error_message
+    })
+
+    return success
+  end
+
+  def self.send_via_email(message_template, model, merge_hash, options)
+    if options[:subject].present?
+      subject = options[:subject]
+    else
+      subject = message_template.merged_email_subject(merge_hash)
+    end
+    if options[:message].present?
+      text = html = options[:message]
+    else
+      text = message_template.merged_email_text(merge_hash)
+      html = message_template.merged_email_html(merge_hash)
+    end
+    email = model.try(:notifun_email).presence || model.try(:email).presence
+    if email
+      email_notifier = Notifun::Notifier.email_notifier.new
+      email_notifier.notify!(email, subject, html, text, message_template, options)
+      success = email_notifier.success
+      error_message = email_notifier.error_message
+    else
+      success = false
+      error_message = "No email."
+    end
+
+    uuid = model.try(:notifun_uuid).presence || model.try(:uuid).presence
+
+    Notifun::Message.create({
+      message_template_key: message_template.key,
+      uuid: uuid,
+      recipient: email,
+      notification_method: "email",
+      message_text: html,
+      success: success,
+      message_title: subject,
+      error_message: error_message
+    })
+
+    return success
+  end
+end