nuntius 0.1.1 → 1.0.27

data/app/presenters/application_presenter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+# http://nithinbekal.com/posts/rails-presenters/
+class ApplicationPresenter < SimpleDelegator
+  delegate :t, to: I18n
+
+  # Returns reference to the object we're decorating
+  def model
+    __getobj__
+  end
+
+  def route
+    Rails.application.routes.url_helpers
+  end
+
+  # Provide access to view/helpers
+  def h
+    @h ||= ActionView::Base.new
+  end
+
+  class << self
+    def model(model_alias)
+      alias_method(model_alias, :model)
+    end
+  end
+end

data/app/presenters/template_presenter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class TemplatePresenter < ApplicationPresenter
+  def all_events
+    events = []
+    Nuntius.config.nuntiable_class_names.each do |class_name|
+      next if class_name == 'Custom'
+
+      messenger = Nuntius::BaseMessenger.messenger_for_class(class_name)
+      messenger.instance_methods(false).each do |m|
+        events << [m, m, { 'data-chain': class_name,
+                           'data-timebased': messenger.timebased_scopes.include?(m) }]
+      end
+    end
+    events.sort_by(&:first)
+  end
+end

data/app/providers/nuntius/apnotic_push_provider.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'apnotic'
+
+module Nuntius
+  class ApnoticPushProvider < BaseProvider
+    transport :push
+
+    setting_reader :certificate,
+                   required: true,
+                   description: 'The contents of a valid APNS push certificate in .pem format'
+    setting_reader :passphrase,
+                   required: false,
+                   description: 'If the APNS certificate is protected by a passphrase, ' \
+                                'provide this variable to use when decrypting it.'
+    setting_reader :environment,
+                   required: false,
+                   default: :production,
+                   description: 'Development or production, defaults to production'
+
+    def deliver
+      return message if message.to.size != 64
+
+      connection = if environment.to_sym == :development
+                     Apnotic::Connection.development(cert_path: StringIO.new(certificate), cert_pass: passphrase)
+                   else
+                     Apnotic::Connection.new(cert_path: StringIO.new(certificate), cert_pass: passphrase)
+                   end
+
+      notification = Apnotic::Notification.new(message.to)
+      notification.alert = message.text
+      notification.custom_payload = message.payload
+
+      response = connection.push(notification)
+
+      message.status = if response.ok?
+                         'sent'
+                       else
+                         'undelivered'
+                       end
+      message
+    end
+  end
+end

