coalla-cms 0.5.1.8

data/app/models/file_upload.rb

@@ -0,0 +1,19 @@
+class FileUpload < ActiveRecord::Base
+
+  mount_uploader :file, FileUploader
+
+  before_save :update_file_attributes
+
+  validates_presence_of :file, unless: :file_cache
+
+  private
+
+  def update_file_attributes
+    if file.present? && file_changed?
+      self.content_type = file.file.content_type
+      self.file_size = file.file.size
+      self.file_name = file.file.filename if self.respond_to? :file_name=
+    end
+  end
+
+end

data/app/models/lookup.rb

@@ -0,0 +1,28 @@
+class Lookup < ActiveRecord::Base
+
+  validates_presence_of :code
+  validates_uniqueness_of :code
+  validates_numericality_of :value, only_integer: true, if: ->(lookup) { lookup.type_code == 'integer' }
+  validates_numericality_of :value, if: ->(lookup) { lookup.type_code == 'float' }
+
+  mount_uploader :file, FileUploader
+
+  def value_options
+    attr_value = read_attribute(:value_options)
+
+    if attr_value.present?
+      ActiveSupport::JSON.decode(attr_value).with_indifferent_access
+    else
+      {}
+    end
+  end
+
+  def value_options=(value)
+    write_attribute(:value_options, ActiveSupport::JSON.encode(value).to_s) if value.present?
+  end
+
+  def select_options
+    value_options.map { |key, value| [value, key] }
+  end
+
+end

data/app/models/site_meta_tags.rb

@@ -0,0 +1,16 @@
+class SiteMetaTags < ActiveRecord::Base
+  self.table_name = 'meta_tags'
+
+  mount_uploader :image, MetaTagsImageUploader
+  mount_uploader :og_image, MetaTagsImageUploader
+
+  validates_uniqueness_of :identifier
+
+  def self.default_tags
+    where(identifier: :default).first
+  end
+
+  def identifier_text
+    identifier == 'default' ? 'Тэги по умолчанию' : identifier
+  end
+end

data/app/uploaders/file_uploader.rb

@@ -0,0 +1,10 @@
+class FileUploader < CarrierWave::Uploader::Base
+
+  storage :file
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+
+end

data/app/uploaders/generic_image_uploader.rb

@@ -0,0 +1,74 @@
+#encoding: utf-8
+require 'carrierwave/processing/mime_types'
+require 'shellwords'
+
+# TODO Добавить настройку watermark_image, position
+
+class GenericImageUploader < CarrierWave::Uploader::Base
+  include CarrierWave::RMagick
+  include CarrierWave::MimeTypes
+
+  before :cache, :capture_size_before_cache
+
+  storage :file
+
+  process :set_content_type
+  process :set_image_properties
+
+  def watermark
+    return if !model || !model.respond_to?(getter(:watermarked?)) || !model.send(getter(:watermarked?))
+
+    manipulate! do |img|
+      logo = Magick::Image.read(Rails.root.join("app/assets/images/watermark.png")).first
+      img.composite(logo, Magick::SouthEastGravity, 0, 0, Magick::OverCompositeOp)
+    end
+  end
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  #def default_url
+  #  "/assets/fallback/" + [version_name, "default.png"].compact.join('_')
+  #end
+
+  def capture_size_before_cache(new_file)
+    return unless model
+    return unless new_file.path
+    if model.respond_to?(setter(:width)) && model.respond_to?(setter(:height))
+      w, h = `identify -format "%wx %h" #{new_file.path.shellescape}`.split(/x/).map { |dim| dim.to_i }
+      model.send(setter(:width), w)
+      model.send(setter(:height), h)
+    end
+  end
+
+  def set_image_properties
+    return if !model || !file
+
+    model.send(setter(:file_name), file.filename) if model.respond_to?(setter(:file_name))
+    model.send(setter(:size), file.size) if model.respond_to?(setter(:size))
+    model.send(setter(:content_type), file.content_type) if model.respond_to?(setter(:content_type))
+  end
+
+  private
+
+  def setter(name)
+    opt = model.class.uploader_options[mounted_as] || {}
+    if opt[:prefixed]
+      "#{mounted_as}_#{name}="
+    else
+      "#{name}="
+    end
+  end
+
+
+  def getter(name)
+    opt = model.class.uploader_options[mounted_as] || {}
+    if opt[:prefixed]
+      "#{mounted_as}_#{name}"
+    else
+      "#{name}"
+    end
+  end
+
+end

