init project

app/controllers/admins/abouts_controller.rb

@@ -0,0 +1,18 @@
+class Admins::AboutsController < Admins::BaseController
+  def edit
+    current_doc
+  end
+
+  def update
+    current_doc.update!(about_us: params[:about_us])
+
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_about_path
+  end
+
+  private
+
+  def current_doc
+    @doc ||= Help.first || Help.create
+  end
+end

app/controllers/admins/agreements_controller.rb

@@ -0,0 +1,18 @@
+class Admins::AgreementsController < Admins::BaseController
+  def edit
+    current_doc
+  end
+
+  def update
+    current_doc.update!(agreement: params[:agreement])
+
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_agreement_path
+  end
+
+  private
+
+  def current_doc
+    @doc ||= Help.first || Help.create
+  end
+end

app/controllers/admins/auth_schools_controller.rb

@@ -0,0 +1,58 @@
+class Admins::AuthSchoolsController < Admins::BaseController
+
+  def index
+    schools = School.where(ec_auth: 1).includes(:users).order("updated_at desc")
+    @params_page = params[:page] || 1
+    @schools = paginate schools
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      school = School.where(id: params[:id]).first
+      school.destroy
+      render_success_js
+    end
+  end
+
+  # 工程认证单位列表搜索学校
+  def search_school
+    @schools = School.where("ec_auth != 1 and name like '%#{params[:name]}%'").limit(10)
+  end
+
+  # 添加认证学校
+  def add_school
+    all_schools = School.all
+    all_schools.where(id: params[:school_id]).update_all(ec_auth: 1)
+    schools = all_schools.where(ec_auth: 1).order("updated_at desc")
+    @params_page = params[:page] || 1
+    @schools = paginate schools
+  end
+
+  # 搜索用户
+  def search_manager
+    school = School.find_by(id: params[:school_id])
+    user_ids = school&.ec_school_users&.pluck(:user_id)
+    @users = User.where.not(id: user_ids).where("concat(lastname, firstname) like ?", "%#{params[:name].strip.to_s}%").limit(10)
+  end
+
+  # 添加认证学校管理员
+  def add_manager
+    ActiveRecord::Base.transaction do
+      user_ids = params[:user_id]
+      @school_id = params[:school_id]
+      user_ids.each do |id|
+        EcSchoolUser.create(user_id: id, school_id: @school_id)
+      end
+      @school_users = User.where(id: user_ids)
+    end
+  end
+
+  # 删除学校管理员
+  def remove_manager
+    ActiveRecord::Base.transaction do
+      manager = EcSchoolUser.where(school_id: params[:school_id], user_id: params[:user_id]).first
+      manager&.destroy
+    end
+  end
+
+end

app/controllers/admins/base_controller.rb

@@ -0,0 +1,45 @@
+class Admins::BaseController < ApplicationController
+  include Base::PaginateHelper
+  include Admins::RenderHelper
+  include Base::ErrorRescueHandler
+
+  layout 'admin'
+
+  skip_before_action :verify_authenticity_token
+  before_action :require_login, :require_admin!
+
+  after_action :rebind_event_if_ajax_render_partial
+  skip_before_action :check_sign
+
+  private
+
+  def require_login
+    return if User.current.logged?
+
+    redirect_to "/login?back_url=#{CGI::escape(request.fullpath)}"
+  end
+
+  def require_admin!
+    return if current_user.blank? || !current_user.logged?
+    return if current_user.admin_or_business?
+
+    render_forbidden
+  end
+
+  # 触发after ajax render partial hooks，执行一些因为局部刷新后失效的绑定事件
+  def rebind_event_if_ajax_render_partial
+    return if request.format.symbol != :js
+    return if response.content_type != 'text/javascript'
+
+    path = Rails.root.join('app/views/admins/shared/after_render_js_hook.js.erb')
+    return unless File.exists?(path)
+
+    append_js = ERB.new(File.open(path).read).result
+    response.body += append_js
+  end
+
+  # 重写此方法，防止影响超级管理员端云上实验室功能，因为那里重写了:current_laboratory方法
+  def setup_laboratory
+    Laboratory.current = Laboratory.find_by_subdomain(request.subdomain) || Laboratory.find(1)
+  end
+end

app/controllers/admins/carousels_controller.rb

@@ -0,0 +1,86 @@
+class Admins::CarouselsController < Admins::BaseController
+  before_action :convert_file!, only: [:create]
+
+  helper_method :current_laboratory
+
+  def index
+    @images = current_laboratory.portal_images.order(position: :asc)
+  end
+
+  def create
+    position = current_laboratory.portal_images.count + 1
+
+    ActiveRecord::Base.transaction do
+      image = current_laboratory.portal_images.create!(create_params.merge(position: position))
+
+      file_path = Util::FileManage.disk_filename('PortalImage', image.id)
+      File.delete(file_path) if File.exist?(file_path) # 删除之前的文件
+      Util.write_file(@file, file_path)
+    end
+
+    flash[:success] = '保存成功'
+    redirect_to admins_laboratory_carousels_path(current_laboratory)
+  end
+
+  def update
+    current_image.update!(update_params)
+    render_ok
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      current_image.destroy!
+      # 前移
+      current_laboratory.portal_images.where('position > ?', current_image.position)
+        .update_all('position = position - 1')
+
+      file_path = Util::FileManage.disk_filename('PortalImage', current_image.id)
+      File.delete(file_path) if File.exist?(file_path)
+    end
+    render_delete_success
+  end
+
+  def drag
+    move  = current_laboratory.portal_images.find_by(id: params[:move_id])
+    after = current_laboratory.portal_images.find_by(id: params[:after_id])
+
+    Admins::DragPortalImageService.call(current_laboratory, move, after)
+    render_ok
+  rescue Admins::DragPortalImageService::Error => e
+    render_error(e.message)
+  end
+
+  private
+
+  def current_laboratory
+    @_current_laboratory ||= Laboratory.find(params[:laboratory_id])
+  end
+
+  def current_image
+    @_current_image ||= current_laboratory.portal_images.find(params[:id])
+  end
+
+  def create_params
+    params.require(:portal_image).permit(:name, :link)
+  end
+
+  def update_params
+    params.permit(:name, :link, :status)
+  end
+
+  def convert_file!
+    max_size = 10 * 1024 * 1024 # 10M
+    file = params.dig('portal_image', 'image')
+    if file.class == ActionDispatch::Http::UploadedFile
+      @file = file
+      render_error('请上传文件') if @file.size.zero?
+      render_error('文件大小超过限制') if @file.size > max_size
+    else
+      file = file.to_s.strip
+      return render_error('请上传正确的图片') if file.blank?
+      @file = Util.convert_base64_image(file, max_size: max_size)
+    end
+  rescue Base64ImageConverter::Error => ex
+    render_error(ex.message)
+  end
+end

app/controllers/admins/choose_mirror_repositories_controller.rb

@@ -0,0 +1,11 @@
+class Admins::ChooseMirrorRepositoriesController < Admins::BaseController
+  def new
+    @mirror     = MirrorRepository.find(params[:mirror_id])
+    @new_mirror = MirrorOperationRecord.where(mirror_repository_id: @mirror.id, status: 1, user_id: -1).first
+  end
+
+  def create
+    mirror = MirrorRepository.find(params[:mirror_id])
+    Admins::ChooseMirrorService.call(mirror, current_user, params[:mirror_number])
+  end
+end

app/controllers/admins/contact_us_controller.rb

@@ -0,0 +1,28 @@
+class Admins::ContactUsController < Admins::BaseController
+  def edit
+    @cooperations = Cooperation.all.group(:user_type)
+    @help = Help.first
+  end
+
+  def update
+    cooperation = Cooperation.find(params[:id])
+    cooperation.update!(update_cooperation_params)
+
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_contact_us_path
+  end
+
+  def update_address
+    help = Help.first || Help.create
+    help.update!(status: params.dig('help', 'status'))
+
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_contact_us_path
+  end
+
+  private
+
+  def update_cooperation_params
+    params.require(:cooperation).permit(:name, :qq, :mail)
+  end
+end

app/controllers/admins/cooperatives_controller.rb

@@ -0,0 +1,84 @@
+class Admins::CooperativesController < Admins::BaseController
+  before_action :convert_file!, only: [:create]
+
+  def index
+    @data = { 'alliance_coop' => [], 'com_coop' => [], 'edu_coop' => [] }
+    @data = @data.merge CooImg.all.group_by(&:img_type)
+  end
+
+  def create
+    position = CooImg.where(img_type: create_params[:img_type]).count + 1
+
+    ActiveRecord::Base.transaction do
+      coo = CooImg.create!(create_params.merge(position: position))
+
+      file_path = Util::FileManage.disk_filename('CooImg', coo.id)
+      File.delete(file_path) if File.exist?(file_path) # 删除之前的文件
+      Util.write_file(@file, file_path)
+
+      coo.update!(url_states: Util::FileManage.disk_file_url('CooImg', coo.id))
+    end
+
+    flash[:success] = '保存成功'
+    redirect_to admins_cooperatives_path
+  end
+
+  def update
+    current_coo.update!(src_states: params[:url])
+    render_ok
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      current_coo.destroy!
+      # 前移
+      CooImg.where(img_type: current_coo.img_type).where('position > ?', current_coo.position)
+        .update_all('position = position - 1')
+
+      file_path = Util::FileManage.disk_filename('CooImg', current_coo.id)
+      File.delete(file_path) if File.exist?(file_path)
+    end
+    render_delete_success
+  end
+
+  def drag
+    move  = CooImg.find_by(id: params[:move_id])
+    after = CooImg.find_by(id: params[:after_id])
+
+    Admins::DragCooperativeService.call(move, after)
+    render_ok
+  rescue Admins::DragCooperativeService::Error => e
+    render_error(e.message)
+  end
+
+  def replace_image_url
+    current_coo.update!(url_states: Util::FileManage.disk_file_url('CooImg', current_coo.id))
+    render_ok
+  end
+
+  private
+
+  def current_coo
+    @_current_coo ||= CooImg.find(params[:id])
+  end
+
+  def create_params
+    params.require(:coo_img).permit(:img_type, :src_states)
+  end
+
+  def convert_file!
+    max_size = 10 * 1024 * 1024 # 10M
+    file = params.dig('coo_img', 'image')
+    if file.class == ActionDispatch::Http::UploadedFile
+      @file = file
+      render_error('请上传文件') if @file.size.zero?
+      render_error('文件大小超过限制') if @file.size > max_size
+    else
+      file = file.to_s.strip
+      return render_error('请上传正确的图片') if file.blank?
+      @file = Util.convert_base64_image(file, max_size: max_size)
+    end
+  rescue Base64ImageConverter::Error => ex
+    render_error(ex.message)
+  end
+end

app/controllers/admins/course_lists_controller.rb

