seminar/app/models/seminar_submission_field.rb

class SeminarSubmissionField
  include Mongoid::Document
  include Mongoid::Timestamps
  include Mongoid::Attributes::Dynamic
  include ::AttributeFieldsHelper
  include ::Admin::SeminarsFieldHelper

  field :key, type: String
  # field :af_count
  field :title, type: String, localize: true
  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_require,type: Boolean, default: true
  
  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 :typeF, type: Hash, default: {cross_lang: "true"}
  belongs_to :seminar_main
  has_many :seminar_submission_values, autosave: true, dependent: :destroy
  accepts_nested_attributes_for :seminar_submission_values, :allow_destroy => true
  before_save :check_option_list
  before_save do |record|
    record.instance_variable_set(:@key_changed, record.key_changed?)
    true
  end
  after_save do |record|
    if record.instance_variable_get(:@key_changed)
      record.seminar_submission_values.update_all(:key=>record.key)
    end
  end
  def get_basic_field_name_org
    "seminar_submission_values"
  end

  def get_basic_field_name
    "seminar_submission_field"
  end
  def block_helper(member,index,disable = false,attribute_type=nil,con_field=nil, to_require=true,rf)
    unless self.disabled
      @index = index
      @require = to_require
      @markup_options = markup_options.merge(:disabled=>disable, :required => to_require)
      @member = member
      if !(con_field.seminar_submission_values.nil?) && con_field.seminar_submission_values!=[]
        @attribute_value = con_field.seminar_submission_values.select{|v| v.seminar_submission_field_id.to_s==rf.id.to_s}[0]
      else
        @attribute_value = nil
      end
      @attribute_type = attribute_type
      @new_attribute = @attribute_value.nil?
      @prefiled_value = @attribute_value.value rescue nil
      html = (instance_eval("render_#{markup}") rescue "")
      return html
    end
  end

  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.seminar.method(self[:key].pluralize.to_sym)  && self.seminar.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.seminar.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 panel
    panel  = $seminar_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

  def self.add_seminar_signup_field(seminar,seminar_param, seminar_submission_field_id=nil,field_status)
    @field_name = 'seminar'
    if field_status.eql?(true)
      @seminar_submission_field = self.find(seminar_submission_field_id) rescue nil
      if @seminar_submission_field.nil?
        @seminar_submission_field = seminar.seminar_submission_fields.build(seminar_param)
        @seminar_submission_field.save
      else
        @seminar_submission_field.update(seminar_param)
      end
    else
      @seminar_submission_field = seminar.seminar_submission_fields.build(seminar_param)
      @seminar_submission_field.save
    end
    return @seminar_submission_field
  end

  protected

  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

   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 cross_lang_convert(opt) 
    
  end

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

  def add_more_convert(opt) 

  end

end