camaleon_cms_rails6 2.5.0

data/app/models/camaleon_cms/ability.rb

@@ -0,0 +1,109 @@
+class CamaleonCms::Ability
+  include CanCan::Ability
+
+  def initialize(user, current_site = nil)
+    # Define abilities for the passed in user here. For example:
+    #
+    user ||= CamaleonCms::User.new # guest user (not logged in)
+    if user.admin?
+      can :manage, :all
+    elsif user.client?
+      can :read, :all
+    else
+      # conditions:
+      current_user_role = user.get_role(current_site) || current_site.user_roles.new
+      @roles_manager ||= current_user_role.get_meta("_manager_#{current_site.id}", {}) || {}
+      @roles_post_type ||= current_user_role.get_meta("_post_type_#{current_site.id}", {}) || {}
+
+      ids_publish = @roles_post_type[:publish] || []
+      ids_edit = @roles_post_type[:edit] || []
+      ids_edit_other = @roles_post_type[:edit_other] || []
+      ids_edit_publish = @roles_post_type[:edit_publish] || []
+      ids_delete = @roles_post_type[:delete] || []
+      ids_delete_other = @roles_post_type[:delete_other] || []
+      ids_delete_publish = @roles_post_type[:delete_publish] || []
+
+      can :posts, CamaleonCms::PostType do |pt|
+        (ids_edit + ids_edit_other + ids_edit_publish).to_i.include?(pt.id) rescue false
+      end
+
+      can :create_post, CamaleonCms::PostType do |pt|
+        ids_edit.to_i.include?(pt.id) rescue false
+      end
+      can :publish_post, CamaleonCms::PostType do |pt|
+        ids_publish.to_i.include?(pt.id) rescue false
+      end
+      can :edit_other, CamaleonCms::PostType do |pt|
+        ids_edit_other.to_i.include?(pt.id) rescue false
+      end
+      can :edit_publish, CamaleonCms::PostType do |pt|
+        ids_edit_publish.to_i.include?(pt.id) rescue false
+      end
+
+      can :categories, CamaleonCms::PostType do |pt|
+        @roles_post_type[:manage_categories].to_i.include?(pt.id) rescue false
+      end
+      can :post_tags, CamaleonCms::PostType do |pt|
+        @roles_post_type[:manage_tags].to_i.include?(pt.id) rescue false
+      end
+
+      can :update, CamaleonCms::Post do |post|
+        pt_id = post.post_type.id
+        r = false
+        r ||= ids_edit.to_i.include?(pt_id) && post.user_id == user.id rescue false
+        r ||= ids_edit_publish.to_i.include?(pt_id) && post.published? rescue false
+        r ||= ids_edit_other.to_i.include?(pt_id) && post.user_id != user.id rescue false
+        r
+      end
+
+      can :destroy, CamaleonCms::Post do |post|
+        pt_id = post.post_type.id
+        r = false
+        r ||= ids_delete.to_i.include?(pt_id) && post.user_id == user.id rescue false
+        r ||= ids_delete_publish.to_i.include?(pt_id) && post.published? rescue false
+        r ||= ids_delete_other.to_i.include?(pt_id) && post.user_id != user.id rescue false
+        r
+      end
+
+      # support for custom abilities for each posttype
+      # sample: http://camaleon.tuzitio.com/documentation/category/40756-uncategorized/custom-models.html
+      @roles_post_type.each do |k , v|
+        next if ['edit', 'edit_other', 'edit_publish', 'publish', 'manage_categories'].include?(k.to_s)
+        can k.to_sym, CamaleonCms::PostType do |pt|
+          v.include?(pt.id.to_s) rescue false
+        end
+      end
+
+      # others
+      can :manage, :media     if @roles_manager[:media] rescue false
+      can :manage, :comments  if @roles_manager[:comments] rescue false
+      # can :manage, :forms     if @roles_manager[:forms] rescue false
+      can :manage, :themes    if @roles_manager[:themes] rescue false
+      can :manage, :widgets   if @roles_manager[:widgets] rescue false
+      can :manage, :nav_menu  if @roles_manager[:nav_menu] rescue false
+      can :manage, :plugins   if @roles_manager[:plugins] rescue false
+      can :manage, :users     if @roles_manager[:users] rescue false
+      can :manage, :settings  if @roles_manager[:settings] rescue false
+      @roles_manager.try(:each) do |rol_manage_key, val_role|
+        can :manage, rol_manage_key.to_sym if val_role.to_s.cama_true? rescue false
+      end
+    end
+    cannot :impersonate, CamaleonCms::User do |u|
+      u.id == user.id
+    end
+  end
+
+  # overwrite can method to support decorator class names
+  def can?(action, subject, *extra_args)
+    if subject.is_a?(Draper::Decorator)
+      super(action,subject.model,*extra_args)
+    else
+      super(action, subject, *extra_args)
+    end
+  end
+
+  # overwrite cannot method to support decorator class names
+  def cannot?(*args)
+    !can?(*args)
+  end
+end

