nuntius 0.1.1 → 1.0.27

data/db/migrate/20201121185718_create_nuntius_inbound_messages.rb

@@ -0,0 +1,21 @@
+class CreateNuntiusInboundMessages < ActiveRecord::Migration[6.0]
+  def change
+    create_table :nuntius_inbound_messages, id: :uuid do |t|
+      t.string :status, default: 'pending'
+      t.string :transport
+      t.string :provider
+      t.string :provider_id
+      t.string :from
+      t.string :to
+      t.string :cc
+      t.string :subject
+      t.text :html
+      t.text :text
+      t.jsonb :payload
+      t.jsonb :metadata
+      t.string :digest
+
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20220412114148_add_last_sent_to_message.rb

@@ -0,0 +1,5 @@
+class AddLastSentToMessage < ActiveRecord::Migration[6.0]
+  def change
+    add_column :nuntius_messages, :last_sent_at, :datetime, null: true
+  end
+end

data/lib/nuntius/active_record_helpers.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'nuntiable'
+require_relative 'devise'
+require_relative 'state_machine'
+require_relative 'transactio'
+
+module Nuntius::ActiveRecordHelpers
+  extend ActiveSupport::Concern
+
+  included do
+    delegate :nuntiable?, to: :class
+  end
+
+  class_methods do
+    def nuntiable(options = {})
+      @_nuntius_nuntiable_options = options
+      include Nuntius::Nuntiable
+      include Nuntius::StateMachine if options[:use_state_machine]
+      include Nuntius::Devise if options[:override_devise]
+      include Nuntius::Transactio
+    end
+
+    def nuntiable?
+      included_modules.include?(Nuntius::Nuntiable)
+    end
+  end
+end

data/lib/nuntius/active_storage_helpers.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Nuntius::ActiveStorageHelpers
+  extend ActiveSupport::Concern
+  included do
+    has_one_attached :content, service: Nuntius.config.active_storage_service
+  end
+end

data/lib/nuntius/configuration.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class Configuration
+    attr_accessor :admin_authentication_module, :base_controller, :base_runner, :layout, :admin_layout, :jobs_queue_name, :visible_scope, :add_metadata, :metadata_fields, :default_template_scope, :allow_custom_events, :active_storage_service
+    attr_writer :logger, :host, :metadata_humanize, :default_params
+
+    attr_reader :transports, :providers
+
+    def initialize
+      @logger = Logger.new(STDOUT)
+      @logger.level = Logger::INFO
+      @base_controller = '::ApplicationController'
+      @base_runner = 'Nuntius::BasicApplicationRunner'
+      @nuntiable_classes = []
+      @nuntiable_class_names = []
+      @transports = []
+      @providers = {}
+      @jobs_queue_name = :message
+      @visible_scope = -> { all }
+      @add_metadata = -> {}
+      @metadata_fields = {}
+      @metadata_humanize = ->(data) { data.inspect }
+      @default_template_scope = ->(_object) { all }
+      @allow_custom_events = false
+      @layout = 'application'
+      @admin_layout = 'application'
+      @active_storage_service = nil
+    end
+
+    # logger [Object].
+    def logger
+      @logger.is_a?(Proc) ? instance_exec(&@logger) : @logger
+    end
+
+    def host(message)
+      @host.is_a?(Proc) ? instance_exec(message, &@host) : @host
+    end
+
+    # Make the part that is important for visible readable for humans
+    def metadata_humanize(metadata)
+      @metadata_humanize.is_a?(Proc) ? instance_exec(metadata, &@metadata_humanize) : @metadata_humanize
+    end
+
+    # admin_mount_point [String].
+    def admin_mount_point
+      @admin_mount_point ||= '/nuntius'
+    end
+
+    def add_nuntiable_class(klass)
+      @nuntiable_class_names = []
+      @nuntiable_classes << klass.to_s unless @nuntiable_classes.include?(klass.to_s)
+    end
+
+    def nuntiable_class_names
+      return @nuntiable_class_names if @nuntiable_class_names.present?
+
+      compile_nuntiable_class_names!
+    end
+
+    def provider(provider, transport:, priority: 1, timeout: 0, settings: {})
+      if @transports.include? transport
+        @providers[transport.to_sym] ||= []
+        @providers[transport.to_sym].push(provider: provider, priority: priority, timeout: timeout, settings: settings)
+      else
+        Nuntius.logger.warn "provider #{provider} not enabled as transport #{transport} is not enabled"
+      end
+    end
+
+    def transport(transport)
+      @transports.push(transport) if transport
+    end
+
+    def default_params(transaction_log_entry)
+      @default_params.is_a?(Proc) ? instance_exec(transaction_log_entry, &@default_params) : @default_params
+    end
+
+    private
+
+    def compile_nuntiable_class_names
+      names = []
+      names << 'Custom' if allow_custom_events
+
+      @nuntiable_classes.each do |klass_name|
+        klass = klass_name.constantize
+        names << klass.name
+        names += klass.descendants.map(&:name)
+      end
+
+      names.sort!
+    end
+
+    def compile_nuntiable_class_names!
+      @nuntiable_class_names = compile_nuntiable_class_names
+    end
+  end
+end

