camaleon_cms 2.1.1.4 → 2.1.2.0

data/app/models/camaleon_cms/nav_menu_item.rb

@@ -16,6 +16,7 @@ class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
   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
@@ -30,6 +31,12 @@ class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
     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
@@ -42,6 +49,12 @@ class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
     children.create({name: value[:label], data_options: {type: value[:type], object_id: value[:link]}})
   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]}})
+  end
+
   # skip uniq slug validation
   def skip_slug_validation?
     true

data/app/models/camaleon_cms/post.rb

@@ -33,7 +33,7 @@ end
 class CamaleonCms::Post < CamaleonCms::PostDefault
   include CamaleonCms::CategoriesTagsForPosts
   default_scope ->{ where(post_class: "Post").order(post_order: :asc, created_at: :desc) }
-  has_many :metas, ->{ where(object_class: 'Post')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+  has_many :metas, ->{ where(object_class: 'Post')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :delete_all
 
   # DEPRECATED
   has_many :post_relationships, class_name: "CamaleonCms::PostRelationship", foreign_key: :objectid, dependent: :destroy,  inverse_of: :posts

data/app/models/camaleon_cms/post_type.rb

@@ -8,7 +8,7 @@
 =end
 class CamaleonCms::PostType < CamaleonCms::TermTaxonomy
   default_scope { where(taxonomy: :post_type) }
-  has_many :metas, ->{ where(object_class: 'PostType')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+  has_many :metas, ->{ where(object_class: 'PostType')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :delete_all
   has_many :categories, :class_name => "CamaleonCms::Category", foreign_key: :parent_id, dependent: :destroy
   has_many :post_tags, :class_name => "CamaleonCms::PostTag", foreign_key: :parent_id, dependent: :destroy
   has_many :posts, class_name: "CamaleonCms::Post", foreign_key: :taxonomy_id, dependent: :destroy
@@ -169,17 +169,18 @@ class CamaleonCms::PostType < CamaleonCms::TermTaxonomy
 
   # destroy all custom field groups assigned to this post type
   def destroy_field_groups
-    # TODO: CHANGE TO SUPPORT DESTROY FOR SITE DESTROY
-    # if self.slug == "post" || self.slug == "page"
-    #   errors.add(:base, "This post type can not be deleted.")
-    #   return false
-    # end
+    unless self.destroyed_by_association.present?
+      if self.slug == "post" || self.slug == "page"
+        errors.add(:base, "This post type can not be deleted.")
+        return false
+      end
+    end
     self.get_field_groups.destroy_all
   end
 
   # reload routes to enable this post type url, like: http://localhost/my-slug
   def refresh_routes
-    PluginRoutes.reload
+    PluginRoutes.reload unless self.destroyed_by_association.present?
   end
 
   # check if slug was changed

data/app/models/camaleon_cms/site.rb

@@ -9,7 +9,7 @@
 class CamaleonCms::Site < CamaleonCms::TermTaxonomy
   # attrs: [name, description, slug]
   default_scope { where(taxonomy: :site).reorder(term_group: :desc) }
-  has_many :metas, -> { where(object_class: 'Site') }, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+  has_many :metas, -> { where(object_class: 'Site') }, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :delete_all
   has_many :post_types, :class_name => "CamaleonCms::PostType", foreign_key: :parent_id, dependent: :destroy
   has_many :nav_menus, :class_name => "CamaleonCms::NavMenu", foreign_key: :parent_id, dependent: :destroy
   has_many :nav_menu_items, :class_name => "CamaleonCms::NavMenuItem", foreign_key: :term_group
@@ -28,6 +28,7 @@ class CamaleonCms::Site < CamaleonCms::TermTaxonomy
   after_create :set_default_user_roles
   after_save :update_routes
   before_destroy :destroy_site
+  after_destroy :reload_routes
   validates_uniqueness_of :slug, scope: :taxonomy
 
   # all user roles for this site
@@ -236,6 +237,21 @@ class CamaleonCms::Site < CamaleonCms::TermTaxonomy
     end
   end
 
+  # check if current site is active or not
+  def is_active?
+    !self.status.present? || self.status == 'active'
+  end
+
+  # check if current site is active or not
+  def is_inactive?
+    self.status == 'inactive'
+  end
+
+  # check if current site is in maintenance or not
+  def is_maintenance?
+    self.status == 'maintenance'
+  end
+
   private
   # destroy all things before site destroy
   def destroy_site
@@ -250,7 +266,7 @@ class CamaleonCms::Site < CamaleonCms::TermTaxonomy
   def default_settings
     default_post_type = [
         {name: 'Post', description: 'Posts', options: {has_category: true, has_tags: true, not_deleted: true, has_summary: true, has_content: true, has_comments: true, has_picture: true, has_template: true, }},
-        {name: 'Page', description: 'Pages', options: {has_category: false, has_tags: false, not_deleted: true, has_summary: false, has_content: true, has_comments: false, has_picture: true, has_template: true, }}
+        {name: 'Page', description: 'Pages', options: {has_category: false, has_tags: false, not_deleted: true, has_summary: false, has_content: true, has_comments: false, has_picture: true, has_template: true, has_layout: true}}
     ]
     default_post_type.each do |pt|
       model_pt = self.post_types.create({name: pt[:name], slug: pt[:name].to_s.parameterize, description: pt[:description], data_options: pt[:options]})
@@ -290,6 +306,10 @@ class CamaleonCms::Site < CamaleonCms::TermTaxonomy
     PluginRoutes.reload if self.slug_changed?
   end
 
+  def reload_routes
+    PluginRoutes.reload
+  end
+
   def before_validating
     slug = self.slug
     slug = self.name if slug.blank?

data/app/models/camaleon_cms/user.rb

@@ -74,8 +74,9 @@ class CamaleonCms::User < ActiveRecord::Base
     self.role == 'client'
   end
 
+  # return the UserRole Object of this user in Site
   def get_role(site)
-    site.user_roles.where(slug: self.role).first
+    @_user_role ||= site.user_roles.where(slug: self.role).first
   end
 
   def set_meta_from_form(metas)

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

@@ -8,10 +8,13 @@
 =end
 module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
   included do
-    has_many :fields, ->(object){ where(:object_class => object.class.to_s.gsub("Decorator","").gsub("CamaleonCms::",""))} , :class_name => "CamaleonCms::CustomField" ,foreign_key: :objectid
-    has_many :field_values, ->(object){where(object_class: object.class.to_s.gsub("Decorator","").gsub("CamaleonCms::",""))}, :class_name => "CamaleonCms::CustomFieldsRelationship", foreign_key: :objectid, dependent: :destroy
-    has_many :custom_field_values, :class_name => "CamaleonCms::CustomFieldsRelationship", foreign_key: :objectid, dependent: :destroy
     before_destroy :_destroy_custom_field_groups
+    has_many :fields, ->(object){ where(:object_class => object.class.to_s.gsub("Decorator","").gsub("CamaleonCms::",""))} , :class_name => "CamaleonCms::CustomField" ,foreign_key: :objectid
+    has_many :field_values, ->(object){where(object_class: object.class.to_s.gsub("Decorator","").gsub("CamaleonCms::",""))}, :class_name => "CamaleonCms::CustomFieldsRelationship", foreign_key: :objectid, dependent: :delete_all
+    has_many :custom_field_values, :class_name => "CamaleonCms::CustomFieldsRelationship", foreign_key: :objectid, dependent: :delete_all
+
+    # valid only for simple groups and not for complex like: posts, post, ... where the group is for individual or children groups
+    has_many :field_groups, ->(object){where(object_class: object.class.to_s.parseCamaClass)}, :class_name => "CamaleonCms::CustomFieldGroup", foreign_key: :objectid
   end
 
 
@@ -25,34 +28,32 @@ module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
   # args: (String) => is a value for kind attribute
   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.gsub("Decorator","").gsub("CamaleonCms::","")
+    class_name = self.class.to_s.parseCamaClass
     case class_name
       when 'Category','Post','PostTag'
         if args[:include_parent]
-           self.post_type.site.custom_field_groups.where("(objectid = ? AND object_class = ?) OR (objectid = ? AND object_class = ?)", self.id || -1, class_name, self.post_type.id, "PostType_#{class_name}")
+          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
-          self.post_type.site.custom_field_groups.where(objectid: self.id || -1, object_class: class_name)
+          CamaleonCms::CustomFieldGroup.where(objectid: self.id || -1, object_class: class_name)
         end
       when 'Widget::Main'
-        self.site.custom_field_groups.where(object_class: class_name, objectid:  self.id)
+        self.field_groups
       when 'Theme'
-        self.site.custom_field_groups.where(object_class: class_name, objectid:  self.id)
+        self.field_groups
       when 'Site'
-        self.custom_field_groups.where(object_class: class_name)
+        self.field_groups
       when 'NavMenuItem'
-        # self.main_menu.custom_field_groups //verify this problem
-        puts "get_field_groups - NavMenuItem: **************#{self.inspect}***** #{self.main_menu.inspect}"
-        CamaleonCms::NavMenu.find(self.main_menu.id).get_field_groups
+        self.main_menu.field_groups
       when 'PostType'
         if args[:kind] == "all"
-          self.site.custom_field_groups.where(object_class: ["PostType_Post", "PostType_Post", "PostType_PostTag", "PostType"], objectid:  self.id )
+          CamaleonCms::CustomFieldGroup.where(object_class: ["PostType_Post", "PostType_Post", "PostType_PostTag", "PostType"], objectid:  self.id )
         elsif args[:kind] == "post_type"
-          self.site.custom_field_groups.where(object_class: class_name)
+          self.field_groups
         else
-          self.site.custom_field_groups.where(object_class: "PostType_#{args[:kind]}", objectid:  self.id )
+          CamaleonCms::CustomFieldGroup.where(object_class: "PostType_#{args[:kind]}", objectid:  self.id )
         end
       else # 'Plugin' or other class
-        self.site.custom_field_groups.where(object_class: class_name, objectid:  self.id) if defined?(self.site)
+        self.field_groups
     end
   end
 
@@ -168,26 +169,17 @@ module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
   # :key3 : {id: 4555, values: ['uno','dos']}
   # }
   def set_field_values(datas = {})
-    ids_old = self.field_values.pluck(:id)
-    ids_saved = []
+    self.field_values.delete_all
     if datas.present?
       datas.each do |key, values|
         if values[:values].present?
-          order_value = 0
-          values[:values].each do |value|
-            item = self.field_values.where({custom_field_id: values[:id], custom_field_slug: key, value: fix_meta_value(value)}).first_or_create!()
-            if defined?(item.id)
-              item.update_column('term_order', order_value)
-              ids_saved << item.id
-              order_value += 1
-            end
+          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})
           end
         end
       end
     end
-
-    ids_deletes = ids_old - ids_saved
-    self.field_values.where(id: ids_deletes).destroy_all if ids_deletes.present?
   end
 
   # return field object for current model

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

@@ -14,7 +14,7 @@ module CamaleonCms::Metas extend ActiveSupport::Concern
     after_create  :save_metas_options, unless: :save_metas_options_skip
     before_update :fix_save_metas_options_no_changed
 
-    has_many :metas, ->(object){where(object_class: object.class.to_s.gsub("Decorator","").gsub("CamaleonCms::", ""))}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+    has_many :metas, ->(object){where(object_class: object.class.to_s.gsub("Decorator","").gsub("CamaleonCms::", ""))}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :delete_all
   end
 
   # Add meta with value or Update meta with key: key
@@ -30,11 +30,11 @@ module CamaleonCms::Metas extend ActiveSupport::Concern
   def get_meta(key, default = nil)
     key_str = key.is_a?(Symbol) ? key.to_s : key
     cama_fetch_cache("meta_#{key_str}") do
-      option = metas.select { |m| m.key.eql?(key_str) }.first
+      option = metas.where(key: key_str).first
       res = ''
       if option.present?
         value = JSON.parse(option.value) rescue option.value
-        res = (value.is_a?(Hash) ? value.to_sym : value) rescue option.value
+        res = (value.is_a?(Hash) ? value.with_indifferent_access : value) rescue option.value
       end
       res == '' ? default : res
     end
@@ -94,6 +94,7 @@ module CamaleonCms::Metas extend ActiveSupport::Concern
       set_meta(meta_key, data)
     end
   end
+  alias_method :set_options, :set_multiple_options
 
   # permit to skip save_metas_options in specific models
   def save_metas_options_skip

data/app/uploaders/camaleon_cms_aws_uploader.rb

@@ -0,0 +1,81 @@
+class CamaleonCmsAwsUploader < CamaleonCmsUploader
+  # recover all files from AWS and parse it to save into DB as cache
+  def browser_files
+    objects = {}
+    objects['/'] = {files: {}, folders: {}}
+    bucket.objects.each do |file|
+      cache_item(file_parse(file), objects)
+    end
+    @current_site.set_meta('cama_media_cache', objects)
+    objects
+  end
+
+  # parse an AWS file into custom file_object
+  def file_parse(s3_file)
+    key = s3_file.is_a?(String) ? s3_file : s3_file.key
+    key = "/#{key}" unless key.starts_with?('/')
+    is_dir = File.extname(key) == ''
+    res = {
+        "name" => File.basename(key),
+        "key" => key,
+        "url" => is_dir ? '' : (@current_site.get_option("filesystem_s3_cloudfront").present? ? File.join(@current_site.get_option("filesystem_s3_cloudfront"), key) : s3_file.public_url),
+        "is_folder" => is_dir,
+        "size" => is_dir ? 0 : s3_file.size.round(2),
+        "format" => is_dir ? 'folder' : self.class.get_file_format(key),
+        "deleteUrl" => '',
+        "thumb" => '',
+        'type' => is_dir ? '' : (s3_file.content_type rescue (MIME::Types.type_for(key).first.content_type rescue "")),
+        'created_at' => is_dir ? '' : s3_file.last_modified,
+        'dimension' => ''
+    }.with_indifferent_access
+    res["thumb"] = version_path(res['url']) if res['format'] == 'image' && File.extname(res['name']).downcase != '.gif'
+    if res['format'] == 'image'
+      # TODO: Recover image dimension (suggestion: save dimesion as metadata)
+    end
+    res
+  end
+
+  # add a file object or file path into AWS server
+  # :key => (String) key of the file ot save in AWS
+  # :args => (HASH) {same_name: false, is_thumb: false}, where:
+  #   - same_name: false => avoid to overwrite an existent file with same key and search for an available key
+  #   - is_thumb: true => if this file is a thumbnail of an uploaded file
+  def add_file(uploaded_io_or_file_path, key, args = {})
+    args, res = {same_name: false, is_thumb: false}.merge(args), nil
+    key = search_new_key(key) unless args[:same_name]
+    s3_file = bucket.object(key.split('/').clean_empty.join('/'))
+    s3_file.upload_file(uploaded_io_or_file_path.is_a?(String) ? uploaded_io_or_file_path : uploaded_io_or_file_path.path, acl: 'public-read')
+    res = cache_item(file_parse(s3_file)) unless args[:is_thumb]
+    res
+  end
+
+  # add new folder to AWS with :key
+  def add_folder(key)
+    s3_file = bucket.object(key.split('/').clean_empty.join('/') << '/')
+    s3_file.put(body: nil)
+    cache_item(file_parse(s3_file))
+    s3_file
+  end
+
+  # delete a folder in AWS with :key
+  def delete_folder(key)
+    bucket.objects(prefix: key.split('/').clean_empty.join('/') << '/').delete
+    reload
+  end
+
+  # delete a file in AWS with :key
+  def delete_file(key)
+    bucket.object(key.split('/').clean_empty.join('/')).delete rescue ''
+    reload
+  end
+
+  # initialize a bucket with AWS configurations
+  # return: (AWS Bucket object)
+  def bucket
+    @bucket ||= lambda{
+      config = Aws.config.update({ region: @current_site.get_option("filesystem_region", 'us-west-2'), credentials: Aws::Credentials.new(@current_site.get_option("filesystem_s3_access_key"), @current_site.get_option("filesystem_s3_secret_key")) })
+      s3 = Aws::S3::Resource.new
+      bucket = s3.bucket(@current_site.get_option("filesystem_s3_bucket_name"))
+    }.call
+  end
+end

data/app/uploaders/camaleon_cms_local_uploader.rb

@@ -0,0 +1,84 @@
+class CamaleonCmsLocalUploader < CamaleonCmsUploader
+  def browser_files(prefix = '/', objects = {})
+    objects[prefix] = {files: {}, folders: {}}
+    path = File.join(@root_folder, prefix)
+    Dir.entries(path).each do |f_name|
+      next if f_name == '..' || f_name == '.' || f_name == 'thumb'
+      f_path = File.join(path, f_name)
+      key = parse_key(f_path)
+      obj = get_file(key) || file_parse(key)
+      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 == '/'
+    objects
+  end
+
+  def after_initialize
+    @root_folder = @args[:root_folder] || @current_site.upload_directory
+    FileUtils.mkdir_p(@root_folder) unless Dir.exist?(@root_folder)
+  end
+
+  def file_parse(key)
+    file_path = File.join(@root_folder, key)
+    url_path, is_dir = file_path.sub(Rails.root.join('public').to_s, ''), File.directory?(file_path)
+    res = {
+        "name" => File.basename(file_path),
+        "key" => parse_key(file_path),
+        "url" => is_dir ? '' : 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),
+        "deleteUrl" => '',
+        "thumb" => '',
+        'type' => (MIME::Types.type_for(file_path).first.content_type rescue ""),
+        'created_at' => File.mtime(file_path),
+        'dimension' => ''
+    }.with_indifferent_access
+    res["thumb"] = version_path(res['url']) if res['format'] == 'image' && File.extname(file_path).downcase != '.gif'
+    if res['format'] == 'image'
+      im = MiniMagick::Image.open(file_path)
+      res['dimension'] = "#{im[:width]}x#{im[:height]}"
+    end
+    res
+  end
+
+  #
+  def add_file(uploaded_io_or_file_path, key, args = {})
+    args, res = {same_name: false, is_thumb: false}.merge(args), nil
+    key = search_new_key(key) unless args[:same_name]
+    add_folder(File.dirname(key)) if File.dirname(key).present?
+    upload_io = uploaded_io_or_file_path.is_a?(String) ? File.open(uploaded_io_or_file_path) : uploaded_io_or_file_path
+    File.open(File.join(@root_folder, key), 'wb'){|file|       file.write(upload_io.read) }
+    res = cache_item(file_parse(key)) unless args[:is_thumb]
+    res
+  end
+
+  def add_folder(key)
+    d, is_new_folder = File.join(@root_folder, key).to_s, false
+    unless Dir.exist?(d)
+      FileUtils.mkdir_p(d)
+      is_new_folder = true if File.basename(d) != 'thumb'
+    end
+    f = file_parse(key)
+    cache_item(f) if is_new_folder
+    f
+  end
+
+  def delete_folder(key)
+    FileUtils.rm_rf(File.join(@root_folder, key))
+    reload
+  end
+
+  def delete_file(key)
+    FileUtils.rm(File.join(@root_folder, key))
+    reload
+  end
+
+  # convert a real file path into file key
+  def parse_key(file_path)
+    r = file_path.sub(@root_folder, '')
+    r = "/#{r}" unless r.starts_with?('/')
+    r
+  end
+end

data/app/uploaders/camaleon_cms_uploader.rb

@@ -0,0 +1,146 @@
+class CamaleonCmsUploader
+  attr_accessor :thumb
+  # root_folder, current_site, service = 'Local', thumb
+  def initialize(args = {})
+    @current_site = args[:current_site]
+    t_w, t_h = @current_site.get_option('filesystem_thumb_size', '100x100').split('x')
+    @thumb = args[:thumb] || {w: t_w, h: t_h}
+    @args = args
+    after_initialize
+  end
+
+  def after_initialize
+
+  end
+
+  # return all files structure, within folder prefix
+  # return json like:
+  # {files: {'file_name': {'name'=> 'a.jpg', key: '/test/a.jpg', url: '', url: '', size: '', format: '', thumb: 'thumb_url', type: '', created_at: '', dimension: '120x120'}}, folders: {'folder name' => {name: 'folder name', key: '/folder name', ...}}}
+  def objects(prefix = '/')
+    prefix = "/#{prefix}" unless prefix.starts_with?('/')
+    db = @current_site.get_meta('cama_media_cache', nil) || browser_files
+    db[prefix.gsub('//', '/')] || {files: {}, folders: {}}
+  end
+
+  # clean cached of files structure saved into DB
+  def clear_cache
+    @current_site.set_meta('cama_media_cache', nil)
+  end
+
+  # search for folders or files that includes search_text in their names
+  def search(search_text)
+    res = {files: {}, folders: {}}
+    (@current_site.get_meta('cama_media_cache', nil) || browser_files).each do |folder_key, object|
+      res[:folders][folder_key] = get_file(folder_key) if !['', '/'].include?(folder_key) && folder_key.split('/').last.include?(search_text)
+      object[:files].each do |file_key, obj|
+        res[:files][file_key] = obj if file_key.include?(search_text)
+      end
+      res
+    end
+    res
+  end
+
+  # reload cache files structure
+  def reload
+    browser_files
+  end
+
+  # save file_parsed as a cache into DB
+  # file_parsed: (HASH) File parsed object
+  # objects_db: HASH Object where to add the current object (optional)
+  def cache_item(file_parsed, _objects_db = nil)
+    objects_db = _objects_db || @current_site.get_meta('cama_media_cache', {}) || {}
+    prefix = File.dirname(file_parsed['key'])
+
+    s = prefix.split('/').clean_empty
+    return file_parsed if s.last == 'thumb'
+    s.each_with_index{|_s, i| k = "/#{File.join(s.slice(0, i), _s)}"; cache_item(file_parse(k), objects_db) unless objects_db[k].present? } unless ['/', '', '.'].include?(prefix)
+
+    objects_db[prefix] = {files: {}, folders: {}} if objects_db[prefix].nil?
+    if file_parsed['format'] == 'folder'
+      objects_db[prefix][:folders][file_parsed['name']] = file_parsed
+    else
+      objects_db[prefix][:files][file_parsed['name']] = file_parsed
+    end
+    @current_site.set_meta('cama_media_cache', objects_db) if _objects_db.nil?
+    file_parsed
+  end
+
+
+  # convert current string path into file version_path, sample:
+  # /media/1/screen.png into /media/1/thumb/screen-png.png
+  # /media/1/screen.png into /media/1/crop_40x40/screen-png.png
+  def version_path(image_path, version_name = 'thumb')
+    File.join(File.dirname(image_path), version_name, "#{File.basename(image_path).parameterize}#{File.extname(image_path)}")
+  end
+
+  # return the file format (String) of path (depends of file extension)
+  def self.get_file_format(path)
+    ext = File.extname(path).sub(".", "").downcase
+    format = "unknown"
+    format = "image" if get_file_format_extensions('image').split(",").include?(ext)
+    format = "video" if get_file_format_extensions('video').split(",").include?(ext)
+    format = "audio" if get_file_format_extensions('audio').split(",").include?(ext)
+    format = "document" if get_file_format_extensions('document').split(",").include?(ext)
+    format = "compress" if get_file_format_extensions('compress').split(",").include?(ext)
+    format
+  end
+
+  # return the files extensión for each format
+  # support for multiples formats, sample: image,audio
+  def self.get_file_format_extensions(format)
+    res = []
+    format.downcase.gsub(' ', '').split(',').each do |f|
+      res << case f
+                when 'image', 'images'
+                  "jpg,jpeg,png,gif,bmp,ico"
+                when 'video', 'videos'
+                  "flv,webm,wmv,avi,swf,mp4,mov,mpg"
+                when 'audio'
+                  "mp3,ogg"
+                when 'document', 'documents'
+                  "pdf,xls,xlsx,doc,docx,ppt,pptx,html,txt,xml,json"
+                when 'compress'
+                  "zip,7z,rar,tar,bz2,gz,rar2"
+                else
+                  ''
+              end
+    end
+    res.join(',')
+  end
+
+  # verify permitted formats (return boolean true | false)
+  # true: if format is accepted
+  # false: if format is not accepted
+  # sample: validate_file_format('/var/www/myfile.xls', 'image,audio,docx,xls') => return true if the file extension is in formats
+  def self.validate_file_format(key, valid_formats = "*")
+    return true if valid_formats == "*" || !valid_formats.present?
+    valid_formats = valid_formats.gsub(' ', '').downcase.split(',') + get_file_format_extensions(valid_formats).split(',')
+    valid_formats.include?(File.extname(key).sub(".", "").downcase)
+  end
+
+
+  # verify if this file name already exist
+  # if the file is already exist, return a new name for this file
+  # sample: search_new_key("my_file/file.txt")
+  def search_new_key(key)
+    _key = key
+    if get_file(key).present?
+      (1..999).each do |i|
+        _key = key.cama_add_postfix_file_name("_#{i}")
+        break unless get_file(_key).present?
+      end
+    end
+    _key
+  end
+
+  # check if file with :key exist and return parsed_file, else return nil
+  def get_file(key, use_cache = true)
+    if use_cache
+      db = (@current_site.get_meta('cama_media_cache') || {})[File.dirname(key)] || {}
+    else
+      db = objects(File.dirname(key)) unless use_cache
+    end
+    (db[:files][File.basename(key)] || db[:folders][File.basename(key)]) rescue nil
+  end
+end