data/app/providers/nuntius/base_provider.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class BaseProvider
+    attr_reader :message
+
+    def initialize(message = nil)
+      @message = message
+    end
+
+    class << self
+      def all_settings
+        @all_settings ||= []
+      end
+
+      def setting_reader(name, required: false, default: nil, description: '')
+        @all_settings ||= []
+        @all_settings.push(name: name, required: required, default: default, description: description)
+        define_method(name) { required ? settings.fetch(name) : settings.dig(name) || default }
+      end
+
+      def transport(transport = nil)
+        @transport = transport if transport
+        @transport
+      end
+
+      def states(mapping = nil)
+        @states = mapping if mapping
+        @states
+      end
+
+      def class_from_name(name, transport)
+        Nuntius.const_get("#{name}_#{transport}_provider".camelize)
+      rescue StandardError
+        nil
+      end
+    end
+
+    # Override this in implementations
+    def deliver
+      @message
+    end
+
+    # Override this in implementations
+    def refresh
+      @message
+    end
+
+    # Override this in implementation
+    def callback(_params)
+      [404, { 'Content-Type' => 'text/html; charset=utf-8' }, ['Not found']]
+    end
+
+    def name
+      self.class.name.demodulize.underscore.gsub(/_#{self.class.transport}_provider$/, '').to_sym
+    end
+
+    private
+
+    def translated_status(status)
+      self.class.states.find { |key, _value| key.is_a?(Array) ? key.include?(status) : key == status }&.last || 'sent'
+    end
+
+    def settings
+      return @settings if @settings
+
+      @settings = Nuntius.config.providers[self.class.transport].to_a.find { |d| d[:provider] == name }[:settings]
+      @settings = instance_exec(@message, &@settings) if @settings.is_a?(Proc)
+      @settings
+    end
+  end
+end

data/app/providers/nuntius/firebase_push_provider.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'fcm'
+
+module Nuntius
+  class FirebasePushProvider < BaseProvider
+    transport :push
+
+    setting_reader :server_key, required: true, description: 'Server key for the project, see Firebase console'
+
+    def deliver
+      fcm = FCM.new(server_key)
+
+      options = (message.payload || {}).merge(data: { body: message.text })
+      response = fcm.send([message.to], options)
+
+      message.status = if response[:status_code] != 200 || response[:response] != 'success'
+                         'undelivered'
+                       else
+                         'sent'
+                       end
+
+      message
+    end
+  end
+end

data/app/providers/nuntius/houston_push_provider.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'houston'
+
+module Nuntius
+  class HoustonPushProvider < BaseProvider
+    transport :push
+
+    setting_reader :certificate,
+                   required: true,
+                   description: 'The contents of a valid APNS push certificate in .pem format'
+    setting_reader :passphrase,
+                   required: false,
+                   description: 'If the APNS certificate is protected by a passphrase, ' \
+                                'provide this variable to use when decrypting it.'
+    setting_reader :environment,
+                   required: false,
+                   default: :production,
+                   description: 'Development or production, defaults to production'
+
+    def deliver
+      return message if message.to.size != 64
+
+      apn = environment.to_sym == :development ? Houston::Client.development : Houston::Client.production
+      apn.certificate = certificate
+      apn.passphrase = passphrase
+
+      notification = Houston::Notification.new((message.payload || {}).merge(device: message.to,
+                                                                             alert: message.text, sound: 'default'))
+      apn.push(notification)
+
+      message.status = if notification.sent?
+                         'sent'
+                       elsif !notification.valid? || notification.error
+                         'undelivered'
+                       end
+      message
+    end
+  end
+end

data/app/providers/nuntius/message_bird_sms_provider.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'messagebird'
+
+module Nuntius
+  # Send SMS messages using messagebird.com
+  class MessageBirdSmsProvider < BaseProvider
+    transport :sms
+
+    setting_reader :auth_token, required: true, description: 'Authentication token'
+    setting_reader :from, required: true, description: "Phone-number or name (say: 'Nuntius') to send the message from"
+
+    # Messagebird statusses: scheduled, sent, buffered, delivered, expired, and delivery_failed.
+    states %w[expired delivery_failed] => 'undelivered', 'delivered' => 'delivered'
+
+    def deliver
+      response = client.message_create(message.from.present? ? message.from : from, message.to, message.text)
+      message.provider_id = response.id
+      message.status = translated_status(response.recipients['items'].first.status)
+      message
+    end
+
+    def refresh
+      response = client.message(message.provider_id)
+      message.provider_id = response.id
+      message.status = translated_status(response.recipients['items'].first.status)
+      Nuntius.logger.info "SMS #{message.to} status: #{message.status}"
+      message
+    rescue StandardError => _e
+      message
+    end
+
+    private
+
+    def client
+      @client ||= ::MessageBird::Client.new(auth_token)
+    end
+  end
+end

data/app/providers/nuntius/slack_slack_provider.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'slack'
+
+module Nuntius
+  class SlackSlackProvider < BaseProvider
+    transport :slack
+
+    setting_reader :api_key, required: true, description: 'API key for the Slack workspace'
+
+    def deliver
+      client = Slack::Web::Client.new(token: api_key)
+
+      message.attachments.each do |attachment|
+        client.files_upload(
+          channels: message[:to],
+          as_user: true,
+          username: message[:from],
+          file: Faraday::UploadIO.new(StringIO.new(attachment.download), attachment.content_type),
+          filename: attachment.filename.to_s
+        )
+      end
+
+      args = (message.payload || {}).merge(channel: message[:to], text: message.text, as_user: true, username: message[:from])
+      response = client.chat_postMessage(args.deep_symbolize_keys)
+
+      message.status = if response['ok']
+                         'sent'
+                       else
+                         'undelivered'
+                       end
+
+      message
+    end
+  end
+end

data/app/providers/nuntius/smtp_mail_provider.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'mail'
+
+module Nuntius
+  class SmtpMailProvider < BaseProvider
+    transport :mail
+
+    setting_reader :from_header, required: true, description: 'From header (example: Nuntius Messenger <nuntius@entdec.com>)'
+    setting_reader :host, required: true, description: 'Host (example: smtp.soverin.net)'
+    setting_reader :port, required: true, description: 'Port (example: 578)'
+    setting_reader :username, required: true, description: 'Username (nuntius@entdec.com)'
+    setting_reader :password, required: true, description: 'Password'
+    setting_reader :allow_list, required: false, default: [], description: 'Allow list (example: [boxture.com, tom@degrunt.net])'
+
+    def deliver
+      return block unless MailAllowList.new(settings[:allow_list]).allowed?(message.to)
+      return block if Nuntius::Message.where(status: %w[complaint bounced], to: message.to).count >= 1
+
+      mail = if message.from.present?
+               Mail.new(sender: from_header, from: message.from)
+             else
+               Mail.new(from: from_header)
+             end
+
+      if Rails.env.test?
+        mail.delivery_method :test
+      else
+        mail.delivery_method :smtp,
+                             address: host,
+                             port: port,
+                             user_name: username,
+                             password: password,
+                             return_response: true
+      end
+
+      mail.to = message.to
+      mail.subject = message.subject
+      mail.part content_type: 'multipart/alternative' do |p|
+        p.text_part = Mail::Part.new(
+          body: message.text,
+          content_type: 'text/plain',
+          charset: 'UTF-8'
+        )
+        if message.html.present?
+          message.html = message.html.gsub('%7B%7Bmessage_url%7D%7D') { message_url(message) }
+          p.html_part = Mail::Part.new(
+            body: message.html,
+            content_type: 'text/html',
+            charset: 'UTF-8'
+          )
+        end
+      end
+
+      message.attachments.each do |attachment|
+        mail.attachments[attachment.filename.to_s] = { mime_type: attachment.content_type, content: attachment.download }
+      end
+
+      response = mail.deliver!
+
+      message.provider_id = mail.message_id
+      message.status = 'undelivered'
+      message.status = 'sent' if Rails.env.test? ? true : response.success?
+      message.last_sent_at = Time.zone.now if message.sent?
+
+      message
+    end
+
+    def block
+      message.status = 'blocked'
+      message
+    end
+
+    private
+
+    def message_url(message)
+      Nuntius::Engine.routes.url_helpers.message_url(message.id, host: Nuntius.config.host(message))
+    end
+  end
+end

data/app/providers/nuntius/twilio_sms_provider.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'twilio-ruby'
+
+module Nuntius
+  # Send SMS messages using twilio.com
+  class TwilioSmsProvider < BaseProvider
+    transport :sms
+
+    setting_reader :auth_token, required: true, description: 'Authentication token'
+    setting_reader :sid, required: true, description: 'Application SID, see Twilio console'
+    setting_reader :from, required: true, description: "Phone-number or name (example: 'Nuntius') to send the message from"
+
+    # Twilio statusses: queued, failed, sent, delivered, or undelivered
+    states %w[failed undelivered] => 'undelivered', 'delivered' => 'delivered'
+
+    def deliver
+      response = client.messages.create(from: message.from.present? ? message.from : from, to: message.to, body: message.text)
+      message.provider_id = response.sid
+      message.status = translated_status(response.status)
+      message
+    end
+
+    def refresh
+      response = client.messages(message.provider_id).fetch
+      message.provider_id = response.sid
+      message.status = translated_status(response.status)
+      message
+    end
+
+    private
+
+    def client
+      @client ||= Twilio::REST::Client.new(sid, auth_token)
+    end
+  end
+end

data/app/providers/nuntius/twilio_voice_provider.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'twilio-ruby'
+
+module Nuntius
+  # Send Voice call messages using twilio.com
+  class TwilioVoiceProvider < BaseProvider
+    transport :voice
+
+    setting_reader :host, required: true, description: 'Host or base-url for the application'
+    setting_reader :auth_token, required: true, description: 'Authentication token'
+    setting_reader :sid, required: true, description: 'Application SID, see Twilio console'
+    setting_reader :from, required: true, description: "Phone-number or name (example: 'Nuntius') to send the message from"
+
+    # Twilio statusses: queued, failed, sent, delivered, or undelivered
+    states %w[failed undelivered] => 'undelivered', %w[delivered completed] => 'delivered'
+
+    def deliver
+      # Need hostname here too
+      response = client.calls.create(from: message.from.present? ? message.from : from, to: message.to, method: 'POST', url: callback_url)
+      message.provider_id = response.sid
+      message.status = translated_status(response.status)
+      message
+    end
+
+    def refresh
+      response = client.calls(message.provider_id).fetch
+      message.provider_id = response.sid
+      message.status = translated_status(response.status)
+      message
+    end
+
+    def callback(params)
+      refresh.save
+
+      twiml = script_for_path(message, "/#{params[:path]}", params)
+
+      if twiml
+        [200, { 'Content-Type' => 'application/xml' }, [twiml[:body]]]
+      else
+        [404, { 'Content-Type' => 'text/html; charset=utf-8' }, ['Not found']]
+      end
+    end
+
+    private
+
+    def client
+      @client ||= Twilio::REST::Client.new(sid, auth_token)
+    end
+
+    def script_for_path(message, path = '/', _params)
+      scripts = message.text.delete("\r").split("\n\n")
+
+      scripts = scripts.map do |script|
+        preamble = Preamble.parse(script)
+        payload = preamble.metadata ? payload = preamble.content : script
+        payload = payload.gsub('{{url}}', callback_url)
+        metadata = preamble.metadata || { path: '/' }
+
+        { headers: metadata.with_indifferent_access, body: payload }
+      end
+
+      scripts.find { |s| s[:headers][:path] == path }
+    end
+
+    def callback_url
+      Nuntius::Engine.routes.url_helpers.callback_url(message.id, host: host)
+    end
+  end
+end

data/app/reportlets/nuntius/application_reportlet.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class ApplicationReportlet < Trado::Reportlet
+    attr_reader :template_ids
+
+    def initialize(params)
+      @template_ids = params[:template_ids]
+    end
+
+    private
+
+    def ymds(_for_display = false)
+      results.map { |r| r['ymd'] }.uniq.sort_by { |w| Date.strptime(w, '%F') }
+    end
+
+    def all_templates
+      map_items(results, :template_id)
+    end
+
+    # Helper to get item for ymd, template_id
+    def ymd_template_id(ymd, template_id, what)
+      find_item(results, { ymd: ymd, template_id: template_id }, what)
+    end
+
+    # Arel helpers
+    def templates
+      Nuntius::Template.arel_table
+    end
+
+    def messages
+      Nuntius::Message.arel_table
+    end
+  end
+end

data/app/reportlets/nuntius/daily_messages_per_template_reportlet.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_reportlet'
+
+module Nuntius
+  class DailyMessagesPerTemplateReportlet < ApplicationReportlet
+    title 'Daily messages per template'
+    cache 1.minute
+
+    def table_data
+      data = [[''] + ymds(true)]
+
+      matrix = all_templates.map do |template|
+        tmpl = Nuntius::Template.find(template)
+        if tmpl
+          template_ymd_totals = ymds.map { |ymd| h.link_to(ymd_template_id(ymd, template, :count), Nuntius::Engine.routes.url_helpers.admin_messages_path(template_id: template)) }
+          [h.link_to(tmpl.description, Nuntius::Engine.routes.url_helpers.edit_admin_template_path(tmpl))] + template_ymd_totals
+        end
+      end
+
+      if matrix.present?
+        data += matrix
+      else
+        data = []
+      end
+      data
+    end
+
+    private
+
+    def results
+      return @results if @results
+
+      select_manager = messages.project(
+        :template_id,
+        Arel.sql("CONCAT(EXTRACT(YEAR FROM created_at :: DATE) :: VARCHAR, '-', EXTRACT(MONTH FROM created_at :: DATE) :: VARCHAR, '-', EXTRACT(DAY FROM created_at :: DATE) :: VARCHAR) AS ymd"),
+        Arel.star.count
+      )
+
+      select_manager = select_manager.where(messages[:template_id].in(template_ids))
+      select_manager = select_manager.where(messages[:created_at].between(7.days.ago..Time.now))
+
+      select_manager = select_manager.group(:template_id, :ymd)
+      select_manager = select_manager.order(:template_id, :ymd)
+
+      Rails.logger.info select_manager.to_sql
+      @results = ActiveRecord::Base.connection.execute(select_manager.to_sql)
+    end
+  end
+end

data/app/runners/nuntius/application_runner.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class ApplicationRunner < Nuntius.config.base_runner.constantize
+  end
+end

data/app/runners/nuntius/basic_application_runner.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nuntius
+  # This is the default runner used for runners in Nuntius, you can insert your
+  # own in the Nuntius configuration in your Rails Nuntius initializer.
+  class BasicApplicationRunner
+    def call
+      perform
+    end
+
+    class << self
+      delegate :call, to: :new
+    end
+  end
+end

data/app/runners/nuntius/timebased_events_runner.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class TimebasedEventsRunner < ApplicationRunner
+    def perform
+      Nuntius::Template.where.not(interval: nil).each do |template|
+        messenger = Nuntius::BaseMessenger.messenger_for_class(template.klass)
+
+        messenger.timebased_scope_for(template).each do |object|
+          Nuntius.event(template.event, object)
+        end
+      end
+    end
+  end
+end

data/app/services/nuntius/application_service.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class ApplicationService < Servitium::Service
+    transactional true
+  end
+end