nuntius 0.1.2 → 1.0.27

data/app/messengers/nuntius/base_messenger.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Nuntius
+  # Messengers select templates, can manipulate them and
+  class BaseMessenger
+    include ActiveSupport::Callbacks
+
+    delegate :liquid_variable_name_for, :class_name_for, :class_names_for, :event_name_for, to: :class
+
+    define_callbacks :action, terminator: ->(_target, result_lambda) { result_lambda.call == false }
+
+    attr_reader :templates, :attachments, :event, :object, :params
+
+    def initialize(object, event, params = {})
+      @object = object
+      @event = event
+      @params = params
+      @attachments = params.fetch(:attachments, [])
+    end
+
+    # Calls the event method on the messenger
+    def call
+      select_templates
+      run_callbacks(:action) do
+        send(@event.to_sym, @object, @params) if respond_to?(@event.to_sym)
+      end
+    end
+
+    # Turns the templates in messages, and dispatches the messages to transports
+    def dispatch(filtered_templates)
+      filtered_templates.each do |template|
+        template.layout = override_layout(template.layout)
+        msg = template.new_message(@object, liquid_context, params)
+        @attachments.each do |attachment|
+          msg.add_attachment(attachment)
+        end
+
+        transport = Nuntius::BaseTransport.class_from_name(template.transport).new
+        transport.deliver(msg) if msg.to.present?
+      end
+    end
+
+    # Allow messengers to override the selected layout
+    def override_layout(selected_layout)
+      selected_layout
+    end
+
+    def attach(attachment)
+      @attachments << attachment
+    end
+
+    class << self
+      #
+      # Returns the variable name used in the liquid context
+      #
+      # @param [Object] obj Any object with a backing drop
+      #
+      # @return [String] underscored, lowercase string
+      #
+      def liquid_variable_name_for(obj)
+        return obj.keys.first.to_s if obj.is_a?(Hash)
+
+        plural = obj.is_a?(Array) || obj.is_a?(ActiveRecord::Relation)
+        list   = plural ? obj : [obj]
+        klass  = list.first.class
+        klass  = klass.base_class if klass.respond_to?(:base_class)
+        name   = klass.name.demodulize
+        name   = name.pluralize if plural
+        name.underscore
+      end
+
+      def class_name_for(obj)
+        if obj.is_a?(Array) || obj.is_a?(ActiveRecord::Relation)
+          obj.first.class.name.demodulize
+        elsif obj.is_a?(Hash)
+          'Custom'
+        elsif obj.is_a?(Class)
+          obj.name.demodulize
+        else
+          obj.class.name
+        end
+      end
+
+      def class_names_for(obj)
+        main_class_name = class_name_for(obj)
+
+        return [main_class_name] if !obj.class.respond_to?(:base_class?) || obj.class.base_class?
+
+        list = [main_class_name]
+        list << obj.class.base_class.name
+        list
+      end
+
+      def event_name_for(obj, event)
+        if obj.is_a?(Hash)
+          "#{obj.keys.first}##{event}"
+        else
+          event
+        end
+      end
+
+      def messenger_for_class(name)
+        klass = messenger_name_for_class(name).safe_constantize
+        klass ||= messenger_name_for_class(name.safe_constantize.superclass).safe_constantize
+        klass ||= messenger_name_for_class(name.safe_constantize.superclass.superclass).safe_constantize
+        klass
+      end
+
+      def messenger_name_for_class(name)
+        "#{name}Messenger"
+      end
+
+      def messenger_for_obj(obj)
+        return Nuntius::CustomMessenger if obj.is_a? Hash
+
+        klass = messenger_name_for_obj(obj).safe_constantize
+
+        # Lets check 2 levels above to see if a messager exists for a possible super class (think STI)
+        klass ||= messenger_name_for_obj(obj.class.superclass).safe_constantize
+        klass ||= messenger_name_for_obj(obj.class.superclass.superclass).safe_constantize
+
+        raise Nuntius::MissingMessengerException.new(self), "messenger missing for #{obj.class.name}" unless klass
+
+        klass
+      end
+
+      def messenger_name_for_obj(obj)
+        "#{class_name_for(obj)}Messenger"
+      end
+
+      def locale(locale = nil)
+        @locale = locale if locale
+        @locale
+      end
+
+      def template_scope(template_scope = nil)
+        @template_scope = template_scope if template_scope
+        @template_scope
+      end
+
+      def timebased_scopes
+        @timebased_scopes ||= {}
+      end
+
+      def timebased_scope(name, &scope_proc)
+        raise ArgumentError, 'timebased_scope must start with before or after' unless %w[before after].detect { |prefix| name.to_s.start_with?(prefix) }
+
+        name = name.to_sym
+        timebased_scopes[name] = scope_proc if scope_proc.present?
+        define_method(name) { |object, params = {}| } unless respond_to?(name)
+        timebased_scopes[name] || nil
+      end
+
+      def timebased_scope_for(template)
+        return [] unless timebased_scopes.include?(template.event.to_sym)
+
+        timebased_scope(template.event)
+          .call(template.interval_time_range, template.metadata)
+          .where("#{template.klass.constantize.table_name}.created_at > ?", template.created_at)
+          .where.not(
+            id: Nuntius::Message.select(:nuntiable_id)
+                                .where(template_id: template.id)
+          )
+      end
+    end
+
+    private
+
+    # Returns the relevant templates for the object / event combination
+    def select_templates
+      return @templates if @templates
+
+      @templates = Template.unscoped.where(klass: class_names_for(@object), event: event_name_for(@object, @event)).where(enabled: true)
+      @templates = @templates.instance_exec(@object, &Nuntius.config.default_template_scope)
+
+      # See if we need to do something additional
+      template_scope_proc = self.class.template_scope
+      @templates = @templates.instance_exec(@object, &template_scope_proc) if template_scope_proc
+
+      @templates
+    end
+
+    def liquid_context
+      assigns = @params || {}
+      instance_variables.reject { |i| %w[@params @object @locale @templates @template_scope].include? i.to_s }.each do |i|
+        assigns[i.to_s[1..-1]] = instance_variable_get(i)
+      end
+
+      context = { liquid_variable_name_for(@object) => (@object.is_a?(Hash) ? @object[@object.keys.first].deep_stringify_keys : @object) }
+      assigns.merge(context)
+    end
+  end
+end

