nuntius 1.0.27 → 1.1.4

data/app/providers/nuntius/base_provider.rb

@@ -13,10 +13,10 @@ module Nuntius
         @all_settings ||= []
       end
 
-      def setting_reader(name, required: false, default: nil, description: '')
+      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 }
+        define_method(name) { required ? settings.fetch(name) : settings[name] || default }
       end
 
       def transport(transport = nil)
@@ -31,7 +31,7 @@ module Nuntius
 
       def class_from_name(name, transport)
         Nuntius.const_get("#{name}_#{transport}_provider".camelize)
-      rescue StandardError
+      rescue
         nil
       end
     end
@@ -48,17 +48,17 @@ module Nuntius
 
     # Override this in implementation
     def callback(_params)
-      [404, { 'Content-Type' => 'text/html; charset=utf-8' }, ['Not found']]
+      [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
+      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'
+      self.class.states.find { |key, _value| key.is_a?(Array) ? key.include?(status) : key == status }&.last || "sent"
     end
 
     def settings

data/app/providers/nuntius/firebase_push_provider.rb

@@ -1,24 +1,24 @@
 # frozen_string_literal: true
 
-require 'fcm'
+require "fcm"
 
 module Nuntius
   class FirebasePushProvider < BaseProvider
     transport :push
 
-    setting_reader :server_key, required: true, description: 'Server key for the project, see Firebase console'
+    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 })
+      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.status = if response[:status_code] != 200 || response[:response] != "success"
+        "undelivered"
+      else
+        "sent"
+      end
 
       message
     end

data/app/providers/nuntius/houston_push_provider.rb

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
-require 'houston'
+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'
+      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.'
+      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'
+      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 = (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'))
+        alert: message.text, sound: "default"))
       apn.push(notification)
 
       message.status = if notification.sent?
-                         'sent'
-                       elsif !notification.valid? || notification.error
-                         'undelivered'
-                       end
+        "sent"
+      elsif !notification.valid? || notification.error
+        "undelivered"
+      end
       message
     end
   end

data/app/providers/nuntius/message_bird_sms_provider.rb

@@ -1,32 +1,32 @@
 # frozen_string_literal: true
 
-require 'messagebird'
+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 :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'
+    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.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.status = translated_status(response.recipients["items"].first.status)
+      Nuntius.config.logger.call.info "SMS #{message.to} status: #{message.status}"
       message
-    rescue StandardError => _e
+    rescue => _e
       message
     end
 

data/app/providers/nuntius/slack_slack_provider.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require 'slack'
+require "slack"
 
 module Nuntius
   class SlackSlackProvider < BaseProvider
     transport :slack
 
-    setting_reader :api_key, required: true, description: 'API key for the Slack workspace'
+    setting_reader :api_key, required: true, description: "API key for the Slack workspace"
 
     def deliver
       client = Slack::Web::Client.new(token: api_key)
@@ -24,11 +24,11 @@ module Nuntius
       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.status = if response["ok"]
+        "sent"
+      else
+        "undelivered"
+      end
 
       message
     end

data/app/providers/nuntius/smtp_mail_provider.rb

@@ -1,80 +1,88 @@
 # frozen_string_literal: true
 
-require 'mail'
+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])'
+    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
+        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
+          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|
+      mail.part content_type: "multipart/alternative" do |p|
         p.text_part = Mail::Part.new(
           body: message.text,
-          content_type: 'text/plain',
-          charset: 'UTF-8'
+          content_type: "text/plain",
+          charset: "UTF-8"
         )
         if message.html.present?
-          message.html = message.html.gsub('%7B%7Bmessage_url%7D%7D') { message_url(message) }
+          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'
+            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 }
+        mail.attachments[attachment.filename.to_s] = {mime_type: attachment.content_type, content: attachment.download}
       end
 
-      response = mail.deliver!
+      begin
+        response = mail.deliver!
+      rescue Net::SMTPFatalError
+        message.status = "rejected"
+        return message
+      rescue Net::SMTPServerBusy, Net::ReadTimeout
+        message.status = "undelivered"
+        return message
+      end
 
       message.provider_id = mail.message_id
-      message.status = 'undelivered'
-      message.status = 'sent' if Rails.env.test? ? true : response.success?
+      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.status = "blocked"
       message
     end
 
     private
 
     def message_url(message)
-      Nuntius::Engine.routes.url_helpers.message_url(message.id, host: Nuntius.config.host(message))
+      Nuntius::Engine.routes.url_helpers.message_url(message.id, host: Nuntius.config.host.call(message))
     end
   end
 end

data/app/providers/nuntius/teams_teams_provider.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class TeamsTeamsProvider < BaseProvider
+    transport :teams
+
+    def deliver
+      # NOTE: Attachments are not supported
+      # https://learn.microsoft.com/en-us/power-automate/overview-adaptive-cards
+      # https://learn.microsoft.com/en-us/microsoftteams/platform/webhooks-and-connectors/how-to/add-incoming-webhook?tabs=newteams%2Cdotnet
+
+      args = (message.payload || {}).merge(text: message.text)
+      response = Faraday.post(message[:to], JSON.dump(args), {"Content-Type": "application/json"})
+
+      message.status = if response.status == 200
+        "sent"
+      else
+        "undelivered"
+      end
+
+      message
+    end
+  end
+end