data/lib/nuntius/deprecator.rb

@@ -0,0 +1,8 @@
+module Nuntius
+  class Deprecator
+    def deprecation_warning(deprecated_method_name, message, _caller_backtrace = nil)
+      message = "#{deprecated_method_name} is deprecated and will be removed from Nuntius | #{message}"
+      Kernel.warn message
+    end
+  end
+end

data/lib/nuntius/devise.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nuntius
+  module Devise
+    extend ActiveSupport::Concern
+
+    included do
+      raise "#{name} must be nuntiable" unless nuntiable?
+
+      orchestrator = Evento::Orchestrator.new(self)
+      orchestrator.define_event_methods_on(messenger, devise: true) { |object, options = {}| }
+
+      orchestrator.override_devise_notification do |notification, *devise_params|
+        # All notifications have either a token as the first param, or nothing
+        Nuntius.event(notification, self, { token: devise_params.first })
+      end
+    end
+  end
+end

data/lib/nuntius/engine.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class Engine < ::Rails::Engine
+    isolate_namespace Nuntius
+
+    initializer 'nuntius.config' do |_app|
+      path = File.expand_path(File.join(File.dirname(__FILE__), '.', 'liquid', '{tags,filters}', '*.rb'))
+      Dir.glob(path).each do |c|
+        require_dependency(c)
+      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
+
+    initializer 'active_storage.attached' do
+      config.after_initialize do
+        ActiveSupport.on_load(:active_record) do
+          Nuntius::Attachment.include(Nuntius::ActiveStorageHelpers)
+        end
+      end
+    end
+
+    #
+    # initializer "webpacker.proxy" do |app|
+    #   insert_middleware = begin
+    #     Nuntius.webpacker.config.dev_server.present?
+    #   rescue
+    #     nil
+    #   end
+    #   next unless insert_middleware
+    #
+    #   app.middleware.insert_before(
+    #     0, Webpacker::DevServerProxy, # "Webpacker::DevServerProxy" if Rails version < 5
+    #     ssl_verify_none: true,
+    #     webpacker: Nuntius.webpacker
+    #   )
+    # end
+  end
+end

