Application_Form/app/models/application_form_signup.rb

# encoding: utf-8
class ApplicationFormSignup
  require 'openssl/cipher'
  include Mongoid::Document
  include Mongoid::Timestamps
  HiddenFields = ['ip', 'application_form_signup_id', 'password', 'status', 'reviewer_ids_list','_id', 'created_at', 'updated_at','application_form_main_id',"serial_number","final_session","final_sessions","preferred_sessions",'application_form_session_id',"application_form_session_ids","preferred_session","sort_number","abstract_number","presentation_type", "cipher_stage_num", "process_stage", "review_status", "agree_reviewer_ids", "agree_reviewer_times"]
  DefaultEnableFields = ['name','tel','phone','email', 'recaptcha']
  field :ip, type: String
  field :sort_number , type: Integer, default: 10000
  field :process_stage, type: Integer, default: 1
  field :review_status, type: Integer, default: 0 # 0 => 審核中, 1 => 不通過, 2=> 申請通過
  field :cipher_stage_num, type: Array, default: []
  field :status
  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: []
  field :reviewer_ids_list, type: Array, default: []
  field :agree_reviewer_ids, type: Hash, default: {}
  field :agree_reviewer_times, type: Hash, default: {}
  def reviewer_ids_list
    main = self.application_form_main
    main.reviewer_enables.each_with_index.collect do |e,k|
      if e
        if main.reviewer_type_list[k]=='fixed'
          main.reviewer_ids_list[k]
        else
          super()[k]
        end
      else
        nil
      end
    end
  end
  belongs_to :application_form_main
  field :application_form_session_id #only store old data , not used
  field :application_form_session_ids, type: Array, default: []
  has_many :application_form_signup_values, :autosave => true, :dependent => :destroy
  has_many :application_form_signup_contributes, :autosave => true, :dependent => :destroy
  
  accepts_nested_attributes_for :application_form_signup_values, allow_destroy: true
  accepts_nested_attributes_for :application_form_signup_contributes, allow_destroy: true
  scope :sort_ordered, ->{ order_by(:sort_number=>1,:created_at=>1) }

  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
    self.random_cipher(false)
    if self.application_form_main
      enable_idx = self.application_form_main.reviewer_enables.index(true)
      self.process_stage = enable_idx.nil? ? 0 : (enable_idx + 1)
    end
    if self.serial_number.nil?
      last_serial_number = ApplicationFormSetting.max(:last_serial_number).to_i
      self.serial_number = last_serial_number + 1
      ApplicationFormSetting.update_all({"$inc"=>{"last_serial_number"=>1}})
    end
  end
  after_destroy do
    application_form_main = self.application_form_main
    if application_form_main.present?
      application_form_reviews = application_form_main.application_form_reviews
      id = self.id.to_s
      application_form_reviews.each do |sr|
        if sr.all_application_form_signup_ids.include?(id)
          sr.application_form_signup_ids.delete(id)
          sr.remove_application_form_signup_ids.delete(id)
          sr.default_application_form_signup_ids.delete(id)
          sr.save
        end
      end
      if application_form_main.unassigned_application_form_signup_ids.delete(id)
        application_form_main.save
      end
    end
    application_form_session = ApplicationFormSession.where(:id=>self.application_form_session_id).first
    if application_form_session
      application_form_session.application_form_signup_ids.delete(self.id.to_s)
      application_form_session.save
    end
  end
  def clean_cipher
    self.update(:cipher_stage_num => [])
  end
  def random_cipher(save_flag=true)
    cipher = OpenSSL::Cipher::AES.new(128, :CBC)
    cipher.encrypt
    key = cipher.random_key
    iv = cipher.random_iv
    (1..5).each do |i|
      encrypted = cipher.update(i.to_s) + cipher.final
      self.cipher_stage_num << Base64.encode64(encrypted).strip()
    end
    self.save if save_flag
  end
  def update_process_stage(new_stage) #stage start from 0
    (0..new_stage - 1).each{|i| self.cipher_stage_num[i] = nil}
    new_stage = new_stage + 1
    self.process_stage = new_stage
    self.save
  end
  def procedure(agree_link=nil)
    stage_trans = I18n.t('application_form.stage')
    text = ""
    main = self.application_form_main
    tmp_process_idx = self.process_stage - 1
    if main
      main.reviewer_enables.each_with_index do |t, i|
        if t
          text += "<span>#{I18n.t("application_form.num.#{i + 1}")}#{stage_trans}: "
          if main.reviewer_type_list[i]=='fixed'
            member_ids = main.reviewer_ids_list[i]
            is_fixed = true
          else
            member_ids = self[:reviewer_ids_list][i] rescue []
            is_fixed = false
          end
          if member_ids.present?
            text += member_ids.map{|id| MemberProfile.find(id).name rescue nil}.compact.join(', ')
            if is_fixed
              text += " (#{I18n.t('application_form.fixed')})"
            else
              text += " (#{I18n.t('application_form.defined_by_applicant')})"
            end
          end
          if i == tmp_process_idx && self.review_status == 0 && agree_link
            text += "<a style=\"margin-left: 0.5em;\" class=\"btn btn-success agree_link\" href=\"#{agree_link}&type=agree\">#{I18n.t('application_form.link_choice.agree')}</a>"
            text += "<a style=\"margin-left: 0.5em;\" class=\"btn btn-danger disagree_link\" href=\"#{agree_link}&type=disagree\">#{I18n.t('application_form.link_choice.disagree')}</a>"
          end
          text += "</span><br>"
        end
      end
    end
    text
  end
  def review_progress(with_details=true, include_time=false)
    stage_trans = I18n.t('application_form.stage')
    max_stage = @max_stage
    if max_stage.nil?
      max_stage = self.application_form_main.get_max_stage
    end
    max_stage += 1
    text = "#{I18n.t('application_form.num.'+self.process_stage.to_s)}#{stage_trans}  / #{I18n.t('application_form.num.'+max_stage.to_s)}#{stage_trans} : #{I18n.t('application_form.status.'+review_status.to_s)}"
    if with_details
      text += "<br>"
      text += review_details(include_time)
    end
    text
  end
  def review_details(include_time=true)
    text = ""
    stage_trans = I18n.t('application_form.stage')
    last_is_disagree = (self.review_status == 1)
    last_idx = (self.process_stage - 1).to_s
    self.agree_reviewer_ids.each do |i, member_id|
      m = MemberProfile.find(member_id) rescue nil
      t = agree_reviewer_times[i]
      if m
        text += "#{I18n.t('application_form.num.'+(i.to_i+1).to_s)}#{stage_trans}: #{m.tmp_name} "
        if i == last_idx && last_is_disagree
          text += I18n.t('application_form.link_choice.disagree')
        else
          text += I18n.t('application_form.link_choice.agree')
        end
        if include_time && t
          text += " (#{t.to_time.strftime("%Y/%m/%d %H:%M")})"
        end
        text += "<br>"
      end
    end
    text
  end
  def get_reviewer_email(stage=self.process_stage, override_reviewer_ids_list=nil, only_email=false)
    stage = stage - 1
    if override_reviewer_ids_list.nil?
      override_reviewer_ids_list = self.reviewer_ids_list
    end
    member_ids = override_reviewer_ids_list[stage]
    if(only_email)
      return MemberProfile.where(:id.in=>member_ids).pluck(:email).select{|s| s.present?}.uniq
    else
      return MemberProfile.where(:id.in=>member_ids).pluck(:id,:email).select{|id,s| s.present?}.uniq{|id,s| s}
    end
  end
  def get_cipher_stage(stage)
    self.cipher_stage_num[stage - 1]
  end
  def get_stage_num(cipher)
    return self.cipher_stage_num.index(cipher)
  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.application_form_signup_contributes.pluck(:preferred_session)
    self.save
  end
  def get_display_fields
    application_form = self.application_form_main
    if application_form.nil?
      return []
    else
      locale = I18n.locale.to_s
      except_fields = ["password", "recaptcha"]
      all_fields = []
      if application_form.application_form_signup_field_sets.count != 0
        all_fields = application_form.application_form_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("application_form.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("application_form_signup.#{field_name}")
          if field_name == "status"
            I18n.t("application_form.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
      application_form.application_form_signup_fields.asc(:_id).each do |rf|
        application_form_signup_value = rf.application_form_signup_values.where(:application_form_signup_id=>self.id).last
        if application_form_signup_value
          value = application_form_signup_value.get_field_value rescue nil
          if value
            all_fields << value
          end
        end
      end
      return all_fields
    end
  end
end