camaleon_cms_rails6 2.5.0

data/app/models/camaleon_cms/nav_menu_item.rb

@@ -0,0 +1,64 @@
+class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
+  alias_attribute :site_id, :term_group
+  alias_attribute :label, :name
+  alias_attribute :url, :description
+  alias_attribute :kind, :slug
+  alias_attribute :target, :status
+  # attr_accessible :label, :url, :kind
+  default_scope { where(taxonomy: :nav_menu_item).order(id: :asc) }
+  cama_define_common_relationships('NavMenuItem')
+  belongs_to :parent, class_name: "CamaleonCms::NavMenu", inverse_of: :children
+  belongs_to :parent_item, class_name: "CamaleonCms::NavMenuItem", foreign_key: :parent_id, inverse_of: :children
+  has_many :children, class_name: "CamaleonCms::NavMenuItem", foreign_key: :parent_id, dependent: :destroy, inverse_of: :parent_item
+
+  before_create :set_parent_site
+  after_create :update_count
+  #before_destroy :update_count
+
+  # return the main menu
+  def main_menu
+    main_menu = self.parent
+    return main_menu if main_menu.present?
+    parent_menu = self.parent_item
+    parent_menu.main_menu if parent_menu.present?
+  end
+
+  # check if this menu have children
+  def have_children?
+    self.children.count != 0
+  end
+
+  # add sub menu for a menu item
+  # same values of NavMenu#append_menu_item
+  # return item created
+  def append_menu_item(value)
+    children.create({name: value[:label], url: value[:link], kind: value[:type], target: value[:target]})
+  end
+
+  # update current menu
+  # value: same as append_menu_item (label, link, target)
+  def update_menu_item(value)
+    self.update({name: value[:label], url: value[:link], target: value[:target]})
+  end
+
+  # overwrite skip uniq slug validation
+  def skip_slug_validation?; true end
+  def before_validating; end
+
+  private
+  def update_count
+    self.parent.update_column('count', self.parent.children.size) if self.parent.present?
+    self.parent_item.update_column('count', self.parent_item.children.size) if self.parent_item.present?
+    self.update_column(:term_group, main_menu.parent_id)
+    self.update_column(:term_order, CamaleonCms::NavMenuItem.where(parent_id: self.parent_id).count) # update position
+  end
+
+  # fast access from site to menu items
+  def set_parent_site
+    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/plugin.rb

@@ -0,0 +1,76 @@
+class CamaleonCms::Plugin < CamaleonCms::TermTaxonomy
+  # attrs:
+  #   term_group => status active (1, nil)
+  #   slug => plugin key
+  #   name => plugin name
+
+  attr_accessor :error
+  cama_define_common_relationships('Plugin')
+  belongs_to :site, class_name: "CamaleonCms::Site", foreign_key: :parent_id
+
+  default_scope { where(taxonomy: :plugin) }
+  scope :active, -> { where(term_group: 1) }
+
+  before_validation :set_default
+  before_destroy :destroy_custom_fields
+
+  # active the plugin
+  def active
+    self.term_group = 1
+    self.save
+  end
+
+  # inactive the plugin
+  def inactive
+    self.term_group = nil
+    self.save
+  end
+
+  # check if plugin is active
+  def active?
+    self.term_group.to_s == "1"
+  end
+
+  # return theme settings configured in config.json
+  def settings
+    PluginRoutes.plugin_info(self.slug)
+  end
+
+  # check if current installation version is older
+  # return boolean
+  def old_version?
+    # self.installed_version.to_s != self.settings["version"].to_s
+    false
+  end
+
+  # set a new installation version for this plugin
+  def installed_version=(version)
+    self.set_option("version_installed", version)
+  end
+
+  # return gem installed version
+  def installed_version
+    return ""
+    res = self.get_option("version_installed")
+    unless res.present? # fix for old installations
+      res = self.settings["version"]
+      self.installed_version= res
+    end
+    res
+  end
+
+  # return the title of this plugin
+  def title
+    PluginRoutes.plugin_info(self.slug)["title"]
+  end
+
+  private
+  def set_default
+    self.name = self.slug unless self.name.present?
+  end
+
+  def destroy_custom_fields
+    self.get_field_groups.destroy_all
+  end
+
+end

