camaleon_cms 0.0.1

data/app/models/concerns/custom_fields_read.rb

@@ -0,0 +1,221 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  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
+module CustomFieldsRead extend ActiveSupport::Concern
+  included do
+    has_many :fields, ->(object){ where(:object_class => object.class.to_s.gsub("Decorator",""))} , :class_name => "CustomField" ,foreign_key: :objectid
+    has_many :field_values, ->(object){where(object_class: object.class.to_s.gsub("Decorator",""))}, :class_name => "CustomFieldsRelationship", foreign_key: :objectid, dependent: :destroy
+    before_destroy :_destroy_custom_field_groups
+  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)
+    # kind: argument only for PostType Objects: (Post (Default) | Category | PostTag).
+      # If kind = "post_type" this will return groups for all post_types
+    # include_parent: (boolean, default false) Permit to recover groups from self + parent post_type (argument valid only for Post | PostTag | Category)
+  # args: (String) => is a value for kind attribute
+  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.gsub("Decorator","")
+    case class_name
+      when 'Category','Post','PostTag'
+        if args[:include_parent]
+           self.post_type.site.custom_field_groups.where("(objectid = ? AND object_class = ?) OR (objectid = ? AND object_class = ?)", self.id || -1, class_name, self.post_type.id, "PostType_#{class_name}")
+        else
+          self.post_type.site.custom_field_groups.where(objectid: self.id || -1, object_class: class_name)
+        end
+      when 'Widget::Main'
+        self.site.custom_field_groups.where(object_class: class_name, objectid:  self.id)
+      when 'Theme'
+        self.site.custom_field_groups.where(object_class: class_name, objectid:  self.id)
+      when 'Site'
+        self.custom_field_groups.where(object_class: class_name)
+      when 'PostType'
+        if args[:kind] == "all"
+          self.site.custom_field_groups.where(object_class: ["PostType_Post", "PostType_Post", "PostType_PostTag", "PostType"], objectid:  self.id )
+        elsif args[:kind] == "post_type"
+          self.site.custom_field_groups.where(object_class: class_name)
+        else
+          self.site.custom_field_groups.where(object_class: "PostType_#{args[:kind]}", objectid:  self.id )
+        end
+      else # 'Plugin' or other class
+        self.site.custom_field_groups.where(object_class: class_name, objectid:  self.id) if defined?(self.site)
+    end
+  end
+
+  # get custom field groups for current user
+  # return collections CustomFieldGroup
+  # site: site object
+  def get_user_field_groups(site)
+    class_name = self.class.to_s.gsub("Decorator","")
+    site.custom_field_groups.where(object_class: class_name)
+  end
+
+
+  # get custom field value
+  # _key: custom field key
+  # if value is not present, then return default
+  def get_field_value(_key, _default = nil)
+    v = _default
+    v = get_field_values(_key).first rescue _default
+    v = _default if v.nil?
+    v
+  end
+  alias_method :get_field, :get_field_value
+
+  # get custom field values
+  # _key: custom field key
+  def get_field_values(_key)
+    self.field_values.where(custom_field_slug: _key).pluck(:value)
+  end
+
+  # ------------- new function update field value -------------
+  def update_field_value(_key, value = nil)
+    self.field_values.where(custom_field_slug: _key).first.update_column('value', value) rescue nil
+  end
+
+
+  # return all values
+  # {key1: value3, key2: [value1, value2], key3: value4}
+  def get_field_values_hash
+    fields = {}
+    self.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.options[:multiple].to_s.to_bool ? values : values.first
+    end
+    fields.to_sym
+  end
+
+  # return all custom fields
+  def get_fields_object(only_frontend = false)
+    fields = {}
+    self.field_values.to_a.uniq.each do |field_value|
+      custom_field = field_value.custom_fields
+      if !only_frontend || 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.options, values: custom_field.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)
+    # descr: description for the group (optional)
+  # 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?
+      group = get_field_groups(kind).create(values)
+    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?
+    f = g.add_manual_field(item, options)
+  end
+  alias_method :add_field, :add_custom_field_to_default_group
+
+  # only custom field plugin (protected)
+  # example:
+  # id: custom_field_id
+  # {
+  # :key : {id: 123, values: ['uno','dos']}
+  # :key2 : {id: 455, values: ['uno','dos']}
+  # :key3 : {id: 4555, values: ['uno','dos']}
+  # }
+  def set_field_values(datas = {})
+    ids_old = self.field_values.pluck(:id)
+    ids_saved = []
+    if datas.present?
+      datas.each do |key, values|
+        if values[:values].present?
+          order_value = 0
+          values[:values].each do |value|
+            item = self.field_values.where({custom_field_id: values[:id], custom_field_slug: key, value: fix_meta_value(value)}).first_or_create!()
+            if defined?(item.id)
+              item.update_column('term_order', order_value)
+              ids_saved << item.id
+              order_value += 1
+            end
+          end
+        end
+      end
+    end
+
+    ids_deletes = ids_old - ids_saved
+    self.field_values.where(id: ids_deletes).destroy_all if ids_deletes.present?
+  end
+
+  # return field object for current model
+  def get_field_object(slug)
+    CustomField.where(parent_id: get_field_groups.pluck(:id), slug: slug).first || CustomField.where(slug: slug, parent_id: get_field_groups({include_parent: true})).first
+  end
+
+  # clear and register values for this custom field
+  # 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)
+    field = get_field_object(key)
+    return unless field.present?
+    self.field_values.where({custom_field_slug: key}).destroy_all if clear
+    if value.is_a?(Array)
+      value.each do |val|
+        self.field_values.create!({custom_field_id: field.id, custom_field_slug: key, value: fix_meta_value(val), term_order: order})
+      end
+    else
+      self.field_values.create!({custom_field_id: field.id, custom_field_slug: key, value: fix_meta_value(value), term_order: order})
+    end
+  end
+
+  private
+  def fix_meta_value(value)
+    if (value.is_a?(Array) || value.is_a?(Hash))
+      value = value.to_json
+    end
+    value
+  end
+
+  def _destroy_custom_field_groups
+    class_name = self.class.to_s.gsub("Decorator","")
+    if ['Category','Post','PostTag'].include?(class_name)
+      # get_field_groups("Post").destroy_all
+      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)
+
+    else
+      get_field_groups().destroy_all if get_field_groups.present?
+    end
+  end
+end

