notification-settings 1.2.6 → 2.0.0

data/lib/notification-settings.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
 
 module NotificationSettings
-  require 'notification_settings/configuration'
+  require_relative 'notification_settings/configuration'
 
-  require 'notification_settings/engine'
+  require_relative 'notification_settings/engine'
 
   autoload :Target, 'notification_settings/target'
   autoload :Subscriber, 'notification_settings/subscriber'
   autoload :Subscribable, 'notification_settings/subscribable'
-  autoload :SettingLibrary, 'notification_settings/setting_library'
-  autoload :SubscriptionLibrary, 'notification_settings/subscription_library'
-  autoload :NotificationLibrary, 'notification_settings/notification_library'
+  autoload :Settings, 'notification_settings/settings'
+  autoload :Status, 'notification_settings/status'
+  autoload :NotificationLib, 'notification_settings/notification_lib'
   autoload :NotificationScopes, 'notification_settings/notification_scopes'
+  autoload :CategoryPreferencesForm,
+           'notification_settings/category_preferences_form'
+  autoload :DeliveryMethodPreferencesForm,
+           'notification_settings/delivery_method_preferences_form'
+  autoload :PreferencesForm, 'notification_settings/preferences_form'
 end

data/lib/notification_settings/category_preferences_form.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module NotificationSettings
+  class CategoryPreferencesForm
+    include ActiveModel::Model
+
+    NotificationSettings.configuration.categories.each do |category|
+      attribute category, :boolean, default: true
+    end
+  end
+end

data/lib/notification_settings/configuration.rb

@@ -2,29 +2,37 @@
 
 module NotificationSettings
   class << self
-    attr_accessor :configuration
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
   end
 
   def self.configure
-    self.configuration ||= Configuration.new
     yield configuration
   end
 
   class Configuration
+    attr_accessor :categories
     attr_accessor :default_category
     attr_accessor :last_seen
     attr_accessor :idle_after
     attr_accessor :offline_after
+    attr_accessor :statuses
     attr_accessor :do_not_notify_statuses
-    attr_accessor :do_not_push_statuses
+    attr_accessor :do_not_deliver_statuses
 
     def initialize
-      @default_category = 'notification'
-      @last_seen = 'last_seen'
+      @categories = [:notification]
+      @default_category = :notification
+      @last_seen = :last_seen
       @idle_after = 10.minutes
       @offline_after = 3.hours
-      @do_not_notify_statuses = []
-      @do_not_push_statuses = ['do not disturb']
+      @statuses = ['online', 'idle', 'offline', 'do not notify',
+                   'do not disturb']
+      @do_not_notify_statuses = ['do not notify']
+      @do_not_deliver_statuses = ['do not disturb']
     end
   end
 end

data/lib/notification_settings/delivery_method_preferences_form.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module NotificationSettings
+  class DeliveryMethodPreferencesForm
+    include ActiveModel::Model
+
+    attribute :enabled, :boolean, default: true
+    NotificationPusher.configuration.delivery_methods
+                      .each do |delivery_method, _|
+      attribute delivery_method, :boolean, default: true
+    end
+  end
+end

data/lib/notification_settings/engine.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rails/railtie'
+require 'rails/engine'
 require 'active_record'
 
 module NotificationSettings

