camaleon_cms 2.1.2.1 → 2.2.0

data/app/models/camaleon_cms/nav_menu.rb

@@ -21,7 +21,7 @@ class CamaleonCms::NavMenu < CamaleonCms::TermTaxonomy
   # sample: {label: "my label", type: "category", link: 12}
   # return item created
   def append_menu_item (value)
-    item = children.create!({name: value[:label], data_options: {type: value[:type], object_id: value[:link]}})
+    item = children.create!({name: value[:label], url: value[:link], kind: value[:type]})
     item
   end
 

data/app/models/camaleon_cms/nav_menu_item.rb

@@ -7,6 +7,11 @@
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
 class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
+  alias_attribute :site_id, :term_group
+  alias_attribute :label, :name
+  alias_attribute :url, :description
+  alias_attribute :kind, :slug
+  attr_accessible :label, :url, :kind
   default_scope { where(taxonomy: :nav_menu_item).order(id: :asc) }
   has_many :metas, ->{ where(object_class: 'NavMenuItem')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
   belongs_to :parent, class_name: "CamaleonCms::NavMenu", inverse_of: :children
@@ -16,8 +21,6 @@ class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
   before_create :set_parent_site
   after_create :update_count
   #before_destroy :update_count
-  alias_attribute :site_id, :term_group
-  alias_attribute :label, :name
 
   # return the main menu
   def main_menu
@@ -27,17 +30,6 @@ class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
     parent_menu.main_menu if parent_menu.present?
   end
 
-  # return the type of this menu (post|category|post_tag|post_type|external)
-  def get_type
-    self.get_option('type')
-  end
-
-  # return the url of the external menu item
-  # return the object_id of menus like posttype, post, category, ...
-  def url
-    get_option('object_id')
-  end
-
   # check if this menu have children
   def have_children?
     self.children.count != 0
@@ -47,19 +39,17 @@ class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
   # same values of NavMenu#append_menu_item
   # return item created
   def append_menu_item(value)
-    children.create({name: value[:label], data_options: {type: value[:type], object_id: value[:link]}})
+    children.create({name: value[:label], url: value[:link], kind: value[:type]})
   end
 
   # update current menu
   # value: same as append_menu_item (label, link)
   def update_menu_item(value)
-    self.update({name: value[:label], data_options: {object_id: value[:link]}})
+    self.update({name: value[:label], url: value[:link]})
   end
 
-  # skip uniq slug validation
-  def skip_slug_validation?
-    true
-  end
+  # overwrite skip uniq slug validation
+  def skip_slug_validation?; true end
 
   private
   def update_count
@@ -73,4 +63,7 @@ class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
     self.site_id = self.parent_item.site_id if self.parent_item.present?
     self.site_id = self.parent.site_id if self.parent.present?
   end
+
+  # overwrite inherit method
+  def destroy_dependencies; end
 end

data/app/models/camaleon_cms/post.rb

@@ -213,7 +213,7 @@ class CamaleonCms::Post < CamaleonCms::PostDefault
   # return the layout assigned to this post
   # post_type: post type owner of this post
   def get_layout(posttype = nil)
-    return get_option("default_template") if !manage_layout?(posttype)
+    return get_option("default_layout") if !manage_layout?(posttype)
     get_meta('layout', get_option("default_layout") || (posttype || self.post_type).get_option('default_layout', nil))
   end
 

data/app/models/camaleon_cms/post_comment.rb

@@ -10,7 +10,8 @@ class CamaleonCms::PostComment < ActiveRecord::Base
   include CamaleonCms::Metas
   self.table_name = "#{PluginRoutes.static_system_info["db_prefix"]}comments"
   attr_accessible :user_id, :post_id, :content, :author, :author_email, :author_url, :author_IP,
-                  :approved, :agent, :agent, :typee, :comment_parent
+                  :approved, :agent, :agent, :typee, :comment_parent, :is_anonymous
+  attr_accessor :is_anonymous
 
   #default_scope order('comments.created_at ASC')
   #approved: approved | pending | spam
@@ -28,6 +29,7 @@ class CamaleonCms::PostComment < ActiveRecord::Base
   scope :approveds, -> { where(:approved => 'approved') }
 
   validates :content, :presence => true
+  validates_presence_of :author, :author_email, if: Proc.new { |c| c.is_anonymous.present? }
   after_create :update_counter
   after_destroy :update_counter
 

data/app/models/camaleon_cms/post_default.rb

@@ -56,7 +56,7 @@ class CamaleonCms::PostDefault < ActiveRecord::Base
 
   # return all menu items in which this post was assigned
   def in_nav_menu_items
-    CamaleonCms::NavMenuItem.joins(:metas).where("value LIKE ?","%\"object_id\":\"#{self.id}\"%").where("value LIKE ?","%\"type\":\"post\"%").readonly(false)
+    CamaleonCms::NavMenuItem.where(url: self.id, kind: 'post')
   end
 
   # Set the meta, field values and the post keywords here

data/app/models/camaleon_cms/post_type.rb

@@ -13,6 +13,7 @@ class CamaleonCms::PostType < CamaleonCms::TermTaxonomy
   has_many :categories, :class_name => "CamaleonCms::Category", foreign_key: :parent_id, dependent: :destroy, inverse_of: :post_type_parent
   has_many :post_tags, :class_name => "CamaleonCms::PostTag", foreign_key: :parent_id, dependent: :destroy, inverse_of: :post_type
   has_many :posts, class_name: "CamaleonCms::Post", foreign_key: :taxonomy_id, dependent: :destroy, inverse_of: :post_type
+  has_many :comments, through: :posts
   has_many :posts_through_categories, foreign_key: :objectid, through: :term_relationships, :source => :objects
   has_many :posts_draft, class_name: "CamaleonCms::Post", foreign_key: :taxonomy_id, dependent: :destroy, source: :drafts, inverse_of: :post_type
   has_many :field_group_taxonomy, -> {where("object_class LIKE ?","PostType_%")}, :class_name => "CamaleonCms::CustomField", foreign_key: :objectid, dependent: :destroy
@@ -108,21 +109,21 @@ class CamaleonCms::PostType < CamaleonCms::TermTaxonomy
   #   settings: Hash of post settings, sample => settings:
   #     {has_content: false, has_summary: true, default_layout: 'my_layout', default_template: 'my_template' } (optional, see more in post.set_setting(...))
   #   data_metas: {template: "", layout: ""}
+  # sample: my_posttype.add_post(title: "My Title", post_order: 5, content: 'lorem_ipsum', settings: {default_template: "home/counters", has_content: false, has_keywords: false, skip_fields: ["sub_tite", 'banner']}, fields: {pattern: true, bg: 'http://www.reallusion.com/de/images/3dx5/whatsnew/3dx5_features_banner_bg_02.jpg'})
+  #   More samples here: https://gist.github.com/owen2345/eba9691585ed78ad6f7b52e9591357bf
   # return created post if it was created, else return errors
   def add_post(args)
     _fields = args.delete(:fields)
     _settings = args.delete(:settings)
     _summary = args.delete(:summary)
     _order_position = args.delete(:order_position)
-    _categories = args.delete(:categories)
-    _tags = args.delete(:tags)
+    args[:data_categories] = _categories = args.delete(:categories)
+    args[:data_tags] = args.delete(:tags)
     _thumb = args.delete(:thumb)
     p = self.posts.new(args)
     p.slug = self.site.get_valid_post_slug(p.title.parameterize) unless p.slug.present?
     if p.save!
       _settings.each{ |k, v| p.set_setting(k, v) } if _settings.present?
-      p.assign_category(_categories) if _categories.present? && self.manage_categories?
-      p.assign_tags(_tags) if _tags.present? && self.manage_tags?
       p.set_position(_order_position) if _order_position.present?
       p.set_summary(_summary) if _summary.present?
       p.set_thumb(_thumb) if _thumb.present?

data/app/models/camaleon_cms/site.rb

@@ -252,6 +252,17 @@ class CamaleonCms::Site < CamaleonCms::TermTaxonomy
     self.status == 'maintenance'
   end
 
+  # return the anonymous user
+  # if the anonymous user not exist, will create one
+  def get_anonymous_user
+    user = self.users.where(username: 'anonymous').first
+    unless user.present?
+      pass = "anonymous#{rand(9999)}"
+      user = self.users.create({email: 'anonymous_user@local.com', username: 'anonymous', password: pass, password_confirmation: pass, first_name: 'Anonymous'})
+    end
+    user
+  end
+
   private
   # destroy all things before site destroy
   def destroy_site
@@ -291,6 +302,7 @@ class CamaleonCms::Site < CamaleonCms::TermTaxonomy
         @nav_menu.append_menu_item({label: title, type: 'post', link: post.id})
       end
     end
+    get_anonymous_user
   end
 
   # assign all users to this new site

data/app/models/camaleon_cms/term_taxonomy.rb

@@ -43,7 +43,7 @@ class CamaleonCms::TermTaxonomy < ActiveRecord::Base
 
   # return all menu items in which this taxonomy was assigned
   def in_nav_menu_items
-    CamaleonCms::NavMenuItem.joins(:metas).where("value LIKE ?","%\"object_id\":\"#{self.id}\"%").where("value LIKE ?","%\"type\":\"#{self.taxonomy}\"%").readonly(false)
+    CamaleonCms::NavMenuItem.where(url: self.id, kind: self.taxonomy)
   end
 
   # permit to skip slug validations for children models, like menu items

data/app/models/camaleon_cms/user_role.rb

@@ -129,8 +129,12 @@ class CamaleonCms::UserRole < CamaleonCms::TermTaxonomy
               key: 'settings',
               label: "#{I18n.t('camaleon_cms.admin.sidebar.settings')}",
               description: "#{I18n.t('camaleon_cms.admin.users.tool_tip.settings')}"
+          },
+          {
+              key: 'theme_settings',
+              label: "#{I18n.t('camaleon_cms.admin.settings.theme_setting', default: 'Theme Settings')}",
+              description: "#{I18n.t('camaleon_cms.admin.users.tool_tip.themes')}"
           }
       ]
   }
