hey-you 0.1.6

data/lib/hey_you/builder/email.rb

@@ -0,0 +1,17 @@
+require_relative '_base'
+
+module HeyYou
+  class Builder
+    class Email < Base
+      attr_reader :subject, :body, :layout, :mailer_class, :mailer_method, :delivery_method
+
+      def build
+        @mailer_class = ch_data.fetch('mailer_class', nil)
+        @mailer_method = ch_data.fetch('mailer_method', nil)
+        @delivery_method = ch_data.fetch('delivery_method', nil)
+        @body = interpolate(ch_data.fetch('body'), options)
+        @subject = interpolate(ch_data.fetch('subject'), options)
+      end
+    end
+  end
+end

data/lib/hey_you/builder/push.rb

@@ -0,0 +1,15 @@
+require_relative '_base'
+
+module HeyYou
+  class Builder
+    class Push < Base
+      attr_reader :body, :title, :data
+
+      def build
+        @title = interpolate(ch_data.fetch('title'), options)
+        @body = interpolate(ch_data.fetch('body'), options)
+        @data = options[:data] || {}
+      end
+    end
+  end
+end

data/lib/hey_you/builder.rb

@@ -0,0 +1,51 @@
+require 'i18n'
+require_relative 'builder/email'
+require_relative 'builder/push'
+
+module HeyYou
+  class Builder
+    attr_reader :data, :options
+
+    # Load data from collection yaml via key and interpolate variables.
+    # Define methods for each registered channel. After initialize you can use
+    #   `instance.<ch_name>`. It will be return instance of HeyYou::Builder::<YOUR_CHANNEL_NAME>
+    #
+    def initialize(key, **options)
+      @data = fetch_from_collection_by_key(key, options[:locale])
+      @options = options
+      config.registered_channels.each do |ch|
+        ch_builder =
+          HeyYou::Builder.const_get("#{ch.downcase.capitalize}").new(data, key, options)
+        instance_variable_set("@#{ch}".to_sym, ch_builder)
+
+        define_ch_method(ch)
+      end
+    end
+
+    private
+
+    def define_ch_method(ch)
+      method_proc = -> { instance_variable_get("@#{ch}".to_sym) }
+      self.class.send(:define_method, ch, method_proc)
+    end
+
+    def fetch_from_collection_by_key(key, locale)
+      keys = []
+      if config.localization
+        locale = locale || I18n.locale
+        raise UnknownLocale, 'You should pass locale.' unless locale
+        keys << locale
+      end
+      keys = keys + key.to_s.split(config.splitter)
+      keys.reduce(config.collection) do |memo, nested_key|
+        memo[nested_key.to_s] if memo
+      end
+    end
+
+    def config
+      Config.config
+    end
+
+    class UnknownLocale < StandardError; end
+  end
+end

data/lib/hey_you/channels/_base.rb

@@ -0,0 +1,42 @@
+module HeyYou
+  module Channels
+    class Base
+      class << self
+        def send!
+          raise NotImplementedError, 'You should define #send! method in your channel.'
+        end
+
+        private
+
+        def credentials_present?
+          required_credentials.all? do |cred|
+            if config.send(self.name.split('::').last.downcase).send(cred).nil?
+              config.logger&.info(
+                "[WARN] required credential was not set. " +
+                "Set `config.#{self.name.downcase}.#{cred}` to send notification with #{self.name.downcase}"
+              )
+              return false
+            end
+            true
+          end
+        end
+
+        def required_credentials
+          []
+        end
+
+        def config
+          Config.config
+        end
+
+        def ch_name
+          self.class.name.split('::').last.downcase
+        end
+
+        def log(msg)
+          config.log("[#{ch_name.upcase}] #{msg}")
+        end
+      end
+    end
+  end
+end

data/lib/hey_you/channels/email.rb

