nuntius 0.1.2 → 1.0.27

data/app/controllers/nuntius/admin/messages_controller.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_admin_controller'
+
+module Nuntius
+  module Admin
+    class MessagesController < ApplicationAdminController
+      def index
+        @messages = Nuntius::Message.visible.order(created_at: :desc)
+        @messages = @messages.where(template_id: params[:template_id]) if params[:template_id]
+      end
+
+      def show
+        @message = Nuntius::Message.visible.find(params[:id])
+      end
+
+      def resend
+        @message = Nuntius::Message.visible.find(params[:id])
+        @message.resend
+        respond_with @message, success: t('.resend_success'), error: t('.resend_error')
+      end
+    end
+  end
+end

data/app/controllers/nuntius/admin/templates_controller.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_admin_controller'
+
+module Nuntius
+  module Admin
+    class TemplatesController < ApplicationAdminController
+      before_action :set_objects, except: [:index]
+
+      def index
+        @templates = Nuntius::Template.visible.order(:description)
+      end
+
+      def new
+        @template = Nuntius::Template.new
+        render :edit
+      end
+
+      def create
+        @template = Nuntius::Template.new(template_params)
+        @template.save
+        respond_with :admin, @template, action: :edit
+      end
+
+      def edit
+        @template = Nuntius::Template.visible.find(params[:id])
+      end
+
+      def show
+        redirect_to :edit_admin_template, status: :see_other
+      end
+
+      def update
+        @template = Nuntius::Template.visible.find(params[:id])
+        @template.update(template_params)
+        respond_with :admin, @template
+      end
+
+      def destroy
+        @template = Nuntius::Template.visible.find(params[:id])
+        @template.destroy
+        respond_with :admin, @template
+      end
+
+      private
+
+      def set_objects
+        @layouts = Nuntius::Layout.visible
+      end
+
+      def template_params
+        params.require(:template).permit(:enabled, :klass, :event, :interval, :transport, :description, :metadata_yaml, :payload, :from, :to, :subject, :layout_id, :html, :text, :payload)
+      end
+    end
+  end
+end

data/app/controllers/nuntius/api/events_controller.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_controller'
+
+module Nuntius
+  class Api::EventsController < ApplicationController
+    skip_before_action :verify_authenticity_token
+
+    layout false
+
+    def create
+      nuntius_params = params.except(:scope, :event, :context, :controller, :action).permit!.to_h
+      Nuntius.event(params[:event], { params[:scope] => params[:context].permit!.to_h }, nuntius_params)
+    end
+  end
+end

data/app/controllers/nuntius/application_admin_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_controller'
+
+module Nuntius
+  class ApplicationAdminController < ApplicationController
+    include Nuntius.config.admin_authentication_module.constantize if Nuntius.config.admin_authentication_module
+
+    layout Nuntius.config.admin_layout
+  end
+end

data/app/controllers/nuntius/application_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class ApplicationController < Nuntius.config.base_controller.constantize
+    self.responder = Auxilium::Responder
+    respond_to :html
+
+    protect_from_forgery with: :exception
+
+    layout Nuntius.config.layout
+  end
+end

data/app/controllers/nuntius/callbacks_controller.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_controller'
+require 'preamble'
+
+module Nuntius
+  class CallbacksController < ApplicationController
+    skip_before_action :verify_authenticity_token
+
+    layout false
+
+    def create
+      message = Nuntius::Message.find(params[:message_id])
+      response = message.nuntius_provider(message).callback(params)
+
+      render body: response[2].first,
+             content_type: response[1]['Content-Type'],
+             layout: false
+    end
+  end
+end

data/app/controllers/nuntius/dashboard_controller.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_admin_controller'
+
+module Nuntius
+  class DashboardController < ApplicationAdminController
+    def show
+      @templates = Nuntius::Template.visible.all
+      @messages = Nuntius::Message.visible.order(created_at: :desc).limit(10)
+    end
+  end
+end

data/app/controllers/nuntius/feedback_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_controller'
+require 'httpclient'
+
+module Nuntius
+  class FeedbackController < ApplicationController
+    skip_before_action :verify_authenticity_token
+
+    layout false
+
+    def awssns
+      Nuntius::AwsSnsProcessorService.perform(notification: ::JSON.parse(request.body.read))
+      head :ok
+    end
+  end
+end