-
 end

data/app/models/concerns/camaleon_cms/custom_fields_read.rb

@@ -21,22 +21,27 @@ module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
   # get custom field groups for current object
   # only: Post_type, Post, Category, PostTag, Widget, Site and a Custom model pre configured
   # return collections CustomFieldGroup
-  # args: (Hash)
-    # kind: argument only for PostType Objects: (Post (Default) | Category | PostTag).
+  # args: (Hash, used only for PostType Objects)
+    # kind: (Post (Default) | Category | PostTag | PostType).
+      # If kind = "Post" this will return all groups for all posts from current post type
+      # If kind = "Category" this will return all groups for all categories from current post type
+      # If kind = "PostTag" this will return all groups for all posttags from current post type
+      # If kind = "all" this will return all groups from current post type
       # If kind = "post_type" this will return groups for all post_types
-      # If kind = "Post" this will return all groups for all posts from current post type + groups of current post type
-    # include_parent: (boolean, default false) Permit to recover groups from self + parent post_type (argument valid only for Post | PostTag | Category)
-  # args: (String) => is a value for kind attribute
+  # Sample: mypost.get_field_groups() ==> return fields for posts from parent posttype
+  # Sample: mycat.get_field_groups() ==> return fields for categories from parent posttype
+  # Sample: myposttag.get_field_groups() ==> return fields for posttags from parent posttype
+  # Sample: mypost_type.get_field_groups({kind: 'Post'}) => return custom fields for posts
+  # Sample: mypost_type.get_field_groups({kind: 'Category'}) => return custom fields for posts
+  # Sample: mypost_type.get_field_groups({kind: 'PostTag'}) => return custom fields for posts
   def get_field_groups(args = {})
     args = args.is_a?(String) ?  {kind: args, include_parent: false } : {kind: "Post", include_parent: false }.merge(args)
     class_name = self.class.to_s.parseCamaClass
     case class_name