data/app/providers/nuntius/twilio_sms_provider.rb

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-require 'twilio-ruby'
+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 :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'
+    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)

data/app/providers/nuntius/twilio_voice_provider.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
-require 'twilio-ruby'
+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 :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'
+    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)
+      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
@@ -36,9 +36,9 @@ module Nuntius
       twiml = script_for_path(message, "/#{params[:path]}", params)
 
       if twiml
-        [200, { 'Content-Type' => 'application/xml' }, [twiml[:body]]]
+        [200, {"Content-Type" => "application/xml"}, [twiml[:body]]]
       else
-        [404, { 'Content-Type' => 'text/html; charset=utf-8' }, ['Not found']]
+        [404, {"Content-Type" => "text/html; charset=utf-8"}, ["Not found"]]
       end
     end
 
@@ -48,16 +48,16 @@ module Nuntius
       @client ||= Twilio::REST::Client.new(sid, auth_token)
     end
 
-    def script_for_path(message, path = '/', _params)
+    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: '/' }
+        payload = preamble.metadata ? preamble.content : script
+        payload = payload.gsub("{{url}}", callback_url)
+        metadata = preamble.metadata || {path: "/"}
 
-        { headers: metadata.with_indifferent_access, body: payload }
+        {headers: metadata.with_indifferent_access, body: payload}
       end
 
       scripts.find { |s| s[:headers][:path] == path }

data/app/services/nuntius/aws_sns_processor_service.rb

@@ -20,13 +20,13 @@ module Nuntius
     end
 
     def perform
-      if context.notification['Type'] == 'SubscriptionConfirmation'
-        Nuntius.config.logger.info('Confirming SNS subscription')
-        HTTPClient.get(body['SubscribeURL'])
+      if context.notification["Type"] == "SubscriptionConfirmation"
+        Nuntius.config.logger.info("Confirming SNS subscription")
+        Faraday.get(body["SubscribeURL"])
         return
       end
 
-      type = context.notification['notificationType']
+      type = context.notification["notificationType"]
 
       unless message_id
         Nuntius.config.logger.warn("SNS / SES message could not determine message id: #{context.notification}")
@@ -39,11 +39,11 @@ module Nuntius
       Nuntius.config.logger.info("SNS /SES updating message #{message.id} for #{type}")
 
       case type
-      when 'Delivery'
+      when "Delivery"
         process_delivery
-      when 'Bounce'
+      when "Bounce"
         process_bounce
-      when 'Complaint'
+      when "Complaint"
         process_complaint
       else
         false
@@ -54,24 +54,24 @@ module Nuntius
 
     def process_delivery
       message.status = :delivered
-      message.metadata[:feedback] = { 'type': 'delivery', 'info': context.notification['delivery'] }
+      message.metadata[:feedback] = {type: "delivery", info: context.notification["delivery"]}
       message.save!
     end
 
     def process_bounce
       message.status = :bounced
-      message.metadata[:feedback] = { 'type': 'bounce', 'info': context.notification['bounce'] }
+      message.metadata[:feedback] = {type: "bounce", info: context.notification["bounce"]}
       message.save!
     end
 
     def process_complaint
       message.status = :complaint
-      message.metadata[:feedback] = { 'type': 'complaint', 'info': context.notification['complaint'] }
+      message.metadata[:feedback] = {type: "complaint", info: context.notification["complaint"]}
       message.save!
     end
 
     def message_id
-      @message_id ||= context.notification.dig('mail', 'commonHeaders', 'messageId')&.[](1...-1)
+      @message_id ||= context.notification.dig("mail", "commonHeaders", "messageId")&.[](1...-1)
     end
 
     def message

data/app/services/nuntius/deliver_campaign_service.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Nuntius
+  class DeliverCampaignService < ApplicationService
+    context do
+      attribute :campaign
+      validates :campaign, presence: true
+    end
+
+    delegate :campaign, to: :context
+
+    def perform
+      deliver
+      campaign.sent!
+    end
+
+    def deliver
+      transporter = BaseTransport.class_from_name(campaign.transport).new
+      campaign.list.subscribers.subscribed.each do |subscriber|
+        transporter.deliver(new_message(subscriber))
+      end
+    end
+
+    def new_message(subscriber, assigns = {})
+      assigns["subscriber"] = subscriber
+      if subscriber.nuntiable
+        name = Nuntius::BaseMessenger.liquid_variable_name_for(subscriber.nuntiable)
+        assigns[name] = subscriber.nuntiable
+      end
+      message = Nuntius::Message.new(transport: campaign.transport, campaign: campaign, nuntiable: subscriber.nuntiable, metadata: campaign.metadata)
+
+      locale_proc = Nuntius::BaseMessenger.messenger_for_obj(subscriber.nuntiable).locale
+      locale = instance_exec(subscriber.nuntiable, &locale_proc) if subscriber.nuntiable && locale_proc
+
+      message.from = render(:from, assigns, locale)
+      message.to = case campaign.transport
+      when "mail"
+        subscriber.email
+      when "sms"
+        subscriber.phone_number
+      when "voice"
+        subscriber.phone_number
+      end
+
+      message.subject = render(:subject, assigns, locale)
+      message.html = render(:html, assigns, locale, layout: campaign.layout&.data)
+
+      message
+    end
+
+    def translation_scope
+      scope = %w[nuntius]
+      scope << campaign.layout.name.underscore.tr(" ", "_") if layout
+      scope.join(".")
+    end
+
+    private
+
+    def render(attr, assigns, locale, options = {})
+      I18n.with_locale(locale) do
+        ::Liquidum.render(campaign.public_send(attr), {assigns: assigns.merge("campaign" => campaign), registers: {"campaign" => campaign}}.merge(options))
+      end
+    end
+  end
+end