data/lib/nuntius/i18n_store.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'i18n/core_ext/hash'
+
+module Nuntius
+  begin
+    require 'oj'
+    class JSON
+      class << self
+        def encode(value)
+          Oj::Rails.encode(value)
+        end
+
+        def decode(value)
+          Oj.load(value)
+        end
+      end
+    end
+  rescue LoadError
+    require 'active_support/json'
+    JSON = ActiveSupport::JSON
+  end
+
+  class I18nStore
+    def initialize; end
+
+    def keys
+      return [] unless template
+
+      result = []
+      locales.each do |locale|
+        result += flat_hash(locale.data).keys
+      end
+      result
+    end
+
+    def [](key)
+      return unless template
+
+      result = {}
+      locales.each do |locale|
+        hash = flat_hash(locale.data).transform_values { |v| JSON.encode(v) }
+        result.merge! hash
+      end
+      result[key]
+    end
+
+    def []=(key, value)
+      # NOOP
+    end
+
+    def with(template)
+      with_custom_backend do
+        self.template = template
+        yield(template)
+        self.template = nil
+      end
+    end
+
+    def template
+      Thread.current[:nuntius_i18n_store_template]
+    end
+
+    def template=(template)
+      Thread.current[:nuntius_i18n_store_template] = template
+    end
+
+    private
+
+    def with_custom_backend
+      Thread.current[:nuntius_i18n_store_old_backend] = I18n.backend
+      I18n.backend = I18n::Backend::Chain.new(custom_i18n_backend, I18n.backend)
+
+      yield
+
+      I18n.backend = Thread.current[:nuntius_i18n_store_old_backend]
+    end
+
+    def locales
+      Nuntius::Locale.all
+    end
+
+    def flat_hash(hash = {})
+      (hash || {}).reduce({}) do |a, (k, v)|
+        tmp = v.is_a?(Hash) ? flat_hash(v).map { |k2, v2| ["#{k}.#{k2}", v2] }.to_h : { k => v }
+        a.merge(tmp)
+      end
+    end
+
+    # Yield our own custom backend
+    def custom_i18n_backend
+      return @custom_i18n_backend if @custom_i18n_backend
+
+      @custom_i18n_backend = I18n::Backend::KeyValue.new(Nuntius.i18n_store)
+      @custom_i18n_backend.class.send(:include, I18n::Backend::Cascade)
+
+      @custom_i18n_backend
+    end
+  end
+end

data/lib/nuntius/liquid/tags/attach_tag.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# Attaches files (from URL)
+#
+# == Basic usage:
+#    {%attach 'https://www.boxture.com/assets/images/logo.png'%}
+#
+class AttachTag < LiquidumTag
+  def render(context)
+    super
+
+    return unless argv1
+
+    message = context.registers['message']
+
+    if argv1.is_a? String
+      message.add_attachment({ url: argv1 })
+    elsif argv1.instance_of?(ActiveStorageAttachedOneDrop) || argv1.instance_of?(ActiveStorage::AttachmentDrop)
+
+      io = StringIO.new(argv1.download)
+      io.rewind
+      content_type = argv1.content_type
+      filename = argv1.filename
+
+      if arg(:convert) == 'pdf' && content_type != 'application/pdf'
+        content_type = 'application/pdf'
+        pdf = Labelary::Label.render(zpl: io.read,
+                                     content_type: content_type,
+                                     dpmm: 8,
+                                     width: arg(:width).blank? ? 4 : arg(:width),
+                                     height: arg(:height).blank? ? 6 : arg(:height))
+
+        io = StringIO.new(pdf)
+        filename = "#{filename}.pdf"
+      end
+
+      message.add_attachment({ content: io, filename: filename, content_type: content_type })
+    end
+
+    ''
+  end
+end
+
+Liquid::Template.register_tag('attach', AttachTag)

data/lib/nuntius/mail_allow_list.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'mail'
+
+module Nuntius
+  class MailAllowList
+    def initialize(allow_list = [])
+      allow_list = [] if allow_list.blank?
+      @allow_list = allow_list.map(&:downcase)
+    end
+
+    def allowed?(email)
+      return true if @allow_list.blank?
+
+      mail_to = Mail::Address.new(email.downcase)
+      allow_list_match = @allow_list.detect do |allow|
+        allow == (allow.include?('@') ? mail_to.to_s : mail_to.domain)
+      end
+
+      allow_list_match.present?
+    end
+  end
+end