@@ -0,0 +1,35 @@
+class Admins::CourseListsController < Admins::BaseController
+
+  def index
+    course_lists = Admins::CourseListQuery.call(params)
+    @course_lists = paginate course_lists.preload(:courses, :user)
+    @params_page = params[:page] || 1
+    respond_to do |format|
+      format.js
+      format.html
+    end
+  end
+
+  def destroy
+    CourseList.find(params[:id]).destroy!
+
+    render_delete_success
+  end
+
+  def merge
+    origin_course_list = CourseList.find_by!(id: params[:origin_course_list_id])
+    o_courselist = CourseList.find_by(name: params[:course_list_name])
+    if o_courselist
+      origin_course_list.courses.each do |course|
+        course.update!(name: course.name.sub(origin_course_list.name, params[:course_list_name]), course_list_id: o_courselist.id)
+      end
+      origin_course_list.destroy
+    else
+      origin_course_list.courses.each do |course|
+        course.update!(name: course.name.sub(origin_course_list.name, params[:course_list_name]))
+      end
+      origin_course_list.update!(name: params[:course_list_name])
+    end
+    render_ok
+  end
+end

app/controllers/admins/courses_controller.rb

@@ -0,0 +1,47 @@
+class Admins::CoursesController < Admins::BaseController
+  before_action :find_course, except: [:index]
+
+  def index
+    default_sort('created_at', 'desc')
+
+    courses = Admins::CourseQuery.call(params)
+    @ended_courses = courses.where(is_end: 1).size
+    @processed_courses = courses.where(is_end: 0).size
+    @courses = paginate courses.includes(:school, :students, :attachments, :homework_commons, teacher: :user_extension)
+
+    respond_to do |format|
+      format.js
+      format.html
+      format.xlsx do
+        @courses = courses.includes(:school, :students, :attachments, :homework_commons, :course_acts, teacher: :user_extension)
+        filename = "课堂列表_#{Time.current.strftime('%Y%m%d%H%M%S')}.xlsx"
+        render xlsx: 'index', filename: filename
+      end
+    end
+  end
+
+  def destroy
+    if @course.is_delete == 0
+      @course.delete!
+      Tiding.create!(user_id: current_user.id, trigger_user_id: current_user.id, container_id: @course.id,
+                     container_type: 'DeleteCourse', tiding_type: 'System', belong_container: @course, extra: @course.name)
+    end
+  end
+
+  def update
+    unless @course.update_attributes!(setting_params)
+      redirect_to admins_courses_path
+      flash[:danger] = "更新失败"
+    end
+  end
+
+  private
+
+  def find_course
+    @course = Course.find_by!(id: params[:id])
+  end
+
+  def setting_params
+    params.permit(:homepage_show, :email_notify)
+  end
+end

app/controllers/admins/customers_controller.rb

@@ -0,0 +1,39 @@
+class Admins::CustomersController < Admins::BaseController
+  # skip_before_action :check_sign
+  helper_method :current_partner
+
+  def index
+    default_sort('created_at', 'desc')
+
+    customers = Admins::CustomerQuery.call(params.merge(partner_id: current_partner.id))
+    @customers = paginate(customers.preload(:school))
+  end
+
+  def create
+    params[:school_ids] = Array.wrap(params[:school_ids])
+    school_ids = School.where(id: params[:school_ids]).pluck(:id)
+
+    ActiveRecord::Base.transaction do
+      school_ids.each do |school_id|
+        next if current_partner.customers.exists?(school_id)
+
+        customer = Customer.create!(school_id: school_id)
+        current_partner.partner_customers.create!(customer: customer)
+      end
+    end
+
+    render_ok
+  end
+
+  def destroy
+    current_partner.customers.find(params[:id]).destroy!
+
+    render_delete_success
+  end
+
+  private
+
+  def current_partner
+    @_current_partner ||= Partner.find(params[:partner_id])
+  end
+end

app/controllers/admins/daily_school_statistics_controller.rb

@@ -0,0 +1,37 @@
+class Admins::DailySchoolStatisticsController < Admins::BaseController
+  def index
+    params[:sort_by] = params[:sort_by].presence || :teacher_count
+    params[:sort_direction] = params[:sort_direction].presence || :desc
+
+    total_count, statistics = Admins::SchoolDailyStatisticService.call(params)
+
+    @statistics = paginate statistics, total_count: total_count
+    @params_page = params[:page] || 1
+
+    respond_to do |format|
+      format.html { load_statistic_total }
+      format.js
+    end
+  end
+
+  def export
+    params[:per_page] = 10000
+    _count, @schools = Admins::SchoolDailyStatisticService.call(params)
+
+    filename = ['学校统计总表', params[:keyword], Time.zone.now.strftime('%Y%m%d%H%M%S')].join('-') << '.xlsx'
+    render xlsx: 'export', filename: filename
+  end
+
+  private
+
+  def load_statistic_total
+    @teacher_total         = User.joins(:user_extension).where(user_extensions: { identity: :teacher }).count
+    @student_total         = User.joins(:user_extension).where(user_extensions: { identity: :student }).count
+    @course_total          = Course.count
+    @active_course_total   = Course.where(is_end: false).count
+    @shixun_homework_total = HomeworkCommon.where(homework_type: 4).count
+    @other_homework_total  = HomeworkCommon.where(homework_type: [1, 3]).count
+    @shixun_total          = Shixun.count
+    @shixun_evaluate_total = SchoolReport.sum(:shixun_evaluate_count)
+  end
+end

app/controllers/admins/dashboards_controller.rb

@@ -0,0 +1,51 @@
+class Admins::DashboardsController < Admins::BaseController
+  def index
+    @active_user_count = User.where(last_login_on: today).count
+    @weekly_active_user_count = User.where(last_login_on: current_week).count
+    @month_active_user_count = User.where(last_login_on: current_month).count
+
+    @new_user_count = User.where(created_on: current_month).count
+  end
+
+  def month_active_user
+    count = UserExtension.where(created_at: current_month).group(:identity).count
+
+    data = [
+      { value: count['teacher'].to_i, name: '老师' },
+      { value: count['student'].to_i, name: '学生' },
+      { value: count['professional'].to_i, name: '专业人士' },
+      { value: count[nil].to_i, name: '未选职业' },
+    ]
+
+    render_ok(data: data)
+  end
+
+  def evaluate
+    names = []
+    data = []
+
+    1.upto(7) do |i|
+      date = i.days.ago
+      names.unshift(date.strftime('%Y-%m-%d'))
+
+      count = Output.where(created_at: date.beginning_of_day..date.end_of_day).count
+      data.unshift(count)
+    end
+
+    render_ok(names: names, data: data)
+  end
+
+  private
+
+  def today
+    Time.now.beginning_of_day..Time.now.end_of_day
+  end
+
+  def current_week
+    7.days.ago.beginning_of_day..Time.now.end_of_day
+  end
+
+  def current_month
+    30.days.ago.beginning_of_day..Time.now.end_of_day
+  end
+end

app/controllers/admins/department_applies_controller.rb

@@ -0,0 +1,106 @@
+class Admins::DepartmentAppliesController < Admins::BaseController
+
+  before_action :get_apply,only:[:agree,:destroy]
+
+  def index
+    params[:status] ||= 0
+    params[:sort_by] = params[:sort_by].presence || 'created_at'
+    params[:sort_direction] = params[:sort_direction].presence || 'desc'
+    applies = Admins::DepartmentApplyQuery.call(params)
+    @depart_applies = paginate applies.preload(:school,user: :user_extension)
+  end
+
+  def agree
+    ActiveRecord::Base.transaction do
+      @depart_apply.update_attribute("status",1)
+      @depart_apply&.applied_messages&.update_all(status:1)
+      @depart_apply&.department&.update_attribute("is_auth",1)
+      @depart_apply&.user&.user_extension&.update_attribute("department_id",@depart_apply.department_id)
+      render_success_js
+    end
+  end
+
+  def merge
+    apply_id = params[:origin_department_id]
+    apply_add =ApplyAddDepartment.find(apply_id)
+    origin_id = apply_add&.department_id
+    new_id = params[:department_id]
+
+    return render_error('请选择其它部门') if origin_id.to_s == new_id.to_s
+
+    origin_department = apply_add&.department
+    to_department = Department.find(new_id)
+
+    return render_error('部门所属单位不相同') if origin_department&.school_id != to_department&.school_id
+
+    ActiveRecord::Base.transaction do
+      applied_message = AppliedMessage.where(applied_id: origin_id, applied_type: "ApplyAddDepartment")
+
+      applied_message.update_all(:status => 4)
+      apply_add.update_attribute(:status, 2)
+      apply_add.tidings.update_all(:status => 1)
+
+      extra = to_department&.name + "(#{apply_add&.department&.school&.try(:name)})"
+      tiding_params = {
+        user_id: apply_add.user_id,
+        trigger_user_id: 0,
+        container_id: apply_add.id,
+        container_type: 'ApplyAddDepartment',
+        belong_container_id: apply_add&.department&.school_id,
+        belong_container_type: "School",
+        tiding_type: "System",
+        status: 3,
+        extra: extra
+      }
+      Tiding.create(tiding_params)
+
+      origin_department.apply_add_departments.delete_all
+
+      origin_department.user_extensions.update_all(department_id: new_id)
+
+      if to_department.identifier.blank? && origin_department.identifier.present?
+        to_department.update!(identifier: origin_department.identifier)
+      end
+
+      origin_department.destroy!
+      apply_add.destroy!
+    end
+    render_ok
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      @depart_apply.update_attribute("status",3)
+      @depart_apply&.applied_messages&.update_all(status:3)
+
+      if params[:tip] == 'unapplied'   #未审批时候删除
+        user_extens = UserExtension.where(department_id: @depart_apply.department_id)
+        user_extens.update_all(department_id:nil)
+        User.where(id: user_extens.pluck(:user_id)).update_all(profile_completed:false)
+
+        tiding_params = {
+          user_id: @depart_apply.user_id,
+          trigger_user_id: 0,
+          container_id: @depart_apply.id,
+          container_type: 'ApplyAddDepartment',
+          belong_container_id: @depart_apply&.department&.school_id,
+          belong_container_type: "School",
+          tiding_type: "System",
+          status: 2,
+          extra: params[:reason]
+        }
+        Tiding.create(tiding_params)
+      end
+
+      @depart_apply&.department&.destroy
+      @depart_apply.destroy
+      render_success_js
+    end
+  end
+
+  private
+
+  def get_apply
+    @depart_apply = ApplyAddDepartment.find_by(id:params[:id])
+  end
+end

app/controllers/admins/department_members_controller.rb

@@ -0,0 +1,20 @@
+class Admins::DepartmentMembersController < Admins::BaseController
+
+  helper_method :current_department
+
+  def create
+    Admins::AddDepartmentMemberService.call(current_department, params)
+    current_department.reload
+  end
+
+  def destroy
+    @member = current_department.department_members.find_by(user_id: params[:user_id])
+    @member.destroy! if @member.present?
+  end
+
+  private
+
+  def current_department
+    @_current_department ||= Department.find(params[:department_id])
+  end
+end

app/controllers/admins/departments_controller.rb

