integral 1.4.0 → 1.5.0

data/app/mailers/integral/devise_mailer.rb

@@ -0,0 +1,6 @@
+module Integral
+  class DeviseMailer < Devise::Mailer
+    layout 'integral/mailer'
+    helper 'integral/mail'
+  end
+end

data/app/models/concerns/integral/notification/subscribable.rb

@@ -0,0 +1,67 @@
+module Integral
+  module Notification
+    module Subscribable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :integral_notification_action
+
+        has_many :notification_subscriptions, as: :subscribable, class_name: "Integral::Notification::Subscription"
+
+          after_commit on: :create do
+            create_notifications(:create)
+          end
+
+          after_commit on: :update do
+            create_notifications(:update)
+          end
+
+          after_commit on: :destroy do
+            create_notifications(:destroy)
+          end
+      end
+
+      class_methods do
+        def notification_subscriptions(omit_users:)
+          Integral::Notification::Subscription.where(subscribable_type: self.name).where.not(user_id: omit_users)
+        end
+
+        def subscribable?
+          true
+        end
+      end
+
+      def subscribable?
+        true
+      end
+
+      def notifiable_users
+        object_notification_subscriptions = notification_subscriptions.group_by(&:state)
+        object_notification_subscription_user_ids = object_notification_subscriptions.values.flatten.map(&:user_id)
+
+        class_notification_subscriptions = self.class.notification_subscriptions(omit_users: object_notification_subscription_user_ids).group_by(&:state)
+        class_notification_subscription_user_ids = class_notification_subscriptions.values.flatten.map(&:user_id)
+
+        top_level_notification_subscription_user_ids = Integral::User.where(notify_me: true).where.not(id: object_notification_subscription_user_ids + class_notification_subscription_user_ids).pluck(:id)
+
+        notifiable_user_ids = (object_notification_subscriptions['subscribed']&.map(&:user_id) || []) + (class_notification_subscriptions['subscribed']&.map(&:user_id) || []) + top_level_notification_subscription_user_ids
+        notifiable_user_ids -= [PaperTrail.request.whodunnit]
+
+        User.find(notifiable_user_ids).select { |user| Pundit.policy!(user, self).receives_notifications? }
+      end
+
+      private
+
+      # TODO Improvements:
+      # - Move into a Job - Pass through the created_at time otherwise the notification sets it when the notifcation was created, rather than when the action was committed
+      # - Anyway to create multiple in one go but still run callbacks?
+      def create_notifications(action)
+        if PaperTrail.request.whodunnit
+          notifiable_users.each do |notifiable|
+            Integral::Notification::Notification.create!(subscribable: self, recipient: notifiable, action: (integral_notification_action || action), actor_id: PaperTrail.request.whodunnit)
+          end
+        end
+      end
+    end
+  end
+end

data/app/models/integral/application_record.rb

@@ -2,5 +2,14 @@ module Integral
   # Base Integral Model.
   class ApplicationRecord < ActiveRecord::Base
     self.abstract_class = true
+
+    # @return [Array] containing available human readable statuses against there numeric value
+    def self.available_statuses(opts = { reverse: false })
+      available_statuses = statuses.map do |key, value|
+        [I18n.t("integral.statuses.#{key}"), key]
+      end
+
+      opts[:reverse] ? available_statuses.each(&:reverse!) : available_statuses
+    end
   end
 end

data/app/models/integral/category.rb

@@ -1,6 +1,11 @@
 module Integral
   # Represents a user post category
   class Category < ApplicationRecord
+    acts_as_integral({
+      backend_main_menu: { enabled: false },
+      backend_create_menu: { enabled: false }
+    })
+
     has_paper_trail class_name: 'Integral::CategoryVersion'
 
     # Slugging