data/lib/nuntius/nuntiable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Nuntius
+  module Nuntiable
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def nuntiable_options
+        @_nuntius_nuntiable_options || {}
+      end
+
+      def messenger
+        Nuntius::BaseMessenger.messenger_for_class(name)
+      end
+    end
+
+    included do
+      raise "Nuntius Messenger has not been implemented for class #{name}" unless messenger
+
+      Nuntius.config.add_nuntiable_class(self)
+      has_many :messages, as: :nuntiable, class_name: 'Nuntius::Message'
+    end
+  end
+end

data/lib/nuntius/state_machine.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Nuntius
+  module StateMachine
+    extend ActiveSupport::Concern
+
+    included do
+      raise "#{name} must be nuntiable" unless nuntiable?
+
+      orchestrator = Evento::Orchestrator.new(self)
+      orchestrator.define_event_methods_on(messenger, state_machine: true) { |object, options = {}| }
+
+      orchestrator.after_audit_trail_commit(:nuntius) do |resource_state_transition|
+        resource = resource_state_transition.resource
+        Nuntius.event(event, resource) if resource.nuntiable? && event.present?
+      end
+    end
+  end
+end

data/lib/nuntius/transactio.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Nuntius
+  module Transactio
+    extend ActiveSupport::Concern
+
+    included do
+      raise "#{name} must be nuntiable" unless nuntiable?
+
+      orchestrator = Evento::Orchestrator.new(self)
+      if nuntiable_options[:life_cycle]
+        orchestrator.define_event_methods_on(messenger, life_cycle: true) do |object, options = {}|
+        end
+      end
+
+      orchestrator = Evento::Orchestrator.new(self)
+      orchestrator.after_transaction_log_commit(:nuntius) do |transaction_log_entry|
+        resource = transaction_log_entry.transaction_loggable
+        event = transaction_log_entry.event
+
+        if resource.present? && event.present? && resource.nuntiable?
+          params = Nuntius.config.default_params(transaction_log_entry)
+
+          Nuntius.event(event, resource, params)
+          Nuntius.event('save', resource, params) if %w[create update].include?(event)
+        end
+      end
+    end
+  end
+end

data/lib/nuntius/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nuntius
-  VERSION = "0.1.1"
+  VERSION = "1.0.27"
 end

data/lib/nuntius.rb

@@ -1,11 +1,77 @@
-require 'openssl'
+# frozen_string_literal: true
+
+require 'auxilium'
+require 'inky'
+require 'httpclient'
+require 'liquidum'
+require 'premailer'
+require 'state_machines-activerecord'
+require 'servitium'
+
+require 'nuntius/deprecator'
+require 'nuntius/engine'
+require 'nuntius/configuration'
+require 'nuntius/active_record_helpers'
+require 'nuntius/active_storage_helpers'
+require 'nuntius/i18n_store'
+require 'nuntius/mail_allow_list'
 
 module Nuntius
-  class Error < RuntimeError; end
-end
+  ROOT_PATH = Pathname.new(File.join(__dir__, '..'))
+
+  class Error < StandardError; end
+
+  class << self
+    attr_reader :config
+
+    def setup
+      @config = Configuration.new
+      yield config
+    end
+
+    def i18n_store
+      @i18n_store ||= Nuntius::I18nStore.new
+    end
 
