integral 1.0.0

data/lib/integral/list_renderer.rb

@@ -0,0 +1,91 @@
+module Integral
+  # Handles safely rendering lists
+  class ListRenderer
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::AssetTagHelper
+    include ActionView::Context
+
+    attr_accessor :list, :opts
+
+    # Renders the provided list with options given
+    #
+    # @return [String] the rendered list
+    def self.render(list, opts = {})
+      renderer = new(list, opts)
+      renderer.render_safely.html_safe
+    end
+
+    # @param list [List] object to render
+    # @param opts [Hash] options hash
+    def initialize(list, opts = {})
+      @opts = opts.reverse_merge(
+        item_renderer: ListItemRenderer,
+        item_renderer_opts: {},
+        wrapper_element: 'ul'
+      )
+
+      @list = list
+    end
+
+    # Performs checks before rendering to see if provided list exists and contains list items
+    def render_safely
+      return render_no_list_warning if list.nil?
+      return render_no_items_warning if list.list_items.empty?
+
+      render
+    end
+
+    # Renders the provided list
+    #
+    # @return [String] the rendered list item
+    def render
+      rendered_items = ''
+
+      list.list_items.each do |list_item|
+        rendered_items += render_item(list_item)
+      end
+
+      content_tag opts[:wrapper_element], rendered_items, html_options, false
+    end
+
+    private
+
+    # @return [String] HTML comment informing nil argument was provided as the list
+    def render_no_list_warning
+      Rails.logger.debug('IntegralMessage: Tried to render a list with a nil argument.')
+      '<!-- Warning: Tried to render a list with a nil argument. -->'
+    end
+
+    # @return [String] HTML comment informing list contains 0 items
+    def render_no_items_warning
+      Rails.logger.debug('IntegralMessage: Tried to render a list with no items.')
+      '<!-- Warning: Tried to render a list with no items. -->'
+    end
+
+    def html_options
+      opts = {}
+      opts[:id] = html_id if html_id.present?
+      opts[:class] = html_classes if html_classes.present?
+      opts[:data] = self.opts[:data_attributes]
+
+      opts
+    end
+
+    def render_item(item)
+      opts[:item_renderer].render(item, opts[:item_renderer_opts])
+    end
+
+    def html_id
+      return list.html_id if list.html_id.present?
+      return opts[:html_id] if opts[:html_id].present?
+      ''
+    end
+
+    def html_classes
+      return list.html_classes unless opts[:html_classes].present?
+
+      "#{list.html_classes} #{opts[:html_classes]}"
+    end
+  end
+end

data/lib/integral/middleware/page_router.rb

@@ -0,0 +1,84 @@
+module Integral
+  # Integral Middleware
+  module Middleware
+    # Handles dynamic page routing.
+    # Checks all GET requests to see if the PATH matches an Integral::Page path
+    # If a match is found the PATH is rewritten from human readable into something Rails
+    # router understands. i.e. '/company/who-we-are' -> /pages/12
+    class PageRouter
+      def initialize(app)
+        @app = app
+      end
+
+      # Handles dynamic Integral::Page routing.
+      def call(env)
+        request = Rack::Request.new(env)
+
+        # Return early if request is not a GET
+        return @app.call(env) unless request.get?
+
+        # Return early if request is within backend area
+        backend_path = "/#{Integral.backend_namespace}/"
+        return @app.call(env) if request.path_info.starts_with?(backend_path)
+
+        # Rewrites path if the request linked to an Integral::Page
+        rewrite_path(env, request.path_info)
+
+        @app.call(env)
+      end
+
+      private
+
+      # Checks to see if path is linked to a page
+      # TODO: Rather than hitting the DB on each request here a Redis solution could be implemented
+      #
+      # @param path [String] Path the request is linked to
+      #
+      # @return [Integer] ID of the Integral::Page the path is linked to
+      def page_identifier(path)
+        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
+      end
+
+      # Converts the request path from human readable into something Rails router understands
+      # i.e. '/company/who-we-are' -> /pages/12
+      #
+      # @param env [Hash] Environment of the request
+      # @param path [String] Path the request is linked to
+      #
+      # @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?
+
+        rewritten_path = "/pages/#{page_id}"
+        env['PATH_INFO'] = rewritten_path
+      rescue StandardError => error
+        handle_rewrite_error(error)
+      end
+
+      # Homepage ID as defined by User within backend settings
+      # Possibly should add a fallback to return Page.first if settings is available
+      #
+      # @return [String] Homepage ID
+      def dynamic_homepage
+        page_id = Integral::Settings['homepage_id']
+        handle_nil_homepage if page_id.nil?
+
+        page_id
+      end
+
+      # Handles if an error occurs when rewriting path
+      def handle_rewrite_error(error)
+        Rails.logger.debug("IntegralMessage: #{error}")
+      end
+
+      # Handles if Dynamic Homepage is enabled & ID is not set
+      def handle_nil_homepage
+        Rails.logger.debug('IntegralMessage: Dynamic Homepage is nil. Set within Backend Settings.')
+      end
+    end
+  end
+end