data/app/controllers/nuntius/inbound_messages/twilio_inbound_smses_controller.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_controller'
+require 'twilio-ruby'
+
+module Nuntius
+  module InboundMessages
+    class TwilioInboundSmsesController < ApplicationController
+      skip_before_action :verify_authenticity_token
+
+      layout false
+
+      # Point twilio to you nuntius mount path (/nuntius/inbound_messages/twilio_inbound_smses)
+      # { 'ToCountry' => 'NL',
+      #   'ToState' => '',
+      #   'SmsMessageSid' => 'SMb711289e438f577f230f5837e9c74a08',
+      #   'NumMedia' => '0',
+      #   'ToCity' => '',
+      #   'FromZip' => '',
+      #   'SmsSid' => 'SMb711289e438f577f230f5837e9c74a08',
+      #   'FromState' => '',
+      #   'SmsStatus' => 'received',
+      #   'FromCity' => '',
+      #   'Body' => 'St',
+      #   'FromCountry' => 'NL',
+      #   'To' => '+3197014204768',
+      #   'MessagingServiceSid' => 'MG790b6bd09f119b54ffb7f03b8841b1c9',
+      #   'ToZip' => '',
+      #   'NumSegments' => '1',
+      #   'MessageSid' => 'SMb711289e438f577f230f5837e9c74a08',
+      #   'AccountSid' => 'ACf54dd7a47a8011d65b54d472a7190549',
+      #   'From' => '+31641085630',
+      #   'ApiVersion' => '2010-04-01',
+      #   'controller' => 'nuntius/inbound_messages/twilio_inbound_smses',
+      #   'action' => 'create' }
+      def create
+        inbound_message = Nuntius::InboundMessage.find_or_create_by!(transport: 'sms', provider: 'twilio', provider_id: params[:SmsSid])
+        inbound_message.from = params[:From]
+        inbound_message.to = params[:To]
+        inbound_message.text = params[:Body]
+        inbound_message.metadata = params
+        inbound_message.save!
+
+        twiml = Nuntius::DeliverInboundMessageService.new(inbound_message).call
+
+        # twiml = Twilio::TwiML::MessagingResponse.new do |resp|
+        #   resp.message body: 'The Robots are coming! Head for the hills!'
+        # end
+
+        render body: twiml.to_s,
+               content_type: 'text/xml',
+               layout: false
+      end
+    end
+  end
+end

data/app/controllers/nuntius/messages_controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_dependency 'nuntius/application_controller'
+
+module Nuntius
+  class MessagesController < ApplicationController
+    layout false
+
+    def show
+      @message = Nuntius::Message.find(params[:id])
+    end
+  end
+end

data/app/drops/nuntius/application_drop.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class ApplicationDrop < Liquid::Drop
+    def initialize(object)
+      @object = object
+    end
+
+    def to_gid
+      @object.to_gid
+    end
+
+    def to_sgid
+      @object.to_sgid
+    end
+  end
+end

data/app/drops/nuntius/campaign_drop.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class CampaignDrop < ApplicationDrop
+    delegate :id, :metadata, to: :@object
+  end
+end

data/app/drops/nuntius/layout_drop.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class LayoutDrop < ApplicationDrop
+    delegate :name, :metadata, :layout, to: :@object
+
+    def attachments
+      ActiveStorageAttachedManyDrop.new(@object.attachments)
+    end
+  end
+end

data/app/drops/nuntius/message_drop.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class MessageDrop < ApplicationDrop
+    delegate :id, :from, :to, :subject, :html, :text, to: :@object
+
+    def base_url
+      Nuntius::Engine.routes.url_helpers.message_url(@object.id, host: host)
+    end
+  end
+end

data/app/drops/nuntius/template_drop.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class TemplateDrop < ApplicationDrop
+    delegate :id, :metadata, :layout, to: :@object
+  end
+end

data/app/exceptions/nuntius/base_exception.rb

@@ -0,0 +1,4 @@
+module Nuntius
+  class BaseException < StandardError
+  end
+end

data/app/exceptions/nuntius/missing_messenger_exception.rb

@@ -0,0 +1,4 @@
+module Nuntius
+  class MissingMessengerException < BaseException
+  end
+end

