cd2_catton_cms 1.1.10

data/app/helpers/c/application_helper.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module C
+  module ApplicationHelper
+    include FontAwesome::Rails::IconHelper
+    ActionView::Base.default_form_builder = CFormBuilder
+
+    def store_page_title(title)
+      title ? "#{title} | #{C.store_name}" : C.store_name
+    end
+
+    def path_exists?(path)
+      begin
+        C::Engine.routes.recognize_path(path)
+      rescue
+        return false
+      end
+      true
+    end
+
+    def content_can_tag(tag, action, subject, content, opts={}, &block)
+      return unless can? action, subject
+      if block
+        opts = content || {}
+        content = capture(&block)
+      end
+      content_tag tag, content, opts
+    end
+
+    def index_table(collection, index_data, opts={})
+      content_tag :div, class: 'data_table' do
+        render 'index_table', collection: collection, index_data: index_data, sortable: opts[:sortable], bulk_actions: opts[:bulk_actions]
+      end
+    end
+
+    def tinymce_standard
+      tinymce(height: 200,
+              menubar: false,
+              plugins: ['autolink lists link image media charmap anchor',
+                        'insertdatetime media table contextmenu paste code textcolor colorpicker'],
+              toolbar: 'undo redo styleselect bold italic alignleft aligncenter alignright alignjustify bullist numlist link media uploadimage forecolor')
+    end
+
+    def tinymce_light
+      tinymce(height: 200,
+              menubar: false,
+              plugins: ['lists'],
+              toolbar: 'undo redo | bold italic | bullist')
+    end
+
+  end
+end

data/app/helpers/c/blogs_helper.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+# TODO: This file has a few rubocop issues but isnt being used - need to clear it up
+# rubocop:disable all
+
+module C
+  module BlogsHelper
+
+    def test_method
+      true
+    end
+
+    # Call in the controller to allow usage of blog_archive_menu and blog_archive_month_submenu
+    # Returns the collection of blogs filtered by the params
+    # Optionally accepts a limit for the size of the returned collection
+    def archive_blogs limit = nil
+      @blog_archive_filter_years, @blog_archive_filter_months = [[], []]
+
+      year = params[:year] || Time.now.year
+      if params[:month].to_i > 0 && params[:month].to_i < 13
+        month = params[:month]
+      else
+        month = Time.now.month
+        params[:month] = nil
+      end
+
+      if C::Blog.any?
+        age_limit = C::Blog.order(:created_at).limit(1).first&.created_at.beginning_of_year
+        num_years = Time.now.year - age_limit.year
+        @blog_archive_filter_years = (age_limit.year..(age_limit.year + num_years)).to_a.reverse
+        @blog_archive_filter_years.select! { |y|  C::Blog.created_in_year(year: y).any? }
+        if age_limit.year.to_s == params[:year].to_s
+          @blog_archive_filter_months = (1..age_limit.month).to_a
+        else
+          @blog_archive_filter_months = (1..12).to_a
+        end
+        @blog_archive_filter_months.select! { |m|  C::Blog.created_in_month(year: year, month: m).any?  }
+        if params[:month]
+          return C::Blog.created_in_month(month: month, year: year, limit: limit).ordered
+        else
+          return C::Blog.created_in_year(year: year, limit: limit).ordered
+        end
+      end
+      return nil
+    end
+
+    # Returns html for a ul of links, which set params[:year]
+    # Only months from @blog_archive_filter_years are listed
+    # Also accepts an options hash
+    # The :permitted option expects an array of keys which are permitted to be included in the generated links
+    # The :submenu option expects a boolean, which can be used to disable rendering the month submenu
+    def blog_archive_menu options = {}
+      permitted = options[:permitted] || []
+      submenu = options[:submenu]
+      submenu = true if submenu.nil?
+
+      content_tag :ul do
+        result = ""
+
+        @blog_archive_filter_years.each do |filter_year|
+          if params[:year].to_s == filter_year.to_s
+            if submenu
+              if params[:month]
+                result += content_tag :li, (
+                (render partial: 'c/front/blogs/archive_filter_year', locals: {permitted: permitted, archive_filter_year: filter_year}) +
+                    blog_archive_month_submenu(permitted: permitted)
+                )
+              else
+                result += content_tag :li, (
+                raw filter_year.to_s + blog_archive_month_submenu(permitted: permitted)
+                )
+              end
+            else
+              result += content_tag :li, filter_year.to_s
+            end
+          else
+            result += content_tag :li, (render partial: 'c/front/blogs/archive_filter_year', locals: {permitted: permitted, archive_filter_year: filter_year})
+          end
+        end
+        raw result
+      end
+    end
+
+    # Returns html for a ul of links, which set params[:month]
+    # Only months from @blog_archive_filter_months are listed
+    # Accepts an options hash
+    # The :permitted option expects an array of keys which are permitted to be included in the generated links
+    def blog_archive_month_submenu options = {}
+      permitted = options[:permitted] || []
+      content_tag :ul do
+        # render partial: 'c/front/blogs/archive_filter_month', collection: @blog_archive_filter_months, locals: {permitted: permitted}
+        result = ""
+        @blog_archive_filter_months.each do |filter_month|
+          if params[:month].to_s == filter_month.to_s
+            result += content_tag :li, (Date::MONTHNAMES[filter_month])
+          else
+            result += render partial: 'c/front/blogs/archive_filter_month', locals: {permitted: permitted, archive_filter_month: filter_month}
+          end
+        end
+        raw result
+      end
+    end
+
+    # Given a hash, permits only :month and :year
+    # Accepts an options hash
+    # The :permitted option expects an array of other keys to permit
+    def safe_params unsafe = {}, options = {}
+      permitted = options[:permitted] || []
+      permitted.push :month, :year
+      params.merge(unsafe).merge(only_path: true, script_name: nil).permit(permitted)
+    end
+
+  end
+end