@@ -0,0 +1,87 @@
+require_relative '_base'
+require 'mail'
+
+module HeyYou
+  module Channels
+    class Email < Base
+      class << self
+        def send!(builder, to:, **options)
+          raise CredentialsNotExists unless credentials_present?
+
+          method = config.email.default_mailing ? :send_via_mail : :send_via_custom_class
+          public_send(method, builder, to, options)
+        end
+
+        # Send email via custom class instance.
+        def send_via_custom_class(builder, to, **options)
+          mailer = mailer_class_from_builder(builder, options)
+
+          mailer_method = options[:mailer_method] ||
+            builder.email.mailer_method ||
+            config.email.default_mailer_method
+
+          delivery_method = options[:delivery_method] ||
+            builder.email.delivery_method ||
+            config.email.default_delivery_method
+
+          log("Build mail via #{mailer}##{mailer_method}. Delivery with #{delivery_method}")
+          mailer_msg = mailer.public_send(mailer_method, data: builder.email, to: to)
+          mailer_msg.public_send(delivery_method)
+        end
+
+        # Send email with standard mail (gem 'mail')
+        def send_via_mail(builder, to, **_)
+          context = self
+          mail = Mail.new do
+            from HeyYou::Config.instance.email.from
+            to to
+            subject builder.email.subject
+            body context.get_body(builder.email.body)
+          end
+
+          mail.delivery_method config.email.mail_delivery_method
+          log("Send mail #{mail}")
+          mail.deliver
+        end
+
+        def get_body(body_text)
+          # TODO: Load layout from config here.
+          body_text
+        end
+
+        def required_credentials
+          %i[from]
+        end
+
+        private
+
+        def mailer_class_from_builder(builder, **options)
+          mailer_class = options[:mailer_class] ||
+            builder.email.mailer_class ||
+            config.email.default_mailer_class
+          unless mailer_class
+            raise(
+              MailerClassNotDefined,
+              'You must set mailer_class in notifications collection or pass :mailer_class option'
+            )
+          end
+
+          begin
+            mailer = Object.const_get(mailer_class.to_s)
+          rescue NameError
+            raise ActionMailerClassNotDefined, "Mailer #{mailer_class} not initialized"
+          end
+
+          mailer
+        end
+      end
+
+      class CredentialsNotExists < StandardError;
+      end
+      class ActionMailerClassNotDefined < StandardError;
+      end
+      class MailerClassNotDefined < StandardError;
+      end
+    end
+  end
+end

data/lib/hey_you/channels/push.rb

@@ -0,0 +1,38 @@
+require_relative '_base'
+
+module HeyYou
+  module Channels
+    class Push < Base
+      class << self
+        def send!(builder, to:, **options)
+          options = build_options(builder)
+          config.logger&.info("[PUSH] Send #{options} body for #{ids(to)}")
+          config.push.fcm_client.send(ids(to), options)
+        end
+
+        private
+
+        def build_options(builder)
+          {
+            data: builder.push.data,
+            notification: {
+              title: builder.push.title,
+              body: builder.push.body
+            },
+            priority: builder.options[:priority] || config.push.priority,
+            time_to_live: config.push.ttl
+          }
+        end
+
+        def ids(to)
+          return to if to.is_a?(Array)
+          [to]
+        end
+
+        def required_credentials
+          %i[fcm_token]
+        end
+      end
+    end
+  end
+end

data/lib/hey_you/config/conigurable.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+
+module HeyYou
+  class Config
+    module Configurable
+
+      def self.extended klass
+        klass.class_eval do
+          include Singleton
+        end
+      end
+
+      def configure(&block)
+        # TODO: log warn "Already configured" instead nil
+        @configured ? nil : instance_eval(&block)
+        @configured = true
+      end
+
+      def config
+        @config ||= self.instance
+      end
+    end
+  end
+end

data/lib/hey_you/config/email.rb

@@ -0,0 +1,31 @@
+require_relative 'conigurable'
+require 'mail'
+
+module HeyYou
+  class Config
+    class Email
+      extend Configurable
+
+      MAIL_DELIVERY_METHOD = :sendmail
+      DEFAULT_ACTION_MAILER_METHOD = :send!
+      DEFAULT_DELIVERY_METHOD = :deliver_now
+
+      attr_accessor(
+        :from,
+        :mail_delivery_method,
+        :default_mailing,
+        :default_delivery_method,
+        :default_mailer_class,
+        :default_mailer_method
+      )
+
+      def initialize
+        @mail_delivery_method ||= MAIL_DELIVERY_METHOD
+        @default_mailing ||= !default_mailer_class.nil?
+        @async ||= true
+        @default_mailer_method ||= DEFAULT_ACTION_MAILER_METHOD
+        @default_delivery_method ||= DEFAULT_DELIVERY_METHOD
+      end
+    end
+  end
+end

data/lib/hey_you/config/push.rb

@@ -0,0 +1,29 @@
+require_relative 'conigurable'
+require 'fcm'
+
+module HeyYou
+  class Config
+    class Push
+      extend Configurable
+
+      DEFAULT_PRIORITY = 'high'
+      DEFAULT_TTL = 60
+      DEFAULT_FCM_TIMEOUT = 30
+
+      attr_accessor :fcm_token, :priority, :ttl, :fcm_timeout
+
+      def initialize
+        @priority = DEFAULT_PRIORITY
+        @ttl = DEFAULT_TTL
+        @fcm_timeout = DEFAULT_FCM_TIMEOUT
+      end
+
+      def fcm_client
+        raise FcmTokenNotExists, 'Can\'t create fcm client: fcm_token not exists' unless fcm_token
+        @fcm_client ||= FCM.new(fcm_token, timeout: fcm_timeout)
+      end
+
+      class FcmTokenNotExists < StandardError; end
+    end
+  end
+end

