integral 1.0.1 → 1.5.0

data/lib/integral/acts_as_integral.rb

@@ -0,0 +1,115 @@
+module Integral
+  # Handles adding Integral behaviour to a class
+  module ActsAsIntegral
+    DEFAULT_OPTIONS ={ notifications: { enabled: true },
+                       cards: { at_a_glance: true, },
+                       backend_main_menu: { enabled: true, order: 11 },
+                       backend_create_menu: { enabled: true, order: 1 }}.freeze
+    class << self
+      attr_writer :backend_main_menu_items
+      attr_writer :backend_create_menu_items
+      attr_writer :backend_at_a_glance_card_items
+    end
+
+    # Accessor for backend main menu items
+    def self.backend_main_menu_items
+      @backend_main_menu_items ||= []
+    end
+
+    # Accessor for backend create menu items
+    def self.backend_create_menu_items
+      @backend_create_menu_items ||= []
+    end
+
+    # Accessor for at a glance card items
+    def self.backend_at_a_glance_card_items
+      @backend_at_a_glance_card_items ||= []
+    end
+
+    # Adds item to main backend dashboard at a glance chart
+    # @param [Class] item
+    def self.add_backend_at_a_glance_card_item(item)
+      backend_at_a_glance_card_items << item unless duplicate_menu_item?(item, backend_at_a_glance_card_items)
+    end
+
+    # Adds item to create menu, expects Hash or Class
+    def self.add_backend_create_menu_item(item)
+      backend_create_menu_items << item unless duplicate_menu_item?(item, backend_create_menu_items)
+    end
+
+    # Adds item to main menu, expects Hash or Class
+    def self.add_backend_main_menu_item(item)
+      backend_main_menu_items << item unless duplicate_menu_item?(item, backend_main_menu_items)
+    end
+
+    # Checks for existing duplicates in menu. Useful in development when app reloads
+    def self.duplicate_menu_item?(item, menu)
+      duplicate_found = if item.class == Class
+                          menu.map(&:to_s).include?(item.to_s)
+                        else
+                          menu.select { |item| item.is_a?(Hash) }.map {|item| item[:id] }.include?(item[:id])
+                        end
+
+      if duplicate_found
+        Rails.logger.error("ActsAsIntegral: Item '#{item.to_s}' not added to menu as it already exists.")
+        true
+      else
+        false
+      end
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      # ActiveRecord::Base extension
+      class ActiveRecord::Base
+        # Adds integral behaviour to models
+        def self.acts_as_integral(options = {})
+          class << self
+            attr_accessor :integral_options
+
+            # @return [Hash] hash representing the class, used to render within the main menu
+            def 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_#{model_name.route_key}_url"),
+                # authorize: proc { policy(self).index? }, can't use this as self is in wrong context
+                authorize_class: self,
+                authorize_action: :index,
+                list_items: [
+                  { label: I18n.t('integral.navigation.dashboard'), url: url_helpers.send("backend_#{model_name.route_key}_url"), authorize_class: self, authorize_action: :index },
+                  { label: I18n.t('integral.actions.create'), url: url_helpers.send("new_backend_#{model_name.singular_route_key}_url"), authorize_class: self, authorize_action: :new },
+                  { label: I18n.t('integral.navigation.listing'), url: url_helpers.send("list_backend_#{model_name.route_key}_url"), authorize_class: self, authorize_action: :list },
+                ]
+              }
+            end
+
+            # @return [Hash] hash representing the class, used to render within the create menu
+            def 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_#{model_name.singular_route_key}_url"),
+                # authorize: proc { policy(self).index? }, can't use this as self is in wrong context
+                authorize_class: self,
+                authorize_action: :new,
+              }
+            end
+
+            def url_helpers
+              Integral::Engine.routes.url_helpers
+            end
+          end
+
+          self.integral_options = Integral::ActsAsIntegral::DEFAULT_OPTIONS.deep_merge(options)
+          Integral::ActsAsIntegral.add_backend_create_menu_item(self) if integral_options.dig(:backend_create_menu, :enabled)
+          Integral::ActsAsIntegral.add_backend_main_menu_item(self) if integral_options.dig(:backend_main_menu, :enabled)
+          Integral::ActsAsIntegral.add_backend_at_a_glance_card_item(self) if integral_options.dig(:cards, :at_a_glance)
+
+          include Integral::Notification::Subscribable if integral_options.dig(:notifications, :enabled)
+        end
+      end
+    end
+  end
+end

