hancock_cms 1.0.0

data/lib/hancock/admin/embedded_element.rb

@@ -0,0 +1,26 @@
+module Hancock
+  module Admin
+    module EmbeddedElement
+      def self.config(nav_label = nil, fields = {})
+        if nav_label.is_a?(Hash)
+          nav_label, fields = nil, nav_label
+        end
+        Proc.new {
+          navigation_label(nav_label || I18n.t('hancock.cms'))
+          field :enabled, :toggle do
+            searchable false
+          end
+          field :name, :string do
+            searchable true
+          end
+
+          Hancock::RailsAdminGroupPatch::hancock_cms_group(self, fields)
+
+          if block_given?
+            yield self
+          end
+        }
+      end
+    end
+  end
+end

data/lib/hancock/configuration.rb

@@ -0,0 +1,48 @@
+module Hancock
+  include Hancock::PluginConfiguration
+
+  def self.config_class
+    Configuration
+  end
+
+  def self.configure
+    yield configuration
+    Hancock::PLUGINS.map(&:reconfigure!)
+  end
+
+
+  class Configuration
+    attr_accessor :main_index_layout
+    attr_accessor :error_layout
+
+    attr_accessor :localize
+
+    attr_accessor :ability_manager_config
+    attr_accessor :ability_admin_config
+
+    attr_accessor :admin_enter_captcha
+    attr_accessor :registration_captcha
+    attr_accessor :recaptcha_support
+    attr_accessor :simple_captcha_support
+
+    attr_accessor :captcha_on_development
+
+    def initialize
+      @main_index_layout = 'application'
+      @error_layout = 'application'
+
+      @localize = false
+
+      @ability_manager_config = []
+      @ability_admin_config = []
+
+      @recaptcha_support = defined?(Recaptcha)
+      @simple_captcha_support = defined?(SimpleCaptcha)
+
+      @admin_enter_captcha = @recaptcha_support or @simple_captcha_support
+      @registration_captcha = @admin_enter_captcha
+
+      @captcha_on_development = false
+    end
+  end
+end

data/lib/hancock/controller.rb

@@ -0,0 +1,30 @@
+module Hancock::Controller
+  extend ActiveSupport::Concern
+  included do
+    include Hancock::Errors
+    include Hancock::Fancybox
+    if defined?(Hancock::Pages)
+      include Hancock::Pages::SeoPages
+      include Hancock::Pages::NavMenu
+      include Hancock::Pages::Blocksetable
+    end
+    protect_from_forgery with: :exception
+    helper_method :page_title
+    helper_method :hide_ym_ga
+  end
+
+  protected
+
+  def page_title
+    Settings ? Settings.default_title : "" #temp
+  end
+
+  def ckeditor_authenticate
+    redirect_to '/' unless user_signed_in? && current_user.has_role?('admin')
+  end
+
+
+  def hide_ym_ga
+    false
+  end
+end

data/lib/hancock/engine.rb

@@ -0,0 +1,48 @@
+module Hancock
+    class Engine < ::Rails::Engine
+      # isolate_namespace Hancock
+
+    # rake_tasks do
+    #   require File.expand_path('../tasks', __FILE__)
+    # end
+
+    initializer "hancock_cms.email_defaults" do
+      # Write default email settings to DB so they can be changed.
+
+      #temp
+      # begin
+      #   if Settings and Settings.table_exists?
+      #     Settings.default_email_from(default: 'noreply@site.domain')
+      #     Settings.form_email(default: 'admin@site.domain')
+      #     Settings.email_topic(default: 'с сайта')
+      #   end
+      # rescue
+      # end
+    end
+    initializer 'hancock_cms.paperclip' do
+      # require 'paperclip/style'
+      # module ::Paperclip
+      #   class Style
+      #     alias_method :processor_options_without_auto_orient, :processor_options
+      #     def processor_options
+      #       processor_options_without_auto_orient.merge(auto_orient: false)
+      #     end
+      #   end
+      # end
+    end
+
+    config.after_initialize do
+      # trigger autoload so models are registered in Mongoid::Elasticearch
+      # Hancock.config.search_models.map(&:constantize)
+
+      # Write default email settings to DB so they can be changed.
+      if Settings and Settings.table_exists?
+        # Settings.default_email_from(default: 'noreply@site.domain')
+        # Settings.form_email(default: 'admin@site.domain')
+        # Settings.email_topic(default: 'с сайта')
+        #
+        Settings.logo_image(kind: :image)
+      end
+    end
+  end
+end