data/lib/integral/partial_list_item_renderer.rb

@@ -0,0 +1,40 @@
+module Integral
+  # Allow list items to be renderered through a partial
+  class PartialListItemRenderer < Integral::ListItemRenderer
+    def initialize(list_item, opts = {})
+      super
+
+      raise_if_partial_path_missing
+    end
+
+    # Override Integral::ListItemRenderer#render_item
+    def render_item
+      partial_opts = {
+        title: title,
+        subtitle: subtitle,
+        description: description,
+        url: url,
+        image: image(@opts[:image_version]),
+        type: list_item.type,
+        object: object_available? ? list_item.object.decorate : nil
+      }
+
+      controller.render partial: @opts[:partial_path], locals: partial_opts, layout: false
+    end
+
+    private
+
+    def raise_if_partial_path_missing
+      return if @opts[:partial_path].present?
+
+      error_msg = 'PartialListItemRenderer requires the partial_path (pass this in via opts hash)'
+      raise ArgumentError, error_msg
+    end
+
+    def controller
+      return @opts[:controller] if @opts[:controller].present?
+
+      ApplicationController
+    end
+  end
+end

data/lib/integral/router.rb

@@ -0,0 +1,106 @@
+module Integral
+  # Handles Integral routing
+  class Router
+    # Loads Integral routes
+    def self.load
+      draw_root
+      draw_frontend
+      draw_backend
+    end
+
+    # Draws root route
+    def self.draw_root
+      Integral::Engine.routes.draw do
+        if Integral.dynamic_homepage_enabled?
+          root 'pages#show'
+        else
+          root Integral.root_path
+        end
+      end
+    end
+
+    # Draws frontend routes including dynamic pages and blog routes
+    def self.draw_frontend
+      Integral::Engine.routes.draw do
+        # Dynamic pages (URLs are rewritten in Integral::Middleware::PageRouter)
+        resources :pages, only: %i[show]
+
+        # Visitor enquiries & newsletter signups
+        post 'contact', to: 'contact#contact'
+        post 'newsletter_signup', to: 'contact#newsletter_signup'
+
+        # Frontend Blog routes
+        if Integral.blog_enabled?
+          scope Integral.blog_namespace do
+            resources :tags, only: %i[index show]
+          end
+          # Post Routing must go after tags otherwise it will override
+          resources Integral.blog_namespace, only: %i[show index], as: :posts, controller: 'posts'
+        end
+      end
+    end
+
+    # Draws backend routes
+    def self.draw_backend
+      Integral::Engine.routes.draw do
+        # Backend [User Only]
+        scope Integral.backend_namespace do
+          # User Authentication
+          devise_for :users, class_name: 'Integral::User', module: :devise
+
+          # WYSIWYG Editor
+          mount Ckeditor::Engine => '/ckeditor'
+        end
+
+        namespace :backend, path: Integral.backend_namespace do
+          get '/', to: 'static_pages#dashboard', as: 'dashboard'
+
+          # User account Profile route
+          get 'account', to: 'users#account'
+
+          # User Management
+          resources :users
+
+          # Image Management
+          resources :images, as: :img
+
+          # Page Management
+          resources :pages, except: [:show] do
+            member do
+              get 'activities', controller: 'pages'
+              get 'activities/:activity_id', to: 'pages#activity', as: :activity
+            end
+          end
+
+          # Activity Management
+          resources :activities, only: %i[index show] do
+            collection do
+              post 'grid'
+            end
+          end
+
+          # Post Management
+          if Integral.blog_enabled?
+            resources :posts, except: [:show] do
+              member do
+                get 'activities', controller: 'posts'
+                get 'activities/:activity_id', to: 'posts#activity', as: :activity
+              end
+              # resources :comments, only: [:create, :destroy]
+            end
+          end
+
+          # List Management
+          resources :lists do
+            member do
+              post 'clone'
+            end
+          end
+
+          # Settings Management
+          resources :settings, only: %i[index create]
+        end
+      end
+    end
+  end
+end