data/lib/integral/acts_as_listable.rb

@@ -2,8 +2,8 @@ module Integral
   # Handles listable behaviour
   module ActsAsListable
     class << self
-       # Keeps a track of listable objects
-       attr_writer :objects
+      # Keeps a track of listable objects
+      attr_writer :objects
      end
 
     # Accessor for listable objects
@@ -16,7 +16,7 @@ module Integral
       class ActiveRecord::Base
         # Adds listable behaviour to objects
         def self.acts_as_listable(_options = {})
-          Integral::ActsAsListable.objects << self
+          Integral::ActsAsListable.objects << self unless Integral::ActsAsListable.objects.map(&:name).include?(self.name)
 
           # @return [Hash] instance as a list item
           # Keys include: id, title, subtitle, image, description, url

data/lib/integral/chart_renderer/base.rb

@@ -24,6 +24,7 @@ module Integral
         data = process_data
 
         return respond_with_chart(data) if data_available?(data)
+
         respond_with_no_data_available
       end
 
@@ -64,6 +65,7 @@ module Integral
           data = data.map(&:uniq).uniq
 
           return true if data.length > 1
+
           data = data.first
         end
 

data/lib/integral/content_renderer.rb

@@ -3,7 +3,7 @@ module Integral
   # A widget could be used to list recent articles from the blog, featured content from a list, etc
   #
   # Example Widget Markup
-  # <p class='integral-widget' data-widget-type='recent_posts' data-widget-value-tagged='awesome-tag'>
+  # <p class='integral-widget' data-widget-type='recent_posts' data-widget-value-tagged='sweet-tag'>
   class ContentRenderer
     # Markup defining a widget
     PLACEHOLDER_SELECTOR = 'p.integral-widget'.freeze
@@ -59,8 +59,8 @@ module Integral
       return widget_not_available_message unless widget.present?
 
       widget[1].constantize.render(options)
-    rescue StandardError => error
-      respond_with_widget_error(error)
+    rescue StandardError => e
+      respond_with_widget_error(e)
     end
 
     # Handles widget errors

data/lib/integral/engine.rb

@@ -35,7 +35,6 @@ module Integral
     # require 'before_render'
     require 'friendly_id'
     require 'acts-as-taggable-on'
-    require 'slack-notifier'
     require 'paranoia'
     require 'inky'
     require 'premailer/rails'
@@ -43,6 +42,7 @@ module Integral
     require 'will_paginate-foundation'
     require 'rails-settings-cached'
     require 'gaffe'
+    require 'fast_jsonapi'
 
     isolate_namespace Integral
 
@@ -64,6 +64,15 @@ module Integral
       Integral::Engine.routes.default_url_options[:host] = Rails.application.routes.default_url_options[:host]
     end
 
+    # Menu Initializaion - Add items to menus which are not directly linked to a Modal
+    initializer "integral.backend.set_main_menu_items" do |app|
+      ActiveSupport::Notifications.subscribe 'integral.routes_loaded' do
+        Integral::ActsAsIntegral.add_backend_main_menu_item(id: :home, icon: 'home', order: 10, label: 'Home', url: Integral::Engine.routes.url_helpers.backend_dashboard_url)
+        Integral::ActsAsIntegral.add_backend_main_menu_item(id: :activities, icon: 'crosshairs', order: 90, label: 'Activities', url: Integral::Engine.routes.url_helpers.backend_activities_url, authorize: proc { policy(Integral::Version).manager? })
+        Integral::ActsAsIntegral.add_backend_main_menu_item(id: :settings, icon: 'cog', order: 100, label: 'Settings', url: Integral::Engine.routes.url_helpers.backend_settings_url, authorize: proc { current_user.admin? })
+      end
+    end
+
     # Clientside I18n
     config.assets.initialize_on_precompile = true
 
@@ -73,7 +82,7 @@ module Integral
     # Allows engine factories to be reused by application
     initializer 'model_core.factories', after: 'factory_bot.set_factory_paths' do
       if defined?(FactoryBot)
