integral 1.0.1 → 1.5.0

data/app/helpers/integral/application_helper.rb

@@ -6,6 +6,13 @@ module Integral
     include Integral::BlogHelper
     include Integral::GalleryHelper
 
+    # @return [String] Javascript snippet containing LD-JSON
+    def render_json_ld
+      content_tag 'script', type: 'application/ld+json' do
+        yield.to_json.html_safe
+      end
+    end
+
     # @param [String] content HTML, most likely generated from the WYSIWYG editor
     #
     # @return [String] Processed HTML. Any Integral Widgets placeholders replaced with content.

data/app/helpers/integral/backend/base_helper.rb

@@ -5,17 +5,105 @@ module Integral
     module BaseHelper
       include Integral::SupportHelper
 
+      def render_main_menu
+        render_menu(extract_menu_items(Integral::ActsAsIntegral.backend_main_menu_items, :integral_backend_main_menu_item))
+      end
+
+      def render_create_menu
+        render_menu(extract_menu_items(Integral::ActsAsIntegral.backend_create_menu_items, :integral_backend_create_menu_item))
+      end
+
+      def recent_user_notifications
+        @recent_user_notifications ||= current_user.notifications.recent
+      end
+
+      # Handles extra optional options to `link_to` - Font awesome icons & wrapper
+      def link_to(name = nil, options = nil, html_options = nil, &block)
+        return super if block_given?
+        return super if html_options.nil?
+
+        if html_options[:icon]
+          name = content_tag(:span, name)
+          name.prepend(icon(html_options.delete(:icon)))
+        end
+
+        if html_options[:wrapper]
+          wrapper = html_options.delete(:wrapper)
+          if wrapper == :cell
+            content_tag(:div, super(name, options, html_options, &block), class: 'cell')
+          else
+            content_tag(wrapper, super(name, options, html_options, &block))
+          end
+        else
+          super(name, options, html_options, &block)
+        end
+      end
+
+      # @return [String] Resource Grid Form
+      def render_resource_grid_form(&block)
+        if block_given?
+          render(layout: "integral/backend/shared/grid/form", &block)
+        else
+          render(partial: "integral/backend/shared/grid/form")
+        end
+      end
+
+      # @return [String] Resource Grid
+      def render_resource_grid(locals = {})
+        render(partial: "integral/backend/shared/grid/grid", locals: locals)
+      end
+
+      # @return [String] Integral card
+      def render_card(partial, locals = {})
+        render(partial: "integral/backend/shared/cards/#{partial}", locals: locals)
+      end
+
+      # @return [Array] returns array of VersionDecorators subclassed depending on the Version subclass
+      def recent_user_activity_grid
+        @recent_user_activity_grid ||= begin
+                                      options = { user: current_user.id }
+                                      options[:object] = resource_klass.to_s if resource_klass.present?
+                                      options[:item_id] = @resource.id if @resource.present?
+
+                                      recent_activity_grid(options)
+                                    end
+      end
+
+      # @return [Array] returns array of VersionDecorators subclassed depending on the Version subclass
+      def recent_site_activity_grid
+        @recent_site_activity_grid ||= begin
+                                      options = {}
+                                      options[:object] = resource_klass.to_s if resource_klass.present?
+                                      options[:item_id] = @resource.id if @resource.present?
+
+                                      recent_activity_grid(options)
+                                    end
+      end
+
+      def recent_activity_grid(options)
+        #Integral::Grids::ActivitiesGrid.new(options)
+        Integral::Grids::ActivitiesGrid.new options do |scope|
+          scope.where.not(whodunnit: nil)
+        end
+      end
+
       # @return [String] title provided through yield or i18n scoped to controller namespace & action
       def page_title
         return content_for(:title) if content_for?(:title)
+        return t("devise.#{controller_name}.#{action_name}.title") if devise_controller?
 
         # Scope is set to current controller namespace & action
-        t('title', scope: "#{controller_path.tr('/', '.')}.#{action_name}")
+        t('title', scope: "#{controller_path.tr('/', '.')}.#{action_name}",
+                   default: I18n.t("integral.backend.titles.#{action_name}",
+                                   type_singular: resource_klass.model_name.human.capitalize,
+                                   type_plural: resource_klass.model_name.human(count: 2).capitalize))
       end
 
       # Renders a grid from a local partial within a datagrid container
       def render_data_grid
-        return content_tag(:div, render(partial: 'grid', locals: { grid: @grid }), data: { 'grid' => true, 'form' => 'grid_form' }) unless block_given?
+        unless block_given?
+          return content_tag(:div, render(partial: 'grid', locals: { grid: @grid }), data: { 'grid' => true, 'form' => 'grid_form' })
+        end
 
         content_tag :div, data: { 'grid' => true, 'form' => 'grid_form' } do
           yield