-      when 'Category','Post','PostTag'
-        if args[:include_parent]
-          CamaleonCms::CustomFieldGroup.where("(objectid = ? AND object_class = ?) OR (objectid = ? AND object_class = ?)", self.id || -1, class_name, self.post_type.id, "PostType_#{class_name}")
-        else
-          CamaleonCms::CustomFieldGroup.where(objectid: self.id || -1, object_class: class_name)
-        end
+      when 'Category','PostTag'
+        self.post_type.get_field_groups(class_name)
+      when 'Post'
+        CamaleonCms::CustomFieldGroup.where("(objectid = ? AND object_class = ?) OR (objectid = ? AND object_class = ?)", self.id || -1, class_name, self.post_type.id, "PostType_#{class_name}")
       when 'NavMenuItem'
         self.main_menu.field_groups
       when 'PostType'
@@ -65,33 +70,48 @@ module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
   # _key: custom field key
   # if value is not present, then return default
   # return default only if the field was not registered
-  def get_field_value(_key, _default = nil)
-    v = _default
-    v = get_field_values(_key).first rescue _default
+  def get_field_value(_key, _default = nil, group_number = 0)
+    v = get_field_values(_key, group_number).first rescue _default
     v.present? ? v : _default
   end
   alias_method :get_field, :get_field_value