data/app/models/camaleon_cms/category.rb

@@ -0,0 +1,52 @@
+class CamaleonCms::Category < CamaleonCms::TermTaxonomy
+  alias_attribute :site_id, :term_group
+  alias_attribute :post_type_id, :status
+
+  default_scope { where(taxonomy: :category) }
+  scope :no_empty, -> { where('count > 0') } # return all categories that contains at least one post
+  scope :empty, -> { where(count: [0, nil]) } # return all categories that does not contain any post
+  # scope :parents, -> { where("term_taxonomy.parent_id IS NULL") }
+
+  cama_define_common_relationships('Category')
+  has_many :posts, foreign_key: :objectid, through: :term_relationships, source: :objects
+  has_many :children, class_name: 'CamaleonCms::Category', foreign_key: :parent_id,
+    dependent: :destroy
+  belongs_to :parent, class_name: 'CamaleonCms::Category', foreign_key: :parent_id
+  belongs_to :post_type_parent, class_name: 'CamaleonCms::PostType', foreign_key: :parent_id,
+    inverse_of: :categories
+  belongs_to :site, class_name: 'CamaleonCms::Site', foreign_key: :site_id
+
+  before_save :set_site
+  before_destroy :set_posts_in_default_category
+
+  # return the post type of this category
+  def post_type
+    cama_fetch_cache('post_type') do
+      ctg = self
+      begin
+        pt = ctg.post_type_parent
+        ctg = ctg.parent
+      end while ctg.present?
+      pt
+    end
+  end
+
+  private
+
+  def set_site
+    pt = self.post_type
+    self.site_id = pt.site_id unless site_id.present?
+    self.status = pt.id unless status.present?
+  end
+
+  # rescue all posts to assign into default category if they don't have any category assigned
+  def set_posts_in_default_category
+    category_default = self.post_type.default_category
+    return if category_default == self
+    self.posts.each do |post|
+      if post.categories.where.not(id: id).blank?
+        post.assign_category(category_default.id)
+      end
+    end
+  end
+end

data/app/models/camaleon_cms/custom_field.rb

@@ -0,0 +1,35 @@
+class CamaleonCms::CustomField < ActiveRecord::Base
+  include CamaleonCms::Metas
+
+  self.primary_key = :id
+  self.table_name = "#{PluginRoutes.static_system_info['db_prefix']}custom_fields"
+
+  alias_attribute :label, :name
+
+  default_scope { order("#{CamaleonCms::CustomField.table_name}.field_order ASC") }
+  scope :configuration, -> { where(parent_id: -1) }
+  scope :visible_group, -> { where(status: nil) }
+
+  # status: nil -> visible on list group fields
+  # attr_accessible :object_class, :objectid, :description, :parent_id, :count, :name, :slug,
+  # :field_order, :status, :is_repeat
+  has_many :metas, -> { where(object_class: 'CustomField') }, class_name: 'CamaleonCms::Meta',
+    foreign_key: :objectid, dependent: :destroy
+  has_many :values, class_name: 'CamaleonCms::CustomFieldsRelationship',
+    foreign_key: :custom_field_id, dependent: :destroy
+  belongs_to :custom_field_group, class_name: 'CamaleonCms::CustomFieldGroup'
+  belongs_to :parent, class_name: 'CamaleonCms::CustomField', foreign_key: :parent_id
+
+  validates :name, :object_class, presence: true
+  validates_uniqueness_of :slug, scope: [:parent_id, :object_class],
+    unless: ->(o) { o.is_a?(CamaleonCms::CustomFieldGroup) }
+
+  before_validation :before_validating
+
+  private
+
+  def before_validating
+    self.slug = name if slug.blank?
+    self.slug = self.slug.to_s.parameterize
+  end
+end

