personal_certificate/app/controllers/personal_certificates_controller.rb

class PersonalCertificatesController < ApplicationController
	include Admin::CertificatesHelper
	def index
		params = OrbitHelper.params
		certificates = Certificate.sort_for_frontend
		page = OrbitHelper.page rescue Page.where(page_id: params[:page_id]).first
		title_is_paper_format = false
		fields_to_show = page.custom_array_field rescue []
		if fields_to_show.blank?
			fields_to_show = ["year", "issue_date", "title", "member_profile"]
		end
		if params[:keywords].present?
			certificates = filter_keywords(certificates,params[:selectbox],params[:keywords])
		end
		certificates = certificates.page(params[:page_no]).per(OrbitHelper.page_data_count)
		certificates_list = certificates.collect do |certificate|
			{'jps' => fields_to_show.map{|field| {"value"=> get_display_field(certificate,field, title_is_paper_format)}}}
		end

		extras = {"th-year" => I18n.t("personal_certificate.year"), "th-issue_date" => I18n.t("personal_certificate.issue_date"), "th-title" => I18n.t("personal_certificate.title"), "th-member_profile" => I18n.t("personal_certificate.member_profile")}
		choice_show = []
		headers = []
		fields_to_show.each do |fs|
			col = 2
			col = 3 if fs == 'title'
			headers << {
				'head-title' => t("personal_certificate.#{fs}"),
				'col' => col
			}
			choice_show << t("personal_certificate.#{fs}")
		end
		choice_value = fields_to_show
		choice_value.unshift('default')
		choice_select = choice_value.map { |iter| iter == params[:selectbox] ? 'selected' : '' }
		choice_select = choice_select.map { |value| { 'choice_select' => value } }
		choice_value = choice_value.map { |value| { 'choice_value' => value } }
		choice_default = t('personal_certificate.extend_translate.select_class')
		choice_show.unshift(choice_default)
		choice_show = choice_show.map { |value| { 'choice_show' => value } }
		choice = choice_value.zip(choice_show, choice_select)
		choice = choice.map { |value| value.inject :merge }
		select_text = t('personal_certificate.extend_translate.search_class')
		search_text = t('personal_certificate.extend_translate.word_to_search')
		@_request = OrbitHelper.request
		csrf_value = form_authenticity_token
		extras = extras.merge({ 'url' => '/' + I18n.locale.to_s + params[:url],
							'select_text' => select_text,
							'search_text' => search_text,
							'search_value' => params[:keywords].to_s.gsub(/\"/,''),
							'csrf_value' => csrf_value
						})
		extras["widget-title"] = I18n.t("module_name.personal_certificate")
		{
			"certificates" => certificates_list,
			"headers" => headers,
			"extras" => extras,
			"total_pages" => certificates.total_pages,
			'choice' => choice
		}
	end

	def show
		params = OrbitHelper.params
		plugin = Certificate.where(:is_hidden=>false).find_by(uid: params[:uid].to_s)
		fields_to_show = ["year", "issue_date", "title", "issued_by", "certificate_category.certificate_type", "expiration_date", "member_profile"]
		{"plugin_datas"=>plugin.get_plugin_data(fields_to_show)}
	end

	def get_display_field(certificate,field, title_is_paper_format=false)
		text_only = false
		value = certificate.send(field) rescue ""
		if field.include?(".")
		    value = certificate
		    field.split(".").each{|f| value = value.send(f) rescue nil }
		end
		file_fields = []
		link_fields = []
		member_fields = []
		if file_fields.include?(field)
		    files = certificate.send(field.pluralize)
		    value = files.map do |file|
		        url = file.file.url
		        title = (file.title.blank? ? File.basename(file.file.path) : file.title)
		        "<li><a href='#{url}'' target='_blank'>#{title}</li>"
		    end
		    value = value.join("")
		elsif link_fields.include?(field)
		    links = certificate.send(field.pluralize)
		    value = links.map do |link|
		        url = link.url
		        title = (link.title.blank? ? url : link.title)
		        "<li><a href='#{url}'' target='_blank'>#{title}</li>"
		    end
		    value = value.join("")
		elsif member_fields.include?(field)
		    members = certificate.send(field.pluralize)
		    value = members.map{|m|
		        path = OrbitHelper.url_to_plugin_show(m.to_param, 'member') rescue '#'
		        ((text_only rescue false) ? m.name : "<a href='#{path}'>#{m.name}</a>")
		    }
		    join_text = (text_only rescue false) ? "," : "<br>"
		    value = value.join(join_text)
		elsif field == "member_profile"
		    member = certificate.member_profile
		    member_name = (member ? member.name : nil)
		    value = (member ? "<a href='#{OrbitHelper.url_to_plugin_show(member.to_param,'member')}' title='#{member_name}'>#{member_name}</a>" : "")
		end
		strftime_hash = {"issue_date"=>"%Y/%m/%d", "expiration_date"=>"%Y/%m/%d"}
		if strftime_hash.keys.include?(field)
		    value = value.strftime(strftime_hash[field]) rescue value
		end
		if field == "title"
		    link = OrbitHelper.url_to_plugin_show(certificate.to_param,'personal_certificate')
		    tmp_title = value
		    url_to_plugin_show_blank = OrbitHelper.instance_variable_get(:@url_to_plugin_show_blank)
		    value = url_to_plugin_show_blank ? tmp_title : "<a href='#{link}' target='_blank' title='#{tmp_title}'>#{tmp_title}</a>"
		end
		value
		return value
	end
	def get_fields_for_index
		@page = Page.find(params[:page_id]) rescue nil
		@fields_to_show = ["year", "issue_date", "title", "issued_by", "certificate_category.certificate_type", "expiration_date"]
		@fields_to_show = @fields_to_show.map { |fs| [t("personal_certificate.#{fs}"), fs] }
		if @page.present? && @page.custom_string_field == 'table'
			@default_fields_to_show = ["year", "issue_date", "title", "member_profile"]
		else
			@default_fields_to_show = ["year", "title"]
		end
		render layout: false
	end

	def save_index_fields
		page = Page.find(params[:page_id]) rescue nil
		page.custom_array_field = params[:keys]
		page.save
		render json: { 'success' => true }.to_json
	end
	def filter_keywords(certificates,select_field,keywords)
		member_fields = []
		file_fields = []
		link_fields = []
		if select_field == "default"
			certificates = certificates.where(:slug_title=>/#{gsub_invalid_character(keywords)}/)
		elsif select_field == "member_profile"
			ms = MemberProfile.all.select{|m| m.name.include?(keywords)}
			certificates = certificates.where(:member_profile_id.in=>ms.map{|m| m.id})
		elsif member_fields.include?(select_field)
			ms = MemberProfile.all.select{|m| m.name.include?(keywords)}
			m_ids = ms.map{|m| m.id.to_s }
			tmp_certificates = certificates.select{|p| (p.send("#{select_field.singularize}_ids") & m_ids).count != 0}
			certificates = certificates.where(:id.in=>tmp_certificates.map{|p| p.id})
		elsif select_field.split(".").count > 1
			relate_name = select_field.split(".").first
			field_name = select_field.split(".").last.gsub(/^\$+/, '')
			relate = relate_name.camelize.constantize
			relate_ids = relate.where(field_name=>/#{gsub_invalid_character(keywords)}/).pluck(:id)	
			certificates = certificates.where("#{relate_name.singularize}_id"=>{'$in'=>relate_ids})
		elsif (Certificate.fields[select_field].options[:type] == Date rescue false)
			keywords = keywords.split(/[\/\-]/)
			if keywords.count > 1
				Date.parse(keywords.join("/"))
			else
				start_time = Date.parse(keywords[0] + "/1/1")
				end_time = Date.parse(keywords[0] + "/12/31")
				certificates = certificates.where(select_field=>{'$gte'=>start_time,'$lte'=>end_time})
			end
		elsif (Certificate.fields[select_field].options[:type] == DateTime rescue false)
			keywords = keywords.split(/[\/\-]/)
			if keywords.count > 1
				DateTime.parse(keywords.join("/"))
			elsif keywords[0].include?(":")
				tmp_certificates = certificates.select{|p| (p.send(select_field).strftime('%Y/%m/%d %H:%M').include?(keywords[0]) rescue false)}
				certificates = certificates.where(:id.in=>tmp_certificates.map{|p| p.id})
			else
				start_time = DateTime.parse(keywords[0] + "/1/1 00:00")
				end_time = DateTime.parse(keywords[0] + "/12/31 23:59")
				certificates = certificates.where(select_field=>{'$gte'=>start_time,'$lte'=>end_time})
			end
		elsif (Certificate.fields[select_field].options[:type] == Integer rescue false)
			tmp_certificates = certificates.select{|p| p.send(select_field).to_s.include?(keywords)}
			certificates = certificates.where(:id.in=>tmp_certificates.map{|p| p.id})
		elsif file_fields.include?(select_field)
			file_field = select_field.camelize.constantize
			ids1 = file_field.where(:file=>/#{gsub_invalid_character(keywords)}/).pluck(:id)
			ids2 = file_field.where(:title=>/#{gsub_invalid_character(keywords)}/).pluck(:id)
			ids = ids1 + ids2
			tmp_certificates = certificates.select{|p| (p.send("#{select_field}_ids") & ids).count != 0}
			certificates = certificates.where(:id.in=>tmp_certificates.map{|p| p.id})
		elsif link_fields.include?(select_field)
			link_field = select_field.camelize.constantize
			ids1 = link_field.where(:title=>/#{gsub_invalid_character(keywords)}/).pluck(:id)
			ids2 = link_field.where(:url=>/#{gsub_invalid_character(keywords)}/).pluck(:id)
			ids = ids1 + ids2
			tmp_certificates = certificates.select{|p| (p.send("#{select_field}_ids") & ids).count != 0}
			certificates = certificates.where(:id.in=>tmp_certificates.map{|p| p.id})
		else
			certificates = certificates.where(select_field=>/#{gsub_invalid_character(keywords)}/)
		end
		return certificates
	end
	def gsub_invalid_character(text)
		::Regexp.escape(text.to_s)
	end
end