data/app/uploaders/meta_tags_image_uploader.rb

@@ -0,0 +1,5 @@
+class MetaTagsImageUploader < GenericImageUploader
+  version :main do
+    resize_to_limit 1024, 1024
+  end
+end

data/app/utils/admin_structure.rb

@@ -0,0 +1,82 @@
+#encoding: utf-8
+class AdminStructure
+
+  include Rails.application.routes.url_helpers
+
+  Section = Struct.new(:name, :path, :icon, :description, :counter, :show_menu_counter, :creation_path) do
+
+    def show_menu_counter?
+      show_menu_counter.present?
+    end
+
+  end
+
+  Separator = Struct.new(:title)
+
+  CONFIG_FILE_NAME = 'structure.rb'
+
+  attr_accessor :sections
+
+  def initialize(controller)
+    @controller = controller
+    @sections = []
+    load_sections_from_config
+  end
+
+  def menu_items
+    dashboard_item = Section.new(I18n.t('admin.common.dashboard'), admin_dashboard_path, 'glyphicon glyphicon-align-left')
+    [dashboard_item] + @sections
+  end
+
+  def sections
+    @sections.find_all { |section| section.is_a?(Section) }
+  end
+
+  private
+
+  def load_sections_from_config
+    config_path = Rails.root.join('config', CONFIG_FILE_NAME).to_s
+    if File.exist?(config_path)
+      instance_eval(File.read(config_path), config_path)
+    end
+  end
+
+  # Options:
+  # creation_path - false or path string
+  def section(section_reference, options = {})
+    path = options.delete(:path)
+    icon = options.delete(:icon)
+    description = options.delete(:description)
+    counter = options.delete(:counter)
+    show_menu_counter = options.delete(:show_menu_counter)
+    creation_path = options.delete(:creation_path)
+    if section_reference.is_a?(Class)
+      section_name = section_reference.model_name.human
+      path = send("admin_#{section_reference.model_name.route_key}_path") unless path
+      counter = ->() { section_reference.count } unless counter
+      creation_path = send("new_admin_#{section_reference.model_name.singular}_path") if creation_path.nil?
+    else
+      section_name = section_reference
+    end
+    @sections << Section.new(section_name, path, icon, description, counter, show_menu_counter, creation_path)
+  end
+
+  def lookup_section(section_references = 'Настройки', category = nil, options = {})
+    default_options = options.merge(path: send('admin_lookups_index_path', category: category),
+                                    icon: 'glyphicon glyphicon-wrench',
+                                    description: 'Раздел содержит различные настройки и тексты')
+    section(section_references, default_options)
+  end
+
+  def meta_tags_section(section_references = 'Мета-тэги', options = {})
+    default_options = options.merge(path: send('admin_meta_tags_path'),
+                                    icon: 'glyphicon glyphicon-tag',
+                                    description: 'Раздел содержит мета-тэги')
+    section(section_references, default_options)
+  end
+
+  def separator(title)
+    @sections << Separator.new(title)
+  end
+
+end

data/app/utils/bootstrap_link_renderer.rb

@@ -0,0 +1,40 @@
+class BootstrapLinkRenderer < WillPaginate::ActionView::LinkRenderer
+
+  protected
+
+  def html_container(html)
+    tag(:div, tag(:ul, html, class: 'pagination'), class: 't-center')
+  end
+
+  def page_number(page)
+    if page == current_page
+      tag(:li, tag(:a, page), class: 'active')
+    else
+      tag(:li, link(page, page, rel: rel_value(page)))
+    end
+  end
+
+  def gap
+    text = @template.will_paginate_translate(:page_gap) { '&hellip;' }
+    tag(:li, tag(:a, text), class: 'disabled')
+  end
+
+  def previous_page
+    num = @collection.current_page > 1 && @collection.current_page - 1
+    previous_or_next_page(num, @options[:previous_label])
+  end
+
+  def next_page
+    num = @collection.current_page < @collection.total_pages && @collection.current_page + 1
+    previous_or_next_page(num, @options[:next_label])
+  end
+
+  def previous_or_next_page(page, text)
+    if page
+      tag(:li, link(text, page))
+    else
+      tag(:li, tag(:a, text), class: 'disabled')
+    end
+  end
+
+end

data/app/utils/table_helpers.rb