data/app/helpers/c/c_form_builder.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module C
+  class CFormBuilder < ActionView::Helpers::FormBuilder
+    def error_messages
+      return unless object.respond_to?(:errors) && object.errors.any?
+
+      header = @template.content_tag(:h4, 'Errors prevented the form from saving', class: 'title-error')
+      errors_array = object.errors.full_messages.map { |message| @template.content_tag(:li, message) }
+      errors_list = @template.safe_join([header, @template.safe_join(errors_array)])
+
+      @template.content_tag(:ul, @template.raw(errors_list), class: 'form_errors')
+    end
+
+    def price_field(method, _options={})
+      @template.field_set_tag '', class: 'price_field' do
+        @template.content_tag(:span, method.to_s.titleize.to_s, class: 'fieldset-title') +
+        fields_for(method) do |builder|
+          @template.content_tag(:div, class: 'gs') do
+            @template.content_tag(:div, class: 'field field--inner-label g-1') { builder.label(:without_tax) + builder.number_field(:without_tax, step: 0.01, min: 0) } +
+              @template.content_tag(:div, class: 'field field--inner-label g-1 g-gutter--narrow') { builder.label(:with_tax) + builder.number_field(:with_tax, step: 0.01, min: 0) } +
+              @template.content_tag(:div, class: 'field field--inner-label g-1 g-gutter--narrow') { builder.label(:tax_rate) + builder.number_field(:tax_rate, step: 0.01, min: 0) }
+          end +
+            builder.label(:override) { builder.check_box(:override) + @template.content_tag(:span, 'Override tax rate', class: 'checkbox-span-label') }
+        end
+      end
+    end
+
+    def image_field(method, options = {})
+      @template.field_set_tag '', class: 'image_field' do
+        @template.content_tag(:span, method.to_s.titleize, class: 'fieldset-title') +
+        hidden_field("#{method}_cache") +
+          (@template.image_tag(@object.send(method)) || '') +
+          file_field(method, options)
+      end
+    end
+
+    def tiny_mce_text_area(method, tinymce_config='standard')
+      text_area(method, class: 'tinymce') +
+      @template.send("tinymce_#{tinymce_config}")
+    end
+
+  end
+end