data/app/messengers/nuntius/custom_messenger.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class CustomMessenger < BaseMessenger
+  end
+end

data/app/models/nuntius/application_record.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/metadata_scoped'
+
+module Nuntius
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    include Liquidum::ToLiquid
+  end
+end

data/app/models/nuntius/attachment.rb

@@ -0,0 +1,13 @@
+module Nuntius
+  class Attachment < ApplicationRecord
+    has_and_belongs_to_many :messages, class_name: 'Message'
+
+    delegate :download, :content_type, :filename, :signed_id, to: :content
+
+    begin
+      has_one_attached :content, service: Nuntius.config.active_storage_service
+    rescue StandardError
+      nil
+    end
+  end
+end

data/app/models/nuntius/campaign.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class Campaign < ApplicationRecord
+    include Nuntius::Concerns::MetadataScoped
+
+    belongs_to :list
+    accepts_nested_attributes_for :list, reject_if: :all_blank
+
+    belongs_to :layout, optional: true
+    has_many :messages, class_name: 'Nuntius::Message'
+    validates :name, presence: true
+
+    state_machine initial: :draft do
+      after_transition any => any, do: :do_after_transition
+
+      event :publish do
+        transition draft: :sending
+      end
+      event :sent do
+        transition sending: :sent
+      end
+    end
+
+    def deliver
+      t = BaseTransport.class_from_name(transport).new
+      list.subscribers.each do |subscriber|
+        t.deliver(new_message(subscriber))
+      end
+    end
+
+    def new_message(subscriber, assigns = {})
+      if subscriber.nuntiable
+        name = Nuntius::BaseMessenger.liquid_variable_name_for(subscriber.nuntiable)
+        assigns[name] = subscriber.nuntiable
+      end
+      message = Nuntius::Message.new(transport: transport, campaign: self, nuntiable: subscriber.nuntiable, metadata: metadata)
+
+      locale_proc = Nuntius::BaseMessenger.messenger_for_obj(subscriber.nuntiable).locale
+      locale = instance_exec(object, &locale_proc) if locale_proc
+
+      message.from = render(:from, assigns, locale)
+      message.to = if transport == 'mail'
+                     %["#{subscriber.first_name} #{subscriber.last_name}" <#{subscriber.email}>]
+                   elsif transport == 'sms'
+                     subscriber.phone_number
+                   elsif transport == 'voice'
+                     subscriber.phone_number
+                   end
+
+      message.subject = render(:subject, assigns, locale)
+      message.html = render(:html, assigns, locale, layout: layout&.data)
+
+      message
+    end
+
+    def translation_scope
+      scope = %w[nuntius]
+      scope << layout.name.underscore.tr(' ', '_') if layout
+      scope.join('.')
+    end
+
+    private
+
+    def render(attr, assigns, locale, options = {})
+      I18n.with_locale(locale) do
+        ::Liquidum.render(send(attr), assigns: assigns.merge(options.merge('campaign' => self)), registers: { 'campaign' => self })
+      end
+    end
+
+    def do_after_transition(transition)
+      deliver if transition.event == :publish
+    end
+  end
+end

data/app/models/nuntius/concerns/metadata_scoped.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Nuntius
+  module Concerns
+    module MetadataScoped
+      extend ActiveSupport::Concern
+
+      include Auxilium::Concerns::MetadataScoped
+
+      included do
+        scope :visible, -> { instance_exec(&Nuntius.config.visible_scope) }
+        before_save :add_metadata
+      end
+
+      private
+
+      def add_metadata
+        self.metadata ||= {}
+        unless Nuntius.config.metadata_fields.empty?
+          Nuntius.config.metadata_fields.each do |field, data|
+            if data[:current]
+              current = data[:current]
+              self.metadata[field.to_s] ||= instance_exec(&current)
+            end
+          end
+        end
+        instance_exec(&Nuntius.config.add_metadata)
+      end
+    end
+  end
+end

data/app/models/nuntius/concerns/yamlify.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Nuntius
+  module Concerns
+    module Yamlify
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def yamlify(attr)
+          define_method(:"#{attr}_yaml=") do |yaml|
+            write_attribute attr, YAML.safe_load(yaml.gsub("\t", '  '))
+          end
+
+          define_method(:"#{attr}_yaml") do
+            return '' if attributes[attr.to_s].blank?
+
+            YAML.dump(attributes[attr.to_s])
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/nuntius/inbound_message.rb

@@ -0,0 +1,14 @@
+module Nuntius
+  class InboundMessage < ApplicationRecord
+    has_one_attached :raw_message, service: Nuntius.config.active_storage_service
+    has_many_attached :attachments, service: Nuntius.config.active_storage_service
+
+    def mail
+      @mail ||= Mail.from_source(source)
+    end
+
+    def source
+      @source ||= raw_message.download
+    end
+  end
+end

data/app/models/nuntius/layout.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class Layout < ApplicationRecord
+    include Nuntius::Concerns::MetadataScoped
+    include Nuntius::Concerns::Yamlify
+
+    has_many_attached :attachments, service: Nuntius.config.active_storage_service
+    has_many :templates, dependent: :restrict_with_error
+
+    yamlify :metadata
+  end
+end

data/app/models/nuntius/list.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class List < ApplicationRecord
+    include Nuntius::Concerns::MetadataScoped
+
+    has_many :subscribers, counter_cache: :subscribers_count
+    accepts_nested_attributes_for :subscribers, reject_if: :all_blank
+  end
+end

data/app/models/nuntius/locale.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class Locale < ApplicationRecord
+    include Nuntius::Concerns::MetadataScoped
+    include Nuntius::Concerns::Yamlify
+
+    yamlify :data
+    yamlify :metadata
+  end
+end

data/app/models/nuntius/message.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Nuntius
+  # Stores individual messages to individual recipients
+  #
+  #
+  # Nuntius will have messages in states:
+  #   pending - nothing done yet
+  #   sent - we've sent it on to the provider
+  #   delivered - have delivery confirmation
+  #   undelivered - have confirmation of non-delivery
+  # Not all transports may provide all states
+  class Message < ApplicationRecord
+    include Nuntius::Concerns::MetadataScoped
+
+    has_and_belongs_to_many :attachments, class_name: 'Attachment'
+
+    belongs_to :campaign, optional: true
+    belongs_to :template, optional: true
+    belongs_to :parent_message, class_name: 'Message', optional: true
+    has_many :child_messages, class_name: 'Message', foreign_key: 'parent_message_id', dependent: :destroy
+    belongs_to :nuntiable, polymorphic: true, optional: true
+
+    validates :transport, presence: true
+
+    before_destroy :cleanup_attachments
+
+    # Weird loading sequence error, is fixed by the lib/nuntius/helpers
+    # begin
+    #   has_many_attached :attachments
+    # rescue NoMethodError
+    # end
+
+    def pending?
+      status == 'pending'
+    end
+
+    def sent?
+      status == 'sent'
+    end
+
+    def blocked?
+      status == 'blocked'
+    end
+
+    def delivered?
+      status == 'delivered'
+    end
+
+    def delivered_or_blocked?
+      delivered? || blocked?
+    end
+
+    def undelivered?
+      status == 'undelivered'
+    end
+
+    # Removes only pending child messages
+    def cleanup!
+      Nuntius::Message.where(status: 'pending').where(parent_message: self).destroy_all
+    end
+
+    def add_attachment(options)
+      attachment = {}
+
+      uri = options[:url] && URI.parse(options[:url])
+
+      if uri&.scheme == 'file'
+        attachment[:io] = File.open(uri.path)
+      elsif uri
+        client = HTTPClient.new
+        client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        client.ssl_config.set_default_paths unless Gem.win_platform?
+        response = client.get(options[:url], follow_redirect: true)
+        content_disposition = response.headers['Content-Disposition'] || ''
+        options[:filename] ||= content_disposition[/filename="([^"]+)"/, 1]
+        attachment[:content_type] = response.content_type
+        attachment[:io] = if response.body.is_a? String
+                            StringIO.new(response.body)
+                          else
+                            # Assume IO object
+                            response.body
+                          end
+      elsif options[:content].respond_to?(:read)
+        attachment[:content_type] = options[:content_type]
+        attachment[:io] = options[:content]
+      else
+        raise 'Cannot add attachment without url or content'
+      end
+
+      # Set the filename
+      attachment[:filename] = options[:filename] || uri.path.split('/').last || 'attachment'
+
+      # (Try to) add file extension if it is missing
+      file_extension = File.extname(attachment[:filename]).delete('.')
+      attachment[:filename] += ".#{Mime::Type.lookup(attachment[:content_type].split(';').first).to_sym}" if file_extension.blank? && attachment[:content_type]
+
+      # Fix content type if file extension known but content type blank
+      attachment[:content_type] ||= Mime::Type.lookup_by_extension(file_extension)&.to_s if file_extension
+
+      if options[:auto_zip] && attachment[:io].size > 1024 * 1024
+        zip_stream = Zip::OutputStream.write_buffer do |zio|
+          zio.put_next_entry attachment[:file_name]
+          zio.write attachment[:io].read
+        end
+        attachment[:content_type] = 'application/zip'
+        attachment[:io] = zip_stream
+      end
+
+      nuntius_attachment = Nuntius::Attachment.new
+      nuntius_attachment.content.attach(io: attachment[:io],
+                                        filename: attachment[:filename],
+                                        content_type: attachment[:content_type])
+
+      attachments.push(nuntius_attachment)
+    rescue StandardError => e
+      Nuntius.config.logger.error "Message: Could not attach #{attachment[:filename]} #{e.message}"
+    end
+
+    def cleanup_attachments
+      attachments.each do |attachment|
+        attachment.destroy if attachment.messages.where.not(id: id).blank?
+      end
+    end
+
+    def nuntius_provider(message)
+      klass = Nuntius::BaseProvider.class_from_name(provider, transport)
+      klass ||= Nuntius::BaseProvider
+      klass.new(message)
+    end
+
+    def resend
+      return if pending?
+      return unless transport
+
+      deliver_as(transport)
+    end
+
+    #
+    # Convenience method to easily send messages without having a template
+    #
+    def deliver_as(transport)
+      klass = BaseTransport.class_from_name(transport).new
+      klass.deliver(self)
+      self
+    end
+  end
+end