-        FactoryBot.definition_file_paths << File.expand_path('../../../spec/factories', __FILE__)
+        FactoryBot.definition_file_paths << File.expand_path('../../spec/factories', __dir__)
       end
     end
 
@@ -97,6 +106,7 @@ module Integral
         'integral/frontend.css',
         'integral/posts-hero-banner.jpg',
         'integral/demo/*',
+        'logo.png',
 
         # Backend
         'integral/backend.js',

data/lib/integral/grids/activities_grid.rb

@@ -6,7 +6,17 @@ module Integral
       include Datagrid
 
       scope do
-        Integral::UserVersion.all.union(Integral::PageVersion.all).union(Integral::PostVersion.all).union(Integral::ListVersion.all).union(Integral::ImageVersion.all).order('created_at DESC')
+        fields = [:id, :item_type, :item_id, :event, :whodunnit, :created_at]
+        scope = Integral::PageVersion.select(fields).all
+
+        [Integral::PostVersion,
+         Integral::CategoryVersion,
+         Integral::ListVersion,
+         Integral::ImageVersion,
+         Integral::UserVersion].concat(Integral.additional_tracked_classes.map { |klass| klass.version_class_name.constantize }).each do |version|
+          scope = scope.union(version.select(fields).all)
+        end
+        scope = scope.order('created_at DESC')
       end
 
       filter(:user, multiple: true) do |value|
@@ -25,12 +35,15 @@ module Integral
         where(item_id: value)
       end
 
+      filter(:created_at) do |value|
+        where("created_at < ?", value)
+      end
+
       column(:date, order: :created_at)
       column(:user, order: :whodunnit)
       column(:action, order: :event)
       column(:object, order: :item_type)
       column(:instance)
-      column(:attributes_changed)
       column(:actions)
     end
   end

data/lib/integral/grids/lists_grid.rb

@@ -14,6 +14,7 @@ module Integral
       end
 
       column(:title, order: :title)
+      column(:description, order: :description)
       column(:updated_at, order: :updated_at)
       column(:actions)
     end

data/lib/integral/grids/posts_grid.rb

@@ -21,8 +21,12 @@ module Integral
         where(user: value)
       end
 
+      filter(:category, multiple: true) do |value|
+        where(category_id: value)
+      end
+
       column(:title, order: :title)
-      column(:user, order: :user)
+      column(:category, order: :category_id)
       column(:status, order: :status)
       column(:view_count, order: :view_count)
       column(:updated_at, order: :updated_at)

data/lib/integral/grids/users_grid.rb

@@ -13,8 +13,13 @@ module Integral
         search(value)
       end
 
+      filter(:status, multiple: true) do |value|
+        where(status: value)
+      end
+
       column(:name, order: :name)
       column(:email, order: :email)
+      column(:status, order: :status)
       column(:updated_at, order: :updated_at)
       column(:actions)
     end

data/lib/integral/list_item_renderer.rb

@@ -76,6 +76,7 @@ module Integral
     # TODO: Move this onto the model level
     def type_for_dropdown
       return list_item.type unless list_item.object?
+
       list_item.object_type.to_s
     end
 
@@ -97,12 +98,13 @@ module Integral
     # @return [String] URL of list item
     def url
       return if list_item.basic?
+
       url = provide_attr(:url)
 
       return url if url.nil? || url.empty?
-      return url if url.match?(URI::DEFAULT_PARSER.make_regexp)
+      return CGI.unescape(url) if url.match?(URI::DEFAULT_PARSER.make_regexp)
 
-      "#{Rails.application.routes.default_url_options[:host]}#{url}"
+      CGI.unescape("#{Rails.application.routes.default_url_options[:host]}#{url}")
     end
 
     # @return [String] subtitle of list item

data/lib/integral/list_renderer.rb

@@ -46,7 +46,11 @@ module Integral
         rendered_items += render_item(list_item)
       end
 
-      content_tag opts[:wrapper_element], rendered_items, html_options, false
+      if opts[:wrapper_element]
+        ontent_tag opts[:wrapper_element], rendered_items, html_options, false
+      else
+        rendered_items
+      end
     end
 
     private