data/app/models/concerns/metas.rb

@@ -0,0 +1,133 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  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
+module Metas extend ActiveSupport::Concern
+  included do
+    has_many :metas, ->(object){where(object_class: object.class.to_s.gsub("Decorator",""))}, :class_name => "Meta", foreign_key: :objectid, dependent: :destroy
+  end
+  @meta_data = nil
+
+  # return collect meta for current model: Post, PostType, Categories, PostTag Site, User, Custom Fields
+  def meta
+    after_finding_meta
+    @meta_data
+  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)})
+    after_finding_meta(true)
+  end
+
+  # return value of meta with key: key,
+  # if meta not exist, return default
+  def get_meta(key, default = nil)
+    option = metas.where(key: key).first
+    if option.present?
+      value = JSON.parse(option.value) rescue option.value
+      (value.is_a?(Hash) ? value.to_sym : value) rescue option.value
+    else
+      default
+    end
+  end
+  # delete meta
+  def delete_meta(key)
+    option = metas.where(key: key).first
+    option.destroy if option.present?
+  end
+
+
+  # return configurations for current object, sample: {"type":"post_type","object_id":"127"}
+  def options
+    after_finding_meta
+    @meta_data[:_default] || {}
+  end
+  # add configuration for current object
+  # key: attribute name
+  # value: attribute value
+  def set_option(key, value = nil)
+    return if key.nil?
+    data = options
+    data[key] = fix_meta_var(value)
+    set_meta('_default', data)
+  end
+  # return configuration for current object
+  # key: attribute name
+  # default: if attribute not exist, return default
+  # return value for attribute
+  def get_option(key = nil, default = nil)
+    values = options.present? ? options : {}
+    key = key.to_sym
+    values.has_key?(key) ? values[key] : default
+  end
+  # delete attribute from configuration
+  def delete_option(key)
+    values = options
+    key = key.to_sym
+    values.delete(key) if values.has_key?(key)
+    set_meta('_default', values)
+  end
+
+  # set multiple configuration
+  # h: {ket1: "sdsds", ff: "fdfdfdfd"}
+  def set_multiple_options(h = {})
+    if h.present?
+      data = options
+      h.each do |key, value|
+        data[key] = fix_meta_var(value)
+      end
+      set_meta('_default', data)
+    end
+  end
+
+  # set multiple datas
+  # a: [{key: "sdsds", value: "fdfdfdfd"}, {key: "other", value: "texts"}]
+  # update: true => update data, false => create new data
+  def set_meta_data(a, update = false)
+    if a.present?
+      data = update ? meta[:set_meta_data] : {}
+      a.each do |row|
+        data[row[:key]] = fix_meta_var(row[:value])
+      end
+      set_meta('_set_meta_data', data)
+    end
+  end
+  # return meta data
+  def meta_data
+    meta[:_set_meta_data] || {}
+  end
+
+  private
+
+  def after_finding_meta(reset = false)
+    if @meta_data.nil? || reset
+      options = {}
+      if metas.count > 0
+        metas.all.each do |item|
+          options[item.key] = JSON.parse(item.value) rescue item.value
+        end
+      end
+      @meta_data = options.to_sym
+    end
+  end
+
+  def fix_meta_value(value)
+    if (value.is_a?(Array) || value.is_a?(Hash))
+      value = value.to_json
+    end
+    fix_meta_var(value)
+  end
+  def fix_meta_var(value)
+    if value.is_a?(String)
+      value = value.to_var
+    end
+    value
+  end
+
+end