data/app/helpers/c/link_to_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module C
+  module LinkToHelper
+    def link_to_delete(text, resource, opts={})
+      nested = [opts.delete(:nested) { [] }].flatten
+
+      opts[:data] ||= {}
+
+      url = opts.delete(:url) { nil }
+      redirection = opts.delete(:redirection) { nil }
+      opts[:data].merge!(delete_link: url || url_for([*nested, resource]),
+                         after_delete_redirection: redirection)
+      link_to text, [:confirm_destroy, *nested, resource], opts
+    end
+
+    def link_to_add_fields(name, f, assoc, opts={})
+      new_object = f.object.send(assoc).build
+      id = new_object.object_id
+      fields = f.fields_for(assoc, new_object, child_index: id) do |builder|
+        render assoc.to_s.singularize + '_fields', f: builder
+      end
+      link_to name, '#', data: { fields: fields.gsub('\n', ''), fields_id: id }.merge(opts)
+    end
+  end
+end

data/app/helpers/c/navigation_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module C
+  module NavigationHelper
+    def ensure_navigation
+      @navigation ||= [{ title: 'Home', url: '/' }]
+    end
+
+    def navigation_add(title, url)
+      ensure_navigation << { title: title, url: url }
+    end
+
+    def render_navigation(partial = nil)
+      render partial: partial || 'c/admin/bread_crumbs', locals: { nav: ensure_navigation }
+    rescue
+      nil
+    end
+
+    def parent_navigation_add(nav)
+      @tree_navigation ||= []
+      @tree_navigation << { title: nav.name, url: nav }
+      if nav.parent
+        parent_navigation_add nav.parent
+      else
+        @tree_navigation.reverse.map { |node| ensure_navigation << node }
+      end
+    end
+  end
+end

data/app/helpers/c/pages_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module C
+  module PagesHelper
+    def get_page(model, url=params[:id])
+      @page = if !url.present? || (url =~ /[^0-9]/)
+                model.get_from_url(url)
+              else
+                # This is accommodating a use-case that *will* result in problems, given enough products
+                model.find_by(id: url) || model.get_from_url(url)
+              end
+      begin
+        @page_info = @page.page_info
+      rescue NoMethodError
+        raise ActiveRecord::RecordNotFound
+      end
+      if @page.respond_to?('layout') && !@page.layout.blank? && @page.layout != 'show'
+        @render = @page.layout
+      else
+        @page
+      end
+    end
+
+    def force_clean_url(object)
+      redirect_to [:front_end, object] if object.url_alias && params[:id] != object.url_alias
+    end
+  end
+end

data/app/helpers/c/storefront_helper.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+module C
+  module StorefrontHelper
+    def menu(menu_item_name, depth=1)
+      return unless (menu_item = C::MenuItem.find_by(machine_name: menu_item_name))
+      return unless menu_item.children.any?
+      content_tag :ul do
+        render partial: 'c/front/application/menu_item', collection: menu_item.children.includes(:page), cached: true, locals: { depth: depth }
+      end
+    end
+
+    def menu_items_for(menu_item_name, depth=1)
+      return unless (menu_item = C::MenuItem.find_by(machine_name: menu_item_name))
+      return unless menu_item.children.any?
+      render partial: 'c/front/application/menu_item', collection: menu_item.children.includes(:page), cached: true, locals: { depth: depth }
+    end
+
+    def category_root_menu
+      content_tag :ul do
+        render partial: 'c/front/application/category_item', collection: C::Category.find_all_by_generation(0)
+      end
+    end
+
+    def meta_tags
+      safe_join([page_title, meta_description]) if @page_info
+    end
+
+    def page_title
+      if @page_info.title.blank?
+        if @page_info.fallback_title.blank?
+          content_tag(:title, C.store_name)
+        else
+          content_tag(:title, @page_info.fallback_title)
+        end
+      else
+        content_tag(:title, @page_info.title)
+      end
+    end
+
+    def meta_description
+      return unless @page_info&.meta_description&.present?
+      tag :meta, name: :description, content: @page_info.meta_description
+    end
+
+    def slideshow(slideshow_name, klass=nil)
+      return 'No slideshow found' unless (slide_show = C::Slideshow.find_by(machine_name: slideshow_name))
+      content_tag :div, class: :slideshow do
+        content_tag :ul do
+          render partial: 'c/front/application/slide', collection: slide_show.slides.ordered, cached: true, locals: { klass: klass }
+        end
+      end
+    end
+
+    def sales_highlights(page)
+      case page
+      when :home
+        render partial: 'c/front/application/sales_highlight', collection: C::SalesHighlight.first(4), cached: true
+      when :store
+        render partial: 'c/front/application/sales_highlight', collection: C::SalesHighlight.first(3), cached: true
+      end
+    end
+  end
+end

