camaleon_cms_rails6 2.5.0

data/app/models/camaleon_cms/post_default.rb

@@ -0,0 +1,78 @@
+class CamaleonCms::PostDefault < ActiveRecord::Base
+  include CamaleonCms::Metas
+  include CamaleonCms::CustomFieldsRead
+  self.table_name = "#{PluginRoutes.static_system_info["db_prefix"]}posts"
+
+  # attr_accessible :user_id, :title, :slug, :content, :content_filtered, :status,  :visibility, :visibility_value, :post_order, :post_type_key, :taxonomy_id, :published_at, :post_parent, :post_order, :is_feature
+  attr_accessor :draft_id
+  # attr_accessible :data_options
+  # attr_accessible :data_metas
+  cattr_accessor :current_user
+  cattr_accessor :current_site
+
+  has_many :term_relationships, class_name: "CamaleonCms::TermRelationship", foreign_key: :objectid, dependent: :destroy, primary_key: :id
+  has_many :children, ->{ where(post_class: "PostDefault") }, class_name: "CamaleonCms::PostDefault", foreign_key: :post_parent, dependent: :destroy, primary_key: :id
+  scope :featured, ->{ where(is_feature: true) }
+
+  validates :title, :slug, presence: true
+
+  # callbacks
+  before_validation :before_validating
+  before_save :before_saved
+  before_destroy :destroy_dependencies
+
+
+  # find a content by slug (support multi language)
+  def self.find_by_slug(slug)
+    #if current_site.present? && current_site.get_meta("languages_site", []).count <= 1
+    #  res = self.where(slug: slug)
+    #else
+    res = self.where("#{CamaleonCms::Post.table_name}.slug = ? OR #{CamaleonCms::Post.table_name}.slug LIKE ? ", slug, "%-->#{slug}<!--%")
+    #end
+    res.reorder("").first
+  end
+
+  # return the parent of a post (support for sub contents or tree of posts)
+  def parent
+    CamaleonCms::Post.where(id: self.post_parent).first
+  end
+
+  # return the author of this Content
+  def author
+    begin
+      CamaleonCms::User.find(self.user_id)
+    rescue
+      CamaleonCms::User.admin_scope.first
+    end
+  end
+
+  # return all menu items in which this post was assigned
+  def in_nav_menu_items
+    CamaleonCms::NavMenuItem.where(url: self.id, kind: 'post')
+  end
+
+  # Set the meta, field values and the post keywords here
+  def set_params(meta, custom_fields, options)
+    self.set_metas(meta)
+    self.set_field_values(custom_fields)
+    self.set_options(options)
+  end
+
+  private
+  def before_validating
+    #self.slug = self.title if self.slug.blank?
+    #self.slug = self.slug.to_s.parameterize
+  end
+
+  # do all before actions to save the content
+  def before_saved
+    self.title = "Untitled" unless self.title.present?
+    self.content_filtered = content.to_s.include?('<!--:-->') ? content.translations.inject({}) { |h, (key, value)| h[key] = value.squish.strip_tags; h }.to_translate : content.to_s.squish.strip_tags
+  end
+
+  # destroy all dependencies of this content
+  # unassign this items from menus
+  def destroy_dependencies
+    in_nav_menu_items.destroy_all
+  end
+end

data/app/models/camaleon_cms/post_relationship.rb

@@ -0,0 +1,20 @@
+
+# DEPRECATED MODEL, NOT USED ANY MORE
+class CamaleonCms::PostRelationship < ActiveRecord::Base
+  self.table_name = "#{PluginRoutes.static_system_info["db_prefix"]}term_relationships"
+  # attr_accessible :objectid, :term_taxonomy_id, :term_order
+  default_scope ->{ order(term_order: :asc) }
+
+  belongs_to :post_type, :class_name => "CamaleonCms::PostType", foreign_key: :term_taxonomy_id, inverse_of: :post_relationships
+  belongs_to :posts, ->{ order("#{CamaleonCms::Post.table_name}.id DESC") }, :class_name => "CamaleonCms::Post", foreign_key: :objectid, inverse_of: :post_relationships, dependent: :destroy
+
+  # callbacks
+  after_create :update_count
+  before_destroy :update_count
+
+  private
+  def update_count
+    self.post_type.update_column('count', self.post_type.posts.size) if self.post_type.present?
+  end
+
+end

data/app/models/camaleon_cms/post_tag.rb

@@ -0,0 +1,7 @@
+class CamaleonCms::PostTag < CamaleonCms::TermTaxonomy
+  default_scope { where(taxonomy: :post_tag) }
+  cama_define_common_relationships('PostTag')
+  has_many :posts, foreign_key: :objectid, through: :term_relationships, :source => :objects
+  belongs_to :post_type, class_name: "CamaleonCms::PostType", foreign_key: :parent_id, inverse_of: :post_tags
+  belongs_to :owner, class_name: CamaManager.get_user_class_name, foreign_key: :user_id
+end