data/app/services/nuntius/deliver_inbound_message_service.rb

@@ -7,8 +7,9 @@ module Nuntius
     end
 
     def perform
-      context.inbound_message.update(status: 'delivered')
-      Nuntius::BaseMessageBox.deliver(context.inbound_message)
+      context.inbound_message.update!(status: "delivered")
+      result = Nuntius::BaseMessageBox.deliver(context.inbound_message)
+      context.inbound_message.update!(status: "processed") if result
     end
   end
 end

data/app/services/nuntius/retrieve_inbound_mail_service.rb

@@ -8,27 +8,34 @@ module Nuntius
 
     def perform
       Mail::IMAP.new(context.settings).all do |message, imap, uid|
-        inbound_message = Nuntius::InboundMessage.find_or_create_by!(transport: 'mail', provider: 'imap', provider_id: message.message_id,
-                                                                     digest: Digest::SHA256.hexdigest(message.to_s), status: 'pending')
-        inbound_message.from = message.from
-        inbound_message.to = message.to
-        inbound_message.text = message.body
-        # inbound_message.metadata = params
-        inbound_message.save!
+        inbound_message = Nuntius::InboundMessage.find_or_initialize_by(transport: "mail", provider: "imap", provider_id: message.message_id)
+        if inbound_message.new_record?
+          inbound_message.digest = Digest::SHA256.hexdigest(message.to_s)
+          inbound_message.from = message.from
+          inbound_message.to = message.to
+          inbound_message.text = message.body
+          inbound_message.save!
 
-        if inbound_message.raw_message.attached?
-          if Digest::SHA256.hexdigest(message.to_s) == Digest::SHA256.hexdigest(inbound_message.raw_message.download)
-            # Only if we have an attachment and it's digest is the same as we find in the mailbox, delete!
-            # This never happens on the first round of fetching it.
-            imap.store(uid, '+FLAGS', [Net::IMAP::DELETED])
-            imap.expunge
-          end
-        else
           si = StringIO.new
           si.write(message.to_s)
           si.rewind
           inbound_message.raw_message.attach(io: si, filename: message.message_id)
-          Nuntius::ProcessInboundMessageJob.perform_later(inbound_message)
+
+        elsif inbound_message.status == "processed" && Digest::SHA256.hexdigest(message.to_s) == Digest::SHA256.hexdigest(inbound_message.raw_message.download)
+
+          if context.settings[:delete_after_processing]
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED])
+            imap.expunge
+          else
+            existing_mailboxes = imap.list("", "*").map(&:name)
+            unless existing_mailboxes.include?("Archive")
+              imap.create("Archive")
+            end
+            imap.uid_copy(uid, "Archive")
+
+            imap.uid_store(uid, "+FLAGS", [Net::IMAP::DELETED])
+            imap.expunge
+          end
         end
       end
     end

data/app/tables/nuntius_campaigns_table.rb

@@ -7,7 +7,15 @@ class NuntiusCampaignsTable < ActionTable::ActionTable
   column(:metadata) { |campaign| Nuntius.config.metadata_humanize(campaign.metadata) }
   column(:transport)
   column(:state)
-  column(:list) { |campaign| campaign.list.name }
+  column(:list, sort_field: "nuntius_lists.name") { |campaign| campaign.list.name }
+
+  column :actions, title: "", sortable: false do |campaign|
+    next unless campaign.can_publish?
+
+    content_tag(:span, class: "btn-group btn-group-xs") do
+      concat link_to(content_tag(:i, nil, class: "fa fa-paper-plane"), nuntius.publish_admin_campaign_path(campaign), data: {turbo_confirm: "Are you sure you want to send out this campaign?", turbo_method: :post}, class: "btn btn-xs btn-danger")
+    end
+  end
 
   initial_order :name, :asc
 
@@ -17,5 +25,6 @@ class NuntiusCampaignsTable < ActionTable::ActionTable
 
   def scope
     @scope = Nuntius::Campaign.visible
+    @scope = Nuntius::Campaign.joins(:list)
   end
 end