# encoding: utf-8 class Admin::SeminarsController < OrbitAdminController require 'axlsx' include Admin::SeminarsHelper helper Admin::SeminarsFieldHelper before_action ->(module_app = @app_title) { set_variables module_app } before_action :set_seminar, only: [:edit, :set_write_off, :seminar_signup, :destroy,:seminar_signup_admin_setting,:update_seminar_signup_admin_setting,:get_reviewer_block,:get_session_block,:update_seminar_review,:update_seminar_session,:reviewer_setting,:update_reviewer_setting,:template_setting,:update_template_setting,:sub_page_setting] before_action :set_seminar_signup_admin_setting, only: [:seminar_signup,:seminar_signup_admin_setting,:update_seminar_signup_admin_setting,:get_reviewer_block,:get_session_block] before_action :check_permission_for_seminar, only: [:seminar_signup,:get_reviewer_block,:get_session_block] before_action :check_manager_for_seminar, only: [:seminar_signup_admin_setting,:update_seminar_signup_admin_setting,:update_seminar_review,:update_seminar_session,:reviewer_setting,:update_reviewer_setting,:template_setting,:update_template_setting] def initialize super @app_title = "seminar" end def filter_fields(categories) { :category=>categories.map{|c| {:title=>(c.title.blank? ? " " : c.title), :id=>c.id}} } end def check_manager_for_seminar OrbitHelper.set_params(params,current_user) OrbitHelper.set_this_module_app("seminar") access_level = OrbitHelper.user_access_level? if (access_level.nil? || access_level == "user") && (@seminar.organizer_id != current_user.member_profile_id rescue true) render_401 elsif access_level == "sub_manager" && @seminar && !(OrbitHelper.user_can_edit?(@seminar)) render_401 end end def check_permission_for_seminar OrbitHelper.set_params(params,current_user) OrbitHelper.set_this_module_app("seminar") access_level = OrbitHelper.user_access_level? if (access_level.nil? || access_level == "user") unless (@seminar.reviewer_ids.include?(current_user.member_profile_id.to_s) rescue false) || (@seminar.organizer_id == current_user.member_profile_id rescue false) render_401 else @user_authenticated_categories = ['all'] end end end def template_setting @seminar_template_setting = @seminar.seminar_template_setting if @seminar_template_setting.nil? @seminar_template_setting = SeminarTemplateSetting.create(:seminar_main=>@seminar) end @seminar_page_root = Page.where(:parent_page_id=>params[:id]).first if @seminar_page_root.nil? @seminar_page_root = @seminar_template_setting.create_seminar_pages end display_menu = [] if @seminar_page_root default_display_menu = SeminarTemplateSetting::DefaultMenu default_display_menu.each do |page_id| page = @seminar_page_root.child_page.where(:page_id=>page_id).first if page display_menu << page_id if page.enabled_for.length != 0 else display_menu << page_id if page_id != "registered_participants" end end end @seminar_template_setting.update(:display_menu=>display_menu) if (CustomBulletinConfig.where(:module=>"seminar").count == 0 rescue false) CustomBulletinConfig.create(:module=>"seminar",:bind_model=>"SeminarMain",:custom_record_callback=>"manage_announcement_count") end if (CustomAlbumConfig.where(:module=>"seminar").count == 0 rescue false) CustomAlbumConfig.create(:module=>"seminar",:bind_model=>"SeminarMain",:custom_record_callback=>"manage_album_count") end end def update_template_setting @seminar_template_setting = SeminarTemplateSetting.find(params[:id]) @seminar_template_setting.update_attributes(seminar_template_setting_params) redirect_to admin_seminars_path end def sub_page_setting @seminar_page_root = Page.where(:parent_page_id=>params[:id]).first @seminar_template_setting = SeminarTemplateSetting.where(:seminar_main_id=>params[:id]).first available_locales = Site.first.in_use_locales rescue I18n.available_locales available_locales = available_locales.map{|l| l.to_s} if @seminar_page_root.nil? @seminar_page_root = @seminar_template_setting.create_seminar_pages else @seminar_template_setting.create_seminar_pages(false) end @items = @seminar_page_root.child_page @parent_pages = [] # exceptions = ["personal_book","personal_conference","personal_diploma","personal_experience","personal_journal","personal_lab","personal_patent","personal_project","personal_research"] exceptions = [] @modules = ModuleApp.where(:key.nin => exceptions).frontend_enabled.order_by(:key=>'asc') @searchfilter = @modules.collect{|m|[t('module_name.'+m.key),m.key]} end def reviewer_setting @seminar_reviews = @seminar.seminar_reviews @fields = [] @fields_translations = [] access_markup = ["select","radio_button","checkbox"] @fields_values = [] @seminar.seminar_signup_fields.each do |f| next if f.disabled if access_markup.include?(f.markup) @fields << "seminar_signup_fields.#{f.id}" @fields_translations << f.title @fields_values << f.option_list end end @seminar.seminar_submission_fields.each do |f| next if f.disabled if access_markup.include?(f.markup) @fields << "seminar_submission_fields.#{f.id}" @fields_translations << f.title @fields_values << f.option_list end end if @seminar.enable_summary_choice @fields << "seminar_signup_contributes.description" begin data2 = @seminar.seminar_submission_field_sets.select{|v| v.field_name=='description'}[0] name2 = data2['name'][I18n.locale] @fields_translations << (name2.present? ? name2 : I18n.t("seminar_signup.description")) rescue @fields_translations << I18n.t("seminar_signup.description") end @fields_values << @seminar.summary_chioices.map.with_index{|v,i| [i.to_s,{I18n.locale=>v}]}.to_h end @fields_values = @fields_values.collect.with_index{|fields_values,i| [i, fields_values.values.map{|v| v[I18n.locale]} ] }.to_h end def update_reviewer_setting seminar_params[:seminar_reviews_attributes].keys.each do |i| if seminar_params[:seminar_reviews_attributes][i][:default_topics].present? seminar_params[:seminar_reviews_attributes][i][:default_topics] = [] if seminar_params[:seminar_reviews_attributes][i][:default_topics].nil? default_topics_values = [] (0...seminar_params[:seminar_reviews_attributes][i][:default_topics].count).each do |ii| default_topics_values << (Array(seminar_params[:seminar_reviews_attributes][i][:default_topics_values][ii.to_s]) rescue []) end seminar_params[:seminar_reviews_attributes][i][:default_topics_values] = default_topics_values else seminar_params[:seminar_reviews_attributes][i][:default_topics] = [] seminar_params[:seminar_reviews_attributes][i][:default_topics_values] = [] end end #render :html => seminar_params and return @seminar.update_attributes(seminar_params) unassigned_seminar_signup_ids = @seminar.seminar_signup_ids.map{|s| s.to_s} unassigned_mode_1_seminar_signup_ids = unassigned_seminar_signup_ids.dup @seminar.seminar_reviews.each do |sr| unassigned_mode_1_seminar_signup_ids = unassigned_mode_1_seminar_signup_ids - sr.get_all_seminar_signup_ids(1) unassigned_seminar_signup_ids = unassigned_seminar_signup_ids - sr.all_seminar_signup_ids end @seminar.unassigned_mode_1_seminar_signup_ids = unassigned_mode_1_seminar_signup_ids @seminar.unassigned_seminar_signup_ids = unassigned_seminar_signup_ids @seminar.save redirect_to admin_seminars_path end def enquiry_for_applicants OrbitHelper.set_params(params,current_user) @access_level = OrbitHelper.user_access_level? @can_edit = true if @access_level == "user" || @access_level.nil? @can_edit = false end reviewer_id = current_user.member_profile_id.to_s if !@can_edit && SeminarMain.where(:reviewer_ids=>reviewer_id).count == 0 && SeminarMain.where(:organizer_id=>reviewer_id).count == 0 render_401 and return end @seminar_signup_admin_setting = SeminarSignupAdminSetting.where(:seminar_main_id=>"enquiry_for_applicants").first if @seminar_signup_admin_setting.nil? @seminar_signup_admin_setting = SeminarSignupAdminSetting.create(:seminar_main_id=>"enquiry_for_applicants") end if params[:name].present? @seminar_signups = SeminarSignup.where(:name => /#{params[:name]}/).sort_ordered.page(params[:page]).per(10) else @seminar_signups = [] end unless @can_edit if @seminar_signups.class != Array seminar_review = SeminarReview.where(:reviewer_id=>reviewer_id) seminar_signup_ids = seminar_review.pluck(:seminar_signup_ids).flatten seminar_sessions = SeminarSession.where(:id.in=>seminar_review.pluck(:seminar_session_ids)) remove_seminar_signup_ids = seminar_review.pluck(:remove_seminar_signup_ids).flatten assign_ids = [] seminars = SeminarMain.where(:id.in => seminar_review.pluck(:seminar_main_id)) final_assign_signup_ids = SeminarSession.where(:id.in=>seminar_review.pluck(:seminar_session_ids).flatten,:seminar_main_id.in=>seminars.where(:assign_mode.in=>[1,2]).pluck(:id)).pluck(:seminar_signup_ids,:default_seminar_signup_ids).flatten default_seminar_signup_ids = seminar_review.where(:seminar_main_id.in=>seminars.where(:assign_mode=>0).pluck(:id)).pluck(:default_seminar_signup_ids).flatten all_seminar_signup_ids = seminar_signup_ids - remove_seminar_signup_ids + final_assign_signup_ids + default_seminar_signup_ids ids2 = SeminarSignup.where(:seminar_main_id.in=> SeminarMain.where(:organizer_id=>current_user.member_profile_id).pluck(:id)).pluck(:id) @seminar_signups = @seminar_signups.where(:id.in=>all_seminar_signup_ids + ids2).sort_ordered.page(params[:page]).per(10) @preferred_sessions = seminar_review.pluck(:session_ids).flatten end end end def get_hide_session seminar_main = SeminarMain.find(params[:id]) rescue nil if seminar_main.nil? render :nothing => true else @seminar = seminar_main @seminar_sessions = @seminar.seminar_sessions @hide_session_ids = (0...seminar_main.summary_chioices.count).to_a - Array(seminar_main.session_show_ids) @hide_sessions = @hide_session_ids.zip(@hide_session_ids.map{|idx| seminar_main.summary_chioices[idx]}).to_h render :layout => false end end def get_hide_reviewer seminar_main = SeminarMain.find(params[:id]) rescue nil if seminar_main.nil? render :nothing => true else @hide_reviewer_ids = Array(seminar_main.reviewer_ids) - Array(seminar_main.reviewer_show_ids) @hide_reviewers = MemberProfile.where(:id.in=>@hide_reviewer_ids) @reviewers = seminar_main.seminar_reviews.where(:reviewer_id.in=>@hide_reviewer_ids).to_a render :layout => false end end def get_session_block @session_id = params[:session_id].to_i @seminar_session = @seminar.seminar_sessions.where(:key=>@session_id).first unless (@seminar.session_show_ids.include?(@session_id) rescue false) @seminar.session_show_ids << @session_id @seminar.save end render :layout => false end def get_reviewer_block @reviewer_id = params[:reviewer_id] unless (@seminar.reviewer_show_ids.include?(@reviewer_id) rescue false) @seminar.reviewer_show_ids << @reviewer_id @seminar.save end render :layout => false end def update_seminar_session if @seminar.nil? render :json => {:success => false} else seminar_main = @seminar session_id = params[:session_id].to_i seminar_main.save seminar_session = @seminar.seminar_sessions.where(:key=>session_id).first @seminar_submission_value = nil extra_infos = {} if params[:contribute_id].present? seminar_signup_contribute = SeminarSignupContribute.find(params[:contribute_id]) seminar_submission_field = seminar_main.seminar_submission_fields.where(:markup=>"seminar_preferred_session").last if seminar_submission_field @seminar_submission_value = seminar_signup_contribute.seminar_submission_values.where(:seminar_submission_field_id=>seminar_submission_field.id).last end end if params[:mode] == "append" if @seminar_submission_value @seminar_submission_value.val = session_id.to_s @seminar_submission_value.save extra_infos = {"edit" => {"target"=>"[data-id=\"#{@seminar_submission_value.id}\"]","text"=>@seminar_submission_value.get_value_by_locale(I18n.locale)}} else @seminar_signup.final_sessions << session_id @seminar_signup.seminar_session_ids << seminar_session.id @seminar_signup.seminar_session_ids = @seminar_signup.seminar_session_ids.uniq @seminar_signup.save seminar_session.seminar_signup_contribute_ids.append(params[:contribute_id]) seminar_signup_contribute.update(:final_session=>session_id) rescue nil seminar_session.seminar_signup_ids << @seminar_signup.id.to_s seminar_main.assign_mode = 1 if seminar_main.assign_mode != 2 seminar_session.save seminar_main.unassigned_mode_1_seminar_signup_ids.delete(@seminar_signup.id.to_s) end elsif params[:mode] == "remove_contribute" if @seminar_submission_value @seminar_submission_value.val = nil @seminar_submission_value.save extra_infos = {"edit" => {"target"=>"[data-id=\"#{@seminar_submission_value.id}\"]","text"=>""}} else seminar_session.seminar_signup_contribute_ids.delete(params[:contribute_id]) seminar_signup_contribute.update(:final_session=>nil) rescue nil seminar_session.save end elsif params[:mode] == "remove" if @seminar_submission_value @seminar_submission_value.val = nil @seminar_submission_value.save extra_infos = {"edit" => {"target"=>"[data-id=\"#{@seminar_submission_value.id}\"]","text"=>""}} else @seminar_signup.final_sessions.delete(session_id) @seminar_signup.seminar_session_ids.delete(seminar_session.id) seminar_session.seminar_signup_ids.delete(@seminar_signup.id.to_s) seminar_session.seminar_signup_contribute_ids.delete(params[:contribute_id]) seminar_signup_contribute.update(:final_session=>nil) rescue nil @seminar_signup.save seminar_session.save seminar_main.assign_mode = 0 if seminar_main.seminar_sessions.where(:seminar_signup_ids.ne=>[]).count == 0 && seminar_main.assign_mode != 2 seminar_main.unassigned_mode_1_seminar_signup_ids << @seminar_signup.id.to_s end elsif params[:mode] == "hide" if seminar_main.session_show_ids.nil? seminar_main.session_show_ids = (0...seminar_main.summary_chioices.count).to_a[0..1] end seminar_main.session_show_ids.delete(session_id) elsif params[:mode] == "show" seminar_main.session_show_ids = seminar_main.session_show_ids.to_a + Array(session_id) else render :json => {:success => false} and return end seminar_main.save render :json => {:success => true}.merge(extra_infos) end end def update_seminar_review if @seminar_review.nil? render :json => {:success => false} else seminar_main = @seminar_review.seminar_main if params[:mode] == "append" @seminar_review.seminar_signup_ids << params[:signup_id] @seminar_review.remove_seminar_signup_ids.delete(params[:signup_id]) seminar_main.unassigned_seminar_signup_ids.delete(params[:signup_id]) seminar_main.unassigned_mode_1_seminar_signup_ids.delete(params[:signup_id]) if(params[:contribute_id].present?) @seminar_review.seminar_signup_contribute_ids << params[:contribute_id] @seminar_review.remove_seminar_signup_contribute_ids.delete(params[:contribute_id]) end elsif params[:mode] == "remove" @seminar_review.seminar_signup_ids.delete(params[:signup_id]) @seminar_review.remove_seminar_signup_ids << params[:signup_id] seminar_main.unassigned_seminar_signup_ids << params[:signup_id] seminar_main.unassigned_mode_1_seminar_signup_ids << params[:signup_id] if(params[:contribute_id].present?) @seminar_review.seminar_signup_contribute_ids.delete(params[:contribute_id]) @seminar_review.remove_seminar_signup_contribute_ids << params[:contribute_id] end elsif params[:mode] == "remove_contribute" if(params[:contribute_id].present?) @seminar_review.seminar_signup_contribute_ids.delete(params[:contribute_id]) @seminar_review.remove_seminar_signup_contribute_ids << params[:contribute_id] end elsif params[:mode] == "hide" if seminar_main.reviewer_show_ids.nil? seminar_main.reviewer_show_ids = seminar_main.reviewer_ids[0..1] end seminar_main.reviewer_show_ids = seminar_main.reviewer_show_ids - Array(@seminar_review.reviewer_id).flatten elsif params[:mode] == "show" seminar_main.reviewer_show_ids = seminar_main.reviewer_show_ids.to_a + Array(@seminar_review.reviewer_id).flatten else render :json => {:success => false} and return end seminar_main.save @seminar_review.save render :json => {:success => true} end end def index @categories = @module_app.categories.enabled @filter_fields = filter_fields(@categories) @table_fields = [:category, 'seminar.title', 'seminar.event_during', 'seminar.signup_during', 'seminar.signup_count', 'seminar.export'] if !params[:sort].blank? if params[:sort] == 'event_during' sort = {:seminar_start_date.to_sym=>params[:order]} elsif params[:sort] == 'signup_during' sort = {:signup_start_date.to_sym=>params[:order]} else sort = {params[:sort].to_sym=>params[:order]} end else sort = {:signup_start_date=>"desc",:created_at=>"desc"} end @seminars = SeminarMain.all.order_by(sort).with_categories(filters("category")) @seminars = search_data(@seminars,[:title]).page(params[:page]).per(10) OrbitHelper.set_params(params,current_user) OrbitHelper.set_this_module_app("seminar") @access_level = OrbitHelper.user_access_level? @can_edit = true if @access_level == "user" || @access_level.nil? @can_edit = false end unless @can_edit reviewer_id = current_user.member_profile_id.to_s ids1 = @seminars.where(:reviewer_ids=>reviewer_id).pluck(:id) ids2 = @seminars.where(:organizer_id=>current_user.member_profile_id).pluck(:id) @seminars = @seminars.where(:id.in=>ids1+ids2) end if request.xhr? render :partial => "index" end end def export @seminar = SeminarMain.find(params[:id]) @seminar_signups = SeminarSignup.where(:seminar_main_id => params[:id]) filename = @seminar.title.parameterize.underscore + "_export.xlsx" if can_see_seminar_signup(@seminar) if !admin_for_seminar(@seminar) @seminar_review = @seminar.seminar_reviews.where(:reviewer_id => current_user.member_profile_id.to_s).first @seminar_signups = @seminar_signups.where(:id.in=>@seminar_review.get_all_seminar_signup_ids) rescue [] end @seminar_signups = @seminar_signups.sort_ordered respond_to do |format| format.xlsx { response.headers['Content-Disposition'] = 'attachment; filename="' + filename + '"' } end else render :nothing => true end end def copy @seminar = SeminarMain.find(params[:id]).clone_new @member = MemberProfile.where(:id.in=>@seminar.reviewer_ids).to_a @email_set = @seminar.seminar_email_sets @signup_sets = @seminar.seminar_signup_field_sets @submission_set = @seminar.seminar_submission_field_sets @custom_set = @seminar.seminar_signup_field_customs @seminar_items = SeminarItem.all @review = @seminar.seminar_reviews.first end def new @member = nil @seminar = SeminarMain.new create_set (false) @signup_sets = @seminar.seminar_signup_field_sets @submission_set = @seminar.seminar_submission_field_sets @custom_set = @seminar.seminar_signup_field_customs @seminar_items = SeminarItem.all @review = @seminar.seminar_reviews.new() end def create if !seminar_params['seminar_links_attributes'].nil? seminar_params['seminar_links_attributes'].each do |idx,link| seminar_params['seminar_links_attributes'].delete(idx.to_s) if link['url'].blank? end end seminar_main_params = seminar_params if seminar_main_params[:copy_id] seminar_signup_set_params = seminar_main_params['seminar_signup_field_sets_attributes'] seminar_submission_set_params = seminar_main_params['seminar_submission_field_sets_attributes'] seminar_email_sets_params = seminar_main_params['seminar_email_sets_attributes'] seminar_signup_field_customs_params = seminar_main_params["seminar_signup_field_customs_attributes"].to_h rescue {} seminar_signup_field_customs_params.each do |k,v| v.delete "title" end seminar_main_params.delete(:seminar_signup_field_sets_attributes) seminar_main_params.delete(:seminar_submission_field_sets_attributes) seminar_main_params.delete(:seminar_email_sets_attributes) end seminar = SeminarMain.new(seminar_main_params) seminar.create_user_id = current_user.id seminar.update_user_id = current_user.id if seminar.copy_id && params["clone_signups"].blank? seminar.except_clone_relations = ["seminar_signups","seminar_signup_values","seminar_signup_contributes","seminar_submission_values"] end seminar.save if seminar_main_params[:copy_id] seminar_signup_set_params.each do |key,value| seminar.seminar_signup_field_sets[key.to_i].update_attributes(value) rescue nil end seminar_submission_set_params.each do |key,value| seminar.seminar_submission_field_sets[key.to_i].update_attributes(value) rescue nil end seminar_email_sets_params.each do |key,value| seminar.seminar_email_sets[key.to_i].update_attributes(value) rescue nil end seminar_signup_field_customs_params.each_with_index do |(key,value),i| seminar.seminar_signup_field_customs[i].update(:seminar_signup_field_id => seminar.seminar_signup_fields.where(:title=>value["title"]).first.id) rescue nil end end redirect_to params['referer_url'] end def edit @seminar_items = SeminarItem.all @seminar = SeminarMain.where(id: params[:id]).first create_set (true) @signup_sets = @seminar.seminar_signup_field_sets @submission_set = @seminar.seminar_submission_field_sets @custom_set = @seminar.seminar_signup_field_customs @member = MemberProfile.where(:id.in=>@seminar.reviewer_ids).to_a rescue [] if (@seminar.organizer_id == current_user.member_profile_id rescue false) @user_authorized_categories = @module_app.categories.enabled.to_a else @user_authorized_categories = nil end end def update @seminar_params = seminar_params rescue {} if @seminar_params.count != 0 @seminar_params[:registration_status] = (@seminar_params[:registration_status] ? @seminar_params[:registration_status] : []) uid = params[:id].split('-').last @seminar = SeminarMain.find_by(:uid=>uid) if @seminar_params.has_key?("title_translations") @seminar_params["reviewer_ids"] = [] if @seminar_params["reviewer_ids"].nil? @seminar_params["organizer_id"] = nil if @seminar_params["organizer_id"].nil? end if @seminar_params[:seminar_signup_fields_attributes] @seminar.update_attributes(@seminar_params.slice(:seminar_signup_fields_attributes)) flash.now[:notice] = "Updated Fields" redirect_to admin_seminars_path and return elsif @seminar_params[:seminar_submission_fields_attributes] @seminar.update_attributes(@seminar_params.slice(:seminar_submission_fields_attributes)) flash.now[:notice] = "Updated Fields" if @seminar.seminar_submission_fields.select{|sf| sf.markup == "seminar_preferred_session"}.count != 0 @seminar.update(:assign_mode => 2) default_sort_number = SeminarSignup.fields['sort_number'].options[:default] SeminarSignup.where(:sort_number=>nil).update_all(:sort_number=>default_sort_number) SeminarSignupContribute.where(:sort_number=>nil).update_all(:sort_number=>default_sort_number) preferred_session_field = @seminar.seminar_submission_fields.select{|sf| sf.markup == "seminar_preferred_session"}.first if preferred_session_field.seminar_submission_values.count != 0 seminar_submission_values = preferred_session_field.seminar_submission_values.to_a seminar_submission_values.each do |v| if v.seminar_signup_contribute.nil? v.destroy next end next if v.val.to_i.to_s != v.val seminar_session = @seminar.seminar_sessions.where(:key=>v.val.to_i).first seminar_session.default_seminar_signup_ids << v.seminar_signup_contribute.seminar_signup_id.to_s seminar_session.default_seminar_signup_ids = seminar_session.default_seminar_signup_ids.uniq seminar_session.save end Thread.new do SeminarMain.where(:update_old_flag=>false).each{|s| s.fix_old_data} end end else if @seminar.seminar_sessions.where(:seminar_signup_ids.ne=>[]).count == 0 @seminar.update(:assign_mode => 0) else @seminar.update(:assign_mode => 1) end end redirect_to admin_seminars_path and return else if !seminar_params['seminar_links_attributes'].nil? seminar_params['seminar_links_attributes'].each do |idx,link| seminar_params['seminar_links_attributes'].delete(idx.to_s) if link['url'].blank? end end @seminar.update_user_id = current_user.id if @seminar.update_attributes(seminar_params) @seminar.update_enable_recaptcha @seminar.seminar_signup_fields.each{|t| t.destroy if t["to_delete"] == true} redirect_to params['referer_url'] and return else flash.now[:error] = t('update.error.category') render action: :edit and return end end Rails.logger.info "&&&&&&&&&&&&&&" if @seminar_params[:seminar_email_sets_attributes] Rails.logger.info "*********************" Rails.logger.info @seminar_params[:seminar_email_sets_attributes] @seminar.update_attributes(@seminar_params[:seminar_email_sets_attributes]) flash.now[:notice] = "Updated Fields" end end redirect_to admin_seminars_path end def set_write_off @seminar.donation_write_off_status = true @seminar.save redirect_to "/admin/seminars?page=#{params['page']}" end def destroy @seminar.destroy redirect_to "/admin/seminars" end def seminar_signup_field @field_name = 'seminar_main' @attribute = SeminarMain.find(params[:id]) @attribute_type = 'seminar' @class = 'seminars' end def seminar_submission_field @field_name = 'seminar_main' @attribute = SeminarMain.find(params[:id]) @attribute_type = 'seminar' @class = 'seminars' end def seminar_signup @seminar_signups = [] @filter_fields = {} @summary_chioices = @seminar.enable_summary_choice ? @seminar.summary_chioices : [] @enable_review_result = @seminar.enable_review_result if @enable_review_result @filter_fields["seminar.assigned_session"] = @summary_chioices.map.with_index{|summary_chioice,i| {:title=>summary_chioice, :id=>i}} rescue [] end if params[:type] == "table" if params[:search].to_i != 0 @seminar_signups = @seminar.seminar_signups.where(:serial_number=>params[:search].to_i) else @seminar_signups = @seminar.seminar_signups.where(:name=>/#{params[:search]}/) end elsif params[:type] == "session" assigned_seminar_signups = @seminar.seminar_sessions.pluck(:seminar_signup_ids,:default_seminar_signup_ids).flatten @seminar_signups = @seminar.seminar_signups.where(:id.nin=>assigned_seminar_signups) else unassigned_seminar_signup_ids = @seminar.unassigned_seminar_signup_ids if @seminar.assign_mode != 0 unassigned_seminar_signup_ids = @seminar.unassigned_mode_1_seminar_signup_ids end @seminar_signups = @seminar.seminar_signups.where(:id.in => unassigned_seminar_signup_ids, :name=>/#{params[:search]}/) end OrbitHelper.set_params(params,current_user) @access_level = OrbitHelper.user_access_level? @can_edit = true if @access_level == "user" || @access_level.nil? @can_edit = false end unless @can_edit @can_edit = (@seminar.organizer_id == current_user.member_profile_id rescue false) end unless @can_edit @seminar_review = @seminar.seminar_reviews.where(:reviewer_id => current_user.member_profile_id.to_s).first @seminar_signups = @seminar.seminar_signups.where(:id.in=>@seminar_review.get_all_seminar_signup_ids) @preferred_sessions = @seminar_review.session_ids if @enable_review_result @filter_fields["seminar.assigned_session"] = @filter_fields["seminar.assigned_session"].select{|h| @preferred_sessions.include?(h[:id])} rescue [] end @append_contribute_ids = @seminar_review.seminar_signup_contribute_ids @remove_contribute_ids = @seminar_review.remove_seminar_signup_contribute_ids end if params[:filters] && params[:filters][:assigned_session].present? @preferred_sessions = params[:filters][:assigned_session].map{|s| s.to_i} @seminar_signups = @seminar_signups.where(:preferred_sessions.in=> @preferred_sessions) end @seminar_signups = @seminar_signups.sort_ordered.page(params[:page]).per(10) if request.xhr? render :layout => false end end def seminar_signup_admin_setting if @seminar.nil? && params[:id] != "enquiry_for_applicants" redirect_to admin_seminars_path end end def update_seminar_signup_admin_setting @seminar_signup_admin_setting.update_attributes(params.require(:seminar_signup_admin_setting).permit!) if params[:id] != "enquiry_for_applicants" redirect_to seminar_signup_admin_seminar_path(params[:id]) + "?type=#{params[:page]}" else redirect_to admin_seminar_enquiry_for_applicants_path end end def set_seminar_signup_admin_setting page = params[:type] || params[:page] if params[:action] == "seminar_signup" page = params[:type] end page = nil if page.blank? @seminar_signup_admin_setting = SeminarSignupAdminSetting.where(:seminar_main_id=>params[:id],:page=>page).first if @seminar_signup_admin_setting.nil? @seminar_signup_admin_setting = SeminarSignupAdminSetting.create(:seminar_main_id=>params[:id],:page=>page) end end def edit_seminar_signup @seminar_signup = SeminarSignup.find(params[:id]) @seminar = SeminarMain.find(@seminar_signup.seminar_main_id) end def delete_seminar_signup @seminar_signup = SeminarSignup.find(params[:id]) @seminar_id = @seminar_signup.seminar_main_id @seminar_signup.destroy redirect_to "/admin/seminars/@seminar_id.to_s/seminar_signup" end private def set_seminar @seminar = SeminarMain.find(params[:id]) rescue nil if params[:action] == "update_seminar_review" @seminar_review = SeminarReview.find(params[:id]) rescue nil @seminar = @seminar_review.seminar_main elsif params[:action] == "update_seminar_session" @seminar_signup = SeminarSignup.find(params[:signup_id]) rescue nil end end def seminar_template_setting_params params.require(:seminar_template_setting).permit! end def seminar_params params.require(:seminar_main).permit! end def create_set (save_flag) except_attributes = SeminarSignup::HiddenFields if @seminar.seminar_signup_field_sets.where(:field_name.in=>except_attributes).destroy != 0 @seminar = @seminar.reload end (SeminarSignup.attribute_names + ['recaptcha']).each do |attr_signup| next if except_attributes.include?(attr_signup) signup_set = @seminar.seminar_signup_field_sets.select{|v| v.field_name==attr_signup } if signup_set.length==0 if SeminarSignup::DefaultEnableFields.include? attr_signup disabled = false else disabled = true end if ['status','name','tel'].include? attr_signup hidden = false else hidden = true end name1 = Hash.new now_locale = I18n.locale I18n.available_locales.each do |locale| I18n.locale = locale name1[locale] = t("seminar_signup.#{attr_signup}") end I18n.locale = now_locale if save_flag @seminar.seminar_signup_field_sets.create(field_name:attr_signup,disabled:disabled,hidden:hidden,name:name1,placeholder:name1) else @seminar.seminar_signup_field_sets.new(field_name:attr_signup,disabled:disabled,hidden:hidden,name:name1,placeholder:name1) end end end @seminar.seminar_submission_field_sets.where(:field_name.in=>except_attributes).destroy SeminarSignupContribute.attribute_names.each do |attr_submission| next if except_attributes.include?(attr_submission) signup_set = @seminar.seminar_submission_field_sets.select{|v| v.field_name==attr_submission } if signup_set.length==0 name1 = Hash.new now_locale = I18n.locale I18n.available_locales.each do |locale| I18n.locale = locale name1[locale] = t("seminar_signup.#{attr_submission}") end I18n.locale = now_locale if save_flag @seminar.seminar_submission_field_sets.create(field_name:attr_submission,name:name1,placeholder:name1) else @seminar.seminar_submission_field_sets.new(field_name:attr_submission,name:name1,placeholder:name1) end end end @seminar.seminar_signup_fields.all.map{|v| v}.each do |field| set = @seminar.seminar_signup_field_customs.select{|v| v.seminar_signup_field_id==field.id} if set.length == 0 @seminar.seminar_signup_field_customs.create(seminar_signup_field_id:field.id) end end @email_set = [] ['signup','submission','add_file','edit_file'].each do |field_name| email_set = @seminar.seminar_email_sets.select{|v| v.field_name==field_name} if email_set.length==0 title = Hash.new content = Hash.new now_locale = I18n.locale I18n.available_locales.each do |locale| I18n.locale = locale title[locale] = t("seminar.email_#{field_name}_success") content[locale] = t("seminar.email_#{field_name}_content") end I18n.locale = now_locale if save_flag email_set = @seminar.seminar_email_sets.create(field_name:field_name,title:title,content:content) else email_set = @seminar.seminar_email_sets.new(field_name:field_name,title:title,content:content) end else email_set = email_set[0] end @email_set << email_set end end end