web47core 0.0.8 → 0.0.9

data/lib/app/models/email_notification.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+#
+# EmailNotification is a concrete class of Notification, sending emails to both members
+# and users, or in the case of eCommerce, customers.
+#
+# This object allows you to create an EmailNotification object, set it's property and
+# tell it send_notification. It'll handle everything from there including
+# 1. Running in the background thread
+# 2. Error recovery
+# 3. Retry on failure
+#
+# The Email object also uses the templating engine to allow the specification of a template
+# and a set of local variables for dynamic content.
+#
+# Usage:
+#
+# email = EmailNotification.new
+# email.to = 'user@abc.com'
+# email.sender = 'me@abc.com'
+# email.subject = 'Today is the day!'
+# email.message = 'Day is today!'
+# email.send_notification
+#
+# You are done! Go about your business of creating awesome software!
+#
+class EmailNotification < Notification
+  # The From: "Joe Smith <joe@abc.com>"
+  field :from, type: String
+  # The Reply-To: "no-reply@abc.com"
+  field :reply_to, type: String
+  # The sender: "joe@abc.com"
+  field :sender, type: String
+  # The cc: header
+  field :cc, type: String
+  # The subject
+  field :subject, type: String
+  #
+  # Validations
+  #
+  validates :subject, presence: true
+  validates :to, presence: true
+
+  # has_many :attachments, class_name: 'EmailNotificationAttachment', dependent: :destroy
+
+  def from_template(template_name, locals = {})
+    super
+    self.subject = subject_from_template(template_name, locals)
+  end
+
+  #
+  # Add a file as an attachment to this email notification.
+  #
+  # Expecting a path to the file, not the file or data itself.
+  # TODO consider how to handle a file object or data object.
+  #
+  # Once you have called this method, the file is stored via PaperClip and
+  # does not need to stay persistant through email delivery.
+  # You can delete it after telling the EmailNotification to send
+  # the notification.
+  #
+  # def add_file(file)
+  #   # Make sure we are saved
+  #   save! unless persisted?
+  #   attachment = EmailNotificationAttachment.new email_notification: self
+  #   attachment.file = open(file)
+  #   attachment.save!
+  # end
+  def deliver_message!
+    mail = Mail.new
+    # Set the from line
+    address = from_address
+    mail.from = address
+    self.from = address
+    # Set the sender line
+    address = sender_address
+    mail.sender = address
+    self.sender = address
+    # Set the reply to
+    address = reply_to_address
+    if address.present?
+      self.reply_to = address
+      mail.reply_to = address
+      mail.sender = address
+    end
+
+    # Set the to address
+    mail.to = to
+
+    # Set the cc line
+    mail.cc = cc unless cc.nil?
+
+    # Set the subject line
+    mail.subject = subject
+
+    # set the message body and send
+    html_message = build_message
+    mail.html_part do
+      content_type 'text/html; charset=UTF-8'
+      body html_message
+    end
+
+    # Add the attachments, if there are any. If not, none are added.
+    add_attachments(attachments) if defined?(attachments)
+
+    # Setup the delivery method for this message only.
+    if 'test'.eql?(ENV['RAILS_ENV'])
+      mail.delivery_method :test
+    else
+      mail.delivery_method :smtp, smtp_configuration
+    end
+
+    # Deliver it
+    mail.deliver
+  rescue StandardError => error
+    # We are catching and rethrowing this only to allow the temp directory to be cleaned up in the ensure block
+    raise error
+  ensure
+    FileUtils.remove_entry_secure(tmp_dir) if defined?(tmp_dir) && tmp_dir.present?
+  end
+
+  def add_attachments(attachments = nil)
+    tmp_dir = Dir.mktmpdir
+    attachments.each do |attachment|
+      # Create a temp directory, it'll get cleaned up in the rescue.
+      tmp_file_path = "#{tmp_dir}/#{attachment.file_file_name}"
+      File.open(tmp_file_path, 'w') do |f|
+        f.write(URI.parse(attachment.file_url).open.read.force_encoding('utf-16').encode)
+      end
+      mail.attachments[attachment.file_file_name] = {
+        mime_type: attachment.file_content_type,
+        content: File.open(tmp_file_path).read.force_encoding('utf-16').encode
+      }
+    end
+  end
+
+  #
+  # sender address
+  #
+  def sender_address
+    address = SystemConfiguration.smtp_user_name
+    unless account.nil?
+      account_smtp = account.fetch_smtp_configuration
+      address = account_smtp.username if account_smtp.use?
+    end
+    address
+  end
+
+  #
+  # From address
+  #
+  def from_address
+    return from if from.present?
+
+    address = SystemConfiguration.default_email
+    if account.present?
+      account_smtp = account.fetch_smtp_configuration
+      address = account_smtp.email_address if account_smtp.use?
+    end
+    address
+  end
+
+  #
+  # Reply to address
+  #
+  def reply_to_address
+    return reply_to if reply_to.present?
+
+    address = nil
+    unless account.nil?
+      smtp = account.fetch_smtp_configuration
+      address = smtp.reply_to_address if smtp.use? && !smtp.reply_to_address.nil? && !smtp.reply_to_address.empty?
+    end
+    address
+  end
+
+  #
+  # SMTP Configuration
+  #
+  def smtp_configuration
+    account.get_smtp_configuration.use? ? account_smtp_configuration : default_smtp_configuration
+  rescue StandardError
+    default_smtp_configuration
+  end
+
+  def account_smtp_configuration
+    smtp = account.fetch_smtp_configuration
+
+    config = {
+      address: smtp.server_name,
+      port: smtp.port,
+      authentication: smtp.authentication_method.to_sym,
+      enable_starttls_auto: smtp.ssl.eql?(true)
+    }
+    config[:domain] = smtp.domain unless smtp.domain.nil? || smtp.domain.empty?
+    config[:user_name] = smtp.username unless smtp.username.nil? || smtp.username.empty?
+    config[:password] = smtp.password unless smtp.password.nil? || smtp.password.empty?
+    config
+  end
+
+  def default_smtp_configuration
+    SystemConfiguration.smtp_configuration
+  end
+
+  #
+  # HTMLize messages
+  #
+  def build_message
+    clean_message = message.strip
+    clean_message = "<html><body><pre>#{clean_message}</pre></body></html>" unless clean_message.start_with?('<')
+    add_notification_tracker(clean_message)
+  end
+
+  def add_notification_tracker(html_message)
+    tracker_url = "#{SystemConfiguration.base_url}/notifications/#{id}/img"
+    return html_message if html_message.include?(tracker_url)
+
+    image_tag = "<img style='height:0;width:0;border:none;display:none;' src='#{tracker_url}' alt=''/></body>"
+    html_message.sub(%r{<\/body>}, image_tag)
+  end
+
+  def subject_from_haml_text(haml_text, locals)
+    locals[:base_url] = SystemConfiguration.base_url
+    haml_engine = Haml::Engine.new(haml_text)
+    self.subject = haml_engine.render(Object.new, stringify_all(locals))
+  end
+
+  def subject_from_liquid_text(liquid_text, locals)
+    self.subject = render_liquid_text(liquid_text, locals)
+  end
+
+  def subject_from_template(template_name, locals)
+    subject = account_subject_template(template_name) ||
+      default_subject_template(template_name) ||
+      template_from_file(template_name, prefix: 'subject')
+    return subject_from_liquid_text(subject, locals) if subject.present?
+
+    subject = template_from_file(template_name, format: 'haml', prefix: 'subject')
+    subject_from_haml_text(subject, locals) if subject.present?
+  end
+
+  def account_subject_template(template_name)
+    self.account.templates.emails.find_by(name: template_name.to_s).subject
+  rescue StandardError
+    nil
+  end
+
+  def default_subject_template(template_name)
+    EmailTemplate.where(account: nil, name: template_name.to_s).template
+  rescue StandardError
+    nil
+  end
+end