data/app/models/nuntius/subscriber.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class Subscriber < ApplicationRecord
+    belongs_to :list
+    belongs_to :nuntiable, polymorphic: true, optional: true
+
+    def name
+      [first_name, last_name].join(' ')
+    end
+  end
+end

data/app/models/nuntius/template.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class Template < ApplicationRecord
+    include Nuntius::Concerns::MetadataScoped
+    include Nuntius::Concerns::Yamlify
+
+    belongs_to :layout, optional: true
+    has_many :messages, class_name: 'Nuntius::Message', dependent: :nullify
+
+    LIQUID_TAGS = /{%(?:(?!%}).)*%}|{{(?:(?!}}).)*}}/.freeze
+
+    validates :description, presence: true
+    validates :from, liquid: true
+    validates :to, liquid: true
+    validates :subject, liquid: true
+    validates :html, liquid: true
+    validates :text, liquid: true
+
+    validates :event, presence: true
+    validates :event, format: { with: /.+#.+/ }, if: ->(t) { t.klass == 'Custom' }
+    validates :interval, format: { allow_blank: true, with: /\A[1-9][0-9]*\s(month|week|day|hour|minute)s?\z/ }
+
+    yamlify :metadata
+
+    def new_message(object, assigns = {}, params = {})
+      message = Nuntius::Message.new(template: self, transport: transport, metadata: metadata)
+      message.nuntiable = object unless object.is_a? Hash
+
+      locale_proc = Nuntius::BaseMessenger.messenger_for_obj(object).locale
+      locale = instance_exec(object, &locale_proc) if locale_proc
+      locale = params[:locale].to_sym if params[:locale]
+
+      options = { registers: { 'template' => self, 'message' => message } }
+
+      message.to = render(:to, assigns, locale, options).split(',').reject(&:empty?).join(',')
+      message.from = render(:from, assigns, locale, options).split(',').reject(&:empty?).join(',')
+      message.subject = render(:subject, assigns, locale, options)
+      message.html = render(:html, assigns, locale, options.merge(layout: layout&.data))
+      message.text = render(:text, assigns, locale, options)
+      message.payload = render(:payload, assigns, locale, options)
+
+      message
+    end
+
+    def translation_scope
+      scope = %w[]
+      scope << layout.name.underscore.tr(' ', '_') if layout
+      scope << klass.underscore.tr('/', '_')
+      scope << event
+      scope << transport
+      scope << description.underscore.gsub(/[^a-z]+/, '_') if description
+      scope.join('.')
+    end
+
+    # Trix correctly escapes the HTML, but for liquid this is not what we need.
+    # This replaces html-entities within the liquid tags ({%...%} and {{...}})
+    def html=(html)
+      html_unescaped_liquid = html.gsub(LIQUID_TAGS) do |m|
+        CGI.unescape_html(m)
+      end
+      write_attribute :html, html_unescaped_liquid if html
+    end
+
+    def interval_duration
+      unless interval.blank?
+        number, type = interval.split(' ')
+        number = number.to_i
+
+        return number.public_send(type) if number.respond_to?(type)
+      end
+
+      0.seconds
+    end
+
+    def interval_time_range
+      return 0.seconds..0.seconds if interval.blank?
+
+      start = if event.start_with?('before')
+                interval_duration.after
+              else
+                interval_duration.ago
+              end
+
+      (start - 1.hour)..start
+    end
+
+    private
+
+    def render(attr, assigns, locale, options = {})
+      I18n.with_locale(locale) do
+        if attr == :payload
+          YAML.safe_load(::Liquidum.render(send(attr), { assigns: assigns.merge('template' => self), registers: { 'template' => self } }.merge(options)))
+        elsif attr == :html
+          ::Liquidum.render(send(attr), { filter: 'markdown', assigns: assigns.merge('template' => self), registers: { 'template' => self } }.merge(options))
+        else
+          ::Liquidum.render(send(attr), { assigns: assigns.merge('template' => self), registers: { 'template' => self } }.merge(options))
+        end
+      end
+    end
+  end
+end