@@ -79,6 +83,7 @@ module Integral
     def html_id
       return list.html_id if list.html_id.present?
       return opts[:html_id] if opts[:html_id].present?
+
       ''
     end
 

data/lib/integral/middleware/page_router.rb

@@ -39,7 +39,13 @@ module Integral
         return dynamic_homepage if path == '/' && Integral.dynamic_homepage_enabled?
 
         # TODO: Speed this up by adding an index & unique constraint on path attribute
-        Integral::Page.find_by_path(path)&.id
+        Integral::Page.not_archived.find_by_path(path)&.id
+      end
+
+      def category_identifier(path)
+        return nil unless path.starts_with?("/#{Integral.blog_namespace}")
+
+        Integral::Category.select(:id, :slug).all.map { |category| [category.id, "/#{Integral.blog_namespace}/#{category.slug}"] }.find { |category| category[1] == path }&.first
       end
 
       # Converts the request path from human readable into something Rails router understands
@@ -51,12 +57,15 @@ module Integral
       # @return [String] Path Rails needs to link the request to the correct Integral::Page record
       def rewrite_path(env, path)
         page_id = page_identifier(path)
-        return if page_id.nil?
+        if page_id
+          env['PATH_INFO'] = "/pages/#{page_id}"
+        else
+          category_id = category_identifier(path)
 
-        rewritten_path = "/pages/#{page_id}"
-        env['PATH_INFO'] = rewritten_path
-      rescue StandardError => error
-        handle_rewrite_error(error)
+          env['PATH_INFO'] = "/#{Integral.blog_namespace}/categories/#{category_id}" if category_id
+        end
+      rescue StandardError => e
+        handle_rewrite_error(e)
       end
 
       # Homepage ID as defined by User within backend settings

data/lib/integral/router.rb

@@ -33,6 +33,7 @@ module Integral
         if Integral.blog_enabled?
           scope Integral.blog_namespace do
             resources :tags, only: %i[index show]
+            resources :categories, only: %i[show]
           end
           # Post Routing must go after tags otherwise it will override
           resources Integral.blog_namespace, only: %i[show index], as: :posts, controller: 'posts'
@@ -59,41 +60,74 @@ module Integral
           get 'account', to: 'users#account'
 
           # User Management
-          resources :users
+          resources :users do
+            get 'list', on: :collection
+            member do
+              put 'read_notification'
+              get 'notifications'
+              put 'block'
+              put 'unblock'
+              get 'activities', controller: 'users'
+              get 'activities/:activity_id', to: 'users#activity', as: :activity
+            end
+          end
+
+          # Notification subscription management
+          resources :notification_subscriptions, only: [:update]
 
           # Image Management
-          resources :images, as: :img
+          resources :images, as: :img do
+            get 'list', on: :collection
+
+            member do
+              get 'activities', controller: 'images'
+              get 'activities/:activity_id', to: 'images#activity', as: :activity
+            end
+          end
 
           # Page Management
-          resources :pages, except: [:show] do
+          resources :pages do
+            get 'list', on: :collection
             member do
+              post 'duplicate'
               get 'activities', controller: 'pages'
               get 'activities/:activity_id', to: 'pages#activity', as: :activity
             end
           end
 
           # Activity Management
-          resources :activities, only: %i[index show] do
+          resources :activities, only: %i[index] do
             collection do
-              post 'grid'
+              post 'widget'
             end
           end
 
           # Post Management
           if Integral.blog_enabled?
-            resources :posts, except: [:show] do
+            resources :posts do
+              get 'list', on: :collection
               member do
+                post 'duplicate'
                 get 'activities', controller: 'posts'
                 get 'activities/:activity_id', to: 'posts#activity', as: :activity
               end
               # resources :comments, only: [:create, :destroy]
             end
+            resources :categories, only: %i[create edit update destroy] do
+              member do
+                get 'activities', controller: 'categories'
+                get 'activities/:activity_id', to: 'categories#activity', as: :activity
+              end
+            end
           end
 
           # List Management
           resources :lists do
+            get 'list', on: :collection
             member do
-              post 'clone'
+              post 'duplicate'
+              get 'activities', controller: 'lists'
+              get 'activities/:activity_id', to: 'lists#activity', as: :activity
             end
           end