data/lib/app/models/email_template.rb

@@ -0,0 +1,6 @@
+class EmailTemplate < Template
+
+  field :subject, type: String
+
+  validates_presence_of :subject
+end

data/lib/app/models/notification.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+#
+#
+class Notification
+  include StandardModel
+  #
+  # Constants
+  #
+  STATE_INVALID = 'invalid'.freeze unless defined? STATE_INVALID
+  STATE_NEW = 'new'.freeze unless defined? STATE_NEW
+  STATE_PROCESSED = 'processed'.freeze unless defined? STATE_PROCESSED
+  STATE_PROCESSING = 'processing'.freeze unless defined? STATE_PROCESSING
+  STATE_RESUBMITTED = 'resubmitted'.freeze unless defined? STATE_RESUBMITTED
+  STATE_RETRYING = 'retrying'.freeze unless defined? STATE_RETRYING
+  STATE_SUBMITTED = 'submitted'.freeze unless defined? STATE_SUBMITTED
+  STATE_VIEWED = 'viewed'.freeze unless defined? STATE_VIEWED
+  unless defined? ALL_STATES
+    ALL_STATES = [STATE_INVALID,
+                  STATE_NEW,
+                  STATE_PROCESSED,
+                  STATE_PROCESSING,
+                  STATE_RESUBMITTED,
+                  STATE_RETRYING,
+                  STATE_SUBMITTED,
+                  STATE_VIEWED].freeze
+  end
+  #
+  # Channels
+  #
+  DELIVERY_EMAIL = 'email'.freeze unless defined? DELIVERY_EMAIL
+  DELIVERY_SLACK = 'slack'.freeze unless defined? DELIVERY_SLACK
+  DELIVERY_SMS = 'sms'.freeze unless defined? DELIVERY_SMS
+  #
+  # Fields
+  #
+  field :retries, type: Integer, default: 0
+  field :state, type: String, default: STATE_NEW
+  field :to, type: String
+  field :message, type: String
+  field :error_message, type: String
+  field :last_viewed_at, type: Time
+  field :viewed_count, type: Integer, default: 0
+  #
+  # Relationships
+  #
+  belongs_to :account, inverse_of: :notifications, optional: true
+  belongs_to :notification_template, inverse_of: :notifications, optional: true
+  #
+  # Validations
+  #
+  validates :state, presence: true, inclusion: { in: ALL_STATES }
+  validates :message, presence: true
+
+  #
+  # Was this notification successful sent
+  #
+  def successful?
+    [STATE_PROCESSED, STATE_VIEWED].include? state
+  end
+
+  #
+  # If this notification can be deleted, we don't want to delete one that is currently being processed.
+  #
+  def deletable?
+    [STATE_PROCESSED, STATE_INVALID, STATE_NEW, STATE_VIEWED].include? state
+  end
+
+  #
+  # If this notification can be resent, we don't want to resend one that is currently being processed.
+  #
+  def sendable?
+    [STATE_PROCESSED, STATE_INVALID, STATE_NEW, STATE_VIEWED].include? state
+  end
+
+  #
+  # Mark this as viewed
+  #
+  def viewed
+    set(state: STATE_VIEWED, last_viewed_at: Time.now.utc, viewed_count: viewed_count + 1)
+  end
+
+  #
+  # Start processing the notification
+  #
+  def start_processing
+    set state: STATE_PROCESSING
+  end
+
+  #
+  # Set to retrying
+  #
+  def retry_delivery(message)
+    set error_message: message, retries: retries + 1, state: STATE_RETRYING
+  end
+
+  #
+  # Finish processing the notification successfully
+  #
+  def finish_processing(message = nil)
+    if message.present?
+      set state: STATE_INVALID, error_message: message
+    else
+      set state: STATE_PROCESSED, error_message: ''
+    end
+  end
+
+  #
+  # Send the notification
+  #
+  def send_notification
+    if state.eql? STATE_NEW
+      self.state = STATE_SUBMITTED
+    else
+      self.retries = 0
+      self.state = STATE_RESUBMITTED
+      self.error_message = 'Retrying'
+    end
+
+    begin
+      deliver_message if save!
+    rescue StandardError => error
+      finish_processing error.message
+    end
+  end
+
+  def deliver_message!
+    raise 'Incomplete class, concrete implementation should implment #deliver_message!'
+  end
+
+  def deliver_message
+    start_processing
+    deliver_message!
+    finish_processing
+  rescue StandardError => error
+    if retries > 10
+      log_error "Unable to process notification id: #{id}, done retrying", error
+      finish_processing "Failed final attempt: #{error.message}"
+      notify_failure(error)
+    else
+      log_error "Unable to process notification id: #{id}, retrying!!", error
+      retry_delivery("Failed attempt # #{retries}: #{error.message}")
+      delay(run_at: 10.minutes.from_now).deliver
+    end
+  end
+
+  handle_asynchronously :deliver_message, priority: 100
+
+  def from_template(template_name, locals = {})
+    locals[:base_url] = SystemConfiguration.base_url
+    self.message = message_from_template(template_name, locals)
+  end
+
+  #
+  # Retrieve the template from the account
+  #
+  # If the account does exists or the template in the account does exist, we catch the error and return nil
+  #
+  def account_message_template(template_name)
+    account.templates.find_by(name: template_name.to_s, _type: "Account#{delivery_channel.humanize}Template").template
+  rescue StandardError
+    nil
+  end
+
+  #
+  # Get the default template stored in the database that is not associated with an account
+  #
+  def default_message_template(template_name)
+    Template.find_by(account: nil, name: template_name.to_s).template
+  rescue StandardError
+    nil
+  end
+
+  #
+  # Retrieve the template out of the project
+  #
+  def template_from_file(template_name, format: 'liquid', prefix: nil)
+    file_name = [template_name, prefix, format].compact.join('.')
+    if File.exist?(Rails.root.join('lib', 'templates', delivery_channel, file_name))
+      File.open(Rails.root.join('lib', 'templates', delivery_channel, file_name))
+    else
+      File.read(File.join(__dir__, '../../lib', 'templates', delivery_channel, file_name))
+    end.read
+  rescue StandardError
+    nil
+  end
+
+  #
+  # Default delivery channel is email, override for sms, SMTP or other channels
+  #
+  def delivery_channel
+    DELIVERY_EMAIL
+  end
+
+  def message_from_template(template_name, locals)
+    template = account_message_template(template_name) || template_from_file(template_name)
+    return message_from_liquid_text(template, locals) if template.present?
+
+    template = template_from_file(template_name, format: 'haml')
+    message_from_haml_text(template, locals) if template.present?
+  end
+
+  def message_from_haml_text(haml_text, locals)
+    locals[:base_url] = SystemConfiguration.base_url
+    engine = Haml::Engine.new(haml_text)
+    self.message = engine.render(Object.new, stringify_all(locals))
+  end
+
+  def message_from_haml_file(file_name, locals)
+    message_from_haml_text(File.read(file_name), locals)
+  end
+
+  def message_from_liquid_text(liquid_text, locals)
+    self.message = render_liquid_text(liquid_text, locals)
+  end
+
+  #
+  # Render the given liquid text
+  #
+  def render_liquid_text(liquid_text, locals = {})
+    locals[:base_url] = SystemConfiguration.base_url
+    Liquid::Template.parse(liquid_text).render(stringify_all(locals))
+  end
+
+  #
+  # Convert all keys and values to strings for liquid sanity
+  #
+  def stringify_all(obj)
+    case obj
+    when Hash
+      result = {}
+      obj.each { |key, value| result[key.to_s] = stringify_all(value) }
+    when Array
+      result = []
+      obj.each { |value| result << stringify_all(value) }
+    when FalseClass
+      result = false
+    when TrueClass
+      result = true
+    else
+      result = obj.to_s
+    end
+    result
+  end
+
+  private
+
+  #
+  # Only send a message if this message is associated with an account
+  # and that has an active smtp configuration
+  # otherwise send it to support for the environment
+  #
+  def notify_failure(error)
+    if account.nil? || !account.fetch_or_build_smtp_configuration.use?
+      error_email = EmailNotification.new
+      params = { company_name: SystemConfiguration.company_name,
+                 error_message: error.message,
+                 notification_url: "#{SystemConfiguration.base_url}/stack/notifications/#{id}" }
+      error_email.from_template(AccountEmailTemplate::EMAIL_NOTIFICATION_FAILED, params)
+      error_email.to = SystemConfiguration.support_email
+      error_email.save!
+      error_email.deliver
+    else
+      account.smtp_admins.each do |admin|
+        error_email = EmailNotification.new
+        params = { company_name: SystemConfiguration.company_name,
+                   error_message: error.message,
+                   notification_url: "#{SystemConfiguration.base_url}/notifications/#{id}" }
+        error_email.from_template(AccountEmailTemplate::EMAIL_NOTIFICATION_FAILED, params)
+        error_email.to = admin.email
+        error_email.save!
+        error_email.deliver
+      end
+    end
+  end
+end