data/app/mailers/c/application_mailer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+module C
+  class ApplicationMailer < ActionMailer::Base
+    default from: "#{C.store_name}<notifications@#{C.domain_name}>"
+    layout 'c/mailer'
+  end
+end

data/app/mailers/c/enquiries_mailer.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module C
+  class EnquiriesMailer < ApplicationMailer
+    def new_enquiry(enq)
+      @enquiry = enq
+      @title = 'A new enquiry has been made'
+      mail to: C.order_notification_email, subject: 'New Enquiry'
+    end
+  end
+end

data/app/models/c/ability.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module C
+  class Ability
+    include CanCan::Ability
+
+    def initialize(user)
+      user ||= C::User.new
+      can :manage, :all if user
+
+      user.permissions.each do |permission|
+        opts = {}
+        opts[:id] = permission.subject_id if permission.subject_id
+
+        can [:read],                      permission.subject, opts if permission.read?
+        can [:new, :create],              permission.subject, opts if permission.new?
+        can [:edit, :update],             permission.subject, opts if permission.edit?
+        can [:destroy, :confirm_destroy], permission.subject, opts if permission.remove?
+      end
+    end
+  end
+end

data/app/models/c/application_record.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module C
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/c/author_record.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module C
+  class AuthorRecord < ApplicationRecord
+    belongs_to :authored, polymorphic: true
+    belongs_to :user
+
+    validates :user, presence: true
+
+    def author
+      user.name
+    end
+  end
+end

data/app/models/c/blog.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module C
+  class Blog < ApplicationRecord
+    include SitePage
+    include Imageable
+    include Previewable
+    include Authorable
+
+    scope :ordered, -> { order created_at: :desc }
+
+    validates :name, presence: true
+
+    def self.created_in_date_range(start_date, end_date, options = {})
+      limit = options.delete(:limit)
+      Blog.where(created_at: start_date...end_date).limit(limit)
+    end
+
+    def self.created_in_month(options = {})
+      year = options[:year] || Time.now.year
+      month = options[:month] || Time.now.month
+      limit = options[:limit]
+      date_start = Time.new(year, month, 1, 0, 0, 0)
+      date_end = date_start.advance(months: 1)
+      created_in_date_range(date_start, date_end, limit: limit)
+    end
+
+    def self.created_in_year(options = {})
+      year = options[:year] || Time.now.year
+      limit = options[:limit]
+      date_start = Time.new(year, 1, 1, 0, 0, 0)
+      date_end = date_start.advance(years: 1)
+      created_in_date_range(date_start, date_end, limit: limit)
+    end
+
+    INDEX_TABLE = {
+      "Name": { link: { name: { call: 'name' }, options: '[:edit, object]' }, sort: 'name' },
+      "Author": { call: 'author', sort: 'author' },
+      "Published": { call: 'published', sort: 'published' },
+      "Created": { call: 'created_at', sort: 'published' },
+      "Edit": { link: { name: { text: 'edit' }, options: '[:edit, object]' } }
+    }.freeze
+  end
+end

data/app/models/c/document.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module C
+  class Document < ApplicationRecord
+    mount_uploader :document, C::FileUploader
+    validates :document, presence: true
+    belongs_to :documentable, polymorphic: true
+
+    INDEX_TABLE = {
+      "Name": { call: 'name' },
+      "File": { call: 'document.url' },
+      "Created": { call: 'created_at' },
+      "Delete": { link: { name: { text: 'Delete' }, options: '[object]', method: :delete, data: { confirm: 'Are you sure?' } } }
+    }.freeze
+
+    # TODO: Add edit to this, name should link to edit page
+  end
+end