@@ -0,0 +1,95 @@
+class Admins::DepartmentsController < Admins::BaseController
+
+  helper_method :current_department
+
+  def index
+    params[:sort_by] ||= 'created_at'
+    params[:sort_direction] ||= 'desc'
+
+    departments = Admins::DepartmentQuery.call(params)
+
+    @departments = paginate departments.preload(:school, :member_users)
+
+    department_ids = @departments.map(&:id)
+    @users_count = UserExtension.where(department_id: department_ids).group(:department_id).count
+    @professional_auth_count = UserExtension.where(department_id: department_ids)
+                                 .joins(:user).where(users: { professional_certification: true })
+                                 .group(:department_id).count
+  end
+
+  def create
+    department_name = params[:department_name].to_s.strip
+    school = School.find(params[:school_id])
+
+    return render_error('部门名称重复') if school.departments.exists?(name: department_name)
+
+    ActiveRecord::Base.transaction do
+      department = school.departments.create!(name: department_name, is_auth: 1)
+      ApplyAddDepartment.create!(school_id: school.id, status: 1, name: department.name,
+                                 department_id: department.id, user_id: current_user.id)
+    end
+
+    render_ok
+  end
+
+  def edit
+  end
+
+  def update
+    identifier = update_params.delete(:identifier).presence
+    if identifier && Department.where.not(id: current_department.id).exists?(identifier: identifier)
+      return render_error('统计链接重复', type: :notify)
+    end
+
+    current_department.update!(update_params.merge(identifier: identifier))
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      current_department.apply_add_departments.update_all(status: 2)
+
+      user_ids = current_department.user_extensions.pluck(:user_id)
+      if user_ids.present?
+        DeleteDepartmentNotifyJob.perform_later(current_department.id, 0, user_ids)
+        current_department.soft_delete!
+      else
+        current_department.destroy!
+      end
+    end
+
+    render_delete_success
+  end
+
+  def merge
+    return render_error('请选择其它部门') if params[:origin_department_id].to_s == params[:department_id].to_s
+
+    origin_department = Department.find(params[:origin_department_id])
+    to_department = Department.find(params[:department_id])
+
+    return render_error('部门所属单位不相同') if origin_department.school_id != to_department.school_id
+
+    ActiveRecord::Base.transaction do
+      origin_department.apply_add_departments.delete_all
+
+      origin_department.user_extensions.update_all(department_id: to_department.id)
+
+      if to_department.identifier.blank? && origin_department.identifier.present?
+        to_department.update!(identifier: origin_department.identifier)
+      end
+
+      origin_department.destroy!
+    end
+
+    render_ok
+  end
+
+  private
+
+  def current_department
+    @_current_department ||= Department.find(params[:id])
+  end
+
+  def update_params
+    params.require(:department).permit(:name, :identifier, :host_count)
+  end
+end

app/controllers/admins/disciplines_controller.rb

@@ -0,0 +1,77 @@
+class Admins::DisciplinesController < Admins::BaseController
+
+  def index
+    @disciplines = Discipline.all
+  end
+
+  def create
+    name = params[:name].to_s.strip
+    return render_error('名称重复') if Discipline.where(name: name).exists?
+    Discipline.create!(name: name, position: Discipline.all.pluck(:position).max + 1)
+    render_ok
+  end
+
+  def edit
+    @discipline = current_discipline
+  end
+
+  def update
+    begin
+      if params[:discipline] && params[:discipline][:name]
+        name = params[:discipline][:name].to_s.strip
+        current_discipline.update_attributes!(name: name)
+      else
+        ActiveRecord::Base.transaction do
+          current_discipline.update_attributes!(setting_params)
+          current_discipline.sub_disciplines.each do |sub|
+            sub.tag_disciplines.each do |tag|
+              tag.update_attributes!(setting_params)
+            end
+            sub.update_attributes!(setting_params)
+          end
+        end
+      end
+    rescue Exception => e
+      @message = e.message
+    end
+    @disciplines = Discipline.all
+  end
+
+  def destroy
+    @discipline_id = params[:id]
+    ActiveRecord::Base.transaction do
+      Discipline.where("position > #{current_discipline.position}").update_all("position=position-1")
+      current_discipline.destroy!
+    end
+  end
+
+  def adjust_position
+    max_position = Discipline.all.pluck(:position).max
+    opr = params[:opr] || "down"
+    if (params[:opr] == "up" && current_discipline.position == 1) || (params[:opr] == "down" && current_discipline.position == max_position)
+      @message = "超出范围"
+    else
+      ActiveRecord::Base.transaction do
+        if opr == "up"
+          Discipline.find_by("position = #{current_discipline.position - 1}")&.update!(position: current_discipline.position)
+          current_discipline.update!(position: current_discipline.position - 1)
+        else
+          Discipline.find_by("position = #{current_discipline.position + 1}")&.update!(position: current_discipline.position)
+          current_discipline.update!(position: current_discipline.position + 1)
+        end
+      end
+    end
+    @disciplines = Discipline.all
+  rescue Exception => e
+    @message = e.message
+  end
+
+  private
+  def current_discipline
+    @_current_discipline = Discipline.find params[:id]
+  end
+
+  def setting_params
+    params.permit(:shixun, :subject, :question)
+  end
+end

app/controllers/admins/ec_templates_controller.rb

@@ -0,0 +1,41 @@
+class Admins::EcTemplatesController < Admins::BaseController
+
+  def index
+    @params_page = params[:page] || 1
+    templates = EcTemplate.where(nil).includes(:attachments).order("updated_at desc")
+    @templates = paginate templates
+  end
+
+  def create_template
+    ActiveRecord::Base.transaction do
+      if params[:template_id] == "-1"
+        ec_template = EcTemplate.new(name: params[:name])
+        ec_template.save
+      else
+        ec_template = EcTemplate.find_by(id: params[:template_id])
+      end
+
+      if params[:attachment_id] != "-1"
+        attachment_id = params[:attachment_id]
+        attachment_tem = Attachment.find_by(id: attachment_id)
+
+        unless attachment_tem.container_id.present? &&  attachment_tem.container_id == ec_template&.id
+          attachment_tem.update_attributes(container_id: ec_template&.id, container_type: "EcTemplate")
+        end
+      end
+
+      @params_page = params[:page] || 1
+      templates = EcTemplate.where(nil).includes(:attachments).order("updated_at desc")
+      @templates = paginate templates
+    end
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      template = EcTemplate.find_by(id: params[:id])
+      template.destroy
+      render_success_js
+    end
+  end
+
+end

app/controllers/admins/examination_authentications_controller.rb

@@ -0,0 +1,30 @@
+class Admins::ExaminationAuthenticationsController < Admins::BaseController
+  def index
+    params[:status] ||= 'pending'
+    params[:sort_direction] = params[:status] == 'pending' ? 'asc' : 'desc'
+
+    applies = Admins::ApplyItemBankQuery.call(params.merge(type: "ExaminationBank"))
+
+    @applies = paginate applies.preload(user: { user_extension: [:school, :department] })
+  end
+
+  def agree
+    ActiveRecord::Base.transaction do
+      exam = ExaminationBank.find current_apply.container_id
+      current_apply.update!(status: 1)
+      exam.update!(public: 1)
+    end
+    render_success_js
+  end
+
+  def refuse
+    current_apply.update!(status: 2)
+    render_success_js
+  end
+
+  private
+
+  def current_apply
+    @_current_apply ||= ApplyAction.find(params[:id])
+  end
+end

app/controllers/admins/files_controller.rb

@@ -0,0 +1,51 @@
+class Admins::FilesController < Admins::BaseController
+  before_action :convert_file!, only: [:create]
+
+  def create
+    File.delete(file_path) if File.exist?(file_path) # 删除之前的文件
+
+    Util.write_file(@file, file_path)
+
+    render_ok(
+      source_id: params[:source_id],
+      source_type: params[:source_type].to_s,
+      suffix: params[:suffix].presence,
+      url: file_url
+    )
+  rescue StandardError => ex
+    logger_error(ex)
+    render_error('上传失败')
+  end
+
+  private
+
+  def convert_file!
+    max_size = 10 * 1024 * 1024 # 10M
+    if params[:file].class == ActionDispatch::Http::UploadedFile
+      @file = params[:file]
+      render_error('请上传文件') if @file.size.zero?
+      render_error('文件大小超过限制') if @file.size > max_size
+    else
+      file = params[:file].to_s.strip
+      return render_error('请上传正确的图片') if file.blank?
+      @file = Util.convert_base64_image(file, max_size: max_size)
+    end
+  rescue Base64ImageConverter::Error => ex
+    render_error(ex.message)
+  end
+
+  def file_path
+    @_file_path ||= begin
+      case params[:source_type].to_s
+      when 'Shixun' then
+        Util::FileManage.disk_filename('Shixun', params[:source_id], params[:suffix].presence)
+      else
+        Util::FileManage.disk_filename(params[:source_type].to_s, params[:source_id].to_s, params[:suffix].presence)
+      end
+    end
+  end
+
+  def file_url
+    Util::FileManage.disk_file_url(params[:source_type].to_s, params[:source_id].to_s, params[:suffix].presence)
+  end
+end

app/controllers/admins/graduation_standards_controller.rb

@@ -0,0 +1,33 @@
+class Admins::GraduationStandardsController < Admins::BaseController
+
+  def index
+    standards = EcGraduationStandard.all.order("updated_at desc")
+    @params_page = params[:page] || 1
+    @standards = paginate standards
+  end
+
+  def create_standard
+    ActiveRecord::Base.transaction do
+      if params[:graduation_id] == "-1"
+        content = params[:content]
+        EcGraduationStandard.create(:content => content)
+      else
+        graduation = EcGraduationStandard.find_by(id: params[:graduation_id])
+        graduation.update_attribute(:content, params[:content])
+      end
+
+      standards = EcGraduationStandard.all.order("updated_at desc")
+      @params_page = params[:page] || 1
+      @standards = paginate standards
+    end
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      @graduation = EcGraduationStandard.find_by(id: params[:id])
+      @graduation.destroy
+      render_success_js
+    end
+  end
+
+end

app/controllers/admins/help_centers_controller.rb

@@ -0,0 +1,18 @@
+class Admins::HelpCentersController < Admins::BaseController
+  def edit
+    current_doc
+  end
+
+  def update
+    current_doc.update!(help_center: params[:help_center])
+
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_help_center_path
+  end
+
+  private
+
+  def current_doc
+    @doc ||= Help.first || Help.create
+  end
+end

app/controllers/admins/identity_authentications_controller.rb

@@ -0,0 +1,45 @@
+class Admins::IdentityAuthenticationsController < Admins::BaseController
+  def index
+    params[:status] ||= 'pending'
+    params[:sort_direction] = params[:status] == 'pending' ? 'asc' : 'desc'
+
+    applies = Admins::ApplyUserAuthenticationQuery.call(params.merge(type: 1))
+
+    @applies = paginate applies.preload(user: { user_extension: [:school, :department] })
+  end
+
+  def agree
+    Admins::IdentityAuths::AgreeApplyService.call(current_apply)
+    render_success_js
+  end
+
+  def refuse
+    Admins::IdentityAuths::RefuseApplyService.call(current_apply, params)
+
+    render_success_js
+  end
+
+  def batch_agree
+    ApplyUserAuthentication.real_name_auth.where(id: params[:ids]).each do |apply|
+      begin
+        Admins::IdentityAuths::AgreeApplyService.call(apply)
+      rescue => e
+        Util.logger_error(e)
+      end
+    end
+
+    render_ok
+  end
+
+  def revoke
+    Admins::IdentityAuths::RevokeApplyService.call(current_apply)
+
+    render_success_js
+  end
+
+  private
+
+  def current_apply
+    @_current_apply ||= ApplyUserAuthentication.real_name_auth.find(params[:id])
+  end
+end

