noticent 0.0.1.pre.pre → 0.0.1

data/config.ru

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler"
+
+Bundler.require :default, :development
+
+Combustion.initialize! :all
+run Combustion::Application

data/lib/noticent.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require 'active_support/all'
+require "active_support/all"
+require "rails/all"
 
 Dir["#{File.dirname(__FILE__)}/noticent/**/*.rb"].each { |f| load(f) }
 load "#{File.dirname(__FILE__)}/generators/noticent/noticent.rb"

data/lib/noticent/active_record_opt_in_provider.rb

@@ -8,7 +8,7 @@ module Noticent
     end
 
     def opt_out(recipient_id:, scope:, entity_id:, alert_name:, channel_name:)
-      Noticent::OptIn.where(recipient_id: recipient_id, scope: scope, entity_id: entity_id, alert_name: alert_name, channel_name: channel_name).delete
+      Noticent::OptIn.where(recipient_id: recipient_id, scope: scope, entity_id: entity_id, alert_name: alert_name, channel_name: channel_name).destroy_all
     end
 
     def opted_in?(recipient_id:, scope:, entity_id:, alert_name:, channel_name:)
@@ -33,5 +33,14 @@ module Noticent
     def remove_alert(scope:, alert_name:)
       Noticent::OptIn.where('scope = ? AND alert_name = ?', scope, alert_name).destroy_all
     end
+
+    def remove_entity(scope:, entity_id:)
+      Noticent::OptIn.where('scope = ? AND entity_id = ?', scope, entity_id).destroy_all
+    end
+
+    def remove_recipient(recipient_id:)
+    Noticent::OptIn.where(recipient_id: recipient_id).destroy_all
+    end
+
   end
 end

data/lib/noticent/channel.rb

@@ -2,41 +2,30 @@
 
 module Noticent
   class Channel
-    @@default_ext = :erb
-    @@default_format = :html
+    class_attribute :default_ext, default: :erb
+    class_attribute :default_format, default: :html
 
-    def initialize(config, recipients, payload, context)
+    attr_accessor :data
+
+    def initialize(config, recipients, payload, configuration)
       @config = config
       @recipients = recipients
       @payload = payload
-      @context = context
+      @configuration = configuration
       @current_user = payload.current_user if payload.respond_to? :current_user
+      @routes = Rails.application.routes.url_helpers
     end
 
-    def render_within_context(template, content)
-      rendered_content = ERB.new(content).result(get_binding)
-      template.nil? ? rendered_content : ERB.new(template).result(get_binding { rendered_content })
+    def render_within_context(template:, content:, context:)
+      @content = ERB.new(content).result(context)
+      template.nil? ? @content : ERB.new(template).result(binding)
     end
 
     protected
 
     attr_reader :payload
     attr_reader :recipients
-    attr_reader :context
-
-    class << self
-      def default_format(format)
-        @@default_format = format
-      end
-
-      def default_ext(ext)
-        @@default_ext = ext
-      end
-    end
-
-    def get_binding
-      binding
-    end
+    attr_reader :configuration
 
     def current_user
       raise Noticent::NoCurrentUser if @current_user.nil?
@@ -44,15 +33,13 @@ module Noticent
       @current_user
     end
 