data/lib/app/models/notification_template.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+#
+# Base class for notification
+#
+class NotificationTemplate < Template
+  include StandardModel
+  #
+  # Fields
+  #
+  field :draft, type: Boolean, default: true
+  #
+  # Relationships
+  #
+  has_many :notifications, dependent: :nullify
+  #
+  # Validations
+  #
+  validates_presence_of :draft
+end

data/lib/app/models/slack_notification.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+#
+# SlackNotification is a concrete class of Notification, sending notifications to the slack
+# system. Initially this will be only used internally, however we could configure this
+# to work with an account's slack configuration.
+#
+# This object allows you to create an EmailNotification object, set it's property and
+# tell it send_notification. It'll handle everything from there including
+# 1. Running in the background thread
+# 2. Error recovery
+# 3. Retry on failure
+#
+# Usage:
+#
+# SlackNotification.say 'Error getting data from resource'
+#
+# or
+# To change the channel it's posted to...
+#
+# SlackNotification.say 'Error getting data from resource', to: 'another_channel'
+#
+# or
+# To who the message is from, the default is the environment name
+#
+# SlackNotification.say 'Error getting data from resource', to: 'another_channel', from: 'someone else'
+#
+# You are done! Go about your business of creating awesome software!
+#
+class SlackNotification < Notification
+  # The slack username to use
+  field :from, type: String
+
+  def deliver_message!
+    return unless SystemConfiguration.slack_configured?
+
+    start_processing
+    payload = { text: message }
+    payload[:channel] = if to.present?
+                          to
+                        elsif SystemConfiguration.slack_support_channel.present?
+                          SystemConfiguration.slack_support_channel
+                        else
+                          'support'
+                        end
+    # Use the environment as the default, otherwise set it as the from
+    payload[:username] = from.presence || Rails.env
+    # Setup the delivery method for this message only.
+    RestClient.post(SystemConfiguration.slack_api_url, payload.to_json)
+    finish_processing
+  rescue StandardError => error
+    App47Logger.log_debug '!!! Error sending SLACK notification !!!'
+    App47Logger.log_debug error.message
+    App47Logger.log_debug error.backtrace
+    App47Logger.log_debug '!!! Error sending SLACK notification !!!'
+    finish_processing error.message
+  end
+
+  #
+  # Limit the number of times the slack notification is retried
+  #
+  def max_retries
+    1
+  end
+
+  #
+  # Default delivery channel is email, override for sms, SMTP or other channels
+  #
+  def delivery_channel
+    DELIVERY_SLACK
+  end
+
+  #
+  # Convenience method to say something when we see something
+  #
+  def self.say(message, to: nil, from: nil, template: nil)
+    return unless SystemConfiguration.slack_configured?
+
+    notification = SlackNotification.new(to: to, from: from)
+    notification.message = if template.present?
+                             notification.message_from_template template, message
+                           elsif message.is_a?(Array)
+                             message.join("\n")
+                           else
+                             message
+                           end
+    notification.send_notification
+  end
+end

