seminar2/app/models/seminar_signup.rb

# encoding: utf-8
class SeminarSignup

  include Mongoid::Document
  include Mongoid::Timestamps
  HiddenFields = ['seminar_signup_id','_id', 'created_at', 'updated_at','seminar_main_id',"serial_number","final_session","final_sessions","preferred_sessions",'seminar_session_id',"seminar_session_ids","preferred_session","sort_number","abstract_number","presentation_type", "filename", "token", "reset_token"]
  DefaultEnableFields = ['status','name','tel','phone','email','password','recaptcha']
  field :sort_number , type: Integer, default: 10000

  field :status
  field :token
  field :is_confirmed, type: Boolean, default: false # for email confirmation
  field :signup_confirmed, type: Boolean, default: false
  field :is_confirmed_date, type: DateTime
  field :signup_confirmed_date, type: DateTime
  field :emails_sent, type: Array, default: []
  field :name # become Last Name for TICC
  field :tel, type: String # become First Name for TICC
  field :unit, localize: true #Only localize for preserving old record
  field :phone, type: String
  field :fax, type: String
  field :email, type: String
  field :address, localize: true
  field :password
  field :note, localize: true
  field :serial_number
  field :final_session #only store old data , not used
  field :final_sessions
  field :preferred_sessions, type: Array, default: []
  belongs_to :seminar_main
  field :seminar_session_id #only store old data , not used
  field :seminar_session_ids, type: Array, default: []
  has_many :seminar_signup_values, :autosave => true, :dependent => :destroy
  has_many :seminar_signup_contributes, :autosave => true, :dependent => :destroy

  accepts_nested_attributes_for :seminar_signup_values, allow_destroy: true
  accepts_nested_attributes_for :seminar_signup_contributes, allow_destroy: true
  scope :sort_ordered, ->{ order_by(:sort_number=>1,:created_at=>1) }
  after_destroy do
    if defined?(OrbitHelper::SharedMutex)
      OrbitHelper::SharedMutex.synchronize do
        seminar_id = self.seminar_main_id.to_s
        signup_count = OrbitHelper::SharedHash['seminar'][:counter][seminar_id]
        if signup_count
          signup_count -= 1
          OrbitHelper::SharedHash['seminar'][:counter][seminar_id] = signup_count
        end
      end
    end
  end
  before_create do
    unit = self.unit_translations.values.select{|v| v.present?}.first
    tmp_unit_translations = self.unit_translations
    self.unit_translations = I18n.available_locales.map do |l|
      l = l.to_s
      tmp = tmp_unit_translations[l]
      [l, (tmp ? tmp : unit)]
    end.to_h
    if self.serial_number.nil?
      # last_serial_number = SeminarMain.where(:id=>self.seminar_main_id).max(:last_serial_number).to_i
      # self.serial_number = last_serial_number + 1
      # SeminarMain.where(:id=>self.seminar_main_id).update_all({"$inc"=>{"last_serial_number"=>1}})
      self.serial_number = DateTime.now.to_i
    end
    self.token = SecureRandom.hex(5)
  end
  after_destroy do
    seminar_main = self.seminar_main
    if seminar_main.present?
      seminar_reviews = seminar_main.seminar_reviews
      id = self.id.to_s
      seminar_reviews.each do |sr|
        if sr.all_seminar_signup_ids.include?(id)
          sr.seminar_signup_ids.delete(id)
          sr.remove_seminar_signup_ids.delete(id)
          sr.default_seminar_signup_ids.delete(id)
          sr.save
        end
      end
      seminar_main.seminar_signups.delete(self) #avoid resave
      if seminar_main.unassigned_seminar_signup_ids.delete(id)
        seminar_main.save
      end
    end
    seminar_session = SeminarSession.where(:id=>self.seminar_session_id).first
    if seminar_session
      seminar_session.seminar_signup_ids.delete(self.id.to_s)
      seminar_session.save
    end
  end

  def generate_token
    token = SecureRandom.hex(5)
    self.token = token
    self.save
    return token
  end
  def display_serial_number
  	display_format_string(self.serial_number,4)
  end
  def display_format_string(num, str_length)
    return format("%0#{str_length}d", num)
  end
  def set_preferred_sessions
    self.preferred_sessions = self.seminar_signup_contributes.pluck(:preferred_session)
    self.save
  end
  def get_display_fields
    seminar = self.seminar_main
    if seminar.nil?
      return []
    else
      locale = I18n.locale.to_s
      except_fields = ["password", "recaptcha"]
      all_fields = []
      if seminar.seminar_signup_field_sets.count != 0
        all_fields = seminar.seminar_signup_field_sets.map do |set|
          field_name = set.field_name
          next if set.disabled || except_fields.include?(field_name)
          value = self.send(field_name) rescue nil
          localize = self.fields[field_name].options[:localize]
          next if value.nil? && !localize
          if field_name == "status"
            value = I18n.t("seminar.registration_status_#{value}")
          elsif localize && field_name != "unit"
            values = self.send("#{field_name}_translations").select{|k,v| v.present?}
            value = ""
            if values.count == 0
              next
            elsif values.count == 1
              value = values.values.first
            else
              last_idx = values.count - 1
              values.each_with_index do |(l, v), i|
                value += (I18n.t(l) + ": " + v )
                if i != last_idx
                  value += "<br>"
                end
              end
            end
          end
          {
            "field_name"=>field_name,
            "title"=>set.name[locale],
            "value"=> value
          }
        end.compact
      else
        field_names = self.class::DefaultEnableFields
        all_fields = field_names.map do |field_name|
          next if except_fields.include?(field_name)
          value = self.send(field_name) rescue nil
          next if value.nil?
          field_name_trans = I18n.t("seminar_signup.#{field_name}")
          if field_name == "status"
            I18n.t("seminar.registration_status_#{value}")
          elsif self.fields[field_name].options[:localize]
            values = self.send("#{field_name}_translations").select{|k,v| v.present?}
            value = ""
            if values.count == 0
              next
            elsif values.count == 1
              value = values.values.first
            else
              last_idx = values.count - 1
              values.each_with_index do |(l, v), i|
                value += (I18n.t(l) + ": " + v )
                if i != last_idx
                  value += "<br>"
                end
              end
            end
          end
          {
            "field_name"=>field_name,
            "title"=> field_name_trans,
            "value"=> value
          }
        end.compact
      end
      seminar.seminar_signup_fields.asc(:_id).each do |rf|
        seminar_signup_value = rf.seminar_signup_values.where(:seminar_signup_id=>self.id).last
        if seminar_signup_value
          value = seminar_signup_value.get_field_value rescue nil
          if value
            all_fields << value
          end
        end
      end
      return all_fields
    end
  end
end