data/app/models/camaleon_cms/custom_field_group.rb

@@ -0,0 +1,136 @@
+class CamaleonCms::CustomFieldGroup < CamaleonCms::CustomField
+  self.primary_key = :id
+  # attrs required: name, slug, description
+  alias_attribute :site_id, :parent_id
+
+  default_scope { where.not(object_class: '_fields')
+    .reorder("#{CamaleonCms::CustomField.table_name}.field_order ASC") }
+
+  has_many :metas, -> { where(object_class: 'CustomFieldGroup') }, class_name: 'CamaleonCms::Meta',
+    foreign_key: :objectid, dependent: :destroy
+  has_many :fields, -> { where(object_class: '_fields') }, class_name: 'CamaleonCms::CustomField',
+    foreign_key: :parent_id, dependent: :destroy
+  belongs_to :site, class_name: 'CamaleonCms::Site', foreign_key: :parent_id
+
+  validates_uniqueness_of :slug, scope: [:object_class, :objectid, :parent_id]
+
+  before_validation :before_validating
+
+  # add fields to group
+  # item:
+  # -  sample:  {"name"=>"Label", "slug"=>"my_slug", "description"=>"my description (optional)"}
+  # -  options (textbox sample):  {"field_key":"text_box","multiple":"1","required":"1",
+  #     "translate":"1"}
+  #   * field_key (string) | translate (boolean) | default_value (unique value) |
+  #      default_values (array - multiple values for this field) | label_eval (boolean) |
+  #      multiple_options (array)
+  #   * multiple_options (used for select, radio and checkboxes ): [{"title"=>"Option Title",
+  #      "value"=>"2", "default"=>"1"}, {"title"=>"abcde", "value"=>"3"}]
+  #   * label_eval: (Boolean, default false), true => will evaluate the label and description of
+  #       current field using (eval('my_label')) to have translatable|dynamic labels
+  # ****** check all options for each case in Admin::CustomFieldsHelper ****
+  # SAMPLE: my_model.add_field({"name"=>"Sub Title", "slug"=>"subtitle"}, {"field_key"=>"text_box",
+  #   "translate"=>true, default_value: "Get in Touch"})
+  def add_manual_field(item, options)
+    c = get_field(item[:slug] || item['slug'])
+    return c if c.present?
+
+    field_item = self.fields.new(item)
+    if field_item.save
+      field_item.set_options(options)
+      auto_save_default_values(field_item, options)
+    end
+    field_item
+  end
+  alias_method :add_field, :add_manual_field
+
+  # return a field with slug = slug from current group
+  def get_field(slug)
+    self.fields.find_by(slug: slug)
+  end
+
+  # only used by form on admin panel (protected)
+  # return array of failed_fields and full_fields [[failed fields], [all fields]]
+  def add_fields(items, item_options)
+    self.fields.where.not(id: items.to_h.map { |_k, obj| obj['id'] }.uniq).destroy_all
+    cache_fields = []
+    order_index = 0
+    errors_saved = []
+    if items.present?
+      items.each do |i, item|
+        item[:field_order] = order_index
+        options = item_options[i] || {}
+        if item[:id].present? && (field_item = self.fields.find_by(id: item[:id])).present?
+          saved = field_item.update(item)
+          cache_fields << field_item
+        else
+          field_item = self.fields.new(item)
+          cache_fields << field_item
+          saved = field_item.save
+          auto_save_default_values(field_item, options) if saved
+          errors_saved << field_item unless saved
+        end
+        if saved
+          field_item.set_meta('_default', options)
+          order_index += 1
+        end
+      end
+    end
+    [errors_saved, cache_fields]
+  end
+
+  # generate the caption for this group
+  def get_caption
+    caption = ''
+    begin
+      case object_class
+        when 'PostType_Post'
+          caption = "Fields for Contents in <b>#{self.site.post_types.find(objectid).decorate.the_title}</b>"
+        when 'PostType_Category'
+          caption = "Fields for Categories in <b>#{self.site.post_types.find(objectid).decorate.the_title}</b>"
+        when 'PostType_PostTag'
+          caption = "Fields for Post tags in <b>#{self.site.post_types.find(objectid).decorate.the_title}</b>"
+        when 'Widget::Main'
+          caption = "Fields for Widget <b>(#{CamaleonCms::Widget::Main.find(objectid).name.translate})</b>"
+        when 'Theme'
+          caption = "Field settings for Theme <b>(#{self.site.themes.find(objectid).name rescue objectid})</b>"
+        when 'NavMenu'
+          caption = "Field settings for Menus <b>(#{CamaleonCms::NavMenu.find(objectid).name})</b>"
+        when 'Site'
+          caption = 'Field settings the site'
+        when 'PostType'
+          caption = 'Fields for all <b>Post_Types</b>'
+        when 'Post'
+          p = CamaleonCms::Post.find(objectid).decorate
+          caption = "Fields for content <b>(#{p.the_title})</b>"
+        else # 'Plugin' or other class
+          caption = "Fields for <b>#{object_class}</b>"
+      end
+    rescue => e
+      Rails.logger.debug "Camaleon CMS - Menu Item Error: #{e.message} ==> Attrs: #{self.attributes}"
+    end
+    caption
+  end
+
+  private
+
+  def before_validating
+    self.slug = "_group-#{name.to_s.parameterize}" unless slug.present?
+  end
+
+  # auto save the default field values
+  def auto_save_default_values(field, options)
+    class_name = object_class.split("_").first
+    if %w(Post Category Plugin Theme).include?(class_name) && objectid && (options[:default_value].present? || options[:default_values].present?)
+      if class_name == 'Theme'
+        owner = "CamaleonCms::#{class_name}".constantize.find(objectid) # owner model
+      else
+        owner = "CamaleonCms::#{class_name}".constantize.find(objectid) rescue "CamaleonCms::#{class_name}".constantize.find_by(slug: objectid) # owner model
+      end
+      (options[:default_values] || [options[:default_value]] || []).each do |value|
+        owner.custom_field_values.create!(custom_field_id: field.id, custom_field_slug: field.slug,
+          value: fix_meta_value(value)) if owner.present?
+      end
+    end
+  end
+end