data/app/models/camaleon_cms/post_type.rb

@@ -0,0 +1,189 @@
+class CamaleonCms::PostType < CamaleonCms::TermTaxonomy
+  alias_attribute :site_id, :parent_id
+  default_scope { where(taxonomy: :post_type) }
+  cama_define_common_relationships('PostType')
+  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
+
+  belongs_to :owner, class_name: CamaManager.get_user_class_name, foreign_key: :user_id
+  belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id
+
+  scope :visible_menu, -> {where(term_group: nil)}
+  scope :hidden_menu, -> {where(term_group: -1)}
+  before_destroy :destroy_field_groups
+  after_create :set_default_site_user_roles
+  after_create :refresh_routes
+  after_destroy :refresh_routes
+  after_update :check_refresh_routes
+  before_update :default_category
+
+  # check if current post type manage categories
+  def manage_categories?
+    options[:has_category] || options[:has_single_category]
+  end
+
+  # hide or show this post type on admin -> contents -> menu
+  # true => enable, false => disable
+  def toggle_show_for_admin_menu(flag)
+    self.update(term_group: flag == true ? nil : -1)
+  end
+
+  # check if this post type is shown on admin -> contents -> menu
+  def show_for_admin_menu?
+    self.term_group == nil
+  end
+
+  # check if this post type manage post tags
+  def manage_tags?
+    options[:has_tags]
+  end
+
+  # check if this post type permit to manage seo attrs in posts
+  def manage_seo?
+    get_option('has_seo', get_option('has_keywords', true))
+  end
+
+  # assign settings for this post type
+  # default values: {
+  #   has_category: false,
+  #   has_tags: false,
+  #   has_summary: true,
+  #   has_content: true,
+  #   has_comments: false,
+  #   has_picture: true,
+  #   has_template: true,
+  #   has_seo: true,
+  #   not_deleted: false,
+  #   has_layout: false,
+  #   default_layout: '',
+  #   contents_route_format: 'post'
+  # }
+  def set_settings(settings = {})
+    settings.each do |key, val|
+      self.set_option(key, val)
+    end
+  end
+
+  # set or update a setting for this post type
+  def set_setting(key, value)
+    self.set_option(key, value)
+  end
+
+  # select full_categories for the post type, include all children categories
+  def full_categories
+    CamaleonCms::Category.where(site_id: site_id, post_type_id: id)
+  end
+
+  # return default category for this post type
+  # only return a category for post types that manage categories
+  def default_category
+    if manage_categories?
+      cat = self.categories.find_by_slug("uncategorized")
+      unless cat.present?
+        cat = self.categories.create({name: 'Uncategorized', slug: 'uncategorized', parent_id: self.id})
+        cat.set_option("not_deleted", true)
+      end
+      cat
+    end
+  end
+
+  # add a post for current model
+  #   title: title for post,    => required
+  #   content: html text content, => required
+  #   thumb: image url, => default (empty). check http://camaleon.tuzitio.com/api-methods.html#section_fileuploads
+  #   categories: [1,3,4,5],    => default (empty)
+  #   tags: String comma separated, => default (empty)
+  #   slug: string key for post,    => default (empty)
+  #   summary: String resume (optional)  => default (empty)
+  #   post_order: Integer to define the order position in the list (optional)
+  #   fields: Hash of values for custom fields, sample => fields: {subtitle: 'abc', icon: 'test' } (optional)
+  #   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_seo: 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)
+    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.set_position(_order_position) if _order_position.present?
+      p.set_summary(_summary) if _summary.present?
+      p.set_thumb(_thumb) if _thumb.present?
+      _fields.each{ |k, v| p.save_field_value(k, v) } if _fields.present?
+      return p.decorate
+    else
+      p.errors
+    end
+  end
+
+  # return all available route formats of this post type for content posts
+  def contents_route_formats
+    {
+      "post_of_post_type" => "<code>/group/:post_type_id-:title/:slug</code><br>  (Sample: http://localhost.com/group/17-services/myservice.html)",
+      "post_of_category" => "<code>/category/:category_id-:title/:slug</code><br>  (Sample: http://localhost.com/category/17-services/myservice.html)",
+      "post_of_category_post_type" => "<code>/:post_type_title/category/:category_id-:title/:slug</code><br>  (Sample: http://localhost.com/services/category/17-services/myservice.html)",
+      "post_of_posttype" => "<code>/:post_type_title/:slug</code><br>  (Sample: http://localhost.com/services/myservice.html)",
+      "post" => "<code>/:slug</code><br>  (Sample: http://localhost.com/myservice.html)",
+      "hierarchy_post" => "<code>/:parent1_slug/:parent2_slug/.../:slug</code><br>  (Sample: http://localhost.com/item-1/item-1-1/item-111.html)"
+    }
+  end
+
+  # return the configuration of routes for post contents
+  def contents_route_format
+    get_option("contents_route_format", "post")
+  end
+
+  # verify if this post_type support for page hierarchy (parents)
+  def manage_hierarchy?
+    get_option('has_parent_structure', false)
+  end
+
+  private
+  # skip save_metas_options callback after save changes (inherit from taxonomy) to call from here manually
+  def save_metas_options_skip
+    true
+  end
+
+  # assign default roles for this post type
+  # define default settings for this post type
+  def set_default_site_user_roles
+    self.set_multiple_options({has_category: false, has_tags: false, has_summary: true, has_content: true, has_comments: false, has_picture: true, has_template: true, has_seo: true, not_deleted: false, has_layout: false, default_layout: ""}.merge(PluginRoutes.fixActionParameter(data_options||{}).to_sym))
+    self.site.set_default_user_roles(self)
+    default_category
+  end
+
+  # destroy all custom field groups assigned to this post type
+  def destroy_field_groups
+    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 unless self.destroyed_by_association.present?
+  end
+
+  # check if slug was changed
+  def check_refresh_routes
+    refresh_routes if cama_attr_changed?(:slug)
+  end
+end