-require "nuntius/version"
-require "nuntius/encodings"
-require "nuntius/key"
-require "nuntius/envelope"
-require "nuntius/messenger"
+    #
+    # Fires an event for use with templates with the object
+    #
+    # Nuntius.event(:your_event, car)
+    #
+    # When custom events are enabled you can also do the following:
+    #
+    # Nuntius.event('shipped', { shipped: { to: 'test@example.com', ref: 'Test-123'} }, attachments: [ { url: 'http://example.com' } ])
+    #
+    def event(event, obj, params = {})
+      return unless event
+      return unless obj.is_a?(Hash) || obj.nuntiable?
+      return unless templates?(obj, event)
+
+      options = params[:options] || {}
+
+      if options[:perform_now] == true
+        Nuntius::MessengerJob.perform_now(obj, event.to_s, params)
+      else
+        job = Nuntius::MessengerJob
+        job.set(wait: options[:wait]) if options[:wait]
+        job.perform_later(obj, event.to_s, params)
+      end
+    end
+
+    def active_storage_enabled?
+      ActiveRecord::Base.connection.table_exists? 'active_storage_attachments'
+    end
+
+    def templates?(obj, event)
+      Nuntius::Template.where(klass: Nuntius::BaseMessenger.class_names_for(obj),
+                              event: Nuntius::BaseMessenger.event_name_for(
+                                obj, event
+                              )).where(enabled: true).count.positive?
+    end
+  end
+
+  # Include helpers
+  ActiveSupport.on_load(:active_record) do
+    include Nuntius::ActiveRecordHelpers
+  end
+end

data/lib/preamble.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Preamble
+  DEFAULTS = {
+    external_encoding: Encoding.default_external
+  }.freeze
+
+  attr_accessor :metadata, :content
+
+  def initialize(metadata, content)
+    @metadata = metadata
+    @content  = content
+  end
+
+  def metadata_with_content
+    @metadata.to_yaml + "---\n" + @content
+  end
+
+  def dump
+    metadata_with_content
+  end
+
+  def save(path, options = {})
+    options = DEFAULTS.merge(options)
+
+    open(path, "w:#{options[:external_encoding]}") do |f|
+      f.write metadata_with_content
+    end
+  end
+
+  def self.parse(data)
+    preamble_lines = +''
+    content_lines  = +''
+
+    state = :before_preamble
+
+    f = StringIO.new(data)
+    f.each do |line|
+      stripped = line.strip
+
+      case state
+      when :before_preamble
+
+        new_state = case stripped
+                    when '---'
+                      :preamble
+                    when ''
+                      :before_preamble
+                    else
+                      content_lines << line
+                      :after_preamble
+                    end
+
+      when :preamble
+
+        new_state = case stripped
+                    when '---'
+                      :after_preamble
+                    else
+                      preamble_lines << line
+                      :preamble
+                    end
+
+      when :after_preamble
+        new_state = :after_preamble
+        content_lines << line
+
+      else
+        raise "Invalid State: #{state}"
+      end
+
+      state = new_state
+    end
+
+    new(YAML.safe_load(preamble_lines), content_lines)
+  end
+
+  def self.load(path, options = {})
+    f = open(path, "r:#{options[:external_encoding]}")
+    parse(f.read)
+  end
+
+  def self.load_multiple(*paths)
+    options = paths.last.is_a?(Hash) ? paths.pop : {}
+    paths.map { |path| Preamble.load(path, options) }
+  end
+end

data/lib/tasks/nuntius_tasks.rake

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+desc 'Release a new version'
+namespace :nuntius do
+  task :release do
+    version_file = './lib/nuntius/version.rb'
+    File.open(version_file, 'w') do |file|
+      file.puts <<~EOVERSION
+        # frozen_string_literal: true
+
+        module Nuntius
+          VERSION = '#{Nuntius::VERSION.split('.').map(&:to_i).tap { |parts| parts[2] += 1 }.join('.')}'
+        end
+      EOVERSION
+    end
+    module Nuntius
+      remove_const :VERSION
+    end
+    load version_file
+    puts "Updated version to #{Nuntius::VERSION}"
+
+    `git commit lib/nuntius/version.rb -m "Version #{Nuntius::VERSION}"`
+    `git push`
+    `git tag #{Nuntius::VERSION}`
+    `git push --tags`
+  end
+end