-
-  # the same as the_field() but if the value is not present, this will return default value
-  def get_field!(_key, _default = nil)
-    v = _default
-    v = get_field_values(_key).first rescue _default
-    v.present? ? v : _default
-  end
+  alias_method :get_field!, :get_field_value
 
   # get custom field values
   # _key: custom field key
-  def get_field_values(_key)
-    self.field_values.where(custom_field_slug: _key).pluck(:value)
+  def get_field_values(_key, group_number = 0)
+    self.field_values.where(custom_field_slug: _key, group_number: group_number).pluck(:value)
   end
   alias_method :get_fields, :get_field_values
 
-  # ------------- new function update field value -------------
-  def update_field_value(_key, value = nil)
-    self.field_values.where(custom_field_slug: _key).first.update_column('value', value) rescue nil
+  # return the values of custom fields grouped by group_number
+  # field_keys: (array of keys)
+  # samples: my_object.get_fields_grouped(['my_slug1', 'my_slug2'])
+  #   return: [
+  #             { 'my_slug1' => ["val 1"], 'my_slug2' => ['val 2']},
+  #             { 'my_slug1' => ["val2 for slug1"], 'my_slug2' => ['val 2 for slug2']}
+  #   ] ==> 2 groups
+  #
+  #   return: [
+  #             { 'my_slug1' => ["val 1", 'val 2 for fields multiple support'], 'my_slug2' => ['val 2']},
+  #             { 'my_slug1' => ["val2 for slug1", 'val 2'], 'my_slug2' => ['val 2 for slug2']}
+  #             { 'my_slug1' => ["val3 for slug1", 'val 3'], 'my_slug2' => ['val 3 for slug2']}
+  #   ] ==> 3 groups
+  #
+  #   puts res[0]['my_slug1'].first ==> "val 1"
+  def get_fields_grouped(field_keys)
+    res = []
+    field_values.where(custom_field_slug: field_keys).order(group_number: :asc).group_by(&:group_number).each do |group_number, group_fields|
+      group = {}
+      field_keys.each do |field_key|
+        group[field_key] = []
+        group_fields.each{ |field| group[field_key] << field.value if field_key == field.custom_field_slug }
+      end
+      res << group
+    end
+    res
   end
 
-
   # return all values
   # {key1: "single value", key2: [multiple, values], key3: value4} if include_options = false
   # {key1: {values: "single value", options: {a:1, b: 4}}, key2: {values: [multiple, values], options: {a=1, b=2} }} if include_options = true
@@ -127,6 +147,7 @@ module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
     # name: name for the group
     # slug: key for group (if slug = _default => this will never show title and description)
     # description: description for the group (optional)
+    # is_repeat: (boolean, optional -> default false) indicate if group support multiple format (repeated values)
   # Model supported: PostType, Category, Post, Posttag, Widget, Plugin, Theme, User and Custom models pre configured
   # Note 1: If you need add fields for all post's or all categories, then you need to add the fields into the
   #     post_type.add_custom_field_group(values, kind = "Post")
