hancock_cms 2.0.0.2 → 2.0.1.1

data/app/helpers/rails_admin/main/hancock_helper.rb

@@ -0,0 +1,51 @@
+require 'rails_admin/main_helper'
+module RailsAdmin::Main
+  module HancockHelper
+
+    def hancock_rails_admin_form_for(*args, &block)
+      options = args.extract_options!.reverse_merge(builder: RailsAdmin::Hancock::FormBuilder)
+      (options[:html] ||= {})[:novalidate] ||= !RailsAdmin::Config.browser_validations
+
+      form_for(*(args << options), &block) << after_nested_form_callbacks
+    end
+
+    def ordered_nodes_stack(nodes_stack = nil, node_model_names = nil)
+      _controller = (defined?(controller) ? controller : self)
+      nodes_stack ||= RailsAdmin::Config.visible_models(controller: _controller)
+      node_model_names ||= nodes_stack.collect { |c| c.abstract_model.model_name }
+
+      _order_array = _controller._current_user.navigation_labels if _controller._current_user and _controller._current_user.respond_to?(:navigation_labels)
+      _order_array ||= Hancock.config.navigation_labels
+      _order_array = _order_array.clone.reverse
+
+      ret = {}
+      grouped_nodes_stack = nodes_stack.group_by(&:navigation_label)
+      navigation_labels = grouped_nodes_stack.keys
+      navigation_labels.sort! do |label_1, label_2|
+        label_1_index = _order_array.index(label_1) || -1
+        label_2_index = _order_array.index(label_2) || -1
+        label_2_index <=> label_1_index
+      end
+      navigation_labels.each do |label|
+        ret[label] = grouped_nodes_stack[label]
+      end
+      ret
+    end
+
+    def hancock_main_navigation
+      nodes_stack = RailsAdmin::Config.visible_models(controller: controller)
+      node_model_names = nodes_stack.collect { |c| c.abstract_model.model_name }
+      _ordered_nodes_stack = ordered_nodes_stack(nodes_stack, node_model_names)
+
+      _ordered_nodes_stack.collect do |navigation_label, nodes|
+        nodes = nodes.select { |n| n.parent.nil? || !n.parent.to_s.in?(node_model_names) }
+        li_stack = hancock_navigation nodes_stack, nodes
+
+        label = navigation_label || t('admin.misc.navigation')
+
+        %(<li class='dropdown-header'>#{capitalize_first_letter label}</li>#{li_stack}) if li_stack.present?
+      end.join.html_safe
+    end
+
+  end
+end

data/app/models/concerns/hancock/boolean_field.rb

@@ -1,11 +1,13 @@
 module Hancock::BooleanField
   extend ActiveSupport::Concern
-  module ClassMethods
+
+  class_methods do
+
     def boolean_field(name, default = true)
       if default.is_a?(Hash)
         default = default[:default]
       end
-      
+
       if Hancock.mongoid?
         field name, type: Mongoid::Boolean, default: default
       end
@@ -16,6 +18,9 @@ module Hancock::BooleanField
       elsif name == 'enabled'
         scope :disabled,  -> { where(enabled: false) }
       end
+      
     end
+
   end
+
 end

data/app/models/concerns/hancock/decorators/embedded_element.rb

@@ -3,15 +3,7 @@ module Hancock::Decorators
     extend ActiveSupport::Concern
 
     included do
-
-      # def image_styles
-      #   super
-      # end
-      #
-      # def image_jcrop_options
-      #   super
-      # end
-      #
+      
       # ############# rails_admin ##############
       # def self.rails_admin_add_fields
       #   [] #super

data/app/models/concerns/hancock/enableable.rb

@@ -5,4 +5,5 @@ module Hancock::Enableable
   included do
     boolean_field(:enabled)
   end
+  
 end

data/app/models/concerns/hancock/hash_field.rb

@@ -2,7 +2,7 @@ if Hancock.mongoid?
   module Hancock::HashField
     extend ActiveSupport::Concern
 
-    module ClassMethods
+    class_methods do
       def hancock_cms_hash_field(name, opts = {})
         opts.merge!({type: Hash, default: {}})
         field "#{name}_hash", opts
@@ -14,7 +14,7 @@ if Hancock.mongoid?
         if opts[:localize]
           meth_str_t = "#{meth_str}_translations".freeze
           meth_hsh_t = "#{meth_hsh}_translations".freeze
-          class_eval <<-EVAL
+          class_eval <<-RUBY
             def #{meth_str_t}=(val)
               return self.#{meth_hsh_t} = {} if val.blank?
               _hash = {}
@@ -63,10 +63,10 @@ if Hancock.mongoid?
               end
               true
             end
-          EVAL
+          RUBY
 
         else
-          class_eval <<-EVAL
+          class_eval <<-RUBY
             def #{meth_str}=(val)
               return self.#{meth_hsh} = {} if val.blank?
               if val.is_a?(String)
@@ -105,9 +105,10 @@ if Hancock.mongoid?
                 true
               end
             end
-          EVAL
-        end
-      end
-    end
+          RUBY
+        end #if opts[:localize]
+      end #def hancock_cms_hash_field(name, opts = {})
+    end # class_methods do
+
   end
 end

data/app/models/concerns/hancock/html_field.rb

@@ -2,7 +2,7 @@ if Hancock.mongoid?
   module Hancock::HtmlField
     extend ActiveSupport::Concern
 
-    module ClassMethods
+    class_methods do
       def hancock_cms_html_field(name, opts = {})
         clear_by_default = opts.delete(:clear_by_default)
         clear_by_default = false unless clear_by_default == true
@@ -12,7 +12,9 @@ if Hancock.mongoid?
         field _html_field_name, opts
         field "#{name}_clear", type: Boolean, default: clear_by_default, localize: opts[:localize]
 
-        class_eval <<-EVAL
+        insertions_for(name) if respond_to?(:insertions_for)
+
+        class_eval <<-RUBY
           def #{name}
             self.#{_html_field_name} ||= ""
             return self.#{_html_field_name} unless self.#{name}_clear
@@ -26,8 +28,9 @@ if Hancock.mongoid?
             self.#{_html_field_name} ||= ""
             Rails::Html::FullSanitizer.new.sanitize(self.#{_html_field_name}.strip)
           end
-        EVAL
+        RUBY
       end
     end
+
   end
 end

data/app/models/concerns/hancock/insertion_field.rb

@@ -0,0 +1,115 @@
+module Hancock::InsertionField
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :added_insertions, :removed_insertions, :insertions_fields
+    self.removed_insertions ||= []
+    self.added_insertions ||= []
+    self.insertions_fields ||= {}
+    def possible_insertions
+      self.class.possible_insertions
+    end
+
+    # /(\[\[(\w+?)\]\] | \{\{(self\.(\w+?))\}\} | \{\{(([\w\-\.]+?)\.(\w+?))\}\} | \{\{(\w+?)\}\} | \{\{(BS\|(\w+?))\}\})/
+    #
+    # reg1 = /\[\[(?<new_bs>(?<new_bs_name>\w+?))\]\]/i
+    # reg2 = /\{\{(?<insertion_old>self\.(?<insertion_old_name>\w+?))\}\}/i
+    # reg3 = /\{\{(?<setting_with_ns>(?<setting_with_ns_ns>[\w\-\.]+?)\.(?<setting_with_ns_name>\w+?))\}\}/i
+    # reg4 = /\{\{(?<setting>(?<setting_name>\w+?))\}\}/i
+    # reg5 = /\{\{(?<old_bs>BS\|(?<old_bs_name>\w+?))\}\}/i
+    # reg6 = /\{\{\{\{(?<insertion>(?<insertion_name>\w+?))\}\}\}\}/i
+    private
+    def process_with_insertions(_data)
+      if _data.nil?
+        ''
+      else
+        if _data.is_a?(Symbol)
+          if insertions_fields.include?(_data)
+            _data = self.send(_data)
+          else
+            return ''
+          end
+        end
+        # {{self.%insertion%}}
+        _ret = _data.gsub(/\{\{self\.(.*?)\}\}/) do
+          get_insertion($1)
+        # {{"some_text"}} #temporary disabled - need tests
+        # end.gsub(/\{\{(['"])(.*?)(\1)\}\}/) do
+        #   $2
+        # {{%ns%.%key%}}
+        end.gsub(/\{\{(([^\.]*?)\.)?(.*?)\}\}/) do
+          (Settings and !$3.nil? and $2 != "self") ? Settings.ns($2).get($3).val : "" #temp
+        end
+        _ret
+      end
+    end
+    def get_insertion(name)
+      begin
+        self.send(name) if possible_insertions.include?(name)
+      rescue
+        ""
+      end
+    end
+  end
+
+  class_methods do
+    def insertions_field(name, opts = {type: String, default: ''})
+      field name, opts
+      insertions_for name, opts
+    end
+    def insertions_for(name, opts = {})
+      return if name.blank?
+      name = name.to_sym
+      return if insertions_fields.keys.include?(name)
+      (opts.delete(:add_insertions) || []).each do |_ins|
+        add_insertion _ins
+      end
+      (["page_#{name}", name.to_s] + (opts.delete(:remove_insertions) || [])).uniq.each do |_ins|
+        remove_insertion _ins
+      end
+      _method_name = opts[:as].present? ? opts[:as] : "page_#{name}"
+      insertions_fields[name] = {
+        method: _method_name,
+        options: opts
+      }
+      if _method_name
+        class_eval <<-RUBY
+          def #{_method_name}
+            process_with_insertions(#{name})
+          end
+        RUBY
+      end
+      name
+    end
+
+    def insertion(name, opts = {})
+      name = name.to_s.strip
+      if opts[:remove]
+        self.removed_insertions << name unless self.removed_insertions.include?(name)
+      else
+        self.added_insertions << name unless self.added_insertions.include?(name)
+      end
+    end
+    def add_insertion(name)
+      insertion(name.to_s.strip)
+    end
+    def remove_insertion(name, opts = {})
+      insertion(name.to_s.strip, opts.merge({remove: true}))
+    end
+
+    def default_insertions
+      # self.fields.keys # we was here but inheritance and we need check
+
+      # # version with store in
+      # return @default_insertions unless @default_insertions.nil?
+      # @default_insertions =
+      self.fields.select { |_name, _field|
+        _field.options[:klass] and self <= _field.options[:klass]
+      }.keys
+    end
+    def possible_insertions
+      @possible_insertions ||= (default_insertions + added_insertions).map(&:to_s).uniq - removed_insertions.map(&:to_s)
+    end
+  end
+
+end

data/app/models/concerns/hancock/mappable.rb

@@ -88,4 +88,5 @@ module Hancock::Mappable
       map_address
     end
   end
+  
 end

data/app/models/concerns/hancock/master_collection.rb

@@ -0,0 +1,31 @@
+if Hancock.mongoid?
+  module Hancock::MasterCollection
+    extend ActiveSupport::Concern
+
+    included do
+      if Hancock.config.mongoid_single_collection
+        if Hancock.config.mongoid_single_collection == true
+          _collection_name = :hancock_master_collection
+        else
+          _collection_name = Hancock.config.mongoid_single_collection
+        end
+        store_in collection: _collection_name
+
+        field(:_type, default: self.name, type: String)
+        default_scope -> { where(_type: self.name) }
+
+        def self.hereditary?
+          true
+        end
+
+        def self.inherited(subclass)
+          subclass.field(:_id, default: -> { BSON::ObjectId.new }, type: BSON::ObjectId, pre_processed: true, overwrite: true)
+          subclass.field(:_type, default: subclass.name, type: String, overwrite: true)
+          subclass.default_scope -> { where(_type: subclass.name) }
+        end
+
+      end
+    end
+
+  end
+end

data/app/models/concerns/hancock/model_localizeable.rb

@@ -1,12 +1,14 @@
 module Hancock::ModelLocalizeable
   extend ActiveSupport::Concern
 
-  module ClassMethods
+  class_methods do
+    
     def convert2localize
       self.all.to_a.map do |p|
         p.convert2localize
       end
     end
+
   end
 
   def convert2localize(save_it = true)
@@ -30,4 +32,5 @@ module Hancock::ModelLocalizeable
     end
     self.save if save_it
   end
+
 end

data/app/models/concerns/hancock/rails_admin_patch.rb

@@ -5,9 +5,25 @@ module Hancock::RailsAdminPatch
     self.class.rails_admin_model
   end
 
-  module ClassMethods
+  def admin_can_actions
+    self.class.admin_can_actions
+  end
+  def admin_cannot_actions
+    self.class.admin_cannot_actions
+  end
+  def manager_can_actions
+    self.class.manager_can_actions
+  end
+  def manager_cannot_actions
+    self.class.manager_cannot_actions
+  end
+
+  class_methods do
     def rails_admin_model
-      to_param.gsub("::", "~").underscore
+      name.split('::').collect(&:underscore).join('~')
+    end
+    def rails_admin_param_key
+      name.split('::').collect(&:underscore).join('_')
     end
 
     def rails_admin_add_fields
@@ -17,6 +33,9 @@ module Hancock::RailsAdminPatch
     def rails_admin_add_config(config)
     end
 
+    def rails_admin_name_synonyms
+      ''.freeze
+    end
 
 
     def admin_can_default_actions
@@ -57,7 +76,7 @@ module Hancock::RailsAdminPatch
       (manager_can_default_actions + manager_can_add_actions + manager_can_user_defined_actions).uniq.freeze
     end
     def manager_cannot_default_actions
-      [].freeze
+      [:model_accesses, :user_abilities].freeze
     end
     def manager_cannot_add_actions
       [].freeze

data/app/models/concerns/hancock/sort_field.rb

@@ -1,12 +1,17 @@
 module Hancock::SortField
   extend ActiveSupport::Concern
 
-  module ClassMethods
-    def sort_field(prefix = '')
+  class_methods do
+
+    def sort_field(prefix = '', opts = {type: Integer, default: 0})
+      if prefix.is_a?(Hash)
+        opts = prefix
+        prefix = opts.delete(:prefix) || ""
+      end
       prefix = "#{prefix}_" unless prefix == ''
 
       if Hancock.mongoid?
-        field "#{prefix}order".to_sym, type: Integer
+        field "#{prefix}order".to_sym, opts
         alias_method "#{prefix}sort", "#{prefix}order"
         scope "#{prefix}ordered".to_sym,  -> { asc("#{prefix}order".to_sym) }
         scope "#{prefix}sorted".to_sym,   -> { asc("#{prefix}order".to_sym) }
@@ -15,6 +20,24 @@ module Hancock::SortField
         scope "#{prefix}ordered".to_sym,  -> { order("#{prefix}order".to_sym => :asc) }
         scope "#{prefix}sorted".to_sym,   -> { order("#{prefix}order".to_sym => :asc) }
       end
+
+
+      class_eval <<-RUBY
+        def set_default_#{prefix}order_value
+          if (_embed_method = self.try(:embed_method_for_parent))
+            begin
+              if (self.#{prefix}order.nil? or self.#{prefix}order == 0) and (_parent = self._parent)
+                self.#{prefix}order = _parent.send(_embed_method).max("#{prefix}order").to_i + 1
+              end
+            rescue
+            end
+          end
+          self.#{prefix}order ||= 0
+          self
+        end
+      RUBY
     end
+
   end
+
 end