@@ -16,5 +21,9 @@ module Integral
     validates_format_of :slug, with: /\A[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*\z/
     validates :title, presence: true, length: { minimum: 4, maximum: 60 }
     validates :description, presence: true, length: { minimum: 25, maximum: 300 }
+
+    def self.integral_icon
+      'tags'
+    end
   end
 end

data/app/models/integral/image.rb

@@ -3,8 +3,12 @@ module Integral
   class Image < ApplicationRecord
     before_save :touch_list_items
 
-    # Soft-deletion
-    acts_as_paranoid
+    acts_as_integral({
+      notifications: { enabled: false },
+      backend_main_menu: { order: 40 },
+      backend_create_menu: { order: 30 }
+    }) # Integral Goodness
+    acts_as_paranoid # Soft-deletion
 
     validates :file, presence: true
     validates :title, presence: true, length: { minimum: 5, maximum: 50 }
@@ -45,11 +49,44 @@ module Integral
     def self.listable_options
       {
         record_title: I18n.t('integral.backend.record_selector.images.record'),
-        selector_path: Engine.routes.url_helpers.backend_images_path,
+        selector_path: Engine.routes.url_helpers.list_backend_images_path,
         selector_title: I18n.t('integral.backend.record_selector.images.title')
       }
     end
 
+    def self.integral_icon
+      'image'
+    end
+
+    def self.integral_backend_main_menu_item
+      {
+        icon: integral_icon,
+        order: integral_options.dig(:backend_main_menu, :order),
+        label: model_name.human.pluralize,
+        url: url_helpers.send("backend_img_index_url"),
+        authorize_class: self,
+        authorize_action: :index,
+        list_items: [
+          { label: I18n.t('integral.navigation.dashboard'), url: url_helpers.send("backend_img_index_url"), authorize_class: self, authorize_action: :index },
+          { label: I18n.t('integral.actions.create'), url: url_helpers.send("new_backend_img_url"), authorize_class: self, authorize_action: :new },
+          { label: I18n.t('integral.navigation.listing'), url: url_helpers.send("list_backend_img_index_url"), authorize_class: self, authorize_action: :list },
+        ]
+      }
+    end
+
+    # @return [Hash] hash representing the class, used to render within the create menu
+    def self.integral_backend_create_menu_item
+      {
+        icon: integral_icon,
+        order: integral_options.dig(:backend_create_menu, :order),
+        label: model_name.human,
+        url: url_helpers.send("new_backend_img_url"),
+        # authorize: proc { policy(self).index? }, can't use this as self is in wrong context
+        authorize_class: self,
+        authorize_action: :new,
+      }
+    end
+
     private
 
     def touch_list_items

data/app/models/integral/list.rb

@@ -3,8 +3,12 @@ module Integral
   class List < ApplicationRecord
     default_scope { includes(:list_items) }
 
-    # Soft-deletion
-    acts_as_paranoid
+    acts_as_integral({
+      backend_main_menu: { order: 50 },
+      backend_create_menu: { order: 40 }
+    }) # Integral Goodness
+
+    acts_as_paranoid # Soft-deletion
 
     # Associations
     has_many :list_items
@@ -48,6 +52,10 @@ module Integral
       new_list
     end
 
+    def self.integral_icon
+      'list'
+    end
+
     private
 
     def validate_unlocked

data/app/models/integral/list_item.rb

@@ -1,24 +1,17 @@
 module Integral
   # Represents an item within a particular list
   class ListItem < ApplicationRecord
-    after_initialize :set_defaults
-    after_touch :touch_list
-
     # Default scope orders by priority and includes children
     default_scope { includes(:children).includes(:image).order(:priority) }
 
     # Associations
     belongs_to :list, optional: true, touch: true
     belongs_to :image, optional: true
-    has_and_belongs_to_many(:children,
-                            -> { order(:priority) },
-                            join_table: 'integral_list_item_connections',
-                            foreign_key: 'parent_id',
-                            association_foreign_key: 'child_id',
-                            class_name: 'ListItem',
-                            after_add: :touch_updated_at,
-                            after_remove: :touch_updated_at,
-                            optional: true)
+    has_many :list_item_connections, foreign_key: 'parent_id'
+    has_many :children, -> { order(:priority) }, through: :list_item_connections
+    has_many :inverse_list_item_connections, class_name: "ListItemConnection", foreign_key: "child_id"
+    # NOTE: A List Item only has one parent
+    has_many :parents, :through => :inverse_list_item_connections
 
     # Validations
     validate :validate_child_absence
@@ -26,6 +19,12 @@ module Integral
     # Nested forms
     accepts_nested_attributes_for :children, reject_if: :all_blank, allow_destroy: true
 
+    # Callbacks
+    after_initialize :set_defaults
+    after_commit :touch_parent, on: :update
+    after_destroy :touch_parent
+    after_touch :touch_list
+
     # @return [Array] list of types available for a list item
     def self.types_collection
       collection = [
@@ -69,8 +68,9 @@ module Integral
       self.type ||= 'Integral::Basic'
     end
 
-    def touch_updated_at(_list_item)
-      touch if persisted?
+    def touch_parent
+      parent = parents.first
+      parent.touch if parent.present? && parent.persisted?
     end
 
     def touch_list

data/app/models/integral/list_item_connection.rb

@@ -0,0 +1,6 @@
+module Integral
+  class ListItemConnection < ApplicationRecord
+    belongs_to :parent, touch: true, class_name: 'Integral::ListItem'
+    belongs_to :child, touch: true, class_name: 'Integral::ListItem', dependent: :destroy
+  end
+end

data/app/models/integral/notification/notification.rb

@@ -0,0 +1,28 @@
+module Integral
+  module Notification
+    class Notification < ApplicationRecord
+      belongs_to :recipient, class_name: "User"
+      belongs_to :actor, class_name: "User", optional: true
+      belongs_to :subscribable, polymorphic: true
+
+      scope :unread, ->{ where(read_at: nil) }
+      scope :recent, ->{ order(created_at: :desc).limit(per_page) }
+
+      self.per_page = 8
+
+      validates :action, presence: true
+
+      def read!
+        update!(read_at: Time.now())
+      end
+
+      def unread?
+        read_at.nil?
+      end
+
+      def to_partial_path
+        'integral/backend/notifications/notification'
+      end
+    end
+  end
+end

data/app/models/integral/notification/subscription.rb

@@ -0,0 +1,14 @@
+module Integral
+  module Notification
+    class Subscription < ApplicationRecord
+      self.table_name = 'integral_notification_subscriptions'
+
+      belongs_to :subscribable, polymorphic: true, optional: true
+      belongs_to :user
+
+      enum state: { subscribed: 'subscribed', unsubscribed: 'unsubscribed' }
+
+      validates :subscribable_type, :state, presence: true
+    end
+  end
+end

data/app/models/integral/page.rb

@@ -4,6 +4,11 @@ module Integral
     include LazyContentable
 
     acts_as_paranoid # Soft-deletion
+    acts_as_integral({
+      backend_main_menu: { order: 20 },
+      backend_create_menu: { order: 10 }
+    }) # Integral Goodness
+
     acts_as_listable # Listable Item
 
     has_paper_trail class_name: 'Integral::PageVersion'
@@ -35,6 +40,7 @@ module Integral
 
     # Callbacks
     before_save :set_paper_trail_event
+    before_save :set_integral_notification_action
 
     # Scopes
     scope :search, ->(query) { where('lower(title) LIKE ? OR lower(path) LIKE ?', "%#{query.downcase}%", "%#{query.downcase}%") }
@@ -71,11 +77,15 @@ module Integral
       {
         icon: 'file',
         record_title: I18n.t('integral.backend.record_selector.pages.record'),
-        selector_path: Engine.routes.url_helpers.backend_pages_path,
+        selector_path: Engine.routes.url_helpers.list_backend_pages_path,
         selector_title: I18n.t('integral.backend.record_selector.pages.title')
       }
     end
 
+    def self.integral_icon
+      'file'
+    end
+
     # @return [Hash] the instance as a card
     def to_card
       # subtitle = self.published_at.present? ? I18n.t('integral.blog.posted_ago', time: time_ago_in_words(self.published_at)) : I18n.t('integral.records.status.draft')
@@ -136,13 +146,10 @@ module Integral
       end
     end
 
-    # @return [Array] containing available human readable statuses against there numeric value
-    def self.available_statuses
-      [
-        ['Draft', 0],
-        ['Published', 1],
-        ['Archived', 2]
-      ]
+    def set_integral_notification_action
+      if persisted? && published? && status_changed?
+        self.integral_notification_action = :publish
+      end
     end
 
     def validate_parent_is_available

data/app/models/integral/post.rb

@@ -5,6 +5,10 @@ module Integral
     include LazyContentable
     include Webhook::Observable
 
+    acts_as_integral({
+      backend_main_menu: { order: 30, enabled: Integral.blog_enabled? },
+      backend_create_menu: { order: 20, enabled: Integral.blog_enabled? }
+    }) # Integral Goodness
     acts_as_paranoid # Soft-deletion
     acts_as_listable if Integral.blog_enabled? # Listable Item
     acts_as_taggable # Tagging
@@ -21,7 +25,7 @@ module Integral
     self.per_page = 8 if respond_to? :per_page
 
     # Associations
-    belongs_to :user
+    belongs_to :user, -> { with_deleted }
     belongs_to :category
     belongs_to :image, class_name: 'Integral::Image', optional: true
     belongs_to :preview_image, class_name: 'Integral::Image', optional: true
@@ -45,16 +49,6 @@ module Integral
     # Scopes
     scope :search, ->(query) { where('lower(title) LIKE ? OR lower(slug) LIKE ?', "%#{query.downcase}%", "%#{query.downcase}%") }
 
-    # @return [Array] containing available human readable statuses against there numeric value
-    def self.available_statuses(opts = { reverse: false })
-      statuses = [
-        [I18n.t('integral.records.status.draft'), 0],
-        [I18n.t('integral.records.status.published'), 1]
-      ]
-
-      opts[:reverse] ? statuses.each(&:reverse!) : statuses
-    end
-
     # Increments the view count of the post if a PostViewing is successfully added
     #
     # @param ip_address [String] Viewers IP address
@@ -101,11 +95,15 @@ module Integral
       {
         icon: 'rss',
         record_title: I18n.t('integral.backend.record_selector.posts.record'),
-        selector_path: Engine.routes.url_helpers.backend_posts_path,
+        selector_path: Engine.routes.url_helpers.list_backend_posts_path,
         selector_title: I18n.t('integral.backend.record_selector.posts.title')
       }
     end
 
+    def self.integral_icon
+      'rss'
+    end
+
     # @return [String] Current tag context
     def tag_context
       status
@@ -166,7 +164,7 @@ module Integral
     end
 
     def deliver_published_webhook_on_update
-      deliver_webhook(:published) if status_changed? && published?
+      deliver_webhook(:published) if saved_change_to_status? && published?
     end
 
     def deliver_published_webhook_on_create

data/app/models/integral/user.rb

@@ -1,8 +1,11 @@
 module Integral
   # User model used to represent a authenticated user
   class User < ApplicationRecord
-    # Soft-deletion
-    acts_as_paranoid
+    acts_as_paranoid # Soft-deletion
+    acts_as_integral({
+      backend_main_menu: { order: 60 },
+      backend_create_menu: { order: 50 }
+    }) # Integral Goodness
 
     mount_uploader :avatar, AvatarUploader
     process_in_background :avatar
@@ -11,9 +14,14 @@ module Integral
     # :confirmable, :timeoutable, :omniauthable, registerable and lockable
     devise :invitable, :database_authenticatable, :recoverable, :rememberable, :trackable, :validatable
 
+    enum status: %i[pending active blocked]
+
     # Relations
     has_many :role_assignments
     has_many :roles, through: :role_assignments
+    # notification_subscription is used by Subscribable concern - Users can have notification_subscriptions AND be subscribable
+    has_many :own_notification_subscriptions, class_name: "Integral::Notification::Subscription"
+    has_many :notifications, class_name: "Integral::Notification::Notification", foreign_key: :recipient_id
 
     # Validations
     validates :name, :email, presence: true
@@ -34,6 +42,10 @@ module Integral
       roles.map { |r| r.name.underscore.to_sym }.any? { |user_role| role_sym.include?(user_role) }
     end
 
+    def self.integral_icon
+      'user'
+    end
+
     # @return [Array] containing available locales
     def self.available_locales
       available_locales = []
@@ -56,6 +68,37 @@ module Integral
       super
     end
 
+    def multiple_page_notifications?
+      notifications.count > Integral::Notification::Notification.per_page
+    end
+
+    # @param subscribable [Class or Instance]
+    def receives_notifications_for?(subscribable)
+      if subscribable.is_a?(Class)
+        subscription = own_notification_subscriptions.find_by(subscribable_type: subscribable.name, subscribable_id: nil)
+
+        return subscription.subscribed? if subscription
+      else
+        instance_subscription = own_notification_subscriptions.find_by(subscribable_type: subscribable.class.name, subscribable_id: subscribable.id)
+
+        return instance_subscription.subscribed? if instance_subscription
+
+        class_level_subscription = own_notification_subscriptions.find_by(subscribable_type: subscribable.class.name, subscribable_id: nil)
+
+        return class_level_subscription.subscribed? if class_level_subscription
+      end
+
+      notify_me
+    end
+
+    def active_for_authentication?
+      super && !blocked?
+    end
+
+    def inactive_message
+      blocked? ? :blocked : super
+    end
+
     private
 
     def send_devise_notification(notification, *args)