data/lib/notification_settings/notification_lib.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require 'notification-handler'
+require 'active_support'
+
+module NotificationSettings
+  module NotificationLib
+    extend ActiveSupport::Concern
+
+    included do
+      before_create :validate_create
+
+      validates :category, inclusion: {
+        in: NotificationSettings.configuration.categories + [nil]
+      }
+
+      belongs_to :subscription,
+                 class_name: 'NotificationSettings::Subscription',
+                 optional: true
+
+      include NotificationSettings::NotificationLib::InstanceMethods
+    end
+
+    # rubocop:disable Metrics/ModuleLength
+    module InstanceMethods
+      def category
+        self[:category] || NotificationSettings.configuration.default_category
+      end
+
+      def deliver(delivery_methods, delivery_options = {})
+        return false unless delivery_allowed?(delivery_methods)
+
+        super
+      end
+
+      def creation_allowed?
+        status_allows_creation? &&
+          settings_allow_creation? &&
+          category_settings_allow_creation?
+      end
+
+      # delivery_methods may be an array or a single value
+      def delivery_allowed?(delivery_methods)
+        creation_allowed? &&
+          status_allows_delivery? &&
+          delivery_methods_allowed?(Array(delivery_methods))
+      end
+
+      private
+
+      def validate_create
+        throw(:abort) unless creation_allowed?
+      end
+
+      def status_allows_creation?
+        !do_not_notify_statuses.include?(target.status)
+      end
+
+      def settings_allow_creation?
+        target.settings.fetch(:enabled, true) &&
+          (subscription.nil? || subscription.settings.fetch(:enabled, true))
+      end
+
+      def category_settings_allow_creation?
+        category_settings(target, category).fetch(:enabled, true) &&
+          (subscription.nil? ||
+            category_settings(subscription, category).fetch(:enabled, true))
+      end
+
+      def delivery_methods_allowed?(delivery_methods)
+        delivery_methods.any? do |delivery_method|
+          delivery_method_allowed?(delivery_method)
+        end
+      end
+
+      def delivery_method_allowed?(delivery_method)
+        settings_allow_delivery?(delivery_method) &&
+          category_settings_allow_delivery?(delivery_method)
+      end
+
+      def status_allows_delivery?
+        !do_not_deliver_statuses.include?(target.status)
+      end
+
+      def settings_allow_delivery?(delivery_method)
+        if local_delivery_method_setting?(delivery_method)
+          local_settings_allow_delivery?(delivery_method)
+        else
+          global_settings_allow_delivery?
+        end
+      end
+
+      def local_delivery_method_setting?(delivery_method)
+        !local_delivery_method_setting(delivery_method).nil?
+      end
+
+      def local_settings_allow_delivery?(delivery_method)
+        local_delivery_method_setting(delivery_method, true)
+      end
+
+      def local_delivery_method_setting(delivery_method, default = nil)
+        delivery_method_setting(target, delivery_method, default) &&
+          (subscription.nil? ||
+            delivery_method_setting(subscription, delivery_method, default))
+      end
+
+      def global_settings_allow_delivery?
+        delivery_method_setting(target, :enabled, true) &&
+          (subscription.nil? ||
+            delivery_method_setting(subscription, :enabled, true))
+      end
+
+      def category_settings_allow_delivery?(delivery_method)
+        if local_delivery_method_category_setting?(delivery_method)
+          local_category_settings_allow_delivery?(delivery_method)
+        else
+          global_category_settings_allow_delivery?
+        end
+      end
+
+      def local_delivery_method_category_setting?(delivery_method)
+        !local_delivery_method_category_setting(delivery_method).nil?
+      end
+
+      def local_category_settings_allow_delivery?(delivery_method)
+        local_delivery_method_category_setting(delivery_method, true)
+      end
+
+      def local_delivery_method_category_setting(delivery_method, default = nil)
+        category_delivery_method_setting(target, category, delivery_method,
+                                         default) &&
+          (subscription.nil? ||
+            category_delivery_method_setting(subscription, category,
+                                             delivery_method, default))
+      end
+
+      def global_category_settings_allow_delivery?
+        category_delivery_method_setting(target, category, :enabled, true) &&
+          (subscription.nil? ||
+            category_delivery_method_setting(subscription, category, :enabled,
+                                             true))
+      end
+
+      def delivery_method_setting(object, delivery_method, default)
+        object.settings.delivery_methods_.fetch(delivery_method.to_s, default)
+      end
+
+      def category_settings(object, category)
+        object.settings.categories_.send("#{category}_")
+      end
+
+      def category_delivery_method_setting(object, category, delivery_method,
+                                           default)
+        category_settings(object, category).delivery_methods_
+                                           .fetch(delivery_method.to_s, default)
+      end
+
+      def do_not_notify_statuses
+        NotificationSettings.configuration.do_not_notify_statuses
+      end
+
+      def do_not_deliver_statuses
+        NotificationSettings.configuration.do_not_deliver_statuses
+      end
+    end
+    # rubocop:enable Metrics/ModuleLength
+  end
+end

data/lib/notification_settings/notification_scopes.rb

@@ -7,11 +7,7 @@ module NotificationSettings
   module NotificationScopes
     extend ActiveSupport::Concern
 
-    included do
-      include NotificationSettings::NotificationScopes::InstanceMethods
-    end
-
-    module InstanceMethods
+    module ClassMethods
       def method_missing(method, *args)
         if method.to_s[/(.+)_category/]
           where(category: $1.singularize.classify)

data/lib/notification_settings/preferences_form.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'active_model'
+
+module NotificationSettings
+  class PreferencesForm
+    include ActiveModel::Model
+
+    attribute :enabled, :boolean, default: true
+  end
+end