data/app/models/camaleon_cms/post.rb

@@ -0,0 +1,265 @@
+class CamaleonCms::PostUniqValidator < ActiveModel::Validator
+  def validate(record)
+    unless record.draft?
+      slug_array = record.slug.to_s.translations_array
+      ptype = record.post_type
+      if ptype.present? # only for posts that belongs to a post type model
+        posts = ptype.site.posts
+                    .where("(#{slug_array.map {|s| "#{CamaleonCms::Post.table_name}.slug LIKE '%-->#{s}<!--%'"}.join(" OR ")} ) OR #{CamaleonCms::Post.table_name}.slug = ?",  record.slug)
+                    .where.not(id: record.id, status: [:draft, :draft_child, :trash])
+        if posts.size > 0
+          if slug_array.size > 1
+            record.errors[:base] << "#{I18n.t('camaleon_cms.admin.post.message.requires_different_slug')}: #{posts.pluck(:slug).map{|slug| record.slug.to_s.translations.map{|lng, r_slug| "#{r_slug} (#{lng})" if slug.translations_array.include?(r_slug) }.join(",") }.join(",").split(",").uniq.clean_empty.join(", ")} "
+          else
+            record.errors[:base] << "#{I18n.t('camaleon_cms.admin.post.message.requires_different_slug')}: #{record.slug.to_s} "
+          end
+        end
+
+        # avoid recursive page parent
+        record.errors[:base] << I18n.t('camaleon_cms.admin.post.message.recursive_hierarchy', default: 'Parent Post Recursive') if record.post_parent.present? && ptype.manage_hierarchy? && record.parents.cama_pluck(:id).include?(record.id)
+      else
+        # validation for other classes
+      end
+    end
+  end
+end
+
+class CamaleonCms::Post < CamaleonCms::PostDefault
+  include CamaleonCms::CategoriesTagsForPosts
+  alias_attribute :post_type_id, :taxonomy_id
+  default_scope ->{ where(post_class: "Post").order(post_order: :asc, created_at: :desc) }
+  cama_define_common_relationships('Post')
+
+  # DEPRECATED
+  has_many :post_relationships, class_name: "CamaleonCms::PostRelationship", foreign_key: :objectid, dependent: :destroy,  inverse_of: :posts
+  has_many :post_types, class_name: "CamaleonCms::PostType", through: :post_relationships, :source => :post_type
+  # END DEPRECATED
+
+  has_many :term_relationships, class_name: "CamaleonCms::TermRelationship", foreign_key: :objectid, dependent: :destroy,  inverse_of: :objects
+  has_many :categories, class_name: "CamaleonCms::Category", through: :term_relationships, :source => :term_taxonomies
+  has_many :post_tags, class_name: "CamaleonCms::PostTag", through: :term_relationships, :source => :term_taxonomies
+  has_many :comments, class_name: "CamaleonCms::PostComment", foreign_key: :post_id, dependent: :destroy
+  has_many :drafts, ->{where(status: 'draft_child')}, class_name: "CamaleonCms::Post", foreign_key: :post_parent, dependent: :destroy
+  has_many :children, class_name: "CamaleonCms::Post", foreign_key: :post_parent, dependent: :destroy, primary_key: :id
+
+  belongs_to :owner, class_name: CamaManager.get_user_class_name, foreign_key: :user_id
+  belongs_to :parent, class_name: "CamaleonCms::Post", foreign_key: :post_parent
+  belongs_to :post_type, class_name: "CamaleonCms::PostType", foreign_key: :taxonomy_id, inverse_of: :posts
+
+  scope :visible_frontend, -> {where(status: 'published')}
+  scope :public_posts, -> {visible_frontend.where(visibility: ['public', ""]) } #public posts (not passwords, not privates)
+  scope :private_posts, -> {where(visibility: 'private') } #public posts (not passwords, not privates)
+
+  scope :trash, -> {where(status: 'trash')}
+  scope :no_trash, -> {where.not(status: 'trash')}
+  scope :published, -> {where(status: 'published')}
+  scope :root_posts, -> {where(post_parent: [nil, ''])}
+  scope :drafts, -> {where(status: %w(draft draft_child))}
+  scope :pending, -> {where(status: 'pending')}
+  scope :latest, -> {reorder(created_at: :desc)}
+
+  validates_with CamaleonCms::PostUniqValidator
+  attr_accessor :show_title_with_parent
+  before_create :fix_post_order, if: lambda{|p| !p.post_order.present? || p.post_order == 0 }
+
+  # return all parents for current page hierarchy ordered bottom to top
+  def parents
+    cama_fetch_cache("parents_#{self.id}") do
+      res = []
+      p = self.parent
+      while p.present?
+        res << p
+        p = p.parent
+      end
+      res
+    end
+  end
+
+  # return all children elements for current post (page hierarchy)
+  def full_children
+    cama_fetch_cache("full_children_#{self.id}") do
+      res = self.children.to_a
+      res.each{|c|  res += c.full_children }
+      res
+    end
+  end
+
+  # return the post type of this post (DEPRECATED)
+  def get_post_type_depre
+    post_types.reorder(nil).first
+  end
+
+  # check if this post was published
+  def published?
+    status == 'published'
+  end
+
+  # check if this is in pending status
+  def pending?
+    status == 'pending'
+  end
+
+  # check if this is in draft status
+  def draft?
+    status == 'draft' || status == 'draft_child'
+  end
+
+  def draft_child?
+    status == 'draft_child'
+  end
+
+  # check if this is in trash status
+  def trash?
+    status == 'trash'
+  end
+
+  # check if current post can manage content
+  # return boolean
+  def manage_content?(posttype = nil)
+    get_option('has_content', (posttype || post_type).get_option('has_content', true))
+  end
+
+  # return boolean
+  def manage_layout?(posttype = nil)
+    get_option('has_layout', (posttype || post_type).get_option('has_layout', false))
+  end
+
+  # check if current post can manage template
+  # return boolean
+  def manage_template?(posttype = nil)
+    get_option('has_template', (posttype || post_type).get_option('has_template', true))
+  end
+
+  # check if current post can manage summary
+  # return boolean
+  def manage_summary?(posttype = nil)
+    get_option('has_summary', (posttype || post_type).get_option('has_summary', true))
+  end
+
+  # check if current post can manage picture
+  # return boolean
+  def manage_picture?(posttype = nil)
+    get_option('has_picture', (posttype || post_type).get_option('has_picture', true))
+  end
+
+  # check if current post can manage comments
+  # return boolean
+  def manage_comments?(posttype = nil)
+    get_option('has_comments', (posttype || post_type).get_option('has_comments', false))
+  end
+
+  # check if the post can be commented
+  # sample: @post.can_commented?
+  # return Boolean (true/false)
+  # to enable comments for current post, use this: post.set_meta('has_comments', '1'). Note: Parent PostType should be enabled for comments too: post_type.set_option('has_comments', true)
+  def can_commented?
+    manage_comments? && get_meta('has_comments').to_s == "1"
+  end
+
+  # check if is required picture for current post
+  def is_required_picture?
+    post_type.get_option('is_required_picture', false)
+  end
+
+  # define post configuration for current post
+  # possible key values (String):
+  #   has_content, boolean (default true)
+  #   has_summary, boolean (default true)
+  #   has_seo, boolean (default true)
+  #   has_picture, boolean (default true)
+  #   has_template, boolean (default false)
+  #   has_comments, boolean (default false)
+  #   default_layout:  (string) (default layout) # this is still used if post type was inactivated layout and overwritten by dropdown in post view
+  #   default_template:  (string) (default template) # this is still used if post type was inactivated template and overwritten by dropdown in post view
+  #   has_layout:  (boolean) (default false)
+  #   skip_fields:  (array) (default empty) array of custom field keys to avoid for this post, sample: ["subtitle", "icon"]
+  # val: value for the setting
+  def set_setting(key, val)
+    set_option(key, val)
+  end
+
+  # assign multiple settings
+  def set_settings(settings = {})
+    settings.each do |key, val|
+      set_setting(key, val)
+    end
+  end
+
+  # put a new order position for this post
+  # new_order_position: (Integer) position number
+  # return nil
+  def set_position(new_order_position)
+    self.update_column("post_order", new_order_position)
+  end
+
+  # save the summary for current post
+  # summary: Text String without html
+  def set_summary(summary)
+    set_meta("summary", summary)
+  end
+
+  # check if current post permit manage seo attrs
+  # has_keywords: used until next version (deprecated to use has_seo)
+  # return boolean
+  def manage_seo?(posttype = nil)
+    get_option('has_seo', get_option('has_keywords', false)) || (posttype || post_type).manage_seo?
+  end
+  alias_method :manage_keywords?, :manage_seo? # method name deprecated to use manage_seo?
+
+  # save the thumbnail url for current post
+  # thumb_url: String url
+  def set_thumb(thumb_url)
+    set_meta("thumb", thumb_url)
+  end
+
+  # save the layout name to be used on render this post
+  # layout_name: String layout name: my_layout.html.erb => 'my_layout'
+  def set_layout(layout_name)
+    set_meta("layout", layout_name)
+  end
+
+  # return the layout assigned to this post
+  # post_type: post type owner of this post
+  def get_layout(posttype = nil)
+    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
+
+  # return the template assigned to this post
+  # verify default template defined in post type
+  # post_type: post type owner of this post
+  def get_template(posttype = nil)
+    return get_option("default_template") if !manage_template?(posttype)
+    get_meta('template', get_option("default_template") || (posttype || self.post_type).get_option('default_template', nil))
+  end
+
+  # increment the counter of visitors
+  def increment_visits!
+    set_meta("visits", total_visits+1)
+  end
+
+  # return the quantity of visits for this post
+  def total_visits
+    get_meta("visits", 0).to_i
+  end
+
+  # return the quantity of comments for this post
+  # TODO comments count to move into cache counter
+  def total_comments
+    self.get_meta("comments_count", 0).to_i
+  end
+
+  # manage the custom decorators for posts
+  # sample: my_post_type.set_option('cama_post_decorator_class', 'ProductDecorator')
+    # Sample: https://github.com/owen2345/camaleon-ecommerce/tree/master/app/decorators/
+  def decorator_class
+    (post_type.get_option('cama_post_decorator_class', 'CamaleonCms::PostDecorator') rescue 'CamaleonCms::PostDecorator').constantize
+  end
+
+  private
+  # calculate a post order when it is empty
+  def fix_post_order
+    last_post = post_type.posts.where.not(id: nil).last
+    self.post_order = last_post.present? ? last_post.post_order + 1 : 1
+  end
+end

data/app/models/camaleon_cms/post_comment.rb

@@ -0,0 +1,44 @@
+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, :is_anonymous
+  attr_accessor :is_anonymous
+
+  #default_scope order('comments.created_at ASC')
+  #approved: approved | pending | spam
+
+  cama_define_common_relationships('PostComment')
+  has_many :children, class_name: "CamaleonCms::PostComment", foreign_key: :comment_parent, dependent: :destroy
+  belongs_to :post, class_name: "CamaleonCms::Post", foreign_key: :post_id
+  belongs_to :parent, class_name: "CamaleonCms::PostComment", foreign_key: :comment_parent
+  belongs_to :user, class_name: CamaManager.get_user_class_name, foreign_key: :user_id
+
+  default_scope {order("#{CamaleonCms::PostComment.table_name}.created_at DESC")}
+
+  scope :main, -> { where(:comment_parent => nil) }
+  scope :comment_parent, -> { where(:comment_parent => 'is not null') }
+  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
+
+  # return the owner of this comment
+  def comment_user
+    self.user
+  end
+
+  # check if this comments is already approved
+  def is_approved?
+    self.approved == 'approved'
+  end
+
+  private
+  # update comment counter
+  def update_counter
+    p = self.post
+    p.set_meta("comments_count", p.comments.count) if p.present?
+  end
+
+end