app/controllers/admins/import_course_members_controller.rb

@@ -0,0 +1,10 @@
+class Admins::ImportCourseMembersController < Admins::BaseController
+  def create
+    return render_error('请上传正确的文件') if params[:file].blank? || !params[:file].is_a?(ActionDispatch::Http::UploadedFile)
+
+    result = Admins::ImportCourseMemberService.call(params[:file].to_io)
+    render_ok(result)
+  rescue Admins::ImportCourseMemberService::Error => ex
+    render_error(ex)
+  end
+end

app/controllers/admins/import_disciplines_controller.rb

@@ -0,0 +1,10 @@
+class Admins::ImportDisciplinesController < Admins::BaseController
+  def create
+    return render_error('请上传正确的文件') if params[:file].blank? || !params[:file].is_a?(ActionDispatch::Http::UploadedFile)
+
+    result = Admins::ImportDisciplineService.call(params[:file].to_io)
+    render_ok(result)
+  rescue Admins::ImportDisciplineService::Error => ex
+    render_error(ex)
+  end
+end

app/controllers/admins/import_users_controller.rb

@@ -0,0 +1,10 @@
+class Admins::ImportUsersController < Admins::BaseController
+  def create
+    return render_error('请上传正确的文件') if params[:file].blank? || !params[:file].is_a?(ActionDispatch::Http::UploadedFile)
+
+    result = Admins::ImportUserService.call(params[:file].to_io)
+    render_ok(result)
+  rescue Admins::ImportUserService::Error => ex
+    render_error(ex)
+  end
+end

app/controllers/admins/item_authentications_controller.rb

@@ -0,0 +1,34 @@
+class Admins::ItemAuthenticationsController < Admins::BaseController
+  def index
+    params[:status] ||= 'pending'
+    params[:sort_direction] = params[:status] == 'pending' ? 'asc' : 'desc'
+
+    applies = Admins::ApplyItemBankQuery.call(params.merge(type: "ItemBank"))
+
+    @applies = paginate applies.preload(user: { user_extension: [:school, :department] })
+  end
+
+  def show
+    @item = ItemBank.find current_apply.container_id
+  end
+
+  def agree
+    ActiveRecord::Base.transaction do
+      item = ItemBank.find current_apply.container_id
+      current_apply.update!(status: 1)
+      item.update!(public: 1)
+    end
+    render_success_js
+  end
+
+  def refuse
+    current_apply.update!(status: 2)
+    render_success_js
+  end
+
+  private
+
+  def current_apply
+    @_current_apply ||= ApplyAction.find(params[:id])
+  end
+end

app/controllers/admins/laboratories_controller.rb

@@ -0,0 +1,85 @@
+class Admins::LaboratoriesController < Admins::BaseController
+  def index
+    default_sort('id', 'desc')
+
+    laboratories = Admins::LaboratoryQuery.call(params)
+    @laboratories = paginate laboratories.preload(:school, :laboratory_users)
+  end
+
+  def create
+    Admins::CreateLaboratoryService.call(create_params)
+    render_ok
+  rescue Admins::CreateLaboratoryService::Error => ex
+    render_error(ex.message)
+  end
+
+  def destroy
+    current_laboratory.destroy!
+
+    render_delete_success
+  end
+
+  def shixuns_for_select
+    except_shixun_ids = current_laboratory.laboratory_shixuns.pluck(:shixun_id)
+
+    shixuns = Shixun.where.not(id: except_shixun_ids)
+
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      like_sql = 'shixuns.name LIKE :keyword OR CONCAT(users.lastname, users.firstname) LIKE :keyword '\
+                 'OR mirror_repositories.name LIKE :keyword'
+      shixuns = shixuns.joins(:user, :mirror_repositories).where(like_sql, keyword: "%#{keyword}%")
+    end
+
+    @count = shixuns.count
+    @shixuns = paginate(shixuns.includes(:user))
+  end
+
+  def subjects_for_select
+    except_subject_ids = current_laboratory.laboratory_subjects.pluck(:subject_id)
+
+    subjects = Subject.where.not(id: except_subject_ids)
+
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      like_sql = 'subjects.name LIKE :keyword OR CONCAT(users.lastname, users.firstname) LIKE :keyword'
+      subjects = subjects.joins(:user).where(like_sql, keyword: "%#{keyword}%")
+    end
+
+    @count = subjects.count
+    @subjects = paginate(subjects.includes(:user))
+  end
+
+  def synchronize_user
+    school = current_laboratory.school
+    users = User.joins(:user_extension).where(user_extensions: {school_id: school.id})
+    users.update_all(laboratory_id: current_laboratory.id)
+  end
+
+  def update_sync_course
+    current_laboratory.update!(sync_course: !current_laboratory.sync_course)
+    @laboratory = current_laboratory
+  end
+
+  def update
+    @laboratory = current_laboratory
+    unless @laboratory.update_attributes!(setting_params)
+      redirect_to admins_laboratories_path
+      flash[:danger] = "更新失败"
+    end
+  end
+
+  private
+
+  def current_laboratory
+    @_current_laboratory ||= Laboratory.find(params[:id])
+  end
+
+  def create_params
+    params.permit(:school_id)
+  end
+
+  def setting_params
+    params.permit(:sync_course, :sync_subject, :sync_shixun)
+  end
+end

app/controllers/admins/laboratory_settings_controller.rb

@@ -0,0 +1,23 @@
+class Admins::LaboratorySettingsController < Admins::BaseController
+  def show
+    @laboratory = current_laboratory
+  end
+
+  def update
+    Admins::SaveLaboratorySettingService.call(current_laboratory, form_params)
+    render_ok
+  end
+
+  private
+
+  def current_laboratory
+    @_current_laboratory ||= Laboratory.find(params[:laboratory_id])
+  end
+
+  def form_params
+    params.permit(:identifier, :name,
+                  :nav_logo, :login_logo, :tab_logo, :oj_banner,
+                  :subject_banner, :course_banner, :competition_banner, :moop_cases_banner,
+                  :footer, navbar: %i[name link hidden])
+  end
+end

app/controllers/admins/laboratory_shixuns_controller.rb

@@ -0,0 +1,48 @@
+class Admins::LaboratoryShixunsController < Admins::BaseController
+  helper_method :current_laboratory, :current_laboratory_shixun
+
+  def index
+    laboratory_shixuns = Admins::LaboratoryShixunQuery.call(current_laboratory, params)
+    @laboratory_shixuns = paginate laboratory_shixuns.includes(shixun: %i[tag_repertoires user])
+  end
+
+  def create
+    shixun_ids = Array.wrap(params[:shixun_ids])
+    shixun_ids = Shixun.where(id: shixun_ids).pluck(:id)
+    exist_shixun_id = current_laboratory.laboratory_shixuns.where(shixun_id: shixun_ids).pluck(:shixun_id)
+
+    LaboratoryShixun.bulk_insert(*%i[shixun_id laboratory_id created_at updated_at]) do |worker|
+      (shixun_ids - exist_shixun_id).each do |shixun_id|
+        worker.add(shixun_id: shixun_id, laboratory_id: current_laboratory.id)
+      end
+    end
+    render_ok
+  end
+
+  def destroy
+    return render_js_error('不能删除自建实训', type: :notify) if current_laboratory_shixun.ownership?
+    current_laboratory_shixun.destroy!
+
+    render_delete_success
+  end
+
+  def homepage
+    current_laboratory_shixun.update!(homepage: true)
+    render_ok
+  end
+
+  def cancel_homepage
+    current_laboratory_shixun.update!(homepage: false)
+    render_ok
+  end
+
+  private
+
+  def current_laboratory
+    @_current_laboratory ||= Laboratory.find(params[:laboratory_id])
+  end
+
+  def current_laboratory_shixun
+    @_current_laboratory_shixun ||= current_laboratory.laboratory_shixuns.find(params[:id])
+  end
+end

app/controllers/admins/laboratory_subjects_controller.rb

@@ -0,0 +1,51 @@
+class Admins::LaboratorySubjectsController < Admins::BaseController
+  helper_method :current_laboratory, :current_laboratory_subject
+
+  def index
+    laboratory_subjects = Admins::LaboratorySubjectQuery.call(current_laboratory, params)
+
+    includes_tables = { subject: [:repertoire, :subject_level_system, user: {user_extension: :school}] }
+    @laboratory_subjects = paginate(laboratory_subjects.includes(includes_tables))
+  end
+
+  def create
+    subject = Subject.find(params[:subject_id])
+    Subjects::CopySubjectService.call(subject, current_user, current_laboratory)
+    render_ok
+  end
+
+  def destroy
+    return render_js_error('不能删除自建课程', type: :notify) if current_laboratory_subject.ownership?
+
+    ActiveRecord::Base.transaction do
+      current_subject = current_laboratory_subject.subject
+      # 实训软删除，并解除与子站的关联
+      current_laboratory.laboratory_shixuns.where(shixun_id: current_subject.shixuns).destroy_all
+      current_subject.shixuns.update_all(status: -1)
+      current_subject.destroy!
+
+      render_delete_success
+    end
+  end
+
+
+  def homepage
+    current_laboratory_subject.update!(homepage: true)
+    render_ok
+  end
+
+  def cancel_homepage
+    current_laboratory_subject.update!(homepage: false)
+    render_ok
+  end
+
+  private
+
+  def current_laboratory
+    @_current_laboratory ||= Laboratory.find(params[:laboratory_id])
+  end
+
+  def current_laboratory_subject
+    @_current_laboratory_subject ||= current_laboratory.laboratory_subjects.find(params[:id])
+  end
+end

app/controllers/admins/laboratory_users_controller.rb

@@ -0,0 +1,19 @@
+class Admins::LaboratoryUsersController < Admins::BaseController
+  helper_method :current_laboratory
+
+  def create
+    Admins::AddLaboratoryUserService.call(current_laboratory, params.permit(user_ids: []))
+    current_laboratory.reload
+  end
+
+  def destroy
+    @laboratory_user = current_laboratory.laboratory_users.find_by(user_id: params[:user_id])
+    @laboratory_user.destroy! if @laboratory_user.present?
+  end
+
+  private
+
+  def current_laboratory
+    @_current_laboratory ||= Laboratory.find(params[:laboratory_id])
+  end
+end

app/controllers/admins/library_applies_controller.rb

@@ -0,0 +1,25 @@
+class Admins::LibraryAppliesController < Admins::BaseController
+  def index
+    params[:status] ||= 'pending'
+    applies = Admins::LibraryApplyQuery.call(params)
+
+    @library_applies = paginate applies.preload(library: :user)
+  end
+
+  def agree
+    Libraries::AgreeApplyService.new(current_library_apply, current_user).call
+    render_success_js
+  end
+
+  def refuse
+    Libraries::RefuseApplyService.new(current_library_apply, current_user, reason: params[:reason]).call
+
+    render_success_js
+  end
+
+  private
+
+  def current_library_apply
+    @_current_library_apply ||= LibraryApply.find(params[:id])
+  end
+end

app/controllers/admins/major_informations_controller.rb

@@ -0,0 +1,8 @@
+class Admins::MajorInformationsController < Admins::BaseController
+
+  def index
+    disciplines = EcDiscipline.includes(ec_discipline_firsts: {ec_majors: :schools}).order("ec_disciplines.code asc")
+    @disciplines = paginate disciplines
+  end
+
+end