data/lib/notification_settings/settings.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'hashie'
+
+module NotificationSettings
+  module Settings
+    extend ActiveSupport::Concern
+
+    included do
+      before_validation :build_settings
+
+      serialize :settings, Hashie::Mash
+
+      include NotificationSettings::Settings::InstanceMethods
+    end
+
+    module InstanceMethods
+      private
+
+      def build_settings
+        return if settings.present? && settings.is_a?(Hashie::Mash)
+
+        self.settings = Hashie::Mash.new
+      end
+    end
+  end
+end

data/lib/notification_settings/{setting_library.rb → status.rb}

@@ -3,27 +3,33 @@
 require 'active_support'
 
 module NotificationSettings
-  module SettingLibrary
+  module Status
     extend ActiveSupport::Concern
 
     included do
-      include NotificationSettings::SettingLibrary::InstanceMethods
+      validates :status,
+                inclusion: { in: NotificationSettings.configuration.statuses }
+
+      include NotificationSettings::Status::InstanceMethods
     end
 
     module InstanceMethods
       def status
+        self[:status] || default_status
+      end
+
+      private
+
+      def default_status
         if idle? && !offline?
-          default = 'idle'
+          'idle'
         elsif offline?
-          default = 'offline'
+          'offline'
         else
           'online'
         end
-        self[:status] || default
       end
 
-      private
-
       def idle?
         return unless time_since_last_seen_round
 
@@ -41,11 +47,9 @@ module NotificationSettings
       end
 
       def time_since_last_seen
-        return unless object.respond_to?(
-          NotificationSettings.configuration.last_seen
-        )
+        return unless respond_to?(NotificationSettings.configuration.last_seen)
 
-        Time.now - object.send(NotificationSettings.configuration.last_seen)
+        Time.now - send(NotificationSettings.configuration.last_seen)
       end
 
       def idle_after

data/lib/notification_settings/subscribable.rb

@@ -7,12 +7,10 @@ module NotificationSettings
     extend ActiveSupport::Concern
 
     included do
-      has_many :notification_subscriptions,
+      has_many :notification_subscribers,
                as: :subscribable,
                class_name: 'NotificationSettings::Subscription',
                dependent: :destroy
-      has_many :notification_subscribers,
-               through: :notification_subscriptions, source: :subscriber
 
       include NotificationSettings::Subscribable::InstanceMethods
     end
@@ -20,24 +18,24 @@ module NotificationSettings
     module InstanceMethods
       def notify_subscribers(options = {})
         options[:object] = self
-        subscribers = notify_dependents(options.delete(:dependents))
-        notification_subscribers&.each do |subscriber|
-          subscribers << subscriber
+        subscriptions = notify_dependents(options.delete(:dependents))
+        notification_subscribers&.each do |subscription|
+          subscriptions << subscription
         end
-        subscribers.to_a.uniq&.each do |subscriber|
-          subscriber.notify(options)
+        subscriptions.to_a.uniq&.each do |subscription|
+          subscription.subscriber.notify(options)
         end
       end
 
       def notify_dependents(dependents)
-        subscribers = []
+        subscriptions = []
         dependents ||= notification_dependents
         dependents&.each do |dependent|
-          dependent.notification_subscribers&.each do |subscriber|
-            subscribers << subscriber
+          dependent.notification_subscribers&.each do |subscription|
+            subscriptions << subscription
           end
         end
-        subscribers
+        subscriptions
       end
 
       private

data/lib/notification_settings/subscriber.rb

@@ -7,28 +7,27 @@ module NotificationSettings
     extend ActiveSupport::Concern
 
     included do
-      has_many :notification_subscriptions,
+      has_many :notification_subscribables,
                as: :subscriber,
                class_name: 'NotificationSettings::Subscription',
                dependent: :destroy
-      has_many :notification_subscribables,
-               through: :notification_subscriptions, source: :subscribable
 
       include NotificationSettings::Subscriber::InstanceMethods
     end
 
     module InstanceMethods
       def subscribe(subscribable, options = {})
-        options[:subscribable] = subscribable
-        notification_subscriptions.create(options)
+        notification_subscribables.create(
+          options.merge(subscribable: subscribable)
+        )
       end
 
       def unsubscribe(subscribable)
-        subscription = notification_subscriptions.find_by(
+        subscription = notification_subscribables.find_by(
           subscribable_id: subscribable.id,
           subscribable_type: subscribable.class.name
         )
-        subscription.destroy
+        subscription&.destroy
       end
     end
   end