data/lib/app/models/sms_notification.rb

@@ -0,0 +1,56 @@
+#
+# SmsNotification is a concrete class of Notification, sending sms to both members
+# and users, or in the case of eCommerce, customers.
+#
+# This object allows you to create an SmsNotification object, set it's property and
+# tell it send_notification. It'll handle everything from there including
+# 1. Running in the background thread
+# 2. Error recovery
+# 3. Retry on failure
+#
+# The SMS object also uses the templating engine to allow the specification of a template
+# and a set of local variables for dynamic content.
+#
+# Usage:
+#
+# sms = SmsNotification.new
+# sms.to = '5713326267'
+# sms.message = 'Day is today!'
+# sms.send_notification
+#
+# You are done! Go about your business of creating awesome software!
+#
+class SmsNotification < Notification
+  #
+  # Fields
+  #
+  field :sid, type: String
+
+  validates_format_of :to, with: %r{\A\+[1-9]{1}[0-9]{3,14}\z}, message: 'Invalid phone number'
+  validates_presence_of :to
+  validates_presence_of :account_id
+
+  def deliver_message!
+    return unless SystemConfiguration.twilio_configured?
+
+    config = SystemConfiguration.configuration
+    account_sid = config.twilio_account_id
+    auth_token = config.twilio_auth_token
+    client = Twilio::REST::Client.new account_sid, auth_token
+
+    message = client.account.messages.create(
+      body: self.message,
+      to: self.to,
+      from: config.twilio_phone_number
+    )
+    # We are saved in the calling class, no reason to save again
+    set sid: message.sid
+  end
+
+  #
+  # set the delivery channel for the templates
+  #
+  def delivery_channel
+    DELIVERY_SMS
+  end
+end