app/controllers/admins/mirror_repositories_controller.rb

@@ -0,0 +1,96 @@
+class Admins::MirrorRepositoriesController < Admins::BaseController
+  before_action :check_shixun_mirrors!, only: [:index]
+
+  def index
+    mirrors = MirrorRepository.all
+    mirrors = mirrors.reorder(status: :desc, main_type: :desc, type_name: :asc)
+
+    @mirrors = paginate mirrors.includes(:mirror_scripts)
+    @error_mirror_names = MirrorRepository.where(status: 5).pluck(:name)
+  end
+
+  def new
+    @mirror = MirrorRepository.new
+  end
+
+  def create
+    @mirror = MirrorRepository.new
+    Admins::SaveMirrorRepositoryService.call(@mirror, current_user, form_params)
+
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_mirror_repository_path(@mirror)
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = '保存失败'
+    render 'new'
+  rescue Admins::SaveMirrorRepositoryService::Error => ex
+    flash.now[:danger] = ex.message
+    render 'new'
+  end
+
+  def edit
+    @mirror = current_mirror
+  end
+
+  def update
+    @mirror = current_mirror
+
+    Admins::SaveMirrorRepositoryService.call(current_mirror, current_user, form_params)
+
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_mirror_repository_path(current_mirror)
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = '保存失败'
+    render 'edit'
+  rescue Admins::SaveMirrorRepositoryService::Error => ex
+    flash.now[:danger] = ex.message
+    render 'edit'
+  end
+
+  def destroy
+    return render_js_error('该状态下不允许删除') unless current_mirror.deletable?
+
+    current_mirror.destroy!
+
+    render_delete_success
+  end
+
+  def for_select
+    mirrors = MirrorRepository.all
+
+    keyword = params[:keyword].to_s.strip
+    mirrors = mirrors.where('name LIKE ?', "%#{keyword}%") if keyword.present?
+
+    @mirrors = paginate mirrors
+
+    render_ok(count: @mirrors.total_count, mirrors: @mirrors.as_json(only: %i[id name]))
+  end
+
+  def merge
+    origin_mirror = MirrorRepository.find(params[:mirror_id])
+    mirror = MirrorRepository.find(params[:new_mirror_id])
+
+    ActiveRecord::Base.transaction do
+      origin_mirror.update!(name: mirror.name, mirrorID: mirror.mirrorID)
+      mirror.destroy!
+    end
+  end
+
+  private
+
+  def current_mirror
+    @_current_mirror ||= MirrorRepository.find(params[:id])
+  end
+
+  def form_params
+    columns = %i[type_name main_type time_limit resource_limit cpu_limit memory_limit description status]
+    params.require(:mirror_repository).permit(*columns)
+  end
+
+  def check_shixun_mirrors!
+    return unless request.format.html?
+
+    Admins::CheckShixunMirrorsService.call
+  rescue Admins::CheckShixunMirrorsService::Error => e
+    internal_server_error(e.message)
+  end
+end

app/controllers/admins/mirror_scripts_controller.rb

@@ -0,0 +1,59 @@
+class Admins::MirrorScriptsController < Admins::BaseController
+  helper_method :current_mirror
+
+  def index
+    scripts = current_mirror.mirror_scripts.order(updated_at: :desc)
+    @scripts = paginate scripts
+  end
+
+  def new
+    @script = current_mirror.mirror_scripts.new
+  end
+
+  def create
+    @script = current_mirror.mirror_scripts.new(form_params)
+
+    if @script.save
+      flash[:success] = '保存成功'
+      redirect_to edit_admins_mirror_repository_mirror_script_path(current_mirror, @script)
+    else
+      flash[:danger] = '保存失败'
+      render 'new'
+    end
+  end
+
+  def edit
+    @script = current_script
+  end
+
+  def update
+    @script = current_script
+
+    if @script.update(form_params)
+      flash[:success] = '保存成功'
+      redirect_to edit_admins_mirror_repository_mirror_script_path(current_mirror, @script)
+    else
+      flash[:danger] = '保存失败'
+      render 'edit'
+    end
+  end
+
+  def destroy
+    current_script.destroy!
+    render_delete_success
+  end
+
+  private
+
+  def current_script
+    @_current_script ||= current_mirror.mirror_scripts.find(params[:id])
+  end
+
+  def current_mirror
+    @_current_mirror ||= MirrorRepository.find(params[:mirror_repository_id])
+  end
+
+  def form_params
+    params.require(:mirror_script).permit(:script_type, :description, :script)
+  end
+end

app/controllers/admins/partners_controller.rb

@@ -0,0 +1,29 @@
+class Admins::PartnersController < Admins::BaseController
+  def index
+    default_sort('created_at', 'desc')
+
+    partners = Admins::PartnerQuery.call(params)
+    @partners = paginate(partners.preload(:school))
+  end
+
+  def create
+    params[:school_ids] = Array.wrap(params[:school_ids])
+
+    school_ids = School.where(id: params[:school_ids]).pluck(:id)
+    exist_school_ids = Partner.where(school_id: school_ids).pluck(:school_id)
+
+    Partner.bulk_insert(*%i[school_id created_at updated_at]) do |worker|
+      (school_ids - exist_school_ids).each do |school_id|
+        worker.add(school_id: school_id)
+      end
+    end
+
+    render_ok
+  end
+
+  def destroy
+    Partner.find(params[:id]).destroy!
+
+    render_delete_success
+  end
+end

app/controllers/admins/professional_authentications_controller.rb

@@ -0,0 +1,44 @@
+class Admins::ProfessionalAuthenticationsController < Admins::BaseController
+  def index
+    params[:status] ||= 'pending'
+    params[:sort_direction] = params[:status] == 'pending' ? 'asc' : 'desc'
+
+    applies = Admins::ApplyUserAuthenticationQuery.call(params.merge(type: 2))
+
+    @applies = paginate applies.preload(user: { user_extension: [:school, :department] })
+  end
+
+  def agree
+    Admins::ProfessionalAuths::AgreeApplyService.call(current_apply)
+    render_success_js
+  end
+
+  def refuse
+    Admins::ProfessionalAuths::RefuseApplyService.call(current_apply, params)
+
+    render_success_js
+  end
+
+  def batch_agree
+    ApplyUserAuthentication.professional_auth.where(id: params[:ids]).each do |apply|
+      begin
+        Admins::ProfessionalAuths::AgreeApplyService.call(apply)
+      rescue => e
+        Util.logger_error(e)
+      end
+    end
+
+    render_ok
+  end
+
+  def revoke
+    Admins::ProfessionalAuths::RevokeApplyService.call(current_apply)
+    render_success_js
+  end
+
+  private
+
+  def current_apply
+    @_current_apply ||= ApplyUserAuthentication.professional_auth.find(params[:id])
+  end
+end

app/controllers/admins/project_package_applies_controller.rb

@@ -0,0 +1,37 @@
+class Admins::ProjectPackageAppliesController < Admins::BaseController
+  before_action :current_apply,only: [:agree,:refuse]
+
+  def index
+    params[:status] ||= 'pending'
+    status = params[:status]
+    if status == 'all'
+      status = %w(agreed refused)
+    end
+    package_applies = ProjectPackageApply.where(status: status)
+    keyword = params[:keyword].to_s.strip || ""
+    if keyword.present?
+      package_applies = package_applies.joins(:project_package).where("project_packages.title like ?","%#{keyword}%")
+    end
+    @package_applies = paginate package_applies.includes(project_package: { creator: :user_extension })
+  end
+
+  def agree
+    ProjectPackages::AgreeApplyService.new(current_apply).call
+    render_success_js
+  rescue ProjectPackages::AgreeApplyService::Error => e
+    render json: { status: -1, message: e.message }
+  end
+
+  def refuse
+    ProjectPackages::RefuseApplyService.new(current_apply, reason: params[:reason]).call
+    render_success_js
+  rescue ProjectPackages::RefuseApplyService::Error => e
+    render json: { status: -1, message: e.message }
+  end
+
+  private
+
+  def current_apply
+    @_current_apply ||= ProjectPackageApply.find(params[:id])
+  end
+end

app/controllers/admins/project_statistics_controller.rb

@@ -0,0 +1,70 @@
+class Admins::ProjectStatisticsController < Admins::BaseController
+
+
+  def index
+    projects = Project.project_statics_select.all
+    by_time = params[:time]
+    project_type = params[:project_type]
+    is_private = params[:is_private]
+    project_category_id = params[:project_category_id]
+    project_language_id = params[:project_language_id]
+    license_id = params[:license_id]
+
+    projects = projects.where(project_type: project_type)  if project_type.present?
+    projects = projects.where(is_private: is_private)  if is_private.present?
+    projects = projects.where(project_category_id: project_category_id)  if project_category_id.present?
+    projects = projects.where(project_language_id: project_language_id)  if project_language_id.present?
+    projects = projects.where(license_id: license_id)  if license_id.present?
+
+    if by_time.present?
+      case by_time.to_s
+      when "week"
+        projects = projects.group_by_week(:created_on).size
+      when "month"
+        projects = projects.group_by_month(:created_on).size
+      when "quarter"
+        projects = projects.group_by_month(:created_on).size
+      when "year"
+        projects = projects.group_by_year(:created_on).size
+      else
+        projects = projects.group_by_day(:created_on).size
+      end
+    end
+    @projects = projects
+  end
+
+  def visits_static
+    projects = Project.project_statics_select.all
+    by_time = params[:time]
+    project_type = params[:project_type]
+    is_private = params[:is_private]
+    project_category_id = params[:project_category_id]
+    project_language_id = params[:project_language_id]
+    license_id = params[:license_id]
+
+    projects = projects.where(project_type: project_type)  if project_type.present?
+    projects = projects.where(is_private: is_private)  if is_private.present?
+    projects = projects.where(project_category_id: project_category_id)  if project_category_id.present?
+    projects = projects.where(project_language_id: project_language_id)  if project_language_id.present?
+    projects = projects.where(license_id: license_id)  if license_id.present?
+
+    if by_time.present?
+      case by_time.to_s
+      when "week"
+        projects = projects.group_by_week(:created_on).size
+      when "month"
+        projects = projects.group_by_month(:created_on).size
+      when "quarter"
+        projects = projects.group_by_month(:created_on).size
+      when "year"
+        projects = projects.group_by_year(:created_on).size
+      else
+        projects = projects.group_by_day(:created_on).size
+      end
+    end
+    @projects = projects
+  end
+
+
+
+end

app/controllers/admins/projects_controller.rb

@@ -0,0 +1,25 @@
+class Admins::ProjectsController < Admins::BaseController
+
+  def index
+    default_sort('created_at', 'desc')
+
+    search = params[:search].to_s.strip
+    projects = Project.where("name like ?", "%#{search}%")
+    @projects = paginate projects.includes(:owner, :members, :issues, :versions, :attachments, :project_score)
+  end
+
+  def destroy
+    project = Project.find_by!(id: params[:id])
+    ActiveRecord::Base.transaction do
+      g = Gitlab.client
+      g.delete_project(project.gpid)
+      # 删除Trustie版本库记录
+      repoisitory = Repository.where(project_id: project.id, type: "Repository::Gitlab").first
+      repoisitory.destroy!
+      Tiding.where(container_id: project.id, container_type: ["JoinProject", "DealProject", "ReporterJoinProject", "ManagerJoinProject"]).destroy_all
+      project.destroy!
+      render_delete_success
+    end
+  end
+
+end