data/lib/hey_you/config.rb

@@ -0,0 +1,111 @@
+require 'yaml'
+require_relative 'config/conigurable'
+require_relative 'config/push'
+require_relative 'config/email'
+
+#
+# @config REQUIRED collection_file [String] - File path for general notifications file
+# @config OPTIONAL env_collection_file [String] - File path for environment notifications file
+# @config OPTIONAL splitter [String] - Chars for split notifications keys in builder.
+#   For example:
+#     if splitter eq `.` you can pass to notification builder 'key_1.nested_key'
+#     if splitter eq `/` you can pass to notification builder 'key_1/nested_key'
+# @config OPTIONAL registered_channels - Channels available for service. If your application
+#   planning use only push and email just set it as [:push, :email]. Default all channels
+#   will available.
+module HeyYou
+  class Config
+    extend Configurable
+
+    DEFAULT_REGISTERED_CHANNELS = %i[email push]
+    DEFAULT_SPLITTER = '.'
+    DEFAULT_GLOBAL_LOG_TAG = 'HeyYou'
+    DEFAULT_LOCALIZATION_FLAG = false
+
+    class CollectionFileNotDefined < StandardError; end
+
+    attr_reader   :collection, :env_collection, :configured, :registered_receivers
+    attr_accessor(
+      :collection_files, :env_collection_file, :splitter,
+      :registered_channels, :localization, :logger, :log_tag
+    )
+
+    def initialize
+      @registered_channels ||= DEFAULT_REGISTERED_CHANNELS
+      @splitter ||= DEFAULT_SPLITTER
+      @registered_receivers = []
+      @log_tag ||= DEFAULT_GLOBAL_LOG_TAG
+      @localization ||= DEFAULT_LOCALIZATION_FLAG
+      define_ch_config_methods
+    end
+
+    def collection_file
+      @collection_files || raise(
+        CollectionFileNotDefined,
+        'You must define HeyYou::Config.collection_files'
+      )
+    end
+
+    def collection
+      @collection ||= load_collection
+    end
+
+    def env_collection
+      @env_collection ||= load_env_collection
+    end
+
+    def registrate_receiver(receiver_class)
+      log("#{receiver_class} registrated as receiver")
+      @registered_receivers << receiver_class
+    end
+
+    # Registrate new custom channel.
+    # For successful registration, in application must be exists:
+    # 1. HeyYou::Channels::<YOUR_CHANNEL_NAME> < HeyYou::Channels::Base
+    # 2. HeyYou::Builder::<YOUR_CHANNEL_NAME> < HeyYou::Builder::Base
+    # 3. HeyYou::Config::<YOUR_CHANNEL_NAME> extended HeyYou::Config::Configurable
+    #
+    def registrate_channel(ch)
+      registered_channels << ch.to_sym
+      define_ch_config_method(ch)
+    end
+
+    def log(msg)
+      logger&.info("[#{log_tag}] #{msg} ")
+    end
+
+    private
+
+    def define_ch_config_methods
+      registered_channels.each do |ch|
+        define_ch_config_method(ch)
+      end
+    end
+
+    # Define method for fetch config of channel.
+    #
+    # For example, if ch == 'push' will define method #push for class instance.
+    # New method will return instance of channel config instance
+    def define_ch_config_method(ch)
+      method_proc = -> { self.class.const_get(ch.capitalize).config }
+      self.class.send(:define_method, ch, method_proc)
+    end
+
+    # Load yaml from collection_file and merge it with yaml from env_collection_file
+    def load_collection
+      @collection_files = [collection_files] if collection_files.is_a?(String)
+      notification_collection = {}
+      collection_files.each do |file|
+        notification_collection.merge!(YAML.load_file(file))
+      end
+      notification_collection.merge!(env_collection)
+    end
+
+    def load_env_collection
+      if env_collection_file
+        return YAML.load_file(env_collection_file) rescue { }
+      end
+      {}
+    end
+  end
+end

data/lib/hey_you/receiver.rb

