web47core 0.0.9 → 0.0.10

data/lib/app/models/concerns/time_zone_able.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+#
+# Objects that can localize time to it, kicking out safe uses of a date format.
+#
+module TimeZoneAble
+  extend ActiveSupport::Concern
+
+  def self.included(base)
+    base.class_eval do
+      #
+      # Fields
+      #
+      field :time_zone, type: String
+      #
+      # Validations
+      #
+      validates :time_zone, inclusion: TZInfo::Timezone.all_identifiers, presence: true
+      #
+      # Callbacks
+      #
+      before_validation :default_time_zone
+    end
+  end
+
+  #
+  # Return the given time in the localized time for this object
+  #
+  def local_time(time, format = :medium, default = 'N/A')
+    tz = TZInfo::Timezone.get(time_zone.presence || SystemConfiguration.default_time_zone)
+    time.present? ? I18n.l(time.in_time_zone(tz), format: format) : default
+  rescue StandardError
+    default
+  end
+
+  #
+  # Return the updated_at if found, otherwise return the created_at. If neither are there
+  # then return unknown
+  #
+  def local_updated_time(obj, format = :medium, default = 'N/A')
+    obj.updated_at.present? ? local_time(obj.updated_at, format, default) : local_time(created_at, format, default)
+  rescue StandardError
+    default
+  end
+
+  def default_time_zone
+    self.time_zone ||= SystemConfiguration.default_time_zone
+  end
+end

data/lib/app/models/notification.rb

@@ -97,9 +97,9 @@ class Notification
   #
   # Finish processing the notification successfully
   #
-  def finish_processing(message = nil)
-    if message.present?
-      set state: STATE_INVALID, error_message: message
+  def finish_processing(processing_message = nil)
+    if processing_message.present?
+      set state: STATE_INVALID, error_message: processing_message
     else
       set state: STATE_PROCESSED, error_message: ''
     end

data/lib/app/models/redis_configuration.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+#
+# Easily fetch the redis configuration from redis.yml in the config directory.
+# There are several formats to support
+#
+# URL with single server
+# development:
+#   url: 'redis://localhost:6379/0'
+#
+# Host/port combination for single server
+# development:
+#   host: localhost
+#   port: 6379
+#   db: 0
+#
+# Sentinel
+# development:
+#   master: production
+#   sentinels:
+#     - host1:6379
+#     - host2:6379
+#     - host3:6379
+#   role: master
+#
+# Available for all options
+#   connect_timeout: 0.2
+#   read_timeout: 0.2
+#   write_timeout: 0.2
+#   timeout: 1
+#
+class RedisConfiguration
+  #
+  # Methods are static
+  #
+  class << self
+    #
+    # Load the configuration using the given DB
+    #
+    # Trying first the URL, then host, then sentinel, then default method
+    #
+    def load(database = nil)
+      load_url(database) || load_host(database) || load_sentinel(database) || load_default(database)
+    end
+
+    private
+
+    #
+    # Load the base set of parameters from the config file
+    #
+    def load_base(raw_config)
+      base = {}
+      %i[connect_timeout namespace read_timeout write_timeout timeout].each do |key|
+        base[key] = raw_config[key.to_s] unless raw_config[key.to_s].nil?
+      end
+      base
+    end
+
+    #
+    # Load a default configuration with the given database
+    #
+    def load_default(database = 0)
+      { host: '127.0.0.1', port: 6_379, db: (database || 0) }
+    end
+
+    #
+    # Load the url
+    #
+    def load_url(database = 0)
+      raw_config = load_file
+      return if raw_config.nil? || raw_config['url'].nil?
+
+      config = load_base(raw_config)
+      config[:url] = raw_config['url']
+      config[:db] = (database || 0)
+      config
+    end
+
+    #
+    # Load the given host
+    #
+    def load_host(database = nil)
+      raw_config = load_file
+      return if raw_config.nil? || raw_config['host'].nil?
+
+      config = load_base(raw_config)
+      config[:host] = raw_config['host']
+      config[:port] = raw_config['port'] || 6_379
+      config[:db] = database || raw_config['db'] || 0
+      config
+    end
+
+    #
+    # Load the sentinel configuration
+    #
+    def load_sentinel(database = 0)
+      raw_config = load_file
+      return if raw_config.nil? || raw_config['master'].nil?
+
+      config = load_base(raw_config)
+      config[:url] = "redis://#{raw_config['master']}"
+      config[:sentinels] = raw_config['sentinels'].collect do |sentinel|
+        parts = sentinel.split(':')
+        host = parts.first
+        port = parts.count.eql?(2) ? parts.last : 26_379
+        { host: host, port: port }
+      end
+      config[:db] = database || 0
+      config[:role] = raw_config['role'] || 'master'
+      config
+    end
+
+    #
+    # Return the config file
+    #
+    def config_file_path
+      File.expand_path('config/redis.yml')
+    end
+
+    #
+    # Load the config/redis.yml and return the environment name
+    #
+    def load_file
+      config = nil
+      file_path = config_file_path
+      if File.exist? file_path
+        yaml_data = YAML.load_file(file_path)
+        config = yaml_data[Rails.env] if yaml_data
+      end
+
+      config
+    rescue StandardError => error
+      puts "Error loading #{config_file_path} file", error
+      nil # return nothing if there is an error
+    end
+  end
+end

data/lib/app/models/slack_notification.rb

@@ -31,38 +31,24 @@ 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
+  def deliver_message
+    if SystemConfiguration.slack_configured?
+      start_processing
+      payload = { text: message }
+      payload[:channel] = to.presence || SystemConfiguration.slack_support_channel
+      # 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
+    else
+      finish_processing 'Slack is not configured'
+    end
   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 !!!'