data/app/helpers/nuntius/application_helper.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Nuntius
+  module ApplicationHelper
+    def nuntius_dashboard_menu
+      Satis::Menus::Builder.build(:dashboard) do |m|
+        m.item :templates, link: nuntius.admin_templates_path, icon: 'fal fa-file'
+        m.item :layouts, link: nuntius.admin_layouts_path, icon: 'fal fa-table-layout'
+        m.item :locales, link: nuntius.admin_locales_path, icon: 'fal fa-language'
+        m.item :campaigns, link: nuntius.admin_campaigns_path, icon: 'fal fa-megaphone'
+        m.item :lists, link: nuntius.admin_lists_path, icon: 'fal fa-address-book'
+      end
+    end
+
+    def nuntius_templates_menu
+      Satis::Menus::Builder.build(:templates) do |m|
+        m.item :new, link: nuntius.new_admin_template_path
+      end
+    end
+
+    def nuntius_messages_menu
+      Satis::Menus::Builder.build(:messages) do |m|
+        m.item :new, link: nuntius.new_admin_message_path
+      end
+    end
+
+    def nuntius_layouts_menu
+      Satis::Menus::Builder.build(:layouts) do |m|
+        m.item :new, link: nuntius.new_admin_layout_path
+      end
+    end
+
+    def nuntius_locales_menu
+      Satis::Menus::Builder.build(:locales) do |m|
+        m.item :new, link: nuntius.new_admin_locale_path
+      end
+    end
+
+    def nuntius_campaigns_menu
+      Satis::Menus::Builder.build(:campaign) do |m|
+        m.item :new, link: nuntius.new_admin_campaign_path
+        m.item :lists, link: nuntius.admin_lists_path
+      end
+    end
+
+    def nuntius_lists_menu
+      Satis::Menus::Builder.build(:lists) do |m|
+        m.item :new, link: nuntius.new_admin_list_path
+      end
+    end
+
+    def nuntius_list_menu
+      Satis::Menus::Builder.build(:lists) do |m|
+        m.item :new_subscriber, link: nuntius.new_admin_list_subscriber_path(@list) if @list.persisted?
+      end
+    end
+
+    def present(model, presenter_class = nil)
+      array = nil
+      if model.is_a? Array
+        array = model
+        model = model.first
+      end
+
+      klass = presenter_class || "#{model.class}Presenter".constantize
+      presenter = array ? array.map { |m| klass.new(m) } : klass.new(model)
+      yield(presenter) if block_given?
+    end
+
+    def method_missing(method, *args, &block)
+      if main_app.respond_to?(method)
+        main_app.send(method, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/app/jobs/nuntius/application_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class ApplicationJob < ActiveJob::Base
+    retry_on ActiveJob::DeserializationError
+    retry_on ActiveRecord::Deadlocked
+    queue_as Nuntius.config.jobs_queue_name
+  end
+end

data/app/jobs/nuntius/deliver_inbound_message_job.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Initializes the appropriate Messenger class and calls the event method
+module Nuntius
+  class DeliverInboundMessageJob < ApplicationJob
+    def perform(inbound_message)
+      Nuntius::DeliverInboundMessageService.new(inbound_message).call
+    end
+  end
+end

data/app/jobs/nuntius/messenger_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Initializes the appropriate Messenger class and calls the event method
+module Nuntius
+  class MessengerJob < ApplicationJob
+    def perform(obj, event, params = {})
+      return unless obj
+
+      messenger = Nuntius::BaseMessenger.messenger_for_obj(obj).new(obj, event, params)
+      return unless messenger.is_a?(Nuntius::CustomMessenger) || messenger.respond_to?(event.to_sym)
+
+      messenger.call
+      templates = messenger.templates
+      messenger.dispatch(templates) if templates.present?
+    end
+  end
+end

data/app/jobs/nuntius/process_inbound_message_job.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Initializes the appropriate Messenger class and calls the event method
+module Nuntius
+  class ProcessInboundMessageJob < ApplicationJob
+    def perform(inbound_message)
+      Nuntius::DeliverInboundMessageService.perform(inbound_message: inbound_message)
+    end
+  end
+end

data/app/jobs/nuntius/purge_message_job.rb

@@ -0,0 +1,13 @@
+module Nuntius
+  class PurgeMessageJob < ApplicationJob
+    def perform(account_id, months)
+      messages = Nuntius::Message.distinct.select(:id).where("metadata ->> 'account_id' = :account", account: account_id)
+      .where(created_at: ..months.months.ago.beginning_of_day)
+      .where.not(status: %w[complaint bounced])
+
+      Nuntius::Message.where(parent_message_id: messages.pluck(:id)).in_batches.update_all(parent_message_id: nil)
+
+      messages.in_batches.destroy_all
+    end
+  end
+end

data/app/jobs/nuntius/retrieve_mail_job.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# Initializes the appropriate Messenger class and calls the event method
+module Nuntius
+  class RetrieveMailJob < ApplicationJob
+    def perform
+      klasses = Nuntius::BaseMessageBox.message_box_for(transport: :mail)
+
+      klasses.each do |klass|
+        RetrieveInboundMailService.new(klass.settings).call
+      end
+
+      Nuntius::InboundMessage.where(status: 'pending').each do |message|
+        Nuntius::DeliverInboundMessageJob.perform_later(message)
+      end
+    end
+  end
+end

data/app/jobs/nuntius/transport_delivery_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# This job will be called only once for each provider sent out to deliver the job
+module Nuntius
+  class TransportDeliveryJob < ApplicationJob
+    def perform(provider_name, message)
+      return if message.delivered_or_blocked?
+      return if message.parent_message&.delivered_or_blocked?
+
+      if message.provider != provider_name
+        original_message = message
+        message = message.dup
+        message.parent_message = original_message
+        message.status = 'pending'
+        message.provider_id = ''
+      end
+      message.provider = provider_name
+      message.save!
+
+      provider = Nuntius::BaseProvider.class_from_name(provider_name, message.transport).new(message)
+      message = provider.deliver
+      message.save! unless message.pending?
+
+      # First refresh check is after 5 seconds
+      if message.delivered_or_blocked?
+        message.cleanup!
+      else
+        Nuntius::TransportRefreshJob.set(wait: 5).perform_later(provider_name, message) unless Rails.env.development?
+      end
+    end
+  end
+end

data/app/jobs/nuntius/transport_refresh_job.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Initializes the appropriate Messenger class and calls the event method
+module Nuntius
+  class TransportRefreshJob < ApplicationJob
+    def perform(provider_name, message)
+      return if message.delivered_or_blocked? || message.refreshes >= 3
+
+      provider = Nuntius::BaseProvider.class_from_name(provider_name, message.transport).new(message)
+      message = provider.refresh
+      # FIXME: This may need to be more atomic
+      message.refreshes += 1
+      message.save!
+
+      if message.delivered_or_blocked?
+        message.cleanup!
+      else
+        Nuntius::TransportRefreshJob.set(wait: message.refreshes + 5).perform_later(provider_name, message)
+      end
+    end
+  end
+end

data/app/message_boxes/nuntius/base_message_box.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Nuntius
+  # Message boxes process inbound messages
+  class BaseMessageBox
+    class << self
+      attr_reader :routes
+
+      def provider(value = nil)
+        @provider = value.to_sym if value
+        @provider
+      end
+
+      def transport(value = nil)
+        @transport = value.to_sym if value
+        @transport
+      end
+
+      def route(mapping = nil)
+        @routes ||= {}
+        @routes = @routes.merge(mapping) if mapping.is_a?(Hash)
+        @routes
+      end
+
+      # Defines the settings
+      def settings(hash = {})
+        @settings = hash if hash
+        @settings
+      end
+
+      def deliver(message)
+        klasses = message_box_for(transport: message.transport.to_sym, provider: message.provider.to_sym)
+        klass, method = message_box_for_route(klasses, message.to)
+
+        klass.new(message).send(method) if method
+      end
+
+      def message_box_for(transport: nil, provider: nil)
+        result = descendants
+        result = result.select { |message_box| message_box.transport == transport } if transport
+        result = result.select { |message_box| message_box.provider == provider } if provider
+        result
+      end
+
+      def mail
+        return nil if transport != 'mail' && provider != 'imap'
+        return @mail if @mail
+
+        @mail = Mail.read(inbound_message.raw_message.download)
+      end
+
+      private
+
+      def descendants
+        ObjectSpace.each_object(Class).select { |k| k < self }
+      end
+
+      def message_box_for_route(message_boxes, recipients)
+        klass = message_boxes.find do |message_box|
+          routes = (message_box.routes || {})
+          routes.any? { |regexp, _method| [*recipients].any? { |recipient| regexp.match(recipient) } }
+        end
+        method = klass.routes.find { |regexp, _method| [*recipients].any? { |recipient| regexp.match(recipient) } }&.last if klass
+
+        [klass, method] if method
+      end
+    end
+
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+  end
+end