data/lib/hancock/migration.rb

@@ -0,0 +1,15 @@
+module Hancock
+  module Migration
+    extend self
+
+    def map_fields(t)
+      t.text :address
+      t.text :map_address
+      t.text :map_hint
+      t.float :latitude
+      t.float :longitude
+      t.float :lat
+      t.float :lon
+    end
+  end
+end

data/lib/hancock/model.rb

@@ -0,0 +1,53 @@
+module Hancock
+  module Model
+    extend ActiveSupport::Concern
+    included do
+      Hancock.register_model(self)
+
+      if Hancock.mongoid?
+        include Mongoid::Document
+        include Mongoid::Timestamps::Short
+
+        if Hancock.config.localize
+          include Hancock::ModelLocalizeable
+        end
+
+        _collection_name = collection_name.to_s
+        if _collection_name =~ /^hancock_/
+          enjoy_collection_name = _collection_name.sub(/^hancock_/, 'enjoy_')
+          if Mongoid.client('default').collections.map(&:name).include?(enjoy_collection_name)
+            modules = []
+            self.name.sub("Hancock", "Enjoy").split("::").each do |mod|
+              modules << mod
+              eval("::#{modules.join("::")} ||= #{modules.join("::").sub("Enjoy", "Hancock")}")
+            end
+            store_in collection: enjoy_collection_name
+          end
+        end
+
+        def self.goto_hancock
+        end
+      end
+
+      include ActiveModel::ForbiddenAttributesProtection
+      include Hancock::BooleanField
+      include Hancock::SortField
+
+      if Hancock.mongoid? and defined?(RailsAdminComments)
+        include RailsAdminComments::Commentable
+        include RailsAdminComments::ModelCommentable
+      end
+
+      if Hancock.mongoid?
+        if defined?(TrackablePatch)
+          include TrackablePatch
+        elsif defined?(Trackable)
+          include Trackable
+        end
+      end
+
+      include Hancock::RailsAdminPatch
+    end
+
+  end
+end

data/lib/hancock/models/embedded_element.rb

@@ -0,0 +1,12 @@
+module Hancock
+  module Models
+    module EmbeddedElement
+      extend ActiveSupport::Concern
+      include Hancock::Model
+      include Hancock::Enableable
+      include Hancock::Sortable
+
+      include Hancock.orm_specific('EmbeddedElement')
+    end
+  end
+end

data/lib/hancock/models/mongoid/embedded_element.rb

@@ -0,0 +1,14 @@
+module Hancock
+  module Models
+    module Mongoid
+      module EmbeddedElement
+        extend ActiveSupport::Concern
+
+        included do
+          field :name, type: String, localize: Hancock.configuration.localize, default: ""
+        end
+        
+      end
+    end
+  end
+end

data/lib/hancock/plugin.rb

@@ -0,0 +1,25 @@
+module Hancock::Plugin
+
+  module ClassMethods
+    def orm
+      Hancock.orm
+    end
+    def mongoid?
+      self.orm == :mongoid
+    end
+    def active_record?
+      self.orm == :active_record
+    end
+    def model_namespace
+      "#{self}::Models::#{self.orm.to_s.camelize}".freeze
+    end
+    def orm_specific(name)
+      "#{model_namespace}::#{name}".constantize
+    end
+  end
+
+  def self.included(base)
+    Hancock::register_plugin(base) unless base == Hancock
+    base.extend(ClassMethods)
+  end
+end

data/lib/hancock/plugin_configuration.rb

@@ -0,0 +1,30 @@
+module Hancock::PluginConfiguration
+
+  module ClassMethods
+    def configuration
+      @configuration ||= config_class.new if config_class
+    end
+    def config
+      @configuration ||= config_class.new if config_class
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reconfigure!
+      if config_class
+        @configuration = config_class.new
+        configure &block if block_given?
+      end
+    end
+
+    def config_class
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+end

data/lib/hancock/rails_admin_ext/config.rb