app/controllers/admins/repertoires_controller.rb

@@ -0,0 +1,36 @@
+class Admins::RepertoiresController < Admins::BaseController
+
+  def index
+    @repertoires = Repertoire.all
+  end
+
+  def edit
+    @repertoire = current_repertoire
+  end
+
+  def update
+    Rails.logger.info("#################--------")
+    if params[:repertoire] && params[:repertoire][:name].present?
+      name = params[:repertoire][:name].to_s.strip
+      current_repertoire.update_attributes!(name: name)
+    end
+    @repertoires = Repertoire.all
+  end
+
+  def create
+    name = params[:name].to_s.strip
+    return render_error('名称重复') if Repertoire.where(name: name).exists?
+    Repertoire.create!(name: name)
+    render_ok
+  end
+
+  def destroy
+    @repertoire_id = params[:id]
+    current_repertoire.destroy!
+  end
+
+  private
+  def current_repertoire
+    @_current_repertoire = Repertoire.find params[:id]
+  end
+end

app/controllers/admins/salesman_channels_controller.rb

@@ -0,0 +1,35 @@
+class Admins::SalesmanChannelsController < Admins::BaseController
+  before_action :set_salesman
+
+  def index
+    @channels = @salesman.salesman_channels
+    if params[:keyword].present?
+      @channels = @channels.joins(:school).where("schools.name like ?", "%#{params[:keyword]}%")
+    end
+    @start_time = params[:start_date]
+    @end_time = params[:end_date].blank? ? Time.now : params[:end_date]
+  end
+
+  def batch_add
+    channel_ids = @salesman.salesman_channels.pluck(:school_id)
+    school_ids = params[:school_ids] - channel_ids
+    school_ids.each do |school_id|
+      school = School.find_by(id: school_id)
+      next if school.blank? || @salesman.salesman_channels.where(school_id: school.id).exists?
+      @salesman.salesman_channels.create!(school_id: school.id)
+    end
+    render_ok
+  rescue Exception => ex
+    render_error(ex.message)
+  end
+
+  def destroy
+    @salesman.salesman_channels.find_by!(id: params[:id]).destroy
+  end
+
+  private
+
+  def set_salesman
+    @salesman = Salesman.find params[:salesman_id]
+  end
+end

app/controllers/admins/salesman_customers_controller.rb

@@ -0,0 +1,28 @@
+class Admins::SalesmanCustomersController < Admins::BaseController
+  before_action :set_salesman
+
+  def index
+    @customers = @salesman.salesman_customers.includes(:user, :school)
+  end
+
+  def batch_add
+    customer_ids = @salesman.salesman_customers.pluck(:user_id)
+    user_ids = params[:user_ids] - customer_ids
+    user_ids.each do |user_id|
+      user = UserExtension.find_by(user_id: user_id)
+      next if user.blank? || @salesman.salesman_customers.where(user_id: user.user_id).exists?
+      @salesman.salesman_customers.create!(user_id: user.user_id, school_id: user.school_id)
+    end
+    render_ok
+  end
+
+  def destroy
+    @salesman.salesman_customers.find_by!(id: params[:id]).destroy
+  end
+
+  private
+  def set_salesman
+    @salesman = Salesman.find params[:salesman_id]
+  end
+
+end

app/controllers/admins/salesmans_controller.rb

@@ -0,0 +1,29 @@
+class Admins::SalesmansController < Admins::BaseController
+  before_action :set_salesman, except: [:index, :batch_add]
+
+  def index
+    @salesmans = Salesman.all
+  end
+
+  def destroy
+    @salesman.destroy!
+  end
+
+  # 批量增加销售人员
+  def batch_add
+    salesman_user_ids = Salesman.where(id: params[:user_ids]).pluck(:user_id)
+    user_ids = params[:user_ids] - salesman_user_ids
+    user_ids.each do |user_id|
+      user = User.find_by(id: user_id)
+      next if user.blank?
+      Salesman.create!(user_id: user.id, name: user.real_name)
+    end
+    render_ok
+  end
+
+  private
+  def set_salesman
+    @salesman = Salesman.find params[:id]
+  end
+
+end

app/controllers/admins/school_statistics_controller.rb

@@ -0,0 +1,50 @@
+class Admins::SchoolStatisticsController < Admins::BaseController
+  before_action :contrast_column_select_options, only: [:contrast]
+
+  def index
+    params[:data_type] ||= 'grow'
+    params[:sort_by] = params[:sort_by].presence || :teacher_increase_count
+    params[:sort_direction] = params[:sort_direction].presence || :desc
+
+    service = Admins::StatisticSchoolDataGrowService.new(params)
+    @grow_summary = service.grow_summary
+
+    total_count, statistics = service.call
+    @params_page = params[:page] || 1
+
+    @statistics = paginate statistics, total_count: total_count
+  end
+
+  def contrast
+    params[:contrast_column] = params[:contrast_column].presence || :teacher_increase_count
+    params[:sort_direction] ||= :desc
+    params[:sort_by] = :percentage
+
+    # 无对比日期时直接返回无数据页面
+    if useless_contrast_date_parameter?
+      @total_count = 0
+      @statistics = paginate([])
+      return
+    end
+
+    total_count, statistics = Admins::StatisticSchoolContrastDataService.call(params)
+
+    @statistics = paginate statistics, total_count: total_count
+  rescue Admins::StatisticSchoolContrastDataService::ParameterError
+    render_unprocessable_entity('参数错误')
+  end
+
+  private
+
+  def useless_contrast_date_parameter?
+    params[:begin_date].blank? && params[:end_date].blank? &&
+      params[:other_begin_date].blank? &&params[:other_end_date].blank?
+  end
+
+  def contrast_column_select_options
+    @select_options =
+      Admins::StatisticSchoolContrastDataService::CONTRAST_COLUMN_LIST.map do |column|
+        [I18n.t("school_daily_report.#{column}"), column]
+      end
+  end
+end

app/controllers/admins/schools_controller.rb

@@ -0,0 +1,30 @@
+class Admins::SchoolsController < Admins::BaseController
+  def index
+    params[:sort_by] ||= 'created_at'
+    params[:sort_direction] ||= 'desc'
+
+    schools = Admins::SchoolQuery.call(params)
+    @total_count =  schools.map(&:id).count
+    @schools = paginate schools
+
+    school_ids = @schools.map(&:id)
+    @department_count = Department.where(school_id: school_ids).group(:school_id).count
+  end
+
+  def destroy
+    users = User.joins(:user_extension).where(user_extensions: { school_id: current_school.id })
+
+    ActiveRecord::Base.transaction do
+      users.update_all(profile_completed: false)
+      current_school.destroy!
+    end
+
+    render_delete_success
+  end
+
+  private
+
+  def current_school
+    @_current_school ||= School.find(params[:id])
+  end
+end

app/controllers/admins/sub_disciplines_controller.rb

@@ -0,0 +1,84 @@
+class Admins::SubDisciplinesController < Admins::BaseController
+
+  def index
+    @discipline = current_discipline
+    @sub_disciplines = current_discipline.sub_disciplines
+  end
+
+  def create
+    name = params[:name].to_s.strip
+    return render_error('名称不能为空') if name.blank?
+    return render_error('名称重复') if current_discipline.sub_disciplines.where(name: name).exists?
+    SubDiscipline.create!(name: name, discipline_id: current_discipline.id, position: current_discipline.sub_disciplines.pluck(:position).max + 1)
+    render_ok
+  end
+
+  def edit
+    @sub_discipline = current_sub_discipline
+  end
+
+  def update
+    begin
+      if params[:sub_discipline] && params[:sub_discipline][:name]
+        name = params[:sub_discipline][:name].to_s.strip
+        current_sub_discipline.update_attributes!(name: name)
+      else
+        ActiveRecord::Base.transaction do
+          current_sub_discipline.update_attributes!(setting_params)
+          current_sub_discipline.tag_disciplines.each do |tag|
+            tag.update_attributes!(setting_params)
+          end
+        end
+      end
+    rescue Exception => e
+      @message = e.message
+    end
+    @sub_disciplines = current_sub_discipline.discipline&.sub_disciplines
+  end
+
+  def destroy
+    @sub_discipline_id = params[:id]
+    ActiveRecord::Base.transaction do
+      discipline = current_sub_discipline.discipline
+      discipline.sub_disciplines.where("position > #{current_sub_discipline.position}").update_all("position=position-1")
+      current_sub_discipline.destroy!
+    end
+  end
+
+  def adjust_position
+    discipline = current_sub_discipline.discipline
+    max_position = discipline.sub_disciplines.pluck(:position).max
+    opr = params[:opr] || "down"
+    if (params[:opr] == "up" && current_sub_discipline.position == 1) || (params[:opr] == "down" && current_sub_discipline.position == max_position)
+      @message = "超出范围"
+    else
+      ActiveRecord::Base.transaction do
+        if opr == "up"
+          discipline.sub_disciplines.find_by("position = #{current_sub_discipline.position - 1}")&.update!(position: current_sub_discipline.position)
+          current_sub_discipline.update!(position: current_sub_discipline.position - 1)
+        else
+          discipline.sub_disciplines.find_by("position = #{current_sub_discipline.position + 1}")&.update!(position: current_sub_discipline.position)
+          current_sub_discipline.update!(position: current_sub_discipline.position + 1)
+        end
+      end
+    end
+    @sub_disciplines = discipline&.sub_disciplines
+  rescue Exception => e
+    @message = e.message
+  end
+
+
+  private
+
+  def current_sub_discipline
+    @_current_sub_discipline = SubDiscipline.find params[:id]
+  end
+
+  def current_discipline
+    @_current_discipline = Discipline.find params[:discipline_id]
+  end
+
+  def setting_params
+    params.permit(:shixun, :subject, :question)
+  end
+end

app/controllers/admins/sub_repertoires_controller.rb

@@ -0,0 +1,45 @@
+class Admins::SubRepertoiresController < Admins::BaseController
+
+  def index
+    @repertoire = current_repertoire
+    @sub_repertoires = current_repertoire.sub_repertoires
+  end
+
+  def create
+    name = params[:name].to_s.strip
+    return render_error('名称重复') if current_repertoire.sub_repertoires.where(name: name).exists?
+    SubRepertoire.create!(name: name, repertoire_id: current_repertoire.id)
+    render_ok
+  end
+
+  def edit
+    @sub_repertoire = current_sub_repertoire
+  end
+
+  def update
+    if params[:sub_repertoire] && params[:sub_repertoire][:name].present?
+      name = params[:sub_repertoire][:name].to_s.strip
+      current_sub_repertoire.update_attributes!(name: name)
+    end
+    @sub_repertoires = current_sub_repertoire.repertoire&.sub_repertoires
+  end
+
+  def destroy
+    @sub_repertoire_id = params[:id]
+    current_sub_repertoire.destroy!
+  end
+
+  private
+
+  def current_sub_repertoire
+    @_current_sub_repertoire = SubRepertoire.find params[:id]
+  end
+
+  def current_repertoire
+    @_current_repertoire = Repertoire.find params[:repertoire_id]
+  end
+
+  def setting_params
+    params.permit(:shixun, :subject, :question)
+  end
+end