data/app/models/concerns/metas_saved.rb

@@ -0,0 +1,10 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  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
+module MetasSaved extend ActiveSupport::Concern
+end

data/app/models/concerns/site_public.rb

@@ -0,0 +1,23 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  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
+module SitePublic
+  extend ActiveSupport::Concern
+
+  def get_post_type(key)
+    post_types.where(slug: key).first
+  end
+  def get_template_name
+    get_option('_theme', 'default')
+  end
+  def get_field(key)
+    get_field_value(key)
+  end
+
+
+end

data/app/models/custom_field.rb

@@ -0,0 +1,34 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  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")}
+  # 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
+
+  scope :configuration, -> {where(parent_id: -1)}
+  scope :visible_group, -> {where(status: nil)}
+
+  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

@@ -0,0 +1,121 @@
+=begin
+  Camaleon CMS is a content management system
+  Copyright (C) 2015 by Owen Peredo Diaz
+  Email: owenperedo@gmail.com
+  This program is free software: you can redistribute it and/or modify   it under the terms of the GNU Affero General Public License as  published by the Free Software Foundation, either version 3 of the  License, or (at your option) any later version.
+  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
+  # attrs required: name, slug, description
+  default_scope { where.not(object_class: '_fields').reorder('custom_fields.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
+  before_validation :before_validating
+
+  # ------------------- fields -----------------
+  # add fields to group
+  # item:
+  # -  sample:  {"name"=>"Label", "slug"=>"my_slug", "description"=>"my description (optional)"}
+  # -  options (textbox sample):  {"field_key":"text_box","multiple":"1","required":"1","translate":"1"}
+
+  # check all options for each case in Admin::CustomFieldsHelper
+  # for select, radio and checkboxes add:
+  # -- multiple_options: [{"title"=>"Option Title", "value"=>"2", "default"=>"1"}, {"title"=>"abcde", "value"=>"3"}]
+  # -- add default for default value
+
+  def add_manual_field(item, options)
+    c = get_field(item[:slug] || item["slug"])
+    return c if c.present?
+
+    field_item = self.fields.create!(item)
+    field_item.set_meta('_default', options)
+    auto_save_default_values(field_item, options)
+    field_item
+  end
+  alias_method :add_field, :add_manual_field
+
+  # return a field with slug = slug from current group
+  def get_field(slug)
+    self.fields.where(slug: slug).first
+  end
+
+  # only used by form on admin panel (protected)
+  def add_fields(items, item_options)
+    ids_old = self.fields.pluck('custom_fields.id')
+    ids_saved = []
+    order_index = 0
+    if items.present?
+      items.each do |i,item|
+        item[:field_order] = order_index
+        options = item_options[i] || {}
+        if item[:id].present?
+          field_item = self.fields.find(item[:id])
+          saved = field_item.update(item)
+        else
+          field_item = self.fields.new(item)
+          saved = field_item.save
+          auto_save_default_values(field_item, options) if saved
+        end
+        if saved
+          field_item.set_meta('_default', options)
+          ids_saved << field_item.id
+          order_index += 1
+        end
+      end
+    end
+    ids_deletes = ids_old - ids_saved
+    self.fields.where(id: ids_deletes).destroy_all if ids_deletes.present?
+  end
+
+  # generate the caption for this group
+  def get_caption
+    caption = ""
+    begin
+      case self.object_class
+        when "PostType_Post"
+          caption = "Fields for Contents in <b>#{self.site.post_types.find(self.objectid).decorate.the_title}</b>"
+        when 'PostType_Category'
+          caption = "Fields for Categories in <b>#{self.site.post_types.find(self.objectid).decorate.the_title}</b>"
+        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>"
+        when 'Theme'
+          caption = "Field settings for Theme <b>(#{self.objectid})</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
+          caption = "Fields for content <b>(#{p.the_title})</b>"
+        else # 'Plugin' or other class
+          caption = "Fields for <b>#{self.object_class}</b>"
+      end
+    rescue => e
+      Rails.logger.info "----------#{e.message}----#{self.attributes}"
+    end
+    caption
+  end
+
+  private
+  def before_validating
+    self.slug = "_group-#{self.name.to_s.parameterize}" unless self.slug.present?
+  end
+
+  # 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
+      else
+        owner = class_name.constantize.find(self.objectid) rescue 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
+  end
+end