@@ -0,0 +1,129 @@
+module Hancock
+  class << self
+    def rails_admin_configuration
+      @rails_admin_configuration ||= RailsAdminConfiguration.new
+    end
+    def rails_admin_config
+      @rails_admin_configuration ||= RailsAdminConfiguration.new
+    end
+    def rails_admin_configure
+      yield rails_admin_configuration
+    end
+
+    def action_visible_for(action_name, model_name)
+      rails_admin_config.action_visible_for action_name, model_name
+    end
+    def action_unvisible_for(action_name, model_name)
+      rails_admin_config.action_unvisible_for action_name, model_name
+    end
+
+    def rails_admin_config_for_actions(actions)
+      rails_admin_config.actions_config(actions)
+    end
+
+    def cancancan_admin_rules(ability_object)
+      rails_admin_config.cancancan_admin_rules(ability_object)
+    end
+    def cancancan_manager_rules(ability_object)
+      rails_admin_config.cancancan_manager_rules(ability_object)
+    end
+  end
+
+  class RailsAdminConfiguration
+
+    attr_reader :actions_list
+    attr_reader :actions_visibility
+
+    def initialize
+      @actions_list ||= []
+      @actions_visibility ||= {}
+
+      action_unvisible_for(:custom_show_in_app, Proc.new { false })
+      action_visible_for(:model_settings, Proc.new { false })
+    end
+
+    def add_action(action_name)
+      @actions_list << action_name.to_sym
+      @actions_list.uniq
+    end
+
+    def remove_action(action_name)
+      @remove_action.delete remove_action.to_sym
+      @actions_list.uniq
+    end
+
+    def action_visible_for(action_name, model_name)
+      action_name = action_name.to_sym
+      add_action(action_name) unless @actions_list.include?(action_name)
+
+      if model_name.is_a?(Proc)
+        @actions_visibility[action_name] = model_name
+      else
+        @actions_visibility[action_name] = [] if @actions_visibility[action_name].is_a?(Proc)
+        @actions_visibility[action_name] ||= []
+        @actions_visibility[action_name] << model_name.to_s
+      end
+    end
+
+    def action_unvisible_for(action_name, model_name)
+      action_name = action_name.to_sym
+      add_action(action_name) unless @actions_list.include?(action_name)
+
+      if model_name.is_a?(Proc)
+        # @actions_visibility[action_name] = model_name
+      else
+        @actions_visibility[action_name] = [] if @actions_visibility[action_name].is_a?(Proc)
+        @actions_visibility[action_name] ||= []
+        @actions_visibility[action_name].delete model_name.to_s
+      end
+    end
+
+    def actions_config(rails_admin_actions)
+
+      @actions_list.each do |action|
+        if rails_admin_actions.respond_to?(action)
+          rails_admin_actions.send(action) do
+            visible do
+              ret = false
+              if bindings[:abstract_model].model.respond_to?(:rails_admin_visible_actions)
+                ret = bindings[:abstract_model].model.rails_admin_visible_actions.include?(action)
+              else
+                if visibility = Hancock.rails_admin_config.actions_visibility[action]
+                  if visibility.is_a?(Proc)
+                    ret = visibility.call(self)
+                  else
+                    ret = visibility.include? bindings[:abstract_model].model_name
+                  end
+                end
+              end # if bindings[:abstract_model].model.respond_to?(:rails_admin_visible_actions)
+              ret
+            end # visible do
+          end # rails_admin_actions.send(action) do
+        end # if rails_admin_actions.respond_to?(action)
+      end # @actions_list.each do |action|
+
+    end
+
+    def cancancan_admin_rules(ability_object)
+      Hancock.config.ability_admin_config.each do |config|
+        _model = config[:model]
+        _model = _model.constantize if _model.is_a?(String)
+        ability_object.send(config[:method], config[:actions], _model)
+      end
+      Hancock::MODELS.each do |_model|
+        ability_object.can _model.admin_can_actions, _model
+      end
+    end
+    def cancancan_manager_rules(ability_object)
+      Hancock.config.ability_manager_config.each do |config|
+        _model = config[:model]
+        _model = _model.constantize if _model.is_a?(String)
+        ability_object.send(config[:method], config[:actions], _model)
+      end
+      Hancock::MODELS.each do |_model|
+        ability_object.can _model.manager_can_actions, _model
+      end
+    end
+
+  end
+end