app/controllers/admins/subject_authorizations_controller.rb

@@ -0,0 +1,49 @@
+class Admins::SubjectAuthorizationsController < Admins::BaseController
+  def index
+    params[:status] ||= 'pending'
+
+    applies = ApplyAction.where(container_type: 'ApplySubject')
+
+    status =
+      case params[:status]
+      when 'pending'   then 0
+      when 'processed' then [1, 2]
+      when 'agreed'    then 1
+      when 'refused'   then 2
+      else 0
+      end
+    applies = applies.where(status: status) if status.present?
+
+    # 关键字模糊查询
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      applies = applies.joins('JOIN subjects ON subjects.id = apply_actions.container_id')
+                  .where('subjects.name LIKE :keyword', keyword: "%#{keyword}%")
+    end
+
+    applies = applies.order(updated_at: :desc)
+
+    @applies = paginate applies.includes(user: :user_extension)
+
+    subject_ids = @applies.map(&:container_id)
+    @subject_map = Subject.where(id: subject_ids).each_with_object({}) { |s, h| h[s.id] = s }
+    @challenge_count_map = Challenge.joins(shixun: :stage_shixuns).where(st: 0, stage_shixuns: { subject_id: subject_ids}).group('subject_id').count
+  end
+
+  def agree
+    Admins::SubjectAuths::AgreeApplyService.call(current_apply, current_user)
+    render_success_js
+  end
+
+  def refuse
+    Admins::SubjectAuths::RefuseApplyService.call(current_apply, current_user, params)
+
+    render_success_js
+  end
+
+  private
+
+  def current_apply
+    @_current_apply ||= ApplyAction.where(container_type: 'ApplySubject').find(params[:id])
+  end
+end

app/controllers/admins/subject_settings_controller.rb

@@ -0,0 +1,34 @@
+class Admins::SubjectSettingsController < Admins::BaseController
+  def index
+    default_sort('created_at', 'desc')
+
+    subjects = Admins::SubjectQuery.call(params)
+    @sub_disciplines = SubDiscipline.where(subject: 1).pluck(:name,:id)
+    @subjects = paginate subjects.includes(:repertoire, :subject_level_system, :sub_disciplines)
+  end
+
+  def update
+    sub_discipline_ids = params[:sub_disciplines] || []
+    sub_ids = sub_discipline_ids.reject(&:blank?).map(&:to_i)
+    old_sub_ids = current_subject.sub_discipline_containers.pluck(:sub_discipline_id)
+    new_ids = sub_ids - old_sub_ids
+    delete_ids = old_sub_ids - sub_ids
+    sub_params = new_ids.map{|sub| {sub_discipline_id: sub}}
+    ActiveRecord::Base.transaction do
+      current_subject.sub_discipline_containers.where(sub_discipline_id: delete_ids).destroy_all
+      current_subject.sub_discipline_containers.create!(sub_params)
+    end
+  end
+
+  def update_mobile_show
+    subject = Subject.find(params[:subject_id])
+    subject.update_attributes(:show_mobile => params[:show_mobile])
+  end
+
+  private
+
+  def current_subject
+    @_current_subject ||= Subject.find(params[:id])
+  end
+
+end

app/controllers/admins/subjects_controller.rb

@@ -0,0 +1,71 @@
+class Admins::SubjectsController < Admins::BaseController
+  def index
+    default_sort('created_at', 'desc')
+
+    subjects = Admins::SubjectQuery.call(params)
+    @subjects = paginate subjects.includes(user: { user_extension: :school })
+  end
+
+  def edit
+    @subject = current_subject
+  end
+
+  def update
+    current_subject.update!(update_params)
+
+    flash[:success] = '保存成功'
+    redirect_to admins_subject_settings_path
+  end
+
+  def destroy
+    current_subject.destroy!
+
+    render_delete_success
+  end
+
+  # 隐藏
+  def hide
+    current_subject.update!(hidden: true)
+    render_ok
+  end
+
+  # 展示
+  def cancel_hide
+    current_subject.update!(hidden: false)
+    render_ok
+  end
+
+  # 设为主页展示
+  def homepage_show
+    current_subject.update!(homepage_show: true)
+    render_ok
+  end
+
+  # 取消主页展示
+  def cancel_homepage_show
+    current_subject.update!(homepage_show: false)
+    render_ok
+  end
+
+  # 设为金课
+  def excellent
+    current_subject.update!(excellent: true, public: 2)
+    render_ok
+  end
+
+  # 取消金课
+  def cancel_excellent
+    current_subject.update!(excellent: false)
+    render_ok
+  end
+
+  private
+
+  def current_subject
+    @_current_subject ||= Subject.find(params[:id])
+  end
+
+  def update_params
+    params.require(:subject).permit(:repertoire_id, :subject_level_system_id, :student_count)
+  end
+end

app/controllers/admins/tag_disciplines_controller.rb

@@ -0,0 +1,79 @@
+class Admins::TagDisciplinesController < Admins::BaseController
+
+  def index
+    @sub_discipline = current_sub_discipline
+    @tag_disciplines = current_sub_discipline.tag_disciplines
+  end
+
+  def create
+    name = params[:name].to_s.strip
+    return render_error('名称重复') if current_sub_discipline.tag_disciplines.where(name: name).exists?
+    TagDiscipline.create!(name: name, sub_discipline_id: current_sub_discipline.id, user_id: current_user.id,
+                          position: current_sub_discipline.tag_disciplines.pluck(:position).max + 1)
+    render_ok
+  end
+
+  def edit
+    @tag_discipline = current_tag_discipline
+  end
+
+  def update
+    begin
+      if params[:tag_discipline] && params[:tag_discipline][:name]
+        name = params[:tag_discipline][:name].to_s.strip
+        current_tag_discipline.update_attributes!(name: name)
+      else
+        current_tag_discipline.update_attributes!(setting_params)
+      end
+    rescue Exception => e
+      @message = e.message
+    end
+    @tag_disciplines = current_tag_discipline.sub_discipline&.tag_disciplines
+  end
+
+  def destroy
+    @tag_discipline_id = params[:id]
+    ActiveRecord::Base.transaction do
+      sub_discipline = current_tag_discipline.sub_discipline
+      sub_discipline.tag_disciplines.where("position > #{current_tag_discipline.position}").update_all("position=position-1")
+      current_tag_discipline.destroy!
+    end
+  end
+
+  def adjust_position
+    sub_discipline = current_tag_discipline.sub_discipline
+    max_position = sub_discipline.tag_disciplines.pluck(:position).max
+    opr = params[:opr] || "down"
+    if (params[:opr] == "up" && current_tag_discipline.position == 1) || (params[:opr] == "down" && current_tag_discipline.position == max_position)
+      @message = "超出范围"
+    else
+      ActiveRecord::Base.transaction do
+        if opr == "up"
+          sub_discipline.tag_disciplines.find_by("position = #{current_tag_discipline.position - 1}")&.update!(position: current_tag_discipline.position)
+          current_tag_discipline.update!(position: current_tag_discipline.position - 1)
+        else
+          sub_discipline.tag_disciplines.find_by("position = #{current_tag_discipline.position + 1}")&.update!(position: current_tag_discipline.position)
+          current_tag_discipline.update!(position: current_tag_discipline.position + 1)
+        end
+      end
+    end
+    @tag_disciplines = sub_discipline&.tag_disciplines
+  rescue Exception => e
+    @message = e.message
+  end
+
+
+  private
+
+  def current_sub_discipline
+    @_current_sub_discipline = SubDiscipline.find params[:sub_discipline_id]
+  end
+
+  def current_tag_discipline
+    @_current_tag_discipline = TagDiscipline.find params[:id]
+  end
+
+  def setting_params
+    params.permit(:shixun, :subject, :question)
+  end
+end

app/controllers/admins/tag_repertoires_controller.rb

@@ -0,0 +1,43 @@
+class Admins::TagRepertoiresController < Admins::BaseController
+
+  def index
+    @sub_repertoire = current_sub_repertoire
+    @tag_repertoires = current_sub_repertoire.tag_repertoires
+  end
+
+  def create
+    name = params[:name].to_s.strip
+    return render_error('名称重复') if current_sub_repertoire.tag_repertoires.where(name: name).exists?
+    TagRepertoire.create!(name: name, sub_repertoire_id: current_sub_repertoire.id)
+    render_ok
+  end
+
+  def edit
+    @tag_repertoire = current_tag_repertoire
+  end
+
+  def update
+    if params[:tag_repertoire] && params[:tag_repertoire][:name].present?
+      name = params[:tag_repertoire][:name].to_s.strip
+      current_tag_repertoire.update_attributes!(name: name)
+    end
+    @tag_repertoires = current_tag_repertoire.sub_repertoire&.tag_repertoires
+  end
+
+  def destroy
+    @tag_repertoire_id = params[:id]
+    current_tag_repertoire.destroy!
+  end
+
+  private
+
+  def current_sub_repertoire
+    @_current_sub_repertoire = SubRepertoire.find params[:sub_repertoire_id]
+  end
+
+  def current_tag_repertoire
+    @_current_tag_repertoire = TagRepertoire.find params[:id]
+  end
+
+
+end

app/controllers/admins/unit_applies_controller.rb

