camaleon_cms_rails6 2.5.0

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

@@ -0,0 +1,310 @@
+module CamaleonCms::CustomFieldsRead extend ActiveSupport::Concern
+  included do
+    before_destroy :_destroy_custom_field_groups
+    # DEPRECATED, INSTEAD USE: custom_fields
+    has_many :fields, ->(object){ where(:object_class => object.class.to_s.gsub("Decorator","").gsub("CamaleonCms::",""))} , :class_name => "CamaleonCms::CustomField" ,foreign_key: :objectid
+    # DEPRECATED, INSTEAD USE: custom_field_values
+    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
+    # DEPRECATED, INSTEAD USE: custom_field_groups
+    has_many :field_groups, ->(object){where(object_class: object.class.to_s.parseCamaClass)}, :class_name => "CamaleonCms::CustomFieldGroup", foreign_key: :objectid
+  end
+
+
+  # get custom field groups for current object
+  # only: Post_type, Post, Category, PostTag, Widget, Site and a Custom model pre configured
+  # return collections CustomFieldGroup
+  # args: (Hash, used only for PostType Objects)
+    # kind: (Post (Default) | Category | PostTag | PostType).
+      # If kind = "Post" this will return all groups for all posts from current post type
+      # If kind = "Category" this will return all groups for all categories from current post type
+      # If kind = "PostTag" this will return all groups for all posttags from current post type
+      # If kind = "all" this will return all groups from current post type
+      # If kind = "post_type" this will return groups for all post_types
+  # Sample: mypost.get_field_groups() ==> return fields for posts from parent posttype
+  # Sample: mycat.get_field_groups() ==> return fields for categories from parent posttype
+  # Sample: myposttag.get_field_groups() ==> return fields for posttags from parent posttype
+  # Sample: mypost_type.get_field_groups({kind: 'Post'}) => return custom fields for posts
+  # Sample: mypost_type.get_field_groups({kind: 'Category'}) => return custom fields for posts
+  # Sample: mypost_type.get_field_groups({kind: 'PostTag'}) => return custom fields for posts
+  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.parseCamaClass
+    case class_name
+      when 'Category','PostTag'
+        self.post_type.get_field_groups(class_name)
+      when 'Post'
+        if self.term_relationships.size.zero? && args[:cat_ids].nil?
+          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
+          cat_ids = self.categories.map(&:id)
+          cat_ids += args[:cat_ids] unless args[:cat_ids].nil?
+          cat_ids += CamaleonCms::Category.find(cat_ids).map {|category| _category_parents_ids(category)}.flatten.uniq
+          CamaleonCms::CustomFieldGroup.where("(objectid = ? AND object_class = ?) OR
+                                               (objectid = ? AND object_class = ?) OR
+                                               (objectid IN (?) AND object_class = ?)",
+                                              self.id || -1, class_name,
+                                              self.post_type.id, "PostType_#{class_name}",
+                                              cat_ids, "Category_#{class_name}")
+        end
+      when 'NavMenuItem'
+        self.main_menu.custom_field_groups
+      when 'PostType'
+        if args[:kind] == "all"
+          CamaleonCms::CustomFieldGroup.where(object_class: ["PostType_Post", "PostType_Post", "PostType_PostTag", "PostType"], objectid:  self.id )
+        elsif args[:kind] == "post_type"
+          self.custom_field_groups
+        else
+          CamaleonCms::CustomFieldGroup.where(object_class: "PostType_#{args[:kind]}", objectid:  self.id )
+        end
+      else # 'Plugin' or other classes
+        self.field_groups
+    end
+  end
+
+  # get custom field groups for current user
+  # return collections CustomFieldGroup
+  # site: site object
+  def get_user_field_groups(site)
+    site.custom_field_groups.where(object_class: self.class.to_s.parseCamaClass)
+  end
+
+
+  # get custom field value
+  # _key: custom field key
+  # if value is not present, then return default
+  # return default only if the field was not registered
+  def get_field_value(_key, _default = nil, group_number = 0)
+    v = get_field_values(_key, group_number).first rescue _default
+    v.present? ? v : _default
+  end
+  alias_method :get_field, :get_field_value
+  alias_method :get_field!, :get_field_value
+
+  # get custom field values
+  # _key: custom field key
+  def get_field_values(_key, group_number = 0)
+    custom_field_values.loaded? ? custom_field_values.select{|f| f.custom_field_slug == _key && f.group_number == group_number}.map{|f| f.value } : custom_field_values.where(custom_field_slug: _key, group_number: group_number).pluck(:value)
+  end
+  alias_method :get_fields, :get_field_values
+
+  # return the values of custom fields grouped by group_number
+  # field_keys: (array of keys)
+  # samples: my_object.get_fields_grouped(['my_slug1', 'my_slug2'])
+  #   return: [
+  #             { 'my_slug1' => ["val 1"], 'my_slug2' => ['val 2']},
+  #             { 'my_slug1' => ["val2 for slug1"], 'my_slug2' => ['val 2 for slug2']}
+  #   ] ==> 2 groups
+  #
+  #   return: [
+  #             { 'my_slug1' => ["val 1", 'val 2 for fields multiple support'], 'my_slug2' => ['val 2']},
+  #             { 'my_slug1' => ["val2 for slug1", 'val 2'], 'my_slug2' => ['val 2 for slug2']}
+  #             { 'my_slug1' => ["val3 for slug1", 'val 3'], 'my_slug2' => ['val 3 for slug2']}
+  #   ] ==> 3 groups
+  #
+  #   puts res[0]['my_slug1'].first ==> "val 1"
+  def get_fields_grouped(field_keys)
+    res = []
+    custom_field_values.where(custom_field_slug: field_keys).order(group_number: :asc).group_by(&:group_number).each do |group_number, group_fields|
+      group = {}
+      field_keys.each do |field_key|
+        _tmp = []
+        group_fields.each{ |field| _tmp << field.value if field_key == field.custom_field_slug }
+        group[field_key] = _tmp if _tmp.present?
+      end
+      res << group
+    end
+    res
+  end
+
+  # return all values
+  # {key1: "single value", key2: [multiple, values], key3: value4} if include_options = false
+  # {key1: {values: "single value", options: {a:1, b: 4}}, key2: {values: [multiple, values], options: {a=1, b=2} }} if include_options = true
+  def get_field_values_hash(include_options = false)
+    fields = {}
+    self.custom_field_values.to_a.uniq.each do |field_value|
+      custom_field = field_value.custom_fields
+      values = custom_field.values.where(objectid: self.id).pluck(:value)
+      fields[field_value.custom_field_slug] = custom_field.cama_options[:multiple].to_s.to_bool ? values : values.first unless include_options
+      fields[field_value.custom_field_slug] = {values: custom_field.cama_options[:multiple].to_s.to_bool ? values : values.first, options: custom_field.cama_options, id: custom_field.id} if include_options
+    end
+    fields.to_sym
+  end
+
+  # return all custom fields for current element
+  # {my_field_slug: {options: {}, values: [], name: '', ...} }
+  # deprecated f attribute
+  def get_fields_object(f=true)
+    fields = {}
+    self.custom_field_values.eager_load(:custom_fields).to_a.uniq.each do |field_value|
+      custom_field = field_value.custom_fields
+      # if custom_field.options[:show_frontend].to_s.to_bool
+      values = custom_field.values.where(objectid: self.id).pluck(:value)
+      fields[field_value.custom_field_slug] = custom_field.attributes.merge(options: custom_field.cama_options, values: custom_field.cama_options[:multiple].to_s.to_bool ? values : values.first)
+      # end
+    end
+    fields.to_sym
+  end
+
+
+  # add a custom field group for current model
+  # values:
+    # name: name for the group
+    # slug: key for group (if slug = _default => this will never show title and description)
+    # description: description for the group (optional)
+    # is_repeat: (boolean, optional -> default false) indicate if group support multiple format (repeated values)
+  # Model supported: PostType, Category, Post, Posttag, Widget, Plugin, Theme, User and Custom models pre configured
+  # Note 1: If you need add fields for all post's or all categories, then you need to add the fields into the
+  #     post_type.add_custom_field_group(values, kind = "Post")
+  #     post_type.add_custom_field_group(values, kind = "Category")
+  # Note 2: If you need add fields for only the Post_type, you have to use options or metas
+  # return: CustomFieldGroup object
+  # kind: argument only for PostType model: (Post | Category | PostTag), default => Post. If kind = "" this will add group for all post_types
+  def add_custom_field_group(values, kind = "Post")
+    values = values.with_indifferent_access
+    group = get_field_groups(kind).where(slug: values[:slug]).first
+    unless group.present?
+      site = _cama_get_field_site
+      values[:parent_id] = site.id if site.present?
+      if self.is_a?(CamaleonCms::Post) # harcoded for post to support custom field groups
+        group = CamaleonCms::CustomFieldGroup.where(object_class: "Post", objectid: self.id).create!(values)
+      else
+        group = get_field_groups(kind).create!(values)
+      end
+    end
+    group
+  end
+  alias_method :add_field_group, :add_custom_field_group
+
+  # Add custom fields for a default group:
+  # This will create a new group with slug=_default if it doesn't exist yet
+  # more details in add_manual_field(item, options) from custom field groups
+  # kind: argument only for PostType model: (Post | Category | PostTag), default => Post
+  def add_custom_field_to_default_group(item, options, kind = "Post")
+    g = get_field_groups(kind).where(slug: "_default").first
+    g = add_custom_field_group({name: "Default Field Group", slug: "_default"}, kind) unless g.present?
+    g.add_manual_field(item, options)
+  end
+  alias_method :add_field, :add_custom_field_to_default_group
+
+  # return field object for current model
+  def get_field_object(slug)
+    CamaleonCms::CustomField.where(
+      slug: slug,
+      parent_id: get_field_groups.pluck(:id),
+    ).first || CamaleonCms::CustomField.where(
+      slug: slug,
+      parent_id: get_field_groups({include_parent: true})
+    ).first
+  end
+
+  # save all fields sent from browser (reservated for browser request)
+  # sample:
+  # {
+  #   "0"=>{ "untitled-text-box"=>{"id"=>"262", "values"=>{"0"=>"33333"}}},
+  #   "1"=>{ "untitled-text-box"=>{"id"=>"262", "values"=>{"0"=>"33333"}}}
+  # }
+  def set_field_values(datas = {})
+    if datas.present?
+      ActiveRecord::Base.transaction do 
+        self.custom_field_values.delete_all
+        datas.each do |index, fields_data|
+          fields_data.each do |field_key, values|
+            if values[:values].present?
+              order_value = -1
+              ((values[:values].is_a?(Hash) || values[:values].is_a?(ActionController::Parameters)) ? values[:values].values : values[:values]).each do |value|
+                item = self.custom_field_values.create!({custom_field_id: values[:id], custom_field_slug: field_key, value: fix_meta_value(value), term_order: order_value += 1, group_number: values[:group_number] || 0})
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  # update new value for field with slug _key
+  # Sample: my_posy.update_field_value('sub_title', 'Test Sub Title')
+  def update_field_value(_key, value = nil, group_number = 0)
+    self.custom_field_values.where(custom_field_slug: _key, group_number: group_number).first.update_column('value', value) rescue nil
+  end
+
+  # Set custom field values for current model
+  # key: slug of the custom field
+  # value: array of values for multiple values support
+  # value: string value
+  def save_field_value(key, value, order = 0, clear = true)
+    set_field_value(key, value, {clear: clear, order: order})
+  end
+
+  # Set custom field values for current model (support for multiple group values)
+  # key: (string required) slug of the custom field
+  # value: (array | string) array: array of values for multiple values support, string: uniq value for the custom field
+  # args:
+  #   field_id: (integer optional) identifier of the custom field
+  #   order: order or position of the field value
+  #   group_number: number of the group (only for custom field group with is_repeat enabled)
+  #   clear: (boolean, default true) if true, will remove previous values and set these values, if not will append values
+  # return false if the was not saved because there is not present the field with slug: key
+  # sample: my_post.set_field_value('subtitle', 'Sub Title')
+  # sample: my_post.set_field_value('subtitle', ['Sub Title1', 'Sub Title2']) # set values for a field (for fields that support multiple values)
+  # sample: my_post.set_field_value('subtitle', 'Sub Title', {group_number: 1})
+  # sample: my_post.set_field_value('subtitle', 'Sub Title', {group_number: 1, group_number: 1}) # add field values for fields in group 1
+  def set_field_value(key, value, args = {})
+    args = {order: 0, group_number: 0, field_id: nil, clear: true}.merge(args)
+    args[:field_id] = get_field_object(key).id rescue nil unless args[:field_id].present?
+    unless args[:field_id].present?
+      raise ArgumentError, "There is no custom field configured for #{key}"
+    end
+    self.custom_field_values.where({custom_field_slug: key, group_number: args[:group_number]}).delete_all if args[:clear]
+    v = {custom_field_id: args[:field_id], custom_field_slug: key, value: fix_meta_value(value), term_order: args[:order], group_number: args[:group_number]}
+    if value.is_a?(Array)
+      value.each do |val|
+        self.custom_field_values.create!(v.merge({value: fix_meta_value(val)}))
+      end
+    else
+      self.custom_field_values.create!(v)
+    end
+  end
+
+  private
+  def fix_meta_value(value)
+    if (value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(ActionController::Parameters))
+      value = value.to_json
+    end
+    value
+  end
+
+  def _destroy_custom_field_groups
+    class_name = self.class.to_s.parseCamaClass
+    if ['Category','Post','PostTag'].include?(class_name)
+      CamaleonCms::CustomFieldGroup.where(objectid: self.id, object_class: class_name).destroy_all
+    elsif ['PostType'].include?(class_name)
+      get_field_groups("Post").destroy_all
+      get_field_groups("Category").destroy_all
+      get_field_groups("PostTag").destroy_all
+    elsif ["NavMenuItem"].include?(class_name) # menu items doesn't include field groups
+    else
+      get_field_groups().destroy_all if get_field_groups.present?
+    end
+  end
+  # return the Site Model owner of current model
+  def _cama_get_field_site
+    case self.class.to_s.parseCamaClass
+      when 'Category','Post','PostTag'
+        self.post_type.site
+      when 'Site'
+        self
+      else
+        self.site
+    end
+  end
+
+  def _category_parents_ids(category)
+    @parents ||= []
+    if category.parent.nil?
+      return @parents
+    else
+      @parents << category.parent.id
+      _category_parents_ids(category.parent)
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+module CamaleonCms::Metas extend ActiveSupport::Concern
+  included do
+    # options and metas auto save support
+    attr_accessor :data_options
+    attr_accessor :data_metas
+    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: :delete_all
+  end
+
+  # Add meta with value or Update meta with key: key
+  # return true or false
+  def set_meta(key, value)
+    metas.where(key: key).update_or_create({value: fix_meta_value(value)})
+    cama_set_cache("meta_#{key}", value)
+  end
+
+  # return value of meta with key: key,
+  # if meta not exist, return default
+  # return default if meta value == ""
+  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.loaded? ? metas.select{|m| m.key == key }.first : metas.where(key: key_str).first
+      res = ''
+      if option.present?
+        value = JSON.parse(option.value) rescue option.value
+        res = (value.is_a?(Hash) ? value.with_indifferent_access : value) rescue option.value
+      end
+      res == '' ? default : res
+    end
+  end
+
+  # delete meta
+  def delete_meta(key)
+    metas.where(key: key).destroy_all
+    cama_remove_cache("meta_#{key}")
+  end
+
+  # return configurations for current object, sample: {"type":"post_type","object_id":"127"}
+  def options(meta_key = "_default")
+    get_meta(meta_key, {})
+  end
+  alias_method :cama_options, :options
+
+  # add configuration for current object
+  # key: attribute name
+  # value: attribute value
+  # meta_key: (String) name of the meta attribute
+  # sample: mymodel.set_custom_option("my_settings", "color", "red")
+  def set_option(key, value = nil, meta_key = "_default")
+    return if key.nil?
+    data = cama_options(meta_key)
+    data[key] = fix_meta_var(value)
+    set_meta(meta_key, data)
+    value
+  end
+
+  # return configuration for current object
+  # key: attribute name
+  # default: if attribute not exist, return default
+  # return default if option value == ""
+  # return value for attribute
+  def get_option(key = nil, default = nil, meta_key = "_default")
+    values = cama_options(meta_key)
+    key = key.to_sym
+    values.has_key?(key) && values[key] != "" ? values[key] : default
+  end
+
+  # delete attribute from configuration
+  def delete_option(key, meta_key = "_default")
+    values = cama_options(meta_key)
+    key = key.to_sym
+    values.delete(key) if values.has_key?(key)
+    set_meta(meta_key, values)
+  end
+
+  # set multiple configurations
+  # h: {ket1: "sdsds", ff: "fdfdfdfd"}
+  def set_options(h = {}, meta_key = "_default")
+    if h.present?
+      data = cama_options(meta_key)
+      PluginRoutes.fixActionParameter(h).to_sym.each do |key, value|
+        data[key] = fix_meta_var(value)
+      end
+      set_meta(meta_key, data)
+    end
+  end
+  alias_method :set_multiple_options, :set_options
+
+  # save multiple metas
+  # sample: set_metas({name: 'Owen', email: 'owenperedo@gmail.com'})
+  def set_metas(data_metas)
+    (data_metas.nil? ? {} : data_metas).each do |key, value|
+      self.set_meta(key, value)
+    end
+  end
+
+  # permit to skip save_metas_options in specific models
+  def save_metas_options_skip
+    false
+  end
+
+  # fix to save options and metas when a model was not changed
+  def fix_save_metas_options_no_changed
+    save_metas_options #unless self.changed?
+  end
+
+  # save all settings for this post type received in data_options and data_metas attribute (options and metas)
+  # sample: Site.first.post_types.create({name: "owen", slug: "my_post_type", data_options: { has_category: true, default_layout: "my_layout" }})
+  def save_metas_options
+    set_multiple_options(data_options)
+    if data_metas.present?
+      data_metas.each do |key, val|
+        set_meta(key, val)
+      end
+    end
+  end
+
+  private
+  # fix to parse value
+  def fix_meta_value(value)
+    if (value.is_a?(Array) || value.is_a?(Hash) || value.is_a?(ActionController::Parameters))
+      value = value.to_json
+    end
+    fix_meta_var(value)
+  end
+
+  # fix to detect type of the variable
+  def fix_meta_var(value)
+    if value.is_a?(String)
+      value = value.to_var
+    end
+    value
+  end
+
+end

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