data/app/models/camaleon_cms/custom_fields_relationship.rb

@@ -0,0 +1,27 @@
+class CamaleonCms::CustomFieldsRelationship < ActiveRecord::Base
+  self.table_name = "#{PluginRoutes.static_system_info['db_prefix']}custom_fields_relationships"
+
+  # attr_accessible :objectid, :custom_field_id, :term_order, :value, :object_class,
+  # :custom_field_slug, :group_number
+  default_scope { order("#{CamaleonCms::CustomFieldsRelationship.table_name}.term_order ASC") }
+
+  # relations
+  belongs_to :custom_fields, class_name: 'CamaleonCms::CustomField', foreign_key: :custom_field_id
+
+  # validates :objectid, :custom_field_id, presence: true
+  validates :custom_field_id, presence: true # error on clone model
+
+  after_save :set_parent_slug
+  after_save :update_model_owner # TODO: convert this model into polymorphic
+
+  private
+
+  def set_parent_slug
+    # self.update_column('custom_field_slug', self.custom_fields.slug)
+  end
+  
+  # touch owner model
+  def update_model_owner
+    "CamaleonCms::#{object_class}".constantize.find(objectid).touch rescue nil # owner model
+  end
+end

data/app/models/camaleon_cms/media.rb

@@ -0,0 +1,54 @@
+class CamaleonCms::Media < ActiveRecord::Base
+  self.table_name = "#{PluginRoutes.static_system_info['db_prefix']}media"
+  belongs_to :site, class_name: 'CamaleonCms::Site'
+  validates :name, uniqueness: {
+    scope: [:site_id, :is_folder, :folder_path, :is_public],
+    message: 'Duplicates not allowed'
+  }
+  scope :only_folder, ->{ where(is_folder: true) }
+  scope :only_file, ->{ where(is_folder: false) }
+  default_scope { order(is_folder: :asc, name: :asc) }
+  before_save :create_parent_folders
+  before_destroy :delete_folder_items
+
+  def self.search(search_expression = '', folder = nil)
+    if search_expression.blank?
+      where(folder_path: folder)
+    else
+      where('name like ?', "%#{search_expression}%")
+    end
+  end
+
+  # search file or folder by key
+  def self.find_by_key(key)
+    key = key.cama_fix_media_key
+    if key == '/'
+      where(folder_path: File.dirname(key))
+    else
+      where(folder_path: File.dirname(key), name: File.basename(key))
+    end
+  end
+
+  # return all items of current folder
+  def items
+    coll = is_public ? site.public_media : site.private_media
+    coll.where(folder_path: "#{folder_path}/#{name}".cama_fix_media_key)
+  end
+
+  private
+  # recover folder or file format
+  def create_parent_folders
+    coll = is_public ? site.public_media : site.private_media
+    _p = []
+    folder_path.split('/').each do |f_name|
+      _path = ('/'+_p.join('/')).cama_fix_media_key
+      coll.only_folder.where(name: f_name, folder_path: _path).first_or_create() if "#{_path}/#{f_name}".cama_fix_media_key != '/'
+      _p.push(f_name)
+    end
+  end
+
+  # return all children items
+  def delete_folder_items
+    items.destroy_all if is_folder
+  end
+end

