camaleon_cms 1.1.0 → 2.0.1

data/app/helpers/{user_roles_helper.rb → camaleon_cms/user_roles_helper.rb}

@@ -7,8 +7,8 @@
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
 #encoding: utf-8
-module UserRolesHelper
-  def _get_roles_values
-    UserRole::ROLES
+module CamaleonCms::UserRolesHelper
+  def cama_get_roles_values
+    CamaleonCms::UserRole::ROLES
   end
 end

data/app/mailers/{html_mailer.rb → camaleon_cms/html_mailer.rb}

@@ -6,10 +6,10 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class HtmlMailer < ActionMailer::Base
-  include SiteHelper
-  include HooksHelper
-  include PluginsHelper
+class CamaleonCms::HtmlMailer < ActionMailer::Base
+  include CamaleonCms::SiteHelper
+  include CamaleonCms::HooksHelper
+  include CamaleonCms::PluginsHelper
   #include ApplicationHelper
   default from: "Camaleon CMS <owenperedo@gmail.com>"
   after_action :set_delivery_options
@@ -37,9 +37,9 @@ class HtmlMailer < ActionMailer::Base
                                             }
     end
 
-    views_dir = "app/apps/themes/#{current_site.get_theme.slug}/views"
-    self.prepend_view_path(File.join($camaleon_engine_dir, views_dir).to_s)
-    self.prepend_view_path(Rails.root.join(views_dir).to_s)
+    theme = current_site.get_theme
+    lookup_context.prefixes.prepend("themes/#{theme.slug}") if theme.settings["gem_mode"]
+    lookup_context.prefixes.prepend("themes/#{theme.slug}/views") unless theme.settings["gem_mode"]
 
     # run hook "email" to customize values
     r = {template_name: template_name, layout_name: layout_name, mail_data: mail_data, files: attachs, format: "html" }

data/app/models/{ability.rb → camaleon_cms/ability.rb}

@@ -6,7 +6,7 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class Ability
+class CamaleonCms::Ability
   include CanCan::Ability
 
   def initialize(user, current_site = nil)
@@ -19,8 +19,8 @@ class Ability
       can :read, :all
     else
       #conditions:
-      @roles_manager = user.get_role(current_site).meta["_manager_#{current_site.id.to_s}".to_sym] || {} rescue {}
-      @roles_post_type ||= user.get_role(current_site).meta["_post_type_#{current_site.id.to_s}".to_sym] || {} rescue {}
+      @roles_manager = user.get_role(current_site).get_meta("_manager_#{current_site.id.to_s}", {})
+      @roles_post_type ||= user.get_role(current_site).get_meta("_post_type_#{current_site.id.to_s}", {})
 
       ids_publish = @roles_post_type[:publish] || []
       ids_edit = @roles_post_type[:edit] || []

data/app/models/{category.rb → camaleon_cms/category.rb}

@@ -6,17 +6,17 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class Category < TermTaxonomy
+class CamaleonCms::Category < CamaleonCms::TermTaxonomy
   # term_group = site_id
   # status = post_type_id
 
   default_scope { where(taxonomy: :category) }