@@ -0,0 +1,87 @@
+module CamaleonCms::SiteDefaultSettings extend ActiveSupport::Concern
+# default structure for each new site
+  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, 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]})
+    end
+
+    # nav menus
+    @nav_menu = self.nav_menus.new({name: "Main Menu", slug: "main_menu"})
+    if @nav_menu.save
+      self.post_types.all.each do |pt|
+        if pt.slug == "post"
+          title = "Sample Post"
+          slug = 'sample-post'
+          content = "<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Integer pharetra ut augue in posuere. Nulla non malesuada dui. Sed egestas tortor ut purus tempor sodales. Duis non sollicitudin nulla, quis mollis neque. Integer sit amet augue ac neque varius auctor. Vestibulum malesuada leo leo, at semper libero efficitur nec. Etiam semper nisi ac nisi ullamcorper, sed tincidunt purus elementum. Mauris ac congue nibh. Quisque pretium eget leo nec suscipit. </p> <p> Vestibulum ultrices orci ut congue interdum. Morbi dolor nunc, imperdiet vel risus semper, tempor dapibus urna. Phasellus luctus pharetra enim quis volutpat. Integer tristique urna nec malesuada ullamcorper. Curabitur dictum, lectus id ultrices rhoncus, ante neque auctor erat, ut sodales nisi odio sit amet lorem. In hac habitasse platea dictumst. Quisque orci orci, hendrerit at luctus tristique, lobortis in diam. Curabitur ligula enim, rhoncus ut vestibulum a, consequat sit amet nisi. Aliquam bibendum fringilla ultrices. Aliquam erat volutpat. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; In justo mi, congue in rhoncus lobortis, facilisis in est. Nam et rhoncus purus. </p> <p> Sed sagittis auctor lectus at rutrum. Morbi ultricies felis mi, ut scelerisque augue facilisis eu. In molestie quam ex. Quisque ut sapien sed odio tempus imperdiet. In id accumsan massa. Morbi quis nunc ullamcorper, interdum enim eu, finibus purus. Vestibulum ac fermentum augue, at tempus ante. Aliquam ultrices, purus ut porttitor gravida, dui augue dignissim massa, ac tempor ante dolor at arcu. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Suspendisse placerat risus est, eget varius mi ultricies in. Duis non odio ut felis dapibus eleifend. In fringilla enim lobortis placerat efficitur. </p> <p> Nulla sodales faucibus urna, quis viverra dolor facilisis sollicitudin. Aenean ac egestas nibh. Nam non tortor eget nibh scelerisque fermentum. Etiam ornare, nunc ut luctus mollis, ante dolor consectetur augue, non scelerisque odio est a nulla. Nullam cursus egestas nulla, nec commodo nibh suscipit ut. Mauris ut felis sem. Aenean at mi at nisi dictum blandit sit amet at erat. Etiam eget lobortis tellus. Curabitur in commodo arcu, at vehicula tortor. </p>"
+        else
+          title = "Welcome"
+          slug = 'welcome'
+          content = "<p style='text-align: center;'><img width='155' height='155' src='http://camaleon.tuzitio.com/media/132/logo2.png' alt='logo' /></p><p><strong>Camaleon CMS</strong>&nbsp;is a free and open-source tool and a fexible content management system (CMS) based on <a href='http://rubyonrails.org'>Ruby on Rails 4</a>&nbsp;and MySQL.&nbsp;</p> <p>With Camaleon you can do the following:</p> <ul> <li>Create instantly a lot of sites&nbsp;in the same installation</li> <li>Manage your content information in several languages</li> <li>Extend current functionality by&nbsp;plugins (MVC structure and no more echo or prints anywhere)</li> <li>Create or install different themes for each site</li> <li>Create your own structure without coding anything (adapt Camaleon as you want&nbsp;and not you for Camaleon)</li> <li>Create your store and start to sell your products using our plugins</li> <li>Avoid web attacks</li> <li>Compare the speed and enjoy the speed of your new Camaleon site</li> <li>Customize or create your themes for mobile support</li> <li>Support&nbsp;more visitors at the same time</li> <li>Manage your information with a panel like wordpress&nbsp;</li> <li>All urls are oriented for SEO</li> <li>Multiples roles of users</li> </ul>"
+        end
+        user = self.users.admin_scope.first
+        user = self.users.admin_scope.create({email: 'admin@local.com', username: 'admin', password: 'admin123', password_confirmation: 'admin123', first_name: 'Administrator'}) unless user.present?
+        post = pt.add_post({title: title, slug: slug, content: content, user_id: user.id, status: 'published'})
+        @nav_menu.append_menu_item({label: title, type: 'post', link: post.id})
+      end
+    end
+    get_anonymous_user
+  end
+
+  # auto create default user roles
+  def set_default_user_roles(post_type = nil)
+    user_role = self.user_roles.where({slug: 'admin', term_group: -1}).first_or_create({name: 'Administrator', description: 'Default roles admin'})
+    if user_role.valid?
+      d, m = {}, {}
+      pts = self.post_types.all.pluck(:id)
+      CamaleonCms::UserRole::ROLES[:post_type].each { |value| d[value[:key]] = pts }
+      CamaleonCms::UserRole::ROLES[:manager].each { |value| m[value[:key]] = 1 }
+      user_role.set_meta("_post_type_#{self.id}", d || {})
+      user_role.set_meta("_manager_#{self.id}", m || {})
+    end
+
+    user_role = self.user_roles.where({slug: 'editor'}).first_or_create({name: 'Editor', description: 'Editor Role'})
+    if user_role.valid?
+      d = {}
+      if post_type.present?
+        d = user_role.get_meta("_post_type_#{self.id}", {})
+        CamaleonCms::UserRole::ROLES[:post_type].each { |value|
+          value_old = d[value[:key].to_sym] || []
+          d[value[:key].to_sym] = value_old + [post_type.id]
+        }
+      else
+        pts = self.post_types.all.pluck(:id)
+        CamaleonCms::UserRole::ROLES[:post_type].each { |value| d[value[:key]] = pts }
+      end
+      user_role.set_meta("_post_type_#{self.id}", d || {})
+    end
+
+    user_role = self.user_roles.where({slug: 'contributor'}).first_or_create({name: 'Contributor', description: 'Contributor Role'})
+    if user_role.valid?
+      d = {}
+      if post_type.present?
+        d = user_role.get_meta("_post_type_#{self.id}", {})
+        CamaleonCms::UserRole::ROLES[:post_type].each { |value|
+          value_old = d[value[:key].to_sym] || []
+          d[value[:key].to_sym] = value_old + [post_type.id] if value[:key].to_s == 'edit'
+        }
+      else
+        pts = self.post_types.all.pluck(:id)
+        CamaleonCms::UserRole::ROLES[:post_type].each { |value| d[value[:key]] = pts if value[:key].to_s == 'edit' }
+      end
+      user_role.set_meta("_post_type_#{self.id}", d || {})
+    end
+
+    unless post_type.present?
+      user_role = self.user_roles.where({slug: 'client', term_group: -1}).first_or_create({name: 'Client', description: 'Default roles client'})
+      if user_role.valid?
+        user_role.set_meta("_post_type_#{self.id}", {})
+        user_role.set_meta("_manager_#{self.id}", {})
+      end
+    end
+
+  end
+end