data/lib/integral/slack_bot.rb

@@ -0,0 +1,45 @@
+module Integral
+  # Interacts with Slack web hook
+  class SlackBot
+    # @param opts [Hash] web hook options
+    def self.ping(opts)
+      return if Integral.slack_web_hook_url.blank?
+
+      slackbot = SlackBot.new(Integral.slack_web_hook_url)
+      slackbot.ping(opts)
+    end
+
+    # @param web_hook_url [String] Slack web hook URL to ping
+    def initialize(web_hook_url)
+      @bot = Slack::Notifier.new(web_hook_url)
+    end
+
+    # @param message_options [Hash] containing slack message options
+    def ping(message_options)
+      ping_opts = {}
+      slack_message = message(message_options[:message])
+
+      response = @bot.ping(slack_message.deep_stringify_keys, ping_opts)
+
+      log_error_message(response) if response != '200'
+    end
+
+    private
+
+    def log_error_message(response)
+      log_message = "Not able to ping slack: #{response.body}"
+      Rails.logger.error log_message
+    end
+
+    def message(options)
+      message = {
+        attachments: [{
+          color: '#d31a5e'
+        }]
+      }
+
+      message[:attachments].first.merge!(options)
+      message
+    end
+  end
+end

data/lib/integral/swiper_list_renderer.rb

@@ -0,0 +1,30 @@
+module Integral
+  # Swiper list renderer - Renders list items within swiper container
+  class SwiperListRenderer < Integral::ListRenderer
+    # Override Integral::ListRenderer#render to wrap swiper-container around all rendered_items
+    def render
+      rendered_items = ''
+      swiper_classes = 'swiper-container list-generated-swiper'
+      list_items = list.list_items.to_a
+
+      list_items.each do |list_item|
+        rendered_items += render_item(list_item)
+      end
+
+      if opts[:html_classes].present?
+        opts[:html_classes] += " #{swiper_classes}"
+      else
+        opts[:html_classes] = swiper_classes
+      end
+
+      rendered_items = [
+        "<div class='swiper-wrapper'>#{rendered_items}</div>",
+        "<div class='swiper-button-prev'></div>",
+        "<div class='swiper-button-next'></div>",
+        "<div class='swiper-pagination'></div>"
+      ].join
+
+      content_tag :div, rendered_items, html_options, false
+    end
+  end
+end

data/lib/integral/version.rb

@@ -0,0 +1,5 @@
+# :nocov:
+module Integral
+  # Integral Version
+  VERSION = '1.0.0'.freeze
+end

data/lib/integral/widgets/recent_posts.rb

@@ -0,0 +1,41 @@
+module Integral
+  # Widgets used to generate dynamic content
+  module Widgets
+    # Outputs recent posts
+    #
+    # Example Widget Markup
+    # <p class='integral-widget' data-widget-type='recent_posts' data-widget-value-tagged='awesome-tag'>
+    class RecentPosts
+      # Render the recent posts
+      def self.render(options = {})
+        options = options.reverse_merge(default_options)
+
+        controller.render(
+          partial: 'integral/posts/collection',
+          locals: { collection: skope(options) },
+          layout: false
+        )
+      end
+
+      # Frontend controller used to render views
+      def self.controller
+        Integral.frontend_parent_controller.constantize
+      end
+
+      # Default widget options
+      def self.default_options
+        {
+          amount: 2,
+          tagged: ''
+        }
+      end
+
+      # Scope of the widget
+      def self.skope(options)
+        skope = Integral::Post.published
+        skope = skope.tagged_with(options[:tagged].split) if options[:tagged].present?
+        skope.limit(options[:amount])
+      end
+    end
+  end
+end