-    def render(format: @@default_format, ext: @@default_ext, layout: '')
+    def render(format: default_format, ext: default_ext, layout: "")
       alert_name = caller[0][/`.*'/][1..-2]
-      channel_name = self.class.name.split('::').last.underscore
+      channel_name = self.class.name.split("::").last.underscore
       view_filename, layout_filename = filenames(channel: channel_name, alert: alert_name, format: format, ext: ext, layout: layout)
 
-      raise Noticent::ViewNotFound, "view #{view_filename} not found" unless File.exist?(view_filename)
-
       view = View.new(view_filename, template_filename: layout_filename, channel: self)
-      view.process
+      view.process(binding)
 
       [view.data, view.content]
     end
@@ -60,16 +47,22 @@ module Noticent
     private
 
     def view_file(channel:, alert:, format:, ext:)
-      File.join(@config.view_dir, channel, "#{alert}.#{format}.#{ext}")
+      view_filename = File.join(@config.view_dir, channel, "#{alert}.#{format}.#{ext}")
+      if !File.exist?(view_filename)
+        # no specific file found, use a convention
+        view_filename = File.join(@config.view_dir, channel, "default.#{format}.#{ext}")
+        raise Noticent::ViewNotFound, "view #{view_filename} not found" unless File.exist?(view_filename)
+      end
+
+      return view_filename
     end
 
     def filenames(channel:, alert:, format:, ext:, layout:)
       view_filename = view_file(channel: channel, alert: alert, format: format, ext: ext)
-      layout_filename = ''
-      layout_filename = File.join(@config.view_dir, 'layouts', "#{layout}.#{format}.#{ext}") unless layout == ''
+      layout_filename = ""
+      layout_filename = File.join(@config.view_dir, "layouts", "#{layout}.#{format}.#{ext}") unless layout == ""
 
       return view_filename, layout_filename
     end
-
   end
 end

data/lib/noticent/config.rb

@@ -2,17 +2,20 @@
 
 module Noticent
   def self.configure(options = {}, &block)
-    if ENV['NOTICENT_RSPEC'] == '1'
+    if ENV["NOTICENT_RSPEC"] == "1"
       options = options.merge(
-        base_module_name: 'Noticent::Testing',
+        base_module_name: "Noticent::Testing",
         base_dir: File.expand_path("#{File.dirname(__FILE__)}/../../testing"),
-        halt_on_error: true
+        halt_on_error: true,
       )
     end
 
     @config = Noticent::Config::Builder.new(options, &block).build
     @config.validate!
 
+    # construct dynamics
+    @config.create_dynamics
+
     @config
   end
 
@@ -28,12 +31,38 @@ module Noticent
     engine.dispatch
   end
 
+  # recipient is the recipient object id
+  # entities is an array of all entity ids this recipient needs to opt in based on the alert defaults
+  # scope is the name of the scope these entities belong to
+  def self.setup_recipient(recipient_id:, scope:, entity_ids:)
+    raise ArgumentError, "no scope named '#{scope}' found" if @config.scopes[scope].nil?
+
+    alerts = @config.alerts_by_scope(scope)
+
+    alerts.each do |alert|
+      channels = @config.alert_channels(alert.name)
+
+      channels.each do |channel|
+        next unless alert.default_for(channel.name)
+
+        entity_ids.each do |entity_id|
+          @config.opt_in_provider.opt_in(recipient_id: recipient_id,
+                                         scope: scope,
+                                         entity_id: entity_id,
+                                         alert_name: alert.name,
+                                         channel_name: channel.name)
+        end
+      end
+    end
+  end
+
   class Config
     attr_reader :hooks
     attr_reader :channels
     attr_reader :scopes
     attr_reader :alerts
     attr_reader :products
+    attr_reader :channel_groups
 
     def initialize(options = {})
       @options = options
@@ -46,12 +75,6 @@ module Noticent
       @channels.values.select { |x| x.group == group }
     end
 
-    def channel_groups
-      return [] if @channels.nil?
-
-      @channels.values.collect(&:group).uniq
-    end
-
     def alert_channels(alert_name)
       alert = @alerts[alert_name]
       raise ArgumentError, "no alert #{alert_name} found" if alert.nil?
@@ -90,23 +113,46 @@ module Noticent
     end
 
     def halt_on_error
-      @options[:halt_on_error].nil? || false
+      @options[:halt_on_error].nil? ? false : @options[:halt_on_error]
+    end
+
+    def skip_alert_with_no_subscribers
+      @options[:skip_alert_with_no_subscribers].nil? ? false : @options[:skip_alert_with_no_subscribers]
+    end
+
+    def default_value
+      @options[:default_value].nil? ? false : @options[:default_value]
+    end
+
+    def use_sub_modules
+      @options[:use_sub_modules].nil? ? false : @options[:use_sub_modules]
     end
 
     def payload_dir
-      File.join(base_dir, 'payloads')
+      File.join(base_dir, "payloads")
     end
 
     def scope_dir
-      File.join(base_dir, 'scopes')
+      File.join(base_dir, "scopes")
     end
 
     def channel_dir
-      File.join(base_dir, 'channels')
+      File.join(base_dir, "channels")
     end
 
     def view_dir
-      File.join(base_dir, 'views')
+      File.join(base_dir, "views")
+    end
+
+    def create_dynamics
+      return if alerts.nil?
+
+      alerts.keys.each do |alert|
+        const_name = "ALERT_#{alert.to_s.upcase}"
+        next if Noticent.const_defined?(const_name)
+
+        Noticent.const_set(const_name, alert)
+      end
     end
 
     def validate!
@@ -119,7 +165,7 @@ module Noticent
       def initialize(options = {}, &block)
         @options = options
         @config = Noticent::Config.new(options)
-        raise BadConfiguration, 'no OptInProvider configured' if @config.opt_in_provider.nil?
+        raise BadConfiguration, "no OptInProvider configured" if @config.opt_in_provider.nil?
 
         instance_eval(&block) if block_given?
 
@@ -150,6 +196,14 @@ module Noticent
         @options[:halt_on_error] = value
       end
 
+      def skip_alert_with_no_subscribers=(value)
+        @options[:skip_alert_with_no_subscribers] = value
+      end
+
+      def use_sub_modules=(value)
+        @options[:use_sub_modules] = value
+      end
+
       def hooks
         if @config.hooks.nil?
           @config.instance_variable_set(:@hooks, Noticent::Definitions::Hooks.new)
@@ -177,8 +231,12 @@ module Noticent
 
       def channel(name, group: :default, klass: nil, &block)
         channels = @config.instance_variable_get(:@channels) || {}
+        channel_groups = @config.instance_variable_get(:@channel_groups) || []
 
         raise BadConfiguration, "channel '#{name}' already defined" if channels.include? name
+        raise BadConfiguration, "a channel group named '#{group}' already exists. channels and channel groups cannot have duplicates" if channel_groups.include? name
+
+        channel_groups << group
 
         channel = Noticent::Definitions::Channel.new(@config, name, group: group, klass: klass)
         hooks.run(:pre_channel_registration, channel)
@@ -188,15 +246,16 @@ module Noticent
         channels[name] = channel
 
         @config.instance_variable_set(:@channels, channels)
+        @config.instance_variable_set(:@channel_groups, channel_groups.uniq)
         channel
       end
 
-      def scope(name, payload_class: nil, &block)
+      def scope(name, payload_class: nil, check_constructor: true, &block)
         scopes = @config.instance_variable_get(:@scopes) || {}
 
         raise BadConfiguration, "scope '#{name}' already defined" if scopes.include? name
 
-        scope = Noticent::Definitions::Scope.new(@config, name, payload_class: payload_class)
+        scope = Noticent::Definitions::Scope.new(@config, name, payload_class: payload_class, check_constructor: check_constructor)
         scope.instance_eval(&block)
 
         scopes[name] = scope

data/lib/noticent/definitions/alert.rb

@@ -8,12 +8,15 @@ module Noticent
       attr_reader :notifiers
       attr_reader :config
       attr_reader :products
+      attr_reader :constructor_name
 
-      def initialize(config, name:, scope:)
+      def initialize(config, name:, scope:, constructor_name:)
         @config = config
         @name = name
         @scope = scope
+        @constructor_name = constructor_name
         @products = Noticent::Definitions::ProductGroup.new(@config)
+        @defaults = { _any_: Noticent::Definitions::Alert::DefaultValue.new(self, :_any_, config.default_value) }
       end
 
       def notify(recipient, template: '')
@@ -27,21 +30,54 @@ module Noticent
         alert_notifier
       end
 
+      def default_for(channel)
+        raise ArgumentError, "no channel named '#{channel}' found" if @config.channels[channel].nil?
+
+        @defaults[channel].nil? ? @defaults[:_any_].value : @defaults[channel].value
+      end
+
+      def default_value
+        @defaults[:_any_].value
+      end
+
+      def default(value, &block)
+        defaults = @defaults
+
+        if block_given?
+          default = Noticent::Definitions::Alert::DefaultValue.new(self, :_any_, value)
+          default.instance_eval(&block)
+
+          defaults[default.channel] = default
+        else
+          defaults[:_any_].value = value
+        end
+
+        @defaults = defaults
+
+        default
+      end
+
       def applies
         @products
       end
 
       def validate!
         channels = @config.alert_channels(@name)
+        raise BadConfiguration, "no notifiers are assigned to alert '#{@name}'" if @notifiers.nil? || @notifiers.empty?
+
         channels.each do |channel|
           raise BadConfiguration, "channel #{channel.name} (#{channel.klass}) has no method called #{@name}" unless channel.klass.method_defined? @name
         end
+
+        # if a payload class is available, we can make sure it has a constructor with the name of the event
+        raise Noticent::BadConfiguration, "payload #{@scope.payload_class} doesn't have a class method called #{name}" if @scope.check_constructor && !@scope.payload_class.respond_to?(@constructor_name)
       end
 
       # holds a list of recipient + channel
       class Notifier
         attr_reader :recipient
-        attr_reader :channel_group
+        attr_reader :channel_group # group to be notified
+        attr_reader :channel # channel to be notified
         attr_reader :template
 
         def initialize(alert, recipient, template: '')
@@ -50,13 +86,51 @@ module Noticent
           @config = alert.config
           @template = template
           @channel_group = :default
+          @channel = nil
+        end
+
+        def on(channel_group_or_name)
+          # is it a group or a channel name?
+          if @config.channel_groups.include? channel_group_or_name
+            # it's a group
+            @channel_group = channel_group_or_name
+            @channel = nil
+          elsif !@config.channels[channel_group_or_name].nil?
+            @channel_group = :_none_
+            @channel = @config.channels[channel_group_or_name]
+          else
+            # not a group and not a channel
+            raise ArgumentError, "no channel or channel group found named '#{channel_group_or_name}'"
+          end
+        end
+
+        # returns an array of all channels this notifier should send to
+        def applicable_channels
+          if @channel_group == :_none_
+            # it's a single channel
+            [@channel]
+          else
+            @config.channels_by_group(@channel_group)
+          end
         end
+      end
+
+      class DefaultValue
+        attr_reader :channel
+        attr_accessor :value
+
+        def initialize(alert, channel, value)
+          @alert = alert
+          @channel = channel
+          @value = value
+        end
+
+        def on(channel)
+          raise BadConfiguration, "no channel named '#{channel}'" if @alert.config.channels[channel].nil?
 
-        def on(channel_group)
-          # validate the group name
-          raise ArgumentError, "no channel group found named '#{channel_group}'" if @config.channels_by_group(channel_group).empty?
+          @channel = channel
 
-          @channel_group = channel_group
+          self
         end
       end
     end