-  has_many :metas, ->{ where(object_class: 'Category')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
+  has_many :metas, ->{ where(object_class: 'Category')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
   has_many :posts, foreign_key: :objectid, through: :term_relationships, :source => :objects
-  has_many :children, class_name: "Category", foreign_key: :parent_id
-  belongs_to :parent, class_name: "Category", foreign_key: :parent_id
-  belongs_to :post_type_parent, class_name: "PostType", foreign_key: :parent_id
-  belongs_to :owner, class_name: "User", foreign_key: :user_id
+  has_many :children, class_name: "CamaleonCms::Category", foreign_key: :parent_id
+  belongs_to :parent, class_name: "CamaleonCms::Category", foreign_key: :parent_id
+  belongs_to :post_type_parent, class_name: "CamaleonCms::PostType", foreign_key: :parent_id
+  belongs_to :owner, class_name: "CamaleonCms::User", foreign_key: :user_id
 
   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
@@ -28,12 +28,14 @@ class Category < TermTaxonomy
 
   # return the post type of this category
   def post_type
-    ctg = self
-    begin
-      pt = ctg.post_type_parent
-      ctg = ctg.parent
-    end while ctg.present?
-    pt
+    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
@@ -43,6 +45,7 @@ class Category < TermTaxonomy
     self.status = pt.id unless self.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

data/app/models/{custom_field.rb → camaleon_cms/custom_field.rb}

@@ -6,17 +6,17 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class CustomField < ActiveRecord::Base
-  include Metas
-  has_many :metas, ->{ where(object_class: 'CustomField')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
-  self.table_name = "custom_fields"
-  default_scope {order("custom_fields.field_order ASC")}
+class CamaleonCms::CustomField < ActiveRecord::Base
+  include CamaleonCms::Metas
+  has_many :metas, ->{ where(object_class: 'CustomField')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+  self.table_name = "#{PluginRoutes.static_system_info["db_prefix"]}custom_fields"
+  default_scope {order("#{CamaleonCms::CustomField.table_name}.field_order ASC")}
   # status: nil -> visible on list group fields
   attr_accessible :object_class, :objectid, :description, :parent_id, :count, :name, :slug, :field_order, :status, :is_repeat
   validates :name, :object_class, presence: true
-  has_many :values, :class_name => "CustomFieldsRelationship", :foreign_key => :custom_field_id, dependent: :destroy
-  belongs_to :custom_field_group, class_name: "CustomFieldGroup"
-  belongs_to :parent, class_name: "CustomField", :foreign_key => :parent_id
+  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
 
   scope :configuration, -> {where(parent_id: -1)}
   scope :visible_group, -> {where(status: nil)}
@@ -24,11 +24,9 @@ class CustomField < ActiveRecord::Base
   before_validation :before_validating
 
   private
-
   def before_validating
     self.slug = self.name if self.slug.blank?
     self.slug = self.slug.to_s.parameterize
   end
 
-
 end

data/app/models/{custom_field_group.rb → camaleon_cms/custom_field_group.rb}

@@ -6,13 +6,13 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class CustomFieldGroup < CustomField
+class CamaleonCms::CustomFieldGroup < CamaleonCms::CustomField
   # attrs required: name, slug, description
-  default_scope { where.not(object_class: '_fields').reorder('custom_fields.field_order ASC') }
+  default_scope { where.not(object_class: '_fields').reorder("#{CamaleonCms::CustomField.table_name}.field_order ASC") }
 
-  has_many :metas, ->{ where(object_class: 'CustomFieldGroup')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
-  has_many :fields, -> {where(object_class: '_fields')}, :class_name => "CustomField", foreign_key: :parent_id, dependent: :destroy
-  belongs_to :site, :class_name => "Site", foreign_key: :parent_id
+  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
   before_validation :before_validating
 
   # ------------------- fields -----------------
@@ -45,7 +45,7 @@ class CustomFieldGroup < CustomField
 
   # only used by form on admin panel (protected)
   def add_fields(items, item_options)
-    ids_old = self.fields.pluck('custom_fields.id')
+    ids_old = self.fields.pluck("#{CamaleonCms::CustomField.table_name}.id")
     ids_saved = []
     order_index = 0
     if items.present?
@@ -83,17 +83,17 @@ class CustomFieldGroup < CustomField
         when 'PostType_PostTag'
           caption = "Fields for Post tags in <b>#{self.site.post_types.find(self.objectid).decorate.the_title}</b>"
         when 'Widget::Main'
-          caption = "Fields for Widget <b>(#{Widget::Main.find(self.objectid).name.translate})</b>"
+          caption = "Fields for Widget <b>(#{CamaleonCms::Widget::Main.find(self.objectid).name.translate})</b>"
         when 'Theme'
           caption = "Field settings for Theme <b>(#{self.objectid})</b>"
         when 'NavMenu'
-          caption = "Field settings for Menus <b>(#{NavMenu.find(self.objectid).name})</b>"
+          caption = "Field settings for Menus <b>(#{CamaleonCms::NavMenu.find(self.objectid).name})</b>"
         when 'Site'
           caption = "Field settings the site"
         when 'PostType'
           caption = "Fields for all <b>Post_Types</b>"
         when 'Post'
-          p = Post.find(self.objectid).decorate
+          p = CamaleonCms::Post.find(self.objectid).decorate
           caption = "Fields for content <b>(#{p.the_title})</b>"
         else # 'Plugin' or other class
           caption = "Fields for <b>#{self.object_class}</b>"
@@ -109,14 +109,15 @@ class CustomFieldGroup < CustomField
     self.slug = "_group-#{self.name.to_s.parameterize}" unless self.slug.present?
   end
 
+  # TODO VERIFY CLASS NAME
   # auto save the default field values
   def auto_save_default_values(field, options)
     class_name = self.object_class.split("_").first
     if ["Post", "Category", "Plugin", "Theme"].include?(class_name) && self.objectid.present? && options[:default_value].present?
       if class_name == "Theme"
-        owner = class_name.constantize.where(id: self.objectid).first # owner model
+        owner = "CamaleonCms::#{class_name}".constantize.where(id: self.objectid).first # owner model
       else
-        owner = class_name.constantize.find(self.objectid) rescue class_name.constantize.where(slug: self.objectid).first # owner model
+        owner = "CamaleonCms::#{class_name}".constantize.find(self.objectid) rescue "CamaleonCms::#{class_name}".constantize.where(slug: self.objectid).first # owner model
       end
       owner.field_values.create!({custom_field_id: field.id, custom_field_slug: field.slug, value: fix_meta_value(options["default_value"]||options[:default_value])}) if owner.present?
     end

data/app/models/{custom_fields_relationship.rb → camaleon_cms/custom_fields_relationship.rb}

@@ -6,12 +6,12 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class CustomFieldsRelationship < ActiveRecord::Base
-  self.table_name = "custom_fields_relationships"
+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
-  default_scope {order('custom_fields_relationships.term_order ASC')}
+  default_scope {order("#{CamaleonCms::CustomFieldsRelationship.table_name}.term_order ASC")}
   # relations
-  belongs_to :custom_fields, :class_name => "CustomField", foreign_key: :custom_field_id
+  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

data/app/models/{meta.rb → camaleon_cms/meta.rb}

@@ -6,10 +6,7 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class Meta < ActiveRecord::Base
-  self.table_name = "metas"
+class CamaleonCms::Meta < ActiveRecord::Base
+  self.table_name = "#{PluginRoutes.static_system_info["db_prefix"]}metas"
   attr_accessible :objectid, :key, :value, :object_class
-  #belongs_to :parent, :foreign_key => :objectid
-
-
 end

data/app/models/{nav_menu.rb → camaleon_cms/nav_menu.rb}

@@ -6,13 +6,13 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class NavMenu < TermTaxonomy
+class CamaleonCms::NavMenu < CamaleonCms::TermTaxonomy
   default_scope { where(taxonomy: :nav_menu) }
-  has_many :metas, ->{ where(object_class: 'NavMenu')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
-  has_many :children, class_name: "NavMenuItem", foreign_key: :parent_id, dependent: :destroy
-  belongs_to :site, :class_name => "Site", foreign_key: :parent_id
+  has_many :metas, ->{ where(object_class: 'NavMenu')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+  has_many :children, class_name: "CamaleonCms::NavMenuItem", foreign_key: :parent_id, dependent: :destroy
+  belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id
 
-  # add multiple menu items for current menu
+  # add multiple menu items for current menu only used from form
   def add_menu_items(menu_data=[])
     children.destroy_all
     saved_nav_items(self, menu_data) if menu_data.present?
@@ -22,20 +22,24 @@ class NavMenu < TermTaxonomy
   # 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"}
+  # 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.new({name: value[:label]})
-    if item.save
-      item.set_meta('_default',{type: value[:type], object_id: value[:link]})
-    end
+    item = children.create({name: value[:label], data_options: {type: value[:type], object_id: value[:link]}})
     item
   end
 
+  # skip uniq slug validation
+  def skip_slug_validation?
+    true
+  end
+
   private
   def saved_nav_items (nav_menu_item, items)
     items.each do |key, value|
       item = nav_menu_item.children.new({name: value[:label]})
-      if item.save
+      if item.save!
         item.set_meta('_default',{type: value[:type], object_id: value[:link]})
         saved_nav_items(item, value[:children]) if value[:children].present?
 
@@ -49,7 +53,4 @@ class NavMenu < TermTaxonomy
       end
     end
   end
-
-
-
 end

data/app/models/{nav_menu_item.rb → camaleon_cms/nav_menu_item.rb}

@@ -6,12 +6,12 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class NavMenuItem < TermTaxonomy
+class CamaleonCms::NavMenuItem < CamaleonCms::TermTaxonomy
   default_scope { where(taxonomy: :nav_menu_item) }
-  has_many :metas, ->{ where(object_class: 'NavMenuItem')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
-  belongs_to :parent, class_name: "NavMenu"
-  belongs_to :parent_item, class_name: "NavMenuItem", foreign_key: :parent_id
-  has_many :children, class_name: "NavMenuItem", foreign_key: :parent_id, dependent: :destroy
+  has_many :metas, ->{ where(object_class: 'NavMenuItem')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+  belongs_to :parent, class_name: "CamaleonCms::NavMenu"
+  belongs_to :parent_item, class_name: "CamaleonCms::NavMenuItem", foreign_key: :parent_id
+  has_many :children, class_name: "CamaleonCms::NavMenuItem", foreign_key: :parent_id, dependent: :destroy
 
   after_create :update_count
   #before_destroy :update_count
@@ -36,11 +36,22 @@ class NavMenuItem < TermTaxonomy
     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], data_options: {type: value[:type], object_id: value[:link]}})
+  end
+
+  # skip uniq slug validation
+  def skip_slug_validation?
+    true
+  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)
   end
-
-
 end

data/app/models/{plugin.rb → camaleon_cms/plugin.rb}

@@ -6,14 +6,14 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class Plugin < TermTaxonomy
+class CamaleonCms::Plugin < CamaleonCms::TermTaxonomy
   # attrs:
   #   term_group => status active (1, nil)
   #   slug => plugin key
   #   name => plugin name
   default_scope { where(taxonomy: :plugin) }
-  has_many :metas, ->{ where(object_class: 'Plugin')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
-  belongs_to :site, :class_name => "Site", foreign_key: :parent_id
+  has_many :metas, ->{ where(object_class: 'Plugin')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
+  belongs_to :site, :class_name => "CamaleonCms::Site", foreign_key: :parent_id
   scope :active, ->{ where(term_group: 1) }
   before_validation :set_default
   attr_accessor :error

data/app/models/{post.rb → camaleon_cms/post.rb}

@@ -6,18 +6,18 @@
   This program is distributed in the hope that it will be useful,  but WITHOUT ANY WARRANTY; without even the implied warranty of  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the  GNU Affero General Public License (GPLv3) for more details.
 =end
-class PostUniqValidator < ActiveModel::Validator
+class CamaleonCms::PostUniqValidator < ActiveModel::Validator
   def validate(record)
     if record.status != '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| "posts.slug LIKE '%-->#{s}<!--%'"}.join(" OR ")} ) OR posts.slug = ?",  record.slug).where("posts.status != 'draft'").where(post_parent: nil).where.not(id: record.id)
+        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("#{CamaleonCms::Post.table_name}.status != 'draft'").where(post_parent: nil).where.not(id: record.id)
         if posts.size > 0
           if slug_array.size > 1
-            record.errors[:base] << "#{I18n.t('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(", ")} "
+            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('admin.post.message.requires_different_slug')}: #{record.slug.to_s} "
+            record.errors[:base] << "#{I18n.t('camaleon_cms.admin.post.message.requires_different_slug')}: #{record.slug.to_s} "
           end
         end
       else
@@ -27,26 +27,26 @@ class PostUniqValidator < ActiveModel::Validator
   end
 end
 
-class Post < PostDefault
-  include CategoriesTagsForPosts
-  default_scope ->{ where(post_class: self.name).order(post_order: :asc) }
-  has_many :metas, ->{ where(object_class: 'Post')}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
+class CamaleonCms::Post < CamaleonCms::PostDefault
+  include CamaleonCms::CategoriesTagsForPosts
+  default_scope ->{ where(post_class: "Post").order(post_order: :asc) }
+  has_many :metas, ->{ where(object_class: 'Post')}, :class_name => "CamaleonCms::Meta", foreign_key: :objectid, dependent: :destroy
 
   # DEPRECATED
-  has_many :post_relationships, class_name: "PostRelationship", foreign_key: :objectid, dependent: :destroy,  inverse_of: :posts
-  has_many :post_types, class_name: "PostType", through: :post_relationships, :source => :post_type
+  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: "TermRelationship", foreign_key: :objectid, dependent: :destroy,  inverse_of: :objects
-  has_many :categories, class_name: "Category", through: :term_relationships, :source => :term_taxonomies
-  has_many :post_tags, class_name: "PostTag", through: :term_relationships, :source => :term_taxonomies
-  has_many :comments, class_name: "PostComment", foreign_key: :post_id, dependent: :destroy
-  has_many :drafts, ->{where(status: 'draft')}, class_name: "Post", foreign_key: :post_parent, dependent: :destroy
-  has_many :children, class_name: "Post", foreign_key: :post_parent, dependent: :destroy, primary_key: :id
+  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')}, 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: "User", foreign_key: :user_id
-  belongs_to :parent, class_name: "Post", foreign_key: :post_parent
-  belongs_to :post_type, class_name: "PostType", foreign_key: :taxonomy_id
+  belongs_to :owner, class_name: "CamaleonCms::User", 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
 
   scope :visible_frontend, -> {where(status: 'published')}
   scope :public_posts, -> {visible_frontend.where(visibility: ['public', ""]) } #public posts (not passwords, not privates)
@@ -58,18 +58,13 @@ class Post < PostDefault
   scope :pendings, -> {where(status: 'pending')}
   scope :latest, -> {reorder(created_at: :desc)}
 
-  validates_with PostUniqValidator
+  validates_with CamaleonCms::PostUniqValidator
 
   # return the post type of this post (DEPRECATED)
   def get_post_type_depre
     post_types.reorder(nil).first
   end
 
-  # return template assigned to this post
-  def template
-    get_meta("template", "")
-  end
-
   # check if this post was published
   def published?
     status == 'published'
@@ -96,6 +91,17 @@ class Post < PostDefault
     get_option('has_content', (posttype || self.post_type).get_option('has_content', true))
   end
 
+  # return boolean
+  def manage_layout?(posttype = nil)
+    get_option('has_layout', (posttype || self.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 || self.post_type).get_option('has_template', true))
+  end
+
   # check if current post can manage summary
   # return boolean
   def manage_summary?(posttype = nil)
@@ -114,12 +120,6 @@ class Post < PostDefault
     get_option('has_picture', (posttype || self.post_type).get_option('has_picture', true))
   end
 
-  # check if current post can manage template
-  # return boolean
-  def manage_template?(posttype = nil)
-    get_option('has_template', (posttype || self.post_type).get_option('has_template', true))
-  end
-
   # check if current post can manage comments
   # return boolean
   def manage_comments?(posttype = nil)
@@ -132,8 +132,12 @@ class Post < PostDefault
   #   has_summary, boolean (default true)
   #   has_keywords, boolean (default true)
   #   has_picture, boolean (default true)
-  #   has_template, 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)
@@ -165,6 +169,27 @@ class Post < PostDefault
     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_template") 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)