@@ -140,7 +161,11 @@ module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
     unless group.present?
       site = _cama_get_field_site
       values[:parent_id] = site.id if site.present?
-      group = get_field_groups(kind).create(values)
+      if self.is_a?(CamaleonCms::Post) # harcoded for post to support custom field groups
+        group = CamaleonCms::CustomFieldGroup.where(object_class: "Post", objectid: self.id).create!(values)
+      else
+        group = get_field_groups(kind).create!(values)
+      end
     end
     group
   end
@@ -157,47 +182,72 @@ module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
   end
   alias_method :add_field, :add_custom_field_to_default_group
 
-  # only custom field plugin (protected)
-  # example:
-  # id: custom_field_id
+  # return field object for current model
+  def get_field_object(slug)
+    CamaleonCms::CustomField.where(parent_id: get_field_groups.pluck(:id), slug: slug).first || CamaleonCms::CustomField.where(slug: slug, parent_id: get_field_groups({include_parent: true})).first
+  end
+
+  # save all fields sent from browser (reservated for browser request)
+  # sample:
   # {
-  # :key : {id: 123, values: ['uno','dos']}
-  # :key2 : {id: 455, values: ['uno','dos']}
-  # :key3 : {id: 4555, values: ['uno','dos']}
+  #   "0"=>{ "untitled-text-box"=>{"id"=>"262", "values"=>{"0"=>"33333"}}},
+  #   "1"=>{ "untitled-text-box"=>{"id"=>"262", "values"=>{"0"=>"33333"}}}
   # }
   def set_field_values(datas = {})
-    self.field_values.delete_all
     if datas.present?
-      datas.each do |key, values|
-        if values[:values].present?
-          order_value = -1
-          (values[:values].is_a?(Hash) ? values[:values].values : values[:values]).each do |value|
-            item = self.field_values.create!({custom_field_id: values[:id], custom_field_slug: key, value: fix_meta_value(value), term_order: order_value += 1})
+      self.field_values.delete_all
+      datas.each do |index, fields_data|
+        fields_data.each do |field_key, values|
+          if values[:values].present?
+            order_value = -1
+            (values[:values].is_a?(Hash) ? values[:values].values : values[:values]).each do |value|
+              item = self.field_values.create!({custom_field_id: values[:id], custom_field_slug: field_key, value: fix_meta_value(value), term_order: order_value += 1, group_number: values[:group_number] || 0})
+            end
           end
         end
       end
     end
   end
 
-  # return field object for current model
-  def get_field_object(slug)
-    CamaleonCms::CustomField.where(parent_id: get_field_groups.pluck(:id), slug: slug).first || CamaleonCms::CustomField.where(slug: slug, parent_id: get_field_groups({include_parent: true})).first
+  # update new value for field with slug _key
+  # Sample: my_posy.update_field_value('sub_title', 'Test Sub Title')
+  def update_field_value(_key, value = nil, group_number = 0)
+    self.field_values.where(custom_field_slug: _key, group_number: group_number).first.update_column('value', value) rescue nil
   end
 
-  # clear and register values for this custom field
+  # Set custom field values for current model
   # key: slug of the custom field
   # value: array of values for multiple values support
   # value: string value
   def save_field_value(key, value, order = 0, clear = true)