data/app/models/camaleon_cms/site.rb

@@ -0,0 +1,242 @@
+class CamaleonCms::Site < CamaleonCms::TermTaxonomy
+  # attrs: [name, description, slug]
+  attr_accessor :site_domain
+  include CamaleonCms::SiteDefaultSettings
+  default_scope { where(taxonomy: :site).reorder(term_group: :desc) }
+  cama_define_common_relationships('Site')
+  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, inverse_of: :site
+  has_many :nav_menu_items, :class_name => "CamaleonCms::NavMenuItem", foreign_key: :term_group
+  has_many :widgets, :class_name => "CamaleonCms::Widget::Main", foreign_key: :parent_id, dependent: :destroy
+  has_many :sidebars, :class_name => "CamaleonCms::Widget::Sidebar", foreign_key: :parent_id, dependent: :destroy
+  has_many :user_roles_rel, :class_name => "CamaleonCms::UserRole", foreign_key: :parent_id, dependent: :destroy
+  has_many :custom_field_groups, :class_name => "CamaleonCms::CustomFieldGroup", foreign_key: :parent_id, dependent: :destroy
+  has_many :term_taxonomies, :class_name => "CamaleonCms::TermTaxonomy", foreign_key: :parent_id
+
+  has_many :posts, through: :post_types, :source => :posts
+  has_many :plugins, :class_name => "CamaleonCms::Plugin", foreign_key: :parent_id, dependent: :destroy
+  has_many :themes, :class_name => "CamaleonCms::Theme", foreign_key: :parent_id, dependent: :destroy
+  has_many :public_media, ->{ where(is_public: true) }, class_name: 'CamaleonCms::Media', foreign_key: :site_id, dependent: :destroy
+  has_many :private_media, ->{ where(is_public: false) }, class_name: 'CamaleonCms::Media', foreign_key: :site_id, dependent: :destroy
+
+  after_create :default_settings
+  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
+  def user_roles
+    if PluginRoutes.system_info["users_share_sites"]
+      CamaleonCms::Site.main_site.user_roles_rel
+    else
+      user_roles_rel
+    end
+  end
+
+  #select full_categories for the site, include all children categories
+  def full_categories
+    CamaleonCms::Category.where({site_id: self.id})
+  end
+
+  # all post_tags for this site
+  def post_tags
+    CamaleonCms::PostTag.includes(:post_type).where(post_type: self.post_types.pluck(:id))
+  end
+
+  # all main categories for this site
+  def categories
+    CamaleonCms::Category.includes(:post_type_parent).where(post_type_parent: self.post_types.pluck(:id))
+  end
+
+  # return all languages configured by the admin
+  # if it is empty, then return default locale
+  def get_languages
+    return @_languages if defined?(@_languages)
+    l = get_meta("languages_site", [I18n.default_locale])
+    @_languages = l.map { |x| x.to_sym } rescue [I18n.default_locale.to_sym]
+  end
+
+  # return current admin language configured for this site
+  def get_admin_language
+    options[:_admin_theme] || "en"
+  end
+
+  # set current admin language for this site
+  def set_admin_language(language)
+    set_option("_admin_theme", language)
+  end
+
+  # return current theme slug configured for this site
+  # if theme was not configured, then return system.json defined
+  def get_theme_slug
+    options[:_theme] || PluginRoutes.system_info["default_template"]
+  end
+
+  # return theme model with slug theme_slug for this site
+  # theme_slug: (optional) if it is null, this will return current theme for this site
+  def get_theme(theme_slug = nil)
+    self.themes.where(slug: (theme_slug || get_theme_slug), status: nil).first_or_create!
+  end
+
+  # return plugin model with slug plugin_slug
+  def get_plugin(plugin_slug)
+    self.plugins.where(slug: plugin_slug).first_or_create!
+  end
+
+  # assign user to this site
+  def assign_user(user)
+    user.assign_site(self)
+  end
+
+  # items per page to be listed on frontend
+  def front_per_page
+    get_option("front_per_page", 10)
+  end
+
+  # items per page to be listed on admin panel
+  def admin_per_page
+    get_option("admin_per_page", 10)
+  end
+
+  # frontend comments status for new comments on frontend
+  def front_comment_status
+    get_option("comment_status", "pending")
+  end
+
+  # security: user register form show captcha?
+  def security_user_register_captcha_enabled?
+    get_option('security_captcha_user_register', false) == true
+  end
+  
+  # check if current site permit capctha for anonymous comments
+  def is_enable_captcha_for_comments?
+    get_option('enable_captcha_for_comments', false)
+  end
+
+  def need_validate_email?
+    get_option('need_validate_email', false) == true
+  end
+
+  # return main site
+  def self.main_site
+    @main_site ||= CamaleonCms::Site.reorder(id: :asc).first
+  end
+
+  # check if this site is the main site
+  # main site is a site that doesn't have slug
+  def main_site?
+    self.class.main_site == self
+  end
+  alias_method :is_default?, :main_site?
+
+  # list all users of current site
+  def users
+    if PluginRoutes.system_info["users_share_sites"]
+      CamaleonCms::User.all
+    else
+      CamaleonCms::User.where(site_id: self.id)
+    end
+  end
+  alias_method :users_include_admins, :users
+
+  # return upload directory for this site (deprecated for cloud support)
+  def upload_directory(inner_directory = nil)
+    File.join(Rails.public_path, "/media/#{PluginRoutes.static_system_info["media_slug_folder"] ? self.slug : self.id}", inner_directory.to_s)
+  end
+
+  # return the directory name where to upload file for this site
+  def upload_directory_name
+    "#{PluginRoutes.static_system_info["media_slug_folder"] ? self.slug : self.id}"
+  end
+
+  # return an available slug for a new post
+  # slug: (String) possible slug value
+  # post_id: (integer, optional) current post id
+  # sample: ("<!--:es-->features-1<!--:--><!--:en-->caract-1<!--:-->") | ("features")
+  # return: (String) available slugs
+  def get_valid_post_slug(slug, post_id=nil)
+    slugs = slug.translations
+    if slugs.present?
+      slugs.each do |k, v|
+        slugs[k] = get_valid_post_slug(v)
+      end
+      slugs.to_translate
+    else
+      res = slug
+      (1..9999).each do |i|
+        p = self.posts.find_by_slug(res)
+        break if !p.present? || (p.present? && p.id == post_id)
+        res = "#{slug}-#{i}"
+      end
+      res
+    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
+
+  # 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
+
+  # return the domain for current site
+  # sample: mysite.com | sample.mysite.com
+  # also, you can define custom domain for this site by: my_site.site_domain = 'my_site.com' # used for sites with different domains to call from console or task
+  def get_domain
+    @site_domain || (main_site? ? slug : (slug.include?(".") ? slug : "#{slug}.#{Cama::Site.main_site.slug}"))
+  end
+
+  private
+  # destroy all things before site destroy
+  def destroy_site
+    unless PluginRoutes.system_info["users_share_sites"]
+      CamaleonCms::User.where(site_id: self.id).destroy_all
+    end
+    FileUtils.rm_rf(File.join(Rails.public_path, "/media/#{upload_directory_name}").to_s) # destroy current media directory
+    users.destroy_all unless PluginRoutes.system_info["users_share_sites"] # destroy all users assigned fot this site
+  end
+
+  # assign all users to this new site
+  # DEPRECATED
+  def set_all_users
+    return
+  end
+
+  # update all routes of the system
+  # reload system routes for this site
+  def update_routes
+    PluginRoutes.reload if cama_attr_changed?(:slug)
+  end
+
+  def reload_routes
+    PluginRoutes.reload
+  end
+
+  def before_validating
+    slug = self.slug
+    slug = self.name if slug.blank?
+    self.name = slug unless self.name.present?
+    self.slug = slug.to_s.try(:downcase)
+  end
+end