data/app/models/camaleon_cms/meta.rb

@@ -0,0 +1,4 @@
+class CamaleonCms::Meta < ActiveRecord::Base
+  self.table_name = "#{PluginRoutes.static_system_info["db_prefix"]}metas"
+  # attr_accessible :objectid, :key, :value, :object_class
+end

data/app/models/camaleon_cms/nav_menu.rb

@@ -0,0 +1,29 @@
+class CamaleonCms::NavMenu < CamaleonCms::TermTaxonomy
+  default_scope { where(taxonomy: :nav_menu).order(id: :asc) }
+  alias_attribute :site_id, :parent_id
+  cama_define_common_relationships('NavMenu')
+  has_many :children, class_name: "CamaleonCms::NavMenuItem", foreign_key: :parent_id, dependent: :destroy, inverse_of: :parent
+  belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id, inverse_of: :nav_menus
+
+  # add menu item for current menu
+  # value: (Hash) is a hash object that contains label, type, link
+  #   options for type: post | category | post_type | post_tag | external
+  # sample: {label: "my label", type: "external", link: "http://camaleon.tuzitio.com", target: '_blank'}
+  # sample: {label: "my label", type: "post", link: 10}
+  # sample: {label: "my label", type: "category", link: 12}
+  # return item created
+  def append_menu_item (value)
+    item = children.create!({name: value[:label], url: value[:link], kind: value[:type], target: value[:target]})
+    item
+  end
+
+  # skip uniq slug validation
+  def skip_slug_validation?
+    true
+  end
+
+  private
+  # overwrite termtaxonomy method
+  def destroy_dependencies
+  end
+end