@@ -0,0 +1,89 @@
+require_relative 'sender'
+
+module HeyYou
+  module Receiver
+    attr_reader :receiver_channels, :receiver_data
+
+    def self.extended klass
+      klass.class_eval do
+        # Method will be injected for instances methods of class.
+        #
+        # This can use something like: user.send_notification('key', options).
+        def send_notification(notification_key, **options)
+          Sender.send_to(self, notification_key, options)
+        end
+      end
+    end
+
+    # Registrate class as receiver.
+    # In parameters pass hash where keys - channels names, and values -
+    # procs with values for receive.
+    #
+    # For instances of classes will be created methods `#{channel_name}_ch_receive_info`
+    # after registrate your class as receiver.
+    #
+    # Example:
+    #
+    # class User
+    #   extend HeyYou::Receiver
+    #
+    #   receive(
+    #     push:  -> { push_tokens.value },
+    #     email: -> { priority_email }
+    #   )
+    #
+    #   ## Or you can use receive with options:
+    #   receive(
+    #     email: { subject: -> { priority_email }, options: { mailer_class: UserMailer, mailer_method: :notify } }
+    #   )
+    #
+    #   ...
+    # end
+    #
+    # user = User.new( push_tokens: PushToken.new(value: "456"), priority_email: 'example@mail.com')
+    # user.push_ch_receive_info # => 456
+    #
+    def receive(receiver_data)
+      check_channels(receiver_data.keys)
+
+      @receiver_data = receiver_data
+      @receiver_channels = receiver_data.keys
+      hey_you_config.registrate_receiver(self)
+
+      define_receive_info_methods
+    end
+
+    private
+
+    def check_channels(channels)
+      channels.all? do |ch|
+        next if hey_you_config.registered_channels.include?(ch.to_sym)
+        raise(
+          NotRegisteredChannel,
+          "Channel #{ch} not registered. Registered channels: #{hey_you_config.registered_channels}"
+        )
+      end
+      @received_channels = channels
+    end
+
+    def define_receive_info_methods
+      receiver_channels.each do |ch|
+        if receiver_data[ch].is_a?(Hash)
+          me = self
+          self.send(:define_method, "#{ch}_ch_receive_info", receiver_data[ch].fetch(:subject))
+          self.send(:define_method, "#{ch}_ch_receive_options", -> { me.receiver_data[ch].fetch(:options, {}) })
+        else
+          self.send(:define_method, "#{ch}_ch_receive_info", receiver_data[ch])
+          self.send(:define_method, "#{ch}_ch_receive_options", -> { {} })
+        end
+      end
+    end
+
+    def hey_you_config
+      Config.config
+    end
+
+    class NotRegisteredChannel < StandardError;
+    end
+  end
+end

data/lib/hey_you/sender.rb

@@ -0,0 +1,81 @@
+require_relative 'builder'
+
+require_relative 'channels/push'
+require_relative 'channels/email'
+
+module HeyYou
+  class Sender
+    class << self
+      # Send notifications for receiver
+      #
+      # @input receiver [Instance of receiver class] - registrated receiver
+      # @input notification_key [String] - key for notification builder
+      # @input options [Hash]
+      #   @option only [String/Array[String]] - whitelist for using channels
+      #
+      def send_to(receiver, notification_key, **options)
+        unless receiver_valid?(receiver)
+          raise NotRegisteredReceiver, "Class '#{receiver.class}' not registered as receiver"
+        end
+
+        result = send!(notification_key, receiver, **options)
+        config.log("Sender result: #{result}")
+        result
+      end
+
+      def send!(notification_key, receiver, **options)
+        to_hash = {}
+        receiver.class.receiver_channels.each do |ch|
+          to_hash[ch] = {
+            # Fetch receiver's info for sending: phone_number, email, etc
+            subject: receiver.public_send("#{ch}_ch_receive_info"),
+            # Fetch receiver's options like :mailer_class
+            options: receiver.public_send("#{ch}_ch_receive_options") || {}
+          }
+        end
+
+        builder = Builder.new(notification_key, options)
+        response = {}
+        config.registered_channels.each do |ch|
+          if channel_allowed?(ch, to_hash, builder, options)
+            config.log(
+              "Send #{ch} to #{to_hash[ch][:subject]} with data: #{builder.send(ch).data}" \
+              " and options: #{to_hash[ch][:options]}"
+            )
+            response[ch] = Channels.const_get(ch.to_s.capitalize).send!(
+              builder, to: to_hash[ch][:subject], **to_hash[ch][:options]
+            )
+          else
+            config.log("Channel #{ch} not allowed.")
+          end
+        end
+        response
+      end
+
+      private
+
+      def channel_allowed?(ch, to, builder, **options)
+        unless to[ch].is_a?(Hash) ? to[ch.to_sym][:subject] || to[ch.to_s][:subject] : to[ch.to_sym] || to[ch.to_s]
+          return false
+        end
+        channel_allowed_by_only?(ch, options[:only]) && !builder.send(ch).nil?
+      end
+
+      def receiver_valid?(receiver)
+        config.registered_receivers.include?(receiver.class)
+      end
+
+      def channel_allowed_by_only?(ch, only)
+        return true unless only
+        return only.map(&:to_sym).include?(ch.to_sym) if only.is_a?(Array)
+        only.to_sym == ch.to_sym
+      end
+
+      def config
+        Config.config
+      end
+    end
+
+    class NotRegisteredReceiver < StandardError; end
+  end
+end

data/lib/hey_you/version.rb

@@ -0,0 +1,3 @@
+module HeyYou
+  VERSION = "0.1.6"
+end