@@ -48,24 +136,62 @@ module Integral
         ChartRenderer::Donut.render(dataset)
       end
 
-      # Donut Graph - At a Glance
-      def dataset_dashboard_atg
-        [
-          { scope: Integral::Page, label: 'Total Pages' },
-          { scope: Integral::List, label: 'Total Lists' },
-          { scope: Integral::Image, label: 'Total Images' },
-          { scope: Integral::User, label: 'Total Users' }
-        ]
-      end
-
       # Line graph - Last week
       def dataset_dashboard_last_week
-        [
+        data = [
           { scope: Integral::Page, label: 'Pages' },
           { scope: Integral::List, label: 'Lists' },
           { scope: Integral::Image, label: 'Images' },
           { scope: Integral::User, label: 'Users' }
         ]
+
+        data.prepend(scope: Integral::Post, label: 'Posts') if Integral.blog_enabled?
+        data
+      end
+
+      def current_user_authorized_for_menu_item?(item)
+        if item[:authorize]
+          instance_eval(&item[:authorize])
+        elsif item[:authorize_class] && item[:authorize_action]
+          Pundit.policy(current_user, item[:authorize_class]).public_send("#{item[:authorize_action]}?")
+        else
+          true
+        end
+      end
+
+      private
+
+      def extract_menu_items(items, extract_method)
+        items = items.map { |item| item.class == Class ? item.send(extract_method) : item }
+      end
+
+      def render_menu(items, options={})
+        return '' if items.empty?
+
+        output = ''
+        items = items.sort_by { |item| item[:order] }
+
+        items.each do |item|
+          next unless current_user_authorized_for_menu_item?(item)
+
+          if item[:list_items]&.any?
+            output += content_tag :li do
+              list = content_tag :ul do
+                list_items = item[:list_items].map do |list_item|
+                  next unless current_user_authorized_for_menu_item?(list_item)
+
+                  link_to list_item[:label], list_item[:url], wrapper: :li
+                end.join.html_safe
+                list_items.prepend(content_tag(:li, item[:label]))
+              end
+              list.prepend(link_to(item[:label], item[:url], icon: item[:icon]))
+            end
+          else
+            output += link_to item[:label], item[:url], wrapper: :li, icon: item[:icon]
+          end
+        end
+
+        output.html_safe
       end
     end
   end

data/app/helpers/integral/blog_helper.rb

@@ -1,6 +1,40 @@
 module Integral
   # Blog Helper which contains methods used through the blog
   module BlogHelper
+    # @return [Relation] featured categories - currently all which have posts associated to them
+    def featured_categories
+      @featured_categories ||= Integral::Category.where(id: Integral::Post.published.select(:category_id).uniq.map(&:category_id))
+    end
+
+    # @param post [Integral::Post] post to convert to JSON-LD
+    #
+    # @return [String] Javascript snippet containing JSON-LD of the provided post
+    def render_post_as_json_ld(post)
+      render_json_ld do
+        post.to_json_ld.merge("@context": 'http://schema.org')
+      end
+    end
+
+    # @param posts [Integral::Post] collection of posts to convert to JSON-LD
+    #
+    # @return [String] Javascript snippet containing JSON-LD of the provided posts
+    def render_posts_as_json_ld(posts, title: t('.title'), url: request.original_url, description: t('.description'))
+      render_json_ld do
+        {
+          "@context": 'http://schema.org',
+          "@type": 'Blog',
+          "name": title,
+          "url": url,
+          "description": description,
+          "publisher": {
+            "@type": 'Organization',
+            "name": Integral::Settings.website_title
+          },
+          "blogPosts": posts.map(&:to_json_ld)
+        }
+      end
+    end
+
     # Whether or not to display newsletter signup widget
     def display_newsletter_signup_widget?
       true
@@ -9,12 +43,14 @@ module Integral
     # Whether or not to display share widget
     def display_share_widget?
       return true if "#{controller_name}.#{action_name}" == 'posts.show'
+
       false
     end
 
     # Whether or not to display recent posts sidebar widget
     def display_recent_posts_widget?
       return false if "#{controller_name}.#{action_name}" == 'posts.index'
+
       true
     end
 
@@ -22,5 +58,15 @@ module Integral
     def display_popular_posts_widget?
       Integral::Post.published.count > 4
     end
+
+    # Whether or not to display most read widget
+    def display_most_read_posts_widget?
+      Integral::Post.published.count > 10
+    end
+
+    # TODO: Change this to use GA API through a GoogleAnalyticsService
+    def most_read_posts
+      @popular_posts.decorate
+    end
   end
 end

data/app/helpers/integral/social_helper.rb

@@ -36,22 +36,6 @@ module Integral
       share_url
     end
 
-    # Google Plus social sharing
-    # URL snippet built from - https://sharingbuttons.io/
-    #
-    # @param [Hash] opts the options to create the share URL
-    # @option opts [String] :url Supply URL if would like to share URL other than the current
-    #
-    # @return [String] Google Plus URL to share a page
-    def google_plus_share_url(opts = {})
-      page_url = opts.fetch(:url, request.original_url)
-
-      page_url = CGI.escape(page_url)
-      share_url = "https://plus.google.com/share?url=#{page_url}"
-
-      share_url
-    end
-
     # Linkedin social sharing
     # URL snippet built from - https://sharingbuttons.io/
     #
@@ -99,13 +83,6 @@ module Integral
       Settings.youtube_url
     end
 
-    # Google Plus Profile URL set from within Backend Settings area
-    #
-    # @return [String] Youtube URL
-    def google_plus_url
-      Settings.google_plus_url
-    end
-
     # Linkedin Profile URL set from within Backend Settings area
     #
     # @return [String] Linkedin URL

data/app/jobs/integral/application_job.rb

@@ -1,6 +1,7 @@
 module Integral
   # All jobs inherit this behaviour
   class ApplicationJob < ActiveJob::Base
+    queue_as :default
     # Automatically retry jobs that encountered a deadlock
     # retry_on ActiveRecord::Deadlocked
 

data/app/jobs/integral/newsletter_signup_job.rb

@@ -1,8 +1,6 @@
 module Integral
   # Carry out actual newsletter signing up process
   class NewsletterSignupJob < ApplicationJob
-    queue_as :default
-
     rescue_from(Gibbon::MailChimpError) do |e|
       error_msg = "NewsletterSignupJob - Error when signing visitor up to Newsletter: #{e.message}"
       Rails.logger.error(error_msg)

data/app/jobs/integral/webhook/delivery_job.rb

@@ -0,0 +1,37 @@
+require 'net/http'
+
+module Integral
+  module Webhook
+    # Handles the delivery of a webhook event payload to a webhook endpoint
+    class DeliveryJob < ApplicationJob
+      # Delivers webhook payload to endpoint
+      def perform(endpoint_id, payload)
+        return unless endpoint = Webhook::Endpoint.find(endpoint_id)
+
+        response = request(endpoint.target_url, payload)
+
+        case response.code
+        when 410
+          endpoint.destroy
+        when 400..599
+          raise response.to_s
+        end
+      end
+
+      private
+
+      def request(endpoint, payload)
+        uri = URI.parse(endpoint)
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request['Content-Type'] = 'application/json'
+        request.body = payload
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+
+        http.request(request)
+      end
+    end
+  end
+end

data/app/mailers/integral/contact_mailer.rb

@@ -49,7 +49,10 @@ module Integral
     # Subject of the forwarding email
     # Adds the enquiry subject if it exists otherwise uses only reference
     def forwarding_subject(enquiry)
-      return "#{enquiry.reference} #{I18n.t('integral.contact_mailer.forward_enquiry.subject')}" if enquiry.subject.blank?
+      if enquiry.subject.blank?
+        return "#{enquiry.reference} #{I18n.t('integral.contact_mailer.forward_enquiry.subject')}"
+      end
+
       "#{enquiry.reference} #{I18n.t('integral.contact_mailer.forward_enquiry.subject')} - #{enquiry.subject}"
     end
   end

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/lazy_contentable.rb

@@ -0,0 +1,54 @@
+# Adds lazy content behaviour to a model
+module Integral
+  # Enable lazy loading WYSIWYG content
+  module LazyContentable
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :lazyload_content
+    end
+
+    # @return [String] body HTML ready for WYSIWYG editor
+    def editor_body
+      html = Nokogiri::HTML(body)
+
+      # Remove image lazyloading
+      html.css('img.lazyload').each do |element|
+        element.attributes['src'].value = element.attributes['data-src'].value
+      end
+
+      html.css('body').inner_html
+    end
+
+    private
+
+    def lazyload_content
+      html = Nokogiri::HTML(body)
+
+      # Add lazyloading to tagged images
+      html.css('img.lazyload').each do |element|
+        element['data-src'] = element.attributes['src'].value
+        element.attributes['src'].value = ''
+      end
+
+      # Add lazy loading to oEmbeds
+      html.css('div[data-oembed-url]').each do |element|
+        next if element.css('blockquote.lazyload').any?
+
+        blockquote = element.css('blockquote').first
+
+        next unless blockquote.present?
+
+        blockquote['class'] = "#{blockquote.attributes['class']} lazyload"
+
+        if element['data-oembed-url'].starts_with?('https://www.instagram.com')
+          blockquote['data-instagram'] = 'instagram'
+        elsif element['data-oembed-url'].starts_with?('https://twitter.com')
+          blockquote['data-twitter'] = 'twitter'
+        end
+      end
+
+      self.body = html.css('body').inner_html
+    end
+  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