orbit-basic/app/models/user/attribute_field.rb

class AttributeField
  include Mongoid::Document
  include Mongoid::Timestamps
  include ::AttributeFieldsHelper

  field :key
  field :af_count
  field :markup ,:default=>"text_field"
  field :option_list ,:type => Hash,:default => {}
  field :markup_options,:type => Hash
  field :built_in, :type => Boolean, :default => false
  field :disabled, :type => Boolean, :default => false
  field :to_delete,:type=> Boolean,:default => false
  
  field :to_search,:type=> Boolean,:default => false
  
  field :typeA,:type=> Hash,:default=>{:cross_lang=>false}
  field :typeB,:type=> Hash,:default=>{}
  field :typeC,:type=> Hash,:default=>{:calendar=>"west_calendar",:format=>"format3"}
  field :typeD,:type=> Hash,:default=>{:cross_lang=>false}
  field :typeE,:type=> Hash,:default=>{}
  field :title, localize: true
  
  belongs_to :attribute
  has_many :attribute_values,:autosave => true, :dependent => :destroy
  before_save :check_option_list

  def markup_value
    get_data["option_list"]
  end

  def add_more
     (get_data["add_more"] == "true" ? true : false) rescue false
  end

  def locale
    get_data["cross_lang"] == "true" ? false : true
  end

  def self_defined_markup_options?
    (self.attribute.role.method(self[:key].pluralize.to_sym)  && self.attribute.role.method(self[:key].pluralize+"_for_"+markup)) rescue false
  end

  def option_list
    if self_defined_markup_options?
      #Class need to have corresponding field and value agent 
     # Ex: For "status" the class must have field called "statuses" for the relation and "statuses_for_select" for the select function 
     method = self.attribute.role.method(self[:key].pluralize+"_for_"+markup)
      return  (method.call rescue {})
    elsif self[:option_list].nil?  || (self[:option_list].empty?)
      return {}
    else
      return self[:option_list]
    end
  end

  def markup_options=(var)
    self[:markup_options] = (eval(var)  rescue {})
  end

  def markup_options
    if self[:markup_options].nil?
      return {}
    else
      Hash[self[:markup_options].map{|key,val|[key.to_sym,val]}]  rescue {}
    end

  end

  def role
    self.attribute.role 
  end

  def panel
    panel  = LIST[:markups][self[:markup]]["panel"]
  end

  def get_data
    self[panel]
  end



  def typeA=(var)
    check_add_more_convert(var)
    check_cross_lang_convert(var,"typeA")
    self["typeA"] = var
  end

  def typeD=(var)
    check_cross_lang_convert(var,"typeD")
    self["typeD"] = var
  end

  def is_built_in?
    self.built_in
  end
  
  def is_disabled?
    self.disabled
  end

protected
  def check_option_list
    self[:option_list] = self[panel]["option_list"] rescue nil
  end

  def add_more_convert(opt) 
    # case opt
    # when :to_add_more
    #   self.attribute_values.each  do |av|
    #     VALID_LOCALES.each  do |loc|
    #       splited_str = av[loc].split(",") rescue []
    #       av["val"] = [] if av["val"].nil? 

    #       old_data = av["val"]
    #       av["val"] = [] 
    #       splited_str.each_with_index do |value,index| 
    #         av["val"][index] =   {loc=>value} 
    #       end
    #       av["val"] << old_data
    #     end
    #     av.unset_all_lang_values
    #     av.save
    #   end #of self.attribute_values.each
    # when :to_no_add_more
    #   self.attribute_values.each  do |av|
    #     VALID_LOCALES.each  do |loc|
    #       binding.pry
    #       if av["val"].kind_of? Array
    #        av[loc] = av["val"].collect{|t| t[loc]}.join(",")
    #       else
    #         av[loc] = av["val"]
    #       end
    #     end
    #     av.unset("val")
    #     av.save
    #   end #of self.attribute_values.each
    # end
  end

  def cross_lang_convert(opt) 
    # case opt
    # when :to_cross_lang
    #   self.attribute_values.each  do |av| 
    #     if add_more
    #       av["val"] = av["val"].collect{|t| t.invert.keys.join(",")}
    #     else
    #       av["val"] = VALID_LOCALES.collect{|t| av[t]}.join(",") 
    #       av.unset_all_lang_values 
    #     end
    #     av.save
    #   end #of self.attribute_values.each
    # when :to_no_cross_lang
    #   default_locale = I18n.default_locale.to_s
    #   self.attribute_values.each  do |av|
    #     if add_more
    #       av["val"] = av["val"].collect{|t| {default_locale => t} } #unless av["val"].nil?
    #     else
    #       av[default_locale] = av["val"]
    #       av.unset("val") 
    #     end
    #     av.save
    #   end #of self.attribute_values.each
    # end
  end

  def check_add_more_convert(var)
    if self["typeA"]["add_more"] != var["add_more"]
      case var["add_more"]
      when "true"  #from no-add_more to add_more
        add_more_convert(:to_add_more)  
      else #from add_more to no-add_more
        add_more_convert(:to_no_add_more)
      end # of case
    end # of if
  end

  def check_cross_lang_convert(var,field)
    if self[field]["cross_lang"] != var["cross_lang"]
      case var["cross_lang"]
      when "true"  #from no-add_more to add_more
        cross_lang_convert(:to_cross_lang)  
      else #from add_more to no-add_more
        cross_lang_convert(:to_no_cross_lang)
      end # of case
    end # of if
  end

end