-    field = get_field_object(key)
-    return unless field.present?
-    self.field_values.where({custom_field_slug: key}).destroy_all if clear
+    set_field_value(key, value, {clear: clear, order: order})
+  end
+
+  # Set custom field values for current model (support for multiple group values)
+  # key: (string required) slug of the custom field
+  # value: (array | string) array: array of values for multiple values support, string: uniq value for the custom field
+  # args:
+  #   field_id: (integer optional) identifier of the custom field
+  #   order: order or position of the field value
+  #   group_number: number of the group (only for custom field group with is_repeat enabled)
+  #   clear: (boolean, default true) if true, will remove previous values and set these values, if not will append values
+  # return false if the was not saved because there is not present the field with slug: key
+  # sample: my_post.set_field_value('subtitle', 'Sub Title')
+  # sample: my_post.set_field_value('subtitle', ['Sub Title1', 'Sub Title2']) # set values for a field (for fields that support multiple values)
+  # sample: my_post.set_field_value('subtitle', 'Sub Title', {group_number: 1})
+  # sample: my_post.set_field_value('subtitle', 'Sub Title', {group_number: 1, group_number: 1}) # add field values for fields in group 1
+  def set_field_value(key, value, args = {})
+    args = {order: 0, group_number: 0, field_id: nil, clear: true}.merge(args)
+    args[:field_id] = get_field_object(key).id rescue nil unless args[:field_id].present?
+    return false unless args[:field_id].present?
+    self.field_values.where({custom_field_slug: key, group_number: args[:group_number]}).delete_all if args[:clear]
+    v = {custom_field_id: args[:field_id], custom_field_slug: key, value: fix_meta_value(value), term_order: args[:order], group_number: args[:group_number]}
     if value.is_a?(Array)
       value.each do |val|
-        self.field_values.create!({custom_field_id: field.id, custom_field_slug: key, value: fix_meta_value(val), term_order: order})
+        self.field_values.create!(v.merge({value: fix_meta_value(val)}))
       end
     else
-      self.field_values.create!({custom_field_id: field.id, custom_field_slug: key, value: fix_meta_value(value), term_order: order})
+      self.field_values.create!(v)
     end
   end
 

data/app/uploaders/camaleon_cms_aws_uploader.rb

@@ -6,7 +6,7 @@ class CamaleonCmsAwsUploader < CamaleonCmsUploader
     bucket.objects.each do |file|
       cache_item(file_parse(file), objects)
     end
-    @current_site.set_meta('cama_media_cache', objects)
+    @current_site.set_meta(cache_key, objects)
     objects
   end
 

data/app/uploaders/camaleon_cms_local_uploader.rb

@@ -1,4 +1,5 @@
 class CamaleonCmsLocalUploader < CamaleonCmsUploader
+  PRIVATE_DIRECTORY = 'private'
   def browser_files(prefix = '/', objects = {})
     objects[prefix] = {files: {}, folders: {}}
     path = File.join(@root_folder, prefix)
@@ -10,12 +11,27 @@ class CamaleonCmsLocalUploader < CamaleonCmsUploader
       cache_item(obj, objects)
       browser_files(File.join(prefix, obj['name']), objects) if obj['format'] == 'folder'
     end
-    @current_site.set_meta('cama_media_cache', objects) if prefix == '/'
+    @current_site.set_meta(cache_key, objects) if prefix == '/'
     objects
   end
 
+  # return the full file path for private file with key
+  # sample: 'my_file.pdf' ==> /var/www/my_app/private/my_file.pdf
+  def self.private_file_path(key, current_site)
+    Rails.root.join(self::PRIVATE_DIRECTORY, current_site.id.to_s, key.gsub(/(\/){2,}/, "/")).to_s
+  end
+
+  # check if this uploader is private mode
+  def is_private_uploader?
+    @args[:private]
+  end
+
   def after_initialize
-    @root_folder = @args[:root_folder] || @current_site.upload_directory
+    if is_private_uploader?
+      @root_folder = Rails.root.join(self.class::PRIVATE_DIRECTORY, @current_site.id.to_s).to_s
+    else
+      @root_folder = @args[:root_folder] || @current_site.upload_directory
+    end
     FileUtils.mkdir_p(@root_folder) unless Dir.exist?(@root_folder)
   end
 
@@ -25,7 +41,7 @@ class CamaleonCmsLocalUploader < CamaleonCmsUploader
     res = {
         "name" => File.basename(file_path),
         "key" => parse_key(file_path),
-        "url" => is_dir ? '' : File.join(@current_site.the_url(locale: false), url_path),
+        "url" => is_dir ? '' : (is_private_uploader? ? url_path.sub("#{@root_folder}/", '') : File.join(@current_site.the_url(locale: false), url_path)),
         "is_folder" => is_dir,
         "size" => is_dir ? 0 : File.size(file_path).round(2),
         "format" => is_dir ? 'folder' : self.class.get_file_format(file_path),