+    log_warn '!!! Error sending SLACK notification !!!', error
     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
   #
@@ -74,8 +60,6 @@ class SlackNotification < Notification
   # 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

data/lib/app/models/sms_notification.rb

@@ -26,9 +26,7 @@ class SmsNotification < Notification
   #
   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
+  validates :to, presence: true, format: { with: /\A\+[1-9]{1}[0-9]{3,14}\z/ }
 
   def deliver_message!
     return unless SystemConfiguration.twilio_configured?
@@ -38,13 +36,13 @@ class SmsNotification < Notification
     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,
+    twilio_message = client.account.messages.create(
+      body: message,
+      to: to,
       from: config.twilio_phone_number
     )
     # We are saved in the calling class, no reason to save again
-    set sid: message.sid
+    set sid: twilio_message.sid
   end
 
   #

data/lib/app/models/smtp_configuration.rb

@@ -28,7 +28,6 @@ class SmtpConfiguration
   # Callbacks
   #
   before_save :update_token
-  #after_save :send_smtp_verification
 
   #
   # If we can use this SMTP configuration or not, it must be confirmed and
@@ -38,111 +37,37 @@ class SmtpConfiguration
     confirmed? && active?
   end
 
+  #
+  # Which fields to protect
+  #
   def secure_fields
     super + %i[password]
   end
 
+  #
+  # Validate the token, returning true of false if valid
+  #
   def validate_token(token)
-    valid = false
-    unless confirmation_token.nil?
-      if confirmation_token.eql? token
-        valid = true
-        unset(:confirmation_token)
-        unset(:verification_message)
-      end
-    end
+    valid = if confirmation_token.present? && confirmation_token.eql?(token)
+              unset(:confirmation_token, :verification_message)
+              true
+            else
+              false
+            end
     set(confirmed: valid)
     valid
   end
 
   #
   # Update the token on save if we are active and the token is not already set.
+  #
   def update_token
     if active?
-      set(confirmation_token: Devise.friendly_token) if confirmation_token.nil?
+      set(confirmation_token: Digest::SHA256.hexdigest("#{id}_#{account.id}")) if confirmation_token.nil?
       set(confirmed: false)
       set(verification_message: 'Sending SMTP verification email(s) to SMTP admins.')
     else
       set(verification_message: 'SMTP Configuration is not active, no verification email will be sent.')
     end
   end
-
-  def send_smtp_verification
-    if self.active?
-      sent_to= []
-      self.account.smtp_admins.each do |admin|
-        sent_to << admin.email if self.send_confirmation(admin)
-      end
-      if sent_to.empty?
-        set(verification_message: "No confirmations emails sent: (#{verification_message}).")
-      else
-        set(verification_message: "Confirmation emails sent to SMTP admins: #{sent_to.join(", ")}")
-      end
-    end
-  end
-
-  def send_confirmation(member)
-    sent = false
-    begin
-      mail = Mail.new
-      # Set the from line
-      mail.from = email_address
-
-      # Set the to address
-      mail.to = member.email
-
-      # Set the subject line
-      mail.subject = 'Verify SMTP configuration change'
-
-      # 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
-
-      # Setup the delivery method for this message only.
-      if Rails.env.test?
-        mail.delivery_method :test
-      else
-        config = { address: self.server_name,
-                   port:  self.port,
-                   authentication: self.authentication_method.to_sym,
-                   enable_starttls_auto: self.ssl.eql?(true) }
-        config[:domain] = self.domain unless self.domain.nil? or self.domain.empty?
-        config[:user_name] = self.username unless self.username.nil? or self.username.empty?
-        config[:password] = self.password unless self.password.nil? or self.password.empty?
-
-        mail.delivery_method :smtp, config
-      end
-
-      # Deliver it
-      mail.deliver
-      sent = true
-
-    rescue Exception=>e
-      App47::Logger.log_error "Unable to send SMTP confirmation email #{e.message}"
-      App47::Logger.log_error e.backtrace
-      set(verification_message: "Unable to send verification email to #{member.email}, error: #{e.message}")
-    end
-    sent
-  end
-
-  def build_message
-    template = File.read(Rails.root.join('app', 'assets', 'templates', 'email', "verify_smtp_configuration.liquid"))
-    engine = Liquid::Template.parse(template)
-    engine.render({
-                    'account_name' => account.name,
-                    'confirmation_url' => "#{SystemConfiguration.webui_url}/smtp_configuration/confirm_change?token=#{confirmation_token}"
-                  })
-  end
-
-  def to_yaml_properties(wrap = true)
-    if wrap
-      self.class.new.to_yaml_properties(false)
-    else
-      super()
-    end
-  end
-
 end

data/lib/web47core.rb

@@ -1,8 +1,12 @@
 require 'app/models/concerns/app47_logger'
 require 'app/models/concerns/cdn_url'
+require 'app/models/concerns/email_able'
+require 'app/models/concerns/search_able'
+require 'app/models/concerns/time_zone_able'
 require 'app/models/concerns/standard_model'
 require 'app/models/concerns/core_system_configuration'
 require 'app/models/concerns/core_account'
+require 'app/models/redis_configuration'
 require 'app/models/notification'
 require 'app/models/template'
 require 'app/models/notification_template'

data/test/fixtures/redis/host.yml

@@ -0,0 +1,5 @@
+test:
+  host: 127.0.0.1
+  port: 6378
+  db: 8
+  namespace: 'cache'

data/test/fixtures/redis/options.yml

@@ -0,0 +1,8 @@
+test:
+  host: 127.0.0.2
+  port: 6372
+  db: 7
+  connect_timeout: 0.2
+  read_timeout: 0.2
+  write_timeout: 0.2
+  timeout: 1