@@ -0,0 +1,196 @@
+class TableHelpers
+
+  class SimpleFormatter
+    def format_value(item, format)
+      case format
+        when Proc
+          format.call(item)
+        else
+          item
+      end
+    end
+  end
+
+  class BooleanFormatter < SimpleFormatter
+
+    def format_value(item, format)
+      case format
+        when Proc
+          format.call(item)
+        when String
+          item ? format : ''
+        when Hash
+          case item
+            when true
+              format[:true].presence || format[:yes].presence || ''
+            else
+              format[:false].presence || format[:no].presence || ''
+          end
+        else
+          item ? '<i class="glyphicon glyphicon-check"></i>'.html_safe : ''
+      end
+    end
+
+    def align
+      :center
+    end
+
+  end
+
+  class DateFormatter < SimpleFormatter
+
+    DATE = '%d.%m.%Y'
+
+    def initialize(default_format)
+      @default_format = default_format
+    end
+
+    def format_value(item, format)
+      if item
+        item = item.localtime if item.respond_to?(:localtime)
+        case format
+          when String
+            Russian::strftime(item, format)
+          when Proc
+            format.call(item)
+          when :date
+            Russian::strftime(item, DATE)
+          else
+            Russian::strftime(item, @default_format)
+        end
+      else
+        ''
+      end
+    end
+
+  end
+
+  class EnumerizeFormatter < SimpleFormatter
+
+    def format_value(item, format)
+      case format
+        when Proc
+          format.call(item)
+        else
+          item.try(:text)
+      end
+    end
+
+  end
+
+  class SelfHelper
+
+    def format_value(item, format)
+      raise "Format should be lambda" unless format.is_a? Proc
+      format.call(item)
+    end
+
+  end
+
+  class MethodHelper
+
+    FORMATS = {
+        boolean: BooleanFormatter.new,
+        date: DateFormatter.new(DateFormatter::DATE),
+        datetime: DateFormatter.new('%d.%m.%Y %H:%M'),
+        enumerize: EnumerizeFormatter.new
+    }
+    FORMATS.default = SimpleFormatter.new
+
+    def initialize(method, type)
+      @method = method
+      @formatter = FORMATS[type]
+    end
+
+    def format_value(item, format)
+      @formatter.format_value(item.send(@method), format)
+    end
+
+    def align
+      @align || @formatter.respond_to?(:align) && @formatter.align || :left
+    end
+
+    def align=(value)
+      @align = value
+    end
+
+    def respond_to?(method)
+      return (@align.present? || @formatter.respond_to?(method)) if method == :align
+      super
+    end
+
+  end
+
+  class ReflectionHelper
+
+    def initialize(method, template)
+      @method = method
+      @template = template
+    end
+
+    def format_value(item, format)
+      target = item.send(@method)
+      case format
+        when Proc
+          format.call(target)
+        when Hash, nil
+          if target
+            options = {label_attr: :id, type: :link, target: :_blank}.merge(format || {})
+            v = target.send(options[:label_attr])
+            case options[:type]
+              when :link
+                @template.link_to(v, target, target: options[:target])
+              else
+                v.to_s
+            end
+          else
+            ''
+          end
+        else
+          target.to_s
+      end
+    end
+
+  end
+
+  def initialize(model_class, template)
+    @model_class = model_class
+    @columns = model_class.columns.index_by(&:name).with_indifferent_access
+    @reflections = model_class.reflections.dup.with_indifferent_access
+    @template = template
+    @helpers = {}
+  end
+
+  def self.for(model_class, template)
+    TableHelpers.new(model_class, template)
+  end
+
+  def [](method)
+    helper = @helpers[method]
+    unless helper
+      helper = case method
+                 when :self
+                   SelfHelper.new
+                 else
+                   r = @reflections[method]
+                   if r
+                     if r.macro == :belongs_to
+                       ReflectionHelper.new(method, @template)
+                     end
+                   else
+                     if @model_class.respond_to?(:enumerized_attributes) && @model_class.enumerized_attributes[method]
+                       type = :enumerize
+                     else
+                       type = @columns[method] && @columns[method].type || :default
+                     end
+                     h = MethodHelper.new(method, type)
+                     h.align = :right if [:integer, :decimal].include?(type.to_sym)
+                     h
+                   end
+               end
+      @helpers[method] = helper
+    end
+    helper
+  end
+
+end