data/app/models/c/enquiry.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+module C
+  class Enquiry < ApplicationRecord
+    enum job_type: [
+      'Supply Only',
+      'Supply and Fit',
+    ]
+
+    enum response_type: [
+      'Callback',
+      'Quote'
+    ]
+
+    enum timber_type: [
+      'Hardwood',
+      'European Oak',
+      'Accoya',
+      'Other',
+    ]
+
+    enum frame: [
+      'Braemar',
+      'Buttermilk',
+      'Dove Grey',
+      'Forest Green',
+      'Garsenia',
+      'Oxford Blue',
+      'Poppy Red',
+      'RAL7034',
+      'Techno White',
+      'Dark Oak',
+      'Mahogany',
+      'Rosewood',
+      'Sikkins Teak',
+      'African Walnut',
+      'Antique Pine',
+      'Ebony',
+      'Jacobean Walnut',
+      'Red Wood',
+      'Saddolins Teak'
+    ]
+
+    enum handle: [
+      'Chrome',
+      'Black',
+      'Gold',
+      'Satin',
+      'White',
+      'Monkey Tail'
+    ]
+
+    mount_uploader :file, C::FileUploader
+
+    validates :phone, presence: true
+    validates :response_type, presence: true
+
+    validates :name, presence: true
+
+    scope :ordered, -> { order created_at: :desc }
+
+    def get_jobs_selected
+      this = []
+      this << 'Windows' if job_windows
+      this << 'Doors' if job_doors
+      this << 'Bi-Fold Doors' if job_bi
+      this << 'Conservatory' if job_conservatory
+      this << 'Lantern Tops' if job_lantern
+      this << 'Garden Rooms' if job_garden
+      this << 'Orangery' if job_orangery
+      this << "Other: #{job_string}" if job_other
+      return this.join(', ')
+    end
+
+    def get_timber_selected
+      if timber_type == 'Other'
+        return 'Other: ' + timber_string
+      else
+        return timber_type
+      end
+    end
+
+    VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i
+    validates :email,
+      presence: true,
+      length: { maximum: 255 },
+      format: { with: VALID_EMAIL_REGEX }
+
+    INDEX_TABLE = {
+      "Name": { call: 'name', sort: 'name' },
+      "Email": { call: 'email', sort: 'email' },
+      "Message": { call: 'body' },
+      "Date": { call: 'created_at', sort: 'created_at' }
+    }.freeze
+  end
+end

data/app/models/c/image.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+module C
+  class Image < ApplicationRecord
+    include Orderable
+
+    validates :image, presence: true
+    belongs_to :imageable, polymorphic: true
+
+    mount_uploader :image, ImageUploader
+  end
+end

data/app/models/c/location.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module C
+  class Location < ApplicationRecord
+    include SitePage
+    include Imageable
+    include Previewable
+    include Orderable
+
+    validates :name, presence: true
+
+    INDEX_TABLE = {
+      "Name": { link: { name: { call: 'name' }, options: '[:edit, object]' }, sort: 'name' },
+      "Published": { call: 'published', sort: 'published' },
+      "Created": { call: 'created_at', sort: 'published' },
+      "Edit": { link: { name: { text: 'edit' }, options: '[:edit, object]' } }
+    }.freeze
+  end
+end

data/app/models/c/menu_item.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module C
+  class MenuItem < ApplicationRecord
+    has_closure_tree order: 'weight'
+
+    validates :machine_name, presence: true
+    validates :name, presence: true
+
+    belongs_to :page
+
+    before_validation on: :create do
+      self.machine_name = name
+    end
+
+    belongs_to :page
+
+    def self.depth_select_options(item)
+      opts = []
+      save_pair = proc do |level, i|
+        level.each do |key, value|
+          next if key.id == item.id
+          opts.append(["#{'-' * i}#{key.name}", key.id])
+          save_pair.call(value, i + 1) if value.class <= Hash
+        end
+      end
+      save_pair.call(hash_tree, 0)
+      opts
+    end
+
+    # Force non blank parametized machine name
+    def machine_name=(val)
+      super val.to_s.parameterize
+    end
+  end
+end

data/app/models/c/non_delete.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module C
+  class NonDelete < ApplicationRecord
+    belongs_to :deletable, polymorphic: true
+
+    def readonly?
+      false
+    end
+  end
+end