@@ -0,0 +1,122 @@
+class Admins::UnitAppliesController < Admins::BaseController
+  before_action :get_apply,only: [:agree,:destroy,:edit,:update]
+
+  def index
+    params[:sort_by] ||= 'created_at'
+    params[:sort_direction] ||= 'desc'
+    unit_applies = Admins::UnitApplyQuery.call(params)
+    @unit_applies = paginate unit_applies.preload(:school, :user)
+  end
+
+  def agree
+    ActiveRecord::Base.transaction do
+      begin
+        @unit_apply.update_attribute("status",1)
+        @unit_apply&.applied_messages&.update_all(status:1)
+        @unit_apply&.school&.update_attribute("province",@unit_apply.province)
+
+        # #申请信息的创建
+        apply_message_params = {
+          user_id: @unit_apply&.user_id,
+          status: 1,
+          viewed: 0,
+          applied_id: @unit_apply.school_id,
+          applied_type: "ApplyAddSchools",
+          name: @unit_apply.name,
+        }
+        AppliedMessage.new(apply_message_params).save(validate: false)
+
+        Tiding.where(user_id: 1, trigger_user_id: @unit_apply.user_id, container_id: @unit_apply.id,
+                     container_type: 'ApplyAddSchools', status: 0, tiding_type: "Apply").update_all(status: 1)
+        #消息的创建
+        tiding_params = {
+          user_id: @unit_apply.user_id,
+          trigger_user_id: 0,
+          container_id: @unit_apply.id,
+          container_type: 'ApplyAddSchools',
+          belong_container_id: @unit_apply.school_id,
+          belong_container_type: "School",
+          tiding_type: "System",
+          status: 1
+        }
+        Tiding.create(tiding_params)
+        render_success_js
+      rescue Exception => e
+        Rails.logger.info("############_________________#########{e}")
+      end
+    end
+  end
+
+  def destroy
+    Admins::DeleteUnitApplyService.call(@unit_apply, params)
+    render_success_js
+  end
+
+  def edit
+    @all_schools = School.where.not(id: @unit_apply.school_id).pluck("name","id")
+
+  end
+
+  def update
+    school = School.find_by(id: params[:school_id])
+    ActiveRecord::Base.transaction do
+      @unit_apply&.applied_messages&.update_all(status:4)
+      Tiding.where(user_id: 1, trigger_user_id: @unit_apply.user_id, container_id: @unit_apply.id,
+                   container_type: 'ApplyAddSchools', status: 0, tiding_type: "Apply").update_all(status: 1)
+
+      #消息的创建
+      tiding_params = {
+        user_id: @unit_apply.user_id,
+        trigger_user_id: 0,
+        container_id: @unit_apply.id,
+        container_type: 'ApplyAddSchools',
+        belong_container_id: params[:school_id],
+        belong_container_type: "School",
+        tiding_type: "System",
+        status: 3,
+        extra: school.try(:name).to_s
+      }
+      Tiding.create(tiding_params)
+
+      UserExtension.where(school_id: @unit_apply.school_id).update_all(school_id: params[:school_id].to_i)
+      ApplyAddDepartment.where(:school_id => @unit_apply.school_id).update_all(school_id: params[:school_id].to_i)
+
+      # 判断重复
+      before_apply_departments = Department.where(school_id: @unit_apply.school_id)
+      before_apply_departments.each do |department|
+        after_dep = Department.where(school_id: params[:school_id].to_i, name: department.name)&.first
+        if after_dep.present?
+          UserExtension.where(school_id: @unit_apply.school_id, department_id: department.id).update_all(department_id: after_dep.id)
+          department.destroy
+          department.apply_add_departments.destroy_all
+        else
+          department.apply_add_departments.update_all(school_id: school.id)
+          department.update_attribute(:school_id, school.id)
+        end
+      end
+
+      @unit_apply&.school&.destroy
+      apply_params = {
+        status: 2,
+        name: school&.name.to_s,
+        school_id: params[:school_id],
+        province: params[:province],
+        city: params[:city],
+        address: params[:address]
+      }
+      @unit_apply.update_attributes(apply_params)
+      # render_success_js
+    end
+  end
+
+  private
+
+  def get_apply
+    @unit_apply = ApplyAddSchool.find_by(id:params[:id])
+  end
+
+  def disk_auth_filename(source_type, source_id, type)
+    File.join(storage_path, "#{source_type}", "#{source_id}#{type}")
+  end
+end
+

app/controllers/admins/user_statistics_controller.rb

@@ -0,0 +1,19 @@
+class Admins::UserStatisticsController < Admins::BaseController
+  def index
+    default_sort('finish_shixun_count', 'desc')
+
+    total_count, users = Admins::UserStatisticQuery.call(params)
+
+    @users = paginate users, total_count: total_count
+  end
+
+  def export
+    default_sort('finish_shixun_count', 'desc')
+
+    params[:per_page] = 10000
+    _count, @users = Admins::UserStatisticQuery.call(params)
+
+    filename = ['用户实训情况', Time.zone.now.strftime('%Y%m%d%H%M%S')].join('-') << '.xlsx'
+    render xlsx: 'export', filename: filename
+  end
+end

app/controllers/admins/users_controller.rb

@@ -0,0 +1,68 @@
+class Admins::UsersController < Admins::BaseController
+  def index
+    params[:sort_by] = params[:sort_by].presence || 'created_on'
+    params[:sort_direction] = params[:sort_direction].presence || 'desc'
+
+    users = Admins::UserQuery.call(params)
+    @users = paginate users.includes(user_extension: :school)
+  end
+
+  def edit
+    @user = User.find(params[:id])
+  end
+
+  def update
+    @user = User.find(params[:id])
+
+    Admins::UpdateUserService.call(@user, update_params)
+    flash[:success] = '保存成功'
+    redirect_to edit_admins_user_path(@user)
+  rescue ActiveRecord::RecordInvalid
+    flash.now[:danger] = '保存失败'
+    render 'edit'
+  rescue Admins::UpdateUserService::Error => ex
+    flash.now[:danger] = ex.message
+    render 'edit'
+  end
+
+  def destroy
+    User.find(params[:id]).destroy!
+
+    render_delete_success
+  end
+
+  def lock
+    User.find(params[:id]).lock!
+
+    render_ok
+  end
+
+  def unlock
+    User.find(params[:id]).activate!
+
+    render_ok
+  end
+
+  def reward_grade
+    user = User.find(params[:user_id])
+    return render_unprocessable_entity('金币数量必须大于0') if params[:grade].to_i <= 0
+
+    RewardGradeService.call(user, container_id: user.id, container_type: 'Feedback', score: params[:grade].to_i, not_unique: true)
+
+    render_ok(grade: user.grade)
+  end
+
+  def reset_login_times
+    User.find(params[:id]).reset_login_times!
+
+    render_ok
+  end
+
+  private
+
+  def update_params
+    params.require(:user).permit(%i[lastname nickname gender identity technical_title student_id is_shixun_marker
+                                    mail phone location location_city school_id department_id admin business is_test
+                                    password professional_certification authentication])
+  end
+end

app/controllers/admins/video_applies_controller.rb

@@ -0,0 +1,41 @@
+class Admins::VideoAppliesController < Admins::BaseController
+
+  def index
+    params[:status] ||= 'pending'
+    status = params[:status]
+    if status == 'all'
+      status = %w(agreed refused)
+    end
+
+    applies = VideoApply.where(status: status).order('video_applies.updated_at desc')
+
+    search = params[:keyword].to_s.strip
+    if search.present?
+      applies = applies.joins(:video)
+                  .where('videos.title like :search', search: "%#{search}%")
+    end
+
+    @video_applies = paginate applies.includes(video: { user: :user_extension })
+  end
+
+  def agree
+    Videos::AgreeApplyService.new(current_video_apply, current_user).call
+    render_success_js
+  rescue Videos::AgreeApplyService::Error => e
+    render json: { status: -1, message: e.message }
+  end
+
+  def refuse
+    Videos::RefuseApplyService.new(current_video_apply, current_user, reason: params[:reason]).call
+    render_success_js
+  rescue Videos::RefuseApplyService::Error => e
+    render json: { status: -1, message: e.message }
+  end
+
+  private
+
+  def current_video_apply
+    @_current_video_apply ||= VideoApply.find(params[:id])
+  end
+end
+

app/controllers/admins/weapp_adverts_controller.rb

@@ -0,0 +1,79 @@
+class Admins::WeappAdvertsController < Admins::BaseController
+  before_action :convert_file!, only: [:create]
+  def index
+    @adverts = WeappSettings::Advert.all
+  end
+
+  def create
+    position = WeappSettings::Advert.count + 1
+
+    ActiveRecord::Base.transaction do
+      advert = WeappSettings::Advert.create!(create_params.merge(position: position))
+
+      file_path = Util::FileManage.source_disk_filename(advert)
+      File.delete(file_path) if File.exist?(file_path) # 删除之前的文件
+      Util.write_file(@file, file_path)
+    end
+
+    flash[:success] = '保存成功'
+    redirect_to admins_weapp_adverts_path
+  end
+
+  def update
+    current_advert.update!(update_params)
+    render_ok
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      current_advert.destroy!
+      # 前移
+      WeappSettings::Advert.where('position > ?', current_advert.position)
+        .update_all('position = position - 1')
+
+      file_path = Util::FileManage.source_disk_filename(current_advert)
+      File.delete(file_path) if File.exist?(file_path)
+    end
+    render_delete_success
+  end
+
+  def drag
+    move  = WeappSettings::Advert.find_by(id: params[:move_id])
+    after = WeappSettings::Advert.find_by(id: params[:after_id])
+
+    Admins::DragWeappAdvertService.call(move, after)
+    render_ok
+  rescue ApplicationService::Error => e
+    render_error(e.message)
+  end
+
+  private
+
+  def current_advert
+    @_current_advert ||= WeappSettings::Advert.find(params[:id])
+  end
+
+  def create_params
+    params.require(:weapp_settings_advert).permit(:link)
+  end
+
+  def update_params
+    params.permit(:link, :online)
+  end
+
+  def convert_file!
+    max_size = 10 * 1024 * 1024 # 10M
+    file = params.dig('weapp_settings_advert', 'image')
+    if file.class == ActionDispatch::Http::UploadedFile
+      @file = file
+      render_error('请上传文件') if @file.size.zero?
+      render_error('文件大小超过限制') if @file.size > max_size
+    else
+      file = file.to_s.strip
+      return render_error('请上传正确的图片') if file.blank?
+      @file = Util.convert_base64_image(file, max_size: max_size)
+    end
+  rescue Base64ImageConverter::Error => ex
+    render_error(ex.message)
+  end
+end

app/controllers/admins/weapp_carousels_controller.rb

@@ -0,0 +1,80 @@
+class Admins::WeappCarouselsController < Admins::BaseController
+  before_action :convert_file!, only: [:create]
+
+  def index
+    @carousels = WeappSettings::Carousel.all
+  end
+
+  def create
+    position = WeappSettings::Carousel.count + 1
+
+    ActiveRecord::Base.transaction do
+      carousel = WeappSettings::Carousel.create!(create_params.merge(position: position))
+
+      file_path = Util::FileManage.source_disk_filename(carousel)
+      File.delete(file_path) if File.exist?(file_path) # 删除之前的文件
+      Util.write_file(@file, file_path)
+    end
+
+    flash[:success] = '保存成功'
+    redirect_to admins_weapp_carousels_path
+  end
+
+  def update
+    current_carousel.update!(update_params)
+    render_ok
+  end
+
+  def destroy
+    ActiveRecord::Base.transaction do
+      current_carousel.destroy!
+      # 前移
+      WeappSettings::Carousel.where('position > ?', current_carousel.position)
+        .update_all('position = position - 1')
+
+      file_path = Util::FileManage.source_disk_filename(current_carousel)
+      File.delete(file_path) if File.exist?(file_path)
+    end
+    render_delete_success
+  end
+
+  def drag
+    move  = WeappSettings::Carousel.find_by(id: params[:move_id])
+    after = WeappSettings::Carousel.find_by(id: params[:after_id])
+
+    Admins::DragWeappCarouselService.call(move, after)
+    render_ok
+  rescue ApplicationService::Error => e
+    render_error(e.message)
+  end
+
+  private
+
+  def current_carousel
+    @_current_carousel ||= WeappSettings::Carousel.find(params[:id])
+  end
+
+  def create_params
+    params.require(:weapp_settings_carousel).permit(:link)
+  end
+
+  def update_params
+    params.permit(:link, :online)
+  end
+
+  def convert_file!
+    max_size = 10 * 1024 * 1024 # 10M
+    file = params.dig('weapp_settings_carousel', 'image')
+    if file.class == ActionDispatch::Http::UploadedFile
+      @file = file
+      render_error('请上传文件') if @file.size.zero?
+      render_error('文件大小超过限制') if @file.size > max_size
+    else
+      file = file.to_s.strip
+      return render_error('请上传正确的图片') if file.blank?
+      @file = Util.convert_base64_image(file, max_size: max_size)
+    end
+  rescue Base64ImageConverter::Error => ex
+    render_error(ex.message)
+  end
+end