class RecruitmentsController < PseudoSessionController
  include ActionView::Helpers::TextHelper
  before_filter :set_key_for_this, :except => ["index", "show"]
  before_filter :load_profile, :except => ["newprofile", "createprofile", "index", "show", "advancedform"]
  before_filter :is_user_authorized?, :except => ["index", "show", "advancedform", "write_recommendation", "create_recommendation"]
  layout :get_layout
  
  def index
    params = OrbitHelper.params
    if params[:page_id] == "jobs"
      load_jobs(params, "type1")
    elsif params[:page_id] == "internships"
      load_jobs(params, "type2")
    elsif params[:page_id] == "exchanges"
      load_jobs(params, "type3")
    elsif params[:page_id] == "candidates"
      load_candidates(params)
    end
  end

  def load_candidates(params)
    data = []
    if params[:type].present? && params[:type] == "aq"
      candidates = advanced_filter_candidates(params)
      criteria = "<span class='criteria'><i>-</i></span> <span class='reset-search'><a href='#{params[:url].gsub("/","")}'><i class='fa fa-refresh' aria-hidden='true'></i></a></span>"
    elsif params[:q].present?
      candidates = filter_candidates(params)
      criteria = "<span class='criteria'><i>- " + params[:q] + "</i></span> <span class='reset-search'><a href='#{params[:url].gsub("/","")}'><i class='fa fa-refresh' aria-hidden='true'></i></a></span>"
    else
      criteria = ""
      candidates = EmployeeProfile.job_seekers
    end
    if !candidates.nil? && !candidates.is_a?(Array)
      candidates = candidates.desc(:updated_at).page(OrbitHelper.page_number).per(OrbitHelper.page_data_count)
      total_pages = candidates.total_pages
    else
      candidates = []
      total_pages = 0
    end
    candidates.each do |candidate|
      company = !candidate.current_company.nil? && candidate.current_company != "" ? candidate.current_company : (candidate.get_current_exp.company_name rescue nil)
      company = "N/A" if company.nil?
      if candidate.experience_years == 0 && candidate.experience_months == 0
        wey = t("recruitment.fresher")
        wem = ""
      else
        wey = (candidate.experience_years.to_s rescue "0") + " year(s)"
        wem = (candidate.experience_months.to_s rescue "0") + " month(s)"
      end
      data << {
        "name" => candidate.recruit_profile.name, 
        "designation" => candidate.desired_job_title,
        "company_name" => company,
        "location" => candidate.desired_place,
        "url_to_show" => OrbitHelper.url_to_show(candidate.recruit_profile.to_param),
        "work_experience_years" => wey,
        "work_experience_months" => wem,
        "introduction" => candidate.introduction,
        "skills" => candidate.skills.collect{|skill| {"skill-tag" => skill}},
        "avatar" => candidate.get_avatar
      }
    end
    {
      "candidates" => data,
      "extras" => {
        "criteria" => criteria,
        "advanced-search" => t("recruitment.advanced_search")
      },
      "total_pages" => total_pages
    }
  end

  def load_jobs(params, type)
    jobs = []
    if params[:type].present? && params[:type] == "aq"
      rjobs = advanced_filter_jobs(params,type)
      criteria = "<span class='criteria'><i>-</i></span> <span class='reset-search'><a href='#{params[:url].gsub("/","")}'><i class='fa fa-refresh' aria-hidden='true'></i></a></span>"
    elsif params[:q].present?
      rjobs = filter_jobs(params, type)
      criteria = "<span class='criteria'><i>- " + params[:q] + "</i></span> <span class='reset-search'><a href='#{params[:url].gsub("/","")}'><i class='fa fa-refresh' aria-hidden='true'></i></a></span>"
    else
      criteria = ""
      rjobs = RecruitmentJob.where(:post_type => type).not_filled
    end
    if !rjobs.nil? && !rjobs.is_a?(Array)
      rjobs = rjobs.desc(:created_at).page(OrbitHelper.page_number).per(OrbitHelper.page_data_count)
      total_pages = rjobs.total_pages
    else
      rjobs = []
      total_pages = 0
    end
    rjobs.each do |rj|
      if rj.work_experience_years == 0 && rj.work_experience_months == 0
        wey = t("recruitment.fresher")
        wem = ""
      else
        wey = (rj.work_experience_years.to_s rescue "0") + " year(s)"
        wem = (rj.work_experience_months.to_s rescue "0") + " month(s)"
      end
      jobs << {
        "company_name" => rj.employer_profile.company_name,
        "industry" => rj.employer_profile.get_industry,
        "avatar" => rj.employer_profile.get_avatar,
        "title" => rj.job_title,
        "url_to_show" => OrbitHelper.url_to_show(rj.to_param),
        "description" => simple_format(truncate(rj.job_description, :length => 50)),
        "postdate" => rj.created_at,
        "work_type" => rj.work_type,
        "location" => rj.location_of_work,
        "work_experience_years" => wey,
        "work_experience_months" => wem,
        "category" => rj.category,
        "post-type" => rj.get_post_type_label,
        "skills" => rj.skills.collect{|skill| {"skill-tag" => skill}}
      }
    end
    {
      "jobs" => jobs,
      "extras" => {
        "criteria" => criteria,
        "advanced-search" => t("recruitment.advanced_search")
      },
      "total_pages" => total_pages
    }
  end

  def show
    params = OrbitHelper.params
    if params[:page_id] == "jobs" || params[:page_id] == "internships" || params[:page_id] == "exchanges"
      show_job(params)
    elsif params[:page_id] == "candidates"
      show_candidate(params)
    end
  end

  def check_session
    page = Page.where(:module => "pseudo_member").first
    session = OrbitHelper.request.session
    available = session[:current_pseudo_user_id].present? && !session[:current_pseudo_user_id].nil? ? "true" : "false"
    {
      "session" => available,
      "url" => "/" + I18n.locale.to_s + page.url,
      "type" => OrbitHelper.params[:page_id]
    }
  end

  def show_candidate(params)
    rp = RecruitProfile.where(:uid => params[:uid]).first
    profile = rp.profile
    if (profile.country_code.nil? || profile.country_code == "") && (profile.phone_number.nil? || profile.phone_number == "")
      phone = t("recruitment.not_available")
    else
      phone = !profile.country_code.nil? ? "+" + profile.country_code + " - " + profile.phone_number : profile.phone_number
    end
    skills = []
    skills = profile.skills.collect{|skill| {"skill-name" => skill}} if !profile.skills.empty?
    infos = []
    ["autobiography", "resume_content"].each do |t|
      if !profile.send(t).nil? && profile.send(t) != ""
        infos << {
          "title" => t("recruitment.#{t}"),
          "text" => simple_format(profile.send(t))
        }
      end
    end

    recommendations = []
    profile.employee_recommendations.desc(:created_at).each do |rec|
      t = {
        "name" => rec.name,
        "email" => rec.email,
        "rec-letter" => rec.info
      }
      
      t["download-file"] =  !rec.file.nil? && !rec.file.url.nil? ? "<a href='#{rec.file.url}' target='_blank'>#{t("recruitment.download_file")}</a>" : ""

      recommendations << t
    end

    academics = []
    profile.employee_academics.each do |aca|
      academics << {
        "title" => (t("recruitment.academic_type.#{aca.academic_type}") + " " + t("recruitment.in") + " " + aca.degree_name),
        "period" => aca.period,
        "note" => aca.note
      }
    end

    experiences = []
    profile.employee_experiences.asc(:end_date).each do |exp|
      experiences << {
        "job-title" => exp.job_title,
        "company-name" => exp.company_name,
        "period" => exp.period,
        "responsibilities" => exp.responsibilities
      }
    end

    if profile.experience_years == 0 && profile.experience_months == 0
      experience = t("recruitment.fresher")
    else
      experience = (profile.experience_years.to_s rescue "0") + " year(s) " + (profile.experience_months.to_s rescue "0") + " month(s)"
    end

    {
      "skills" => skills,
      "infos" => infos,
      "academics" => academics,
      "experiences" => experiences,
      "recommendations" => recommendations,
      "data" => {
        "name" => rp.name,
        "job-title" => profile.desired_job_title,
        "company-name" => profile.current_company,
        "phone" => phone,
        "email" => rp.email,
        "website" => profile.website,
        "avatar" => profile.get_avatar,
        "resume-url" => (profile.resume.url rescue ""),
        "resume-text" => t("recruitment.resume_text"),
        "location-title" => t("recruitment.location"),
        "location" => profile.desired_place,
        "experience-title" => t("recruitment.experience_title"),
        "experience" => experience,
        "gender-title" => t("recruitment.gender_title"),
        "gender" => t("recruitment.gender.#{profile.gender}"),
        "martial-title" => t("recruitment.martial_title"),
        "martial" => (!profile.marital_status.nil? && profile.marital_status != "" ? t("recruitment.martial.#{profile.marital_status}") :  t("recruitment.not_available")),
        "language-title" => t("recruitment.language_title"),
        "language" => profile.languages,
        "workingtime-title" => t("recruitment.workingtime_title"),
        "workingtime" => (!profile.working_time.nil? && profile.working_time != "" ? t("recruitment.working_time.#{profile.working_time}") : t("recruitment.not_available")),
        "recommendation-title" => t("recruitment.recommendation")
      }
    }
  end

  def show_job(params)
    job = RecruitmentJob.where(:uid => params[:uid]).first
    profile = job.employer_profile
    infos = []
    if !profile.company_profile.nil? && profile.company_profile != ""
      infos << {
        "title" => t("recruitment.company_profile"),
        "text" => simple_format(profile.company_profile)
      }
    end
    ["job_description", "other_conditions"].each do |jj|
      if !job.send(jj).nil? && job.send(jj) != ""
        infos << {
          "title" => t("recruitment.#{jj}"),
          "text" => simple_format(job.send(jj))
        }
      end
    end
    if !job.skills.empty?
      skills = job.skills.collect{|skill| "<span class='label label-default'>#{skill}</span>"}
      skills = skills.join(" ")
    else
      skills = t("recruitment.not_available")
    end

    if job.work_experience_years == 0 && job.work_experience_months == 0
      experience = t("recruitment.fresher")
    else
      experience = (job.work_experience_years.to_s rescue "0") + " year(s) " + (job.work_experience_months.to_s rescue "0") + " month(s)"
    end
    if !job.holiday_system.nil? || job.holiday_system != ""
      if job.holiday_system == "type2" && !job.holiday_system_other.nil? && job.holiday_system_other != ""
        holiday = job.holiday_system_other
      else
        holiday = t("recruitment.holiday_system.#{job.holiday_system}")
      end
    else
      holiday = t("recruitment.not_available")
    end
    session = OrbitHelper.request.session
    applybtn = ""
    if session[:current_pseudo_user_id].present? && !session[:current_pseudo_user_id].nil?
      pu = PseudoUser.find(session[:current_pseudo_user_id])  rescue nil
      current_loggedin_user = RecruitProfile.where(:pseudo_member_id => pu.user_name).first rescue nil
      if !current_loggedin_user.nil? && current_loggedin_user.is_employee?
        if !current_loggedin_user.profile.is_job_applied?(job.id.to_s)
         applybtn = "<a href='#' id='jobApplicationBtn' class='btn btn-primary'>#{"recruitment.apply"}</a>"
       else
         applybtn = "<a href='#' disabled='disabled' class='btn btn-success'>#{"recruitment.already_applied"}</a>"
       end
      end
    end
    if job.max_salary > job.min_salary
      range = (job.min_salary * 1000).to_s + " ~ " + (job.max_salary * 1000).to_s + " / Month "
    elsif job.max_salary == job.min_salary
      range = t("recruitment.not_available")
    elsif job.max_salary < job.min_salary
      range = (job.min_salary * 1000).to_s + " ~ #{t('recruitment.salary.type1')} / Month"
    end
    if job.internship_duration > 0
      duration = job.internship_duration.to_s + " #{t("recruitment.months")}"
    end
    if job.part_time?
      parttime = "<span class='label label-primary'>#{t("recruitment.internship_part_time")}<span>"
    end

    {
      "infos" => infos,
      "data" => {
        "post-type" => job.get_post_type_label,
        "part-time" => parttime,
        "exchange-duration-title" => t("recruitment.exchange_duration"),
        "min-credit-title" => t("recruitment.min_credit_score"),
        "min-credit" => (job.min_credit_score > 0 ? job.min_credit_score : t("recruitment.not_available")),
        "exchange-start-title" => t("recruitment.exchange_start_date"),
        "exchange-start" => (job.exchange_start_date.nil? ? t("recruitment.not_available") : job.exchange_start_date ),
        "internship-duration-title" => t("recruitment.internship_duration"),
        "internship-duration" => duration,
        "perks-title" => t("recruitment.perks_title"),
        "perks" => (job.perks.nil? || job.perks != "" ? t("recruitment.perks.#{job.perks}") : t("recruitment.not_available")),
        "job-title" => job.job_title,
        "job-category" => job.get_category,
        "avatar" => profile.get_avatar,
        "company-name" => profile.company_name,
        "industry" => profile.get_industry,
        "post-date" => job.created_at,
        "location-title" => t("recruitment.location"),
        "location" => (!job.location_of_work.nil? && job.location_of_work != "" ? job.location_of_work : t("recruitment.not_available")),
        "skills-title" => t("recruitment.skills_title"),
        "skills" => skills,
        "experience-title" => t("recruitment.experience_title"),
        "experience" => experience,
        "min-qualification-title" => t("recruitment.min_qualification"),
        "min-qualification" => (!job.academic_type.nil? && job.academic_type != "" ? t("recruitment.academic_type.#{job.academic_type}") : t("recruitment.not_available")),
        "qualification-title" => t("recruitment.qualification"),
        "qualification" => (!job.academic_requirement.nil? && job.academic_requirement != "" ? simple_format(job.academic_requirement) : t("recruitment.not_available")),
        "salary-title" => t("recruitment.salary-title"),
        "salary" => (!job.salary.nil? && job.salary != "" ? t("recruitment.salary.#{job.salary}") : t("recruitment.not_available")),
        "salary-range" => t("recruitment.salary_range"),
        "range" => range,
        "travel-title" => t("recruitment.travel"),
        "travel" => (!job.travel_assignment.nil? && job.travel_assignment != "" ? t("recruitment.travel_assignment.#{job.travel_assignment}") : t("recruitment.not_available")),
        "joining-title" => t("recruitment.joining"),
        "joining" => (!job.joining_time.nil? && job.joining_time != "" ? t("recruitment.joining_time.#{job.joining_time}") : t("recruitment.not_available")),
        "worktype-title" => t("recruitment.worktype_title"),
        "worktype" => (!job.work_type.nil? && job.work_type != "" ? t("recruitment.work_type.#{job.work_type}") : t("recruitment.not_available")),
        "language-title" => t("recruitment.language"),
        "language" => (!job.language_requirement.nil? && job.language_requirement != "" ? job.language_requirement : t("recruitment.not_available")),
        "workingtime-title" => t("recruitment.workingtime_title"),
        "workingtime" => (!job.working_time.nil? && job.working_time != "" ? t("recruitment.working_time.#{job.working_time}") : t("recruitment.not_available")),
        "holiday-title" => t("recruitment.holiday_title"),
        "holiday" => holiday,
        "apply-btn" => applybtn,
        "job-id" => job.id.to_s
      }
    }
  end

  def firstruncheck 
    if @profile.nil?
      redirect_to select_profile_path
    else
      redirect_to mydashboard_path
    end
  end

  def job_applications
    if @profile.is_employee? || @profile.profile.recruitment_jobs.where(:id => params[:id]).count == 0
      redirect_to mydashboard_path and return
    end
    @applications = EmployeeJobApplication.where(:job => params[:id]).not_archived.desc(:created_at)
  end

  def archive_application
    eja = EmployeeJobApplication.find(params[:id])
    eja.archived = true
    eja.save
    redirect_to "/recruit/#{eja.id.to_s}/job_applications"
  end

  def advancedform
    @industries = RecruitmentIndustry.all.asc(:industry_title).collect{|ri| [ri.industry_title, ri.id]}
    @categories = RecruitmentCategory.all.asc(:job_category).collect{|ri| [ri.job_category, ri.id]}
    @locations = RecruitmentJob.all.asc(:location_of_work).pluck(:location_of_work).uniq
    render :layout => false
  end

  def applyjob
    if @profile.is_employee?
      eja = EmployeeJobApplication.new
      eja.job = params[:job_id]
      eja.cover_letter = params[:cover_letter]
      eja.employee_profile_id = @profile.profile.id
      eja.save
    end
    redirect_to mydashboard_path
  end

  def select_profile
  end

  def newprofile
    @profile = RecruitProfile.new
    if params[:type] == "1"
      @profile.build_employee_profile
    elsif params[:type] == "2"
      @profile.build_employer_profile
    end
  end

  def createprofile
    profile = RecruitProfile.create(profile_params)
    if profile.is_employer?
      redirect_to mydashboard_path
    elsif profile.is_employee?
      if params[:commit] == "Next" && params[:step] == "step1"
        redirect_to employee_academics_path
      elsif params[:commit] == "Save"
        redirect_to mydashboard_path
      end
    end
  end

  def employee_academics
    @academic = EmployeeAcademic.new
    @academics = @profile.profile.employee_academics
    @academic_types = ["type1","type2","type3","type4"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  def edit_employee_academic
    @academic = EmployeeAcademic.find(params[:id])
    @academic_types = ["type1","type2","type3","type4"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  def update_academic
    academic = EmployeeAcademic.find(params[:id])
    academic.update_attributes(employee_academic_params)
    redirect_to employee_academics_path
  end

  def create_academic
    if params[:commit] == "Add"
      academic = EmployeeAcademic.create(employee_academic_params)
      redirect_to employee_academics_path
    elsif params[:commit] = "Next"
      if params[:employee_academic][:degree_name].present?
        academic = EmployeeAcademic.create(employee_academic_params)
      end
      redirect_to employee_portfolio_path
    end
  end

  
  def employee_portfolio
  end

  def recruitment_dashboard
    if @profile.is_employer?
      @jobsposted = @profile.profile.recruitment_jobs.desc(:created_at)
    elsif @profile.is_employee?
      @applications = @profile.profile.employee_job_applications.desc(:created_at)
    end
  end

  def editprofile
  end

  def updateprofile
    @profile.update_attributes(profile_params)
    if @profile.is_employer?
      redirect_to mydashboard_path
    elsif @profile.is_employee?
      if params[:commit] == "Next" 
        if params[:step] == "step3"
          redirect_to employee_experience_path
        elsif params[:step] == "step1"
          redirect_to employee_academics_path
        end
      elsif params[:commit] == "Save"
        redirect_to mydashboard_path
      end
    end
  end

  def employee_experience
    @exeperiences = @profile.employee_profile.employee_experiences.desc(:created_at)
    @experience = EmployeeExperience.new
  end

  def create_experience
    if params[:commit] == "Add"
      academic = EmployeeExperience.create(employee_exp_params)
      redirect_to employee_experience_path
    elsif params[:commit] = "Finish"
      if params[:employee_experience][:job_title].present? || params[:employee_experience][:company_name].present?
        academic = EmployeeExperience.create(employee_exp_params)
      end
      redirect_to mydashboard_path
    end
  end

  def employee_recommendation
    @recommendations = @profile.profile.employee_recommendations.desc(:created_at)
    if request.request_method == "POST"
      token = rand(10**8).to_s
      eprofile = @profile.profile
      eprofile.recommendation_tokens << token
      eprofile.save
      url = "http://#{request.host_with_port}/recruit/#{@profile.uid}/write_recommendation?token=#{token}"
      data = {"url" => url, "letter" => params[:request_letter], "referral_name" => params[:referral_name], "name" => @profile.name, "respected" => t("recruitment.respected"), "recommendation_link" => t("recruitment.recommendation_link"), "yours_sincerely" => t("recruitment.yours_sincerely")}
      email = Email.new
      email.mail_to = params[:referral_email]
      email.mail_subject = t("recruitment.recommendation_subject")
      email.template = "recruitments/recommendation_email.html.erb"
      email.template_data = data
      email.deliver
      redirect_to employee_recommendation_path
    end
  end

  def write_recommendation
    @profile = RecruitProfile.where(:uid => params[:id]).first
    @is_written = @profile.profile.employee_recommendations.where(:employee_recommendation_token => params[:token]).count > 0
    @recommendation = EmployeeRecommendation.new
  end

  def create_recommendation
    if request.request_method == "POST"
      rec = EmployeeRecommendation.create(recommendation_params)
    end
  end

  def delete_employee_recommendation
    rec = EmployeeRecommendation.find(params[:id])
    rec.destroy
    redirect_to employee_recommendation_path
  end

  def edit_employee_experience
    @experience = EmployeeExperience.find(params[:id])
  end

  def update_exmployee_experience
    experience = EmployeeExperience.find(params[:id])
    experience.update_attributes(employee_exp_params)
    redirect_to employee_experience_path
  end

  def addjob
    @job = RecruitmentJob.new
    @academic_types = ["type1","type2","type3"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  def editjob
    @job = RecruitmentJob.find(params[:id])
    @academic_types = ["type1","type2","type3"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  def createjob
    job = RecruitmentJob.create(recruitment_job_params)
    redirect_to mydashboard_path
  end

  def updatejob
    job = RecruitmentJob.find(params[:id])
    job.update_attributes(recruitment_job_params)
    redirect_to mydashboard_path
  end

  def markfilled
    job = RecruitmentJob.find(params[:id])
    if job.employer_profile_id.to_s == @profile.profile.id.to_s
      job.filled = true
      job.save
    end
    redirect_to mydashboard_path
  end

  def unmarkfilled
    job = RecruitmentJob.find(params[:id])
    if job.employer_profile_id.to_s == @profile.profile.id.to_s
      job.filled = false
      job.save
    end
    redirect_to mydashboard_path
  end

  def deletejob
    job = RecruitmentJob.find(params[:id])
    job.destroy
    redirect_to mydashboard_path
  end


  # ------ ------ internship ------ ------- #

  def addinternship
    @job = RecruitmentJob.new
    @academic_types = ["type1","type2","type3"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  def editinternship
    @job = RecruitmentJob.find(params[:id])
    @academic_types = ["type1","type2","type3"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  # ------ ------ exchange ------ ------- #

  def addexchange
    @job = RecruitmentJob.new
    @academic_types = ["type1","type2","type3"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  def editexchange
    @job = RecruitmentJob.find(params[:id])
    @academic_types = ["type1","type2","type3"].collect{|t| [t("recruitment.academic_type.#{t}"), t]}
  end

  # ------ ------ account settings ------ ------- #
  def account_settings
  end

  def update_settings
    pu = PseudoUser.where(:user_name => @profile.pseudo_member_id).first
    if pu.update_password(params[:password],params[:password_confirmation])
      redirect_to mydashboard_path
    else
      redirect_to account_settings_path(:err => "1")
    end
  end

  private

  def filter_jobs(params, type)
    rjobs = []

    keywords = params[:q].split(",").collect{|s| /#{s.strip}/i}
    companies = EmployerProfile.where(:company_name.in => keywords).pluck(:id)
    skills = RecruitmentJob.where(:post_type => type).where(:skills.in => keywords)
    designations = RecruitmentJob.where(:post_type => type).where(:job_title.in => keywords)
    query = []
    if companies.count > 0
      query << {:employer_profile_id.in => companies}
    end
    if skills.count > 0
      query << {:skills.in => keywords}
    end
    if designations.count > 0
      query << {:job_title.in => keywords}
    end
    if !query.empty?
      rjobs =  RecruitmentJob.where(:post_type => type).any_of(query).not_filled
    end
    rjobs
  end

  def advanced_filter_jobs(params, type)
    if params[:q].present?
      rjobs = filter_jobs(params, type)
    else
      rjobs = []
    end
    query = []
    if params[:exp].present?
      if params[:exp].to_i > 0
        query << {:work_experience_years.gte => params[:exp].to_i}
      else
        query << {:work_experience_years => params[:exp]}
      end
    end
    if params[:industry].present?
      companies = EmployerProfile.where(:industry => params[:industry]).pluck(:id)
      if companies.count > 0
        query << {:employer_profile_id.in => companies}
      end
    end
    if params[:category].present?
      query << {:category => params[:category]}
    end
    if params[:location].present?
      query << {:location_of_work => /#{params[:location]}/i}
    end
    if !query.empty?
      if !rjobs.empty?
        rjobs = rjobs.where(query.reduce({}, :merge))
      else
        rjobs = RecruitmentJob.where(:post_type => type).where(query.reduce({}, :merge))
      end
    end
    rjobs
  end

  def filter_candidates
  end

  def advanced_filter_candidates
  end

  def get_layout
    "recruit"
  end

  def load_profile
    @profile = RecruitProfile.where(:pseudo_member_id => current_pseudo_user.user_name).first rescue nil
  end

  def profile_params
    par = params.require(:recruit_profile).permit!
    if par[:employee_profile_attributes].present? && par[:employee_profile_attributes][:skills].present?
      par[:employee_profile_attributes][:skills] = par[:employee_profile_attributes][:skills].split(",") 
      par[:employee_profile_attributes][:skills].collect!{|sk| sk.strip}
    end
    # debugger
    par
  end

  def employee_academic_params
    params.require(:employee_academic).permit!
  end

  def employee_exp_params
    params.require(:employee_experience).permit!
  end

  def recruitment_job_params
    par = params.require(:recruitment_job).permit!
    if par[:skills].present? 
      par[:skills] = par[:skills].split(",") 
      par[:skills].collect!{|sk| sk.strip}
    elsif par[:skills] == ""
      par[:skills] = []
    end
    par
  end

  def recommendation_params
    params.require(:employee_recommendation).permit!
  end

end