init project

app/queries/admins/apply_item_bank_query.rb

@@ -0,0 +1,34 @@
+class Admins::ApplyItemBankQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :updated_at, default_by: :updated_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    applies = ApplyAction.where(container_type: params[:type].presence || "ItemBank")
+
+    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(user: { user_extension: :school })
+                  .where('CONCAT(lastname,firstname) LIKE :keyword OR schools.name LIKE :keyword', keyword: "%#{keyword}%")
+    end
+
+    custom_sort(applies, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/apply_user_authentication_query.rb

@@ -0,0 +1,34 @@
+class Admins::ApplyUserAuthenticationQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :updated_at, default_by: :updated_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    applies = ApplyUserAuthentication.where(auth_type: params[:type].presence || 1)
+
+    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(user: { user_extension: :school })
+                  .where('CONCAT(lastname,firstname) LIKE :keyword OR schools.name LIKE :keyword', keyword: "%#{keyword}%")
+    end
+
+    custom_sort(applies, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/course_list_query.rb

@@ -0,0 +1,30 @@
+class Admins::CourseListQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    course_lists = CourseList.all
+
+    # 关键字模糊查询
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      search_type = params[:search_type] || "0"
+      case search_type
+      when "0"
+        course_lists = course_lists.joins(:user)
+                      .where('CONCAT(lastname, firstname) like :keyword', keyword: "%#{keyword}%")
+      when "1"
+        course_lists = course_lists.where('name like :keyword', keyword: "%#{keyword}%")
+      end
+    end
+
+    custom_sort(course_lists, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/course_query.rb

@@ -0,0 +1,44 @@
+class Admins::CourseQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc, default_table: 'courses'
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    courses = Course.all
+
+    courses = courses.where(id: params[:id]) if params[:id].present?
+
+    # 状态过滤
+    status =
+      case params[:status].to_s.strip
+      when 'processing'   then 0
+      when 'ended'  then 1
+      end
+    courses = courses.where(is_end: status) if status
+
+    # 单位
+    if params[:school_id].present?
+      courses = courses.where(school_id: params[:school_id])
+    end
+
+    # 首页展示
+    if params[:homepage_show].present? && params[:homepage_show].to_s == 'true'
+      courses = courses.where(homepage_show: true)
+    end
+
+    # 关键字
+    keyword = params[:keyword].to_s.strip
+    if keyword
+      sql = 'CONCAT(lastname, firstname) LIKE :keyword OR courses.name LIKE :keyword OR course_lists.name LIKE :keyword'
+      courses = courses.joins(:teacher, :course_list).where(sql, keyword: "%#{keyword}%")
+    end
+
+    custom_sort(courses, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/customer_query.rb

@@ -0,0 +1,24 @@
+class Admins::CustomerQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc, default_table: 'customers'
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    customers = Customer.all
+
+    if params[:partner_id].present?
+      customers = customers.joins(:partner_customers).where(partner_customers: { partner_id: params[:partner_id] })
+    end
+
+    keyword = params[:keyword].to_s.strip
+    customers = customers.joins(:school).where('schools.name LIKE ?', "%#{keyword}%") if keyword.present?
+
+    custom_sort(customers, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/department_apply_query.rb

@@ -0,0 +1,25 @@
+class Admins::DepartmentApplyQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    status = params[:status]
+
+    applies = ApplyAddDepartment.where(status: status) if status.present?
+
+    # 关键字模糊查询
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      applies = applies.where('name LIKE :keyword', keyword: "%#{keyword}%")
+    end
+
+    custom_sort(applies, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/department_query.rb

@@ -0,0 +1,32 @@
+class Admins::DepartmentQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    departments = Department.where(is_auth: true).without_deleted
+
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      departments = departments.joins(:school)
+                      .where('schools.name LIKE :keyword OR departments.name LIKE :keyword', keyword: "%#{keyword}%")
+    end
+
+    if params[:with_member].to_s == 'true'
+      subquery = DepartmentMember.where('department_id = departments.id').select('1 AS one').to_sql
+      departments = departments.where("EXISTS(#{subquery})")
+    end
+
+    if params[:with_identifier].to_s == 'true'
+      departments = departments.where.not(identifier: nil).where.not(identifier: '')
+    end
+
+    custom_sort(departments, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/laboratory_query.rb

@@ -0,0 +1,23 @@
+class Admins::LaboratoryQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :id, default_by: :id, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    laboratories = Laboratory.all
+
+    keyword = strip_param(:keyword)
+    if keyword.present?
+      like_sql = 'schools.name LIKE :keyword OR laboratories.identifier LIKE :keyword'
+      laboratories = laboratories.left_joins(:school).where(like_sql, keyword: "%#{keyword}%")
+    end
+
+    custom_sort laboratories, params[:sort_by], params[:sort_direction]
+  end
+end

app/queries/admins/laboratory_shixun_query.rb

@@ -0,0 +1,36 @@
+class Admins::LaboratoryShixunQuery < ApplicationQuery
+  attr_reader :laboratory, :params
+
+  def initialize(laboratory, params)
+    @laboratory = laboratory
+    @params     = params
+  end
+
+  def call
+    laboratory_shixuns = laboratory.laboratory_shixuns.joins(:shixun)
+
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      like_sql = 'shixuns.name LIKE :keyword OR CONCAT(users.lastname, users.firstname) LIKE :keyword'
+      laboratory_shixuns = laboratory_shixuns.joins(shixun: :user).where(like_sql, keyword: "%#{keyword}%")
+    end
+
+    # 实训状态
+    laboratory_shixuns = laboratory_shixuns.where(shixuns: { status: params[:status] }) if params[:status].present?
+
+    # 技术平台
+    if params[:tag_id].present?
+      laboratory_shixuns = laboratory_shixuns.joins(shixun: :shixun_mirror_repositories)
+                             .where(shixun_mirror_repositories: { mirror_repository_id: params[:tag_id] })
+    end
+
+    # 首页展示、单位自建
+    %i[homepage ownership].each do |column|
+      if params[column].present? && params[column].to_s == 'true'
+        laboratory_shixuns = laboratory_shixuns.where(column => true)
+      end
+    end
+
+    laboratory_shixuns
+  end
+end

app/queries/admins/laboratory_subject_query.rb

@@ -0,0 +1,36 @@
+class Admins::LaboratorySubjectQuery < ApplicationQuery
+  attr_reader :laboratory, :params
+
+  def initialize(laboratory, params)
+    @laboratory = laboratory
+    @params     = params
+  end
+
+  def call
+    laboratory_subjects = laboratory.laboratory_subjects.joins(:subject)
+
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      like_sql = 'subjects.name LIKE :keyword OR CONCAT(users.lastname, users.firstname) LIKE :keyword'
+      laboratory_subjects = laboratory_subjects.joins(subject: :user).where(like_sql, keyword: "%#{keyword}%")
+    end
+
+    # 状态
+    laboratory_subjects = laboratory_subjects.where(subjects: { status: params[:status] }) if params[:status].present?
+
+    # 创建者单位
+    if params[:school_id].present?
+      laboratory_subjects = laboratory_subjects.joins(subjects: { user: :user_extension })
+                              .where(user_extensions: { school_id: params[:school_id] })
+    end
+
+    # 首页展示、单位自建
+    %i[homepage ownership].each do |column|
+      if params[column].present? && params[column].to_s == 'true'
+        laboratory_subjects = laboratory_subjects.where(column => true)
+      end
+    end
+
+    laboratory_subjects
+  end
+end

app/queries/admins/library_apply_query.rb

@@ -0,0 +1,29 @@
+class Admins::LibraryApplyQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :updated_at, default_by: :updated_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    status =
+        case params[:status]
+        when 'processed' then %w(agreed refused)
+        else params[:status]
+        end
+    applies = LibraryApply.where(status: status) if status.present?
+
+    # 关键字模糊查询
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      applies = applies.joins(:library)
+                    .where('title LIKE :keyword OR uuid LIKE :keyword', keyword: "%#{keyword}%")
+    end
+
+    custom_sort(applies, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/partner_query.rb

@@ -0,0 +1,20 @@
+class Admins::PartnerQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    partners = Partner.all
+
+    keyword = params[:keyword].to_s.strip
+    partners = partners.joins(:school).where('schools.name LIKE ?', "%#{keyword}%") if keyword.present?
+
+    custom_sort(partners, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/school_query.rb

@@ -0,0 +1,23 @@
+class Admins::SchoolQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :users_count, :created_at, default_by: :created_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    schools = School.all
+
+    keyword = strip_param(:keyword)
+    Rails.logger.info("###########{keyword}")
+    if keyword
+      schools = schools.where('schools.name LIKE ?', "%#{keyword}%")
+    end
+    schools = schools.left_joins(:user_extensions).select('schools.*, IFNULL(count(user_extensions.user_id),0) users_count').group('schools.id')
+    custom_sort schools, params[:sort_by], params[:sort_direction]
+  end
+end

app/queries/admins/subject_query.rb

@@ -0,0 +1,49 @@
+class Admins::SubjectQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc, default_table: 'subjects'
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    subjects = Subject.all
+
+    subjects = subjects.where(id: params[:id]) if params[:id].present?
+
+    # 状态过滤
+    status =
+        case params[:status].to_s.strip
+        when "editing" then {status: 0}
+        when "applying" then {status: 2, public: [0, 1]}
+        when "pending" then {public: 1}
+        when "published" then {public: 2}
+        end
+
+    subjects = subjects.where(status) if status
+
+    # 创建者单位
+    if params[:school_id].present?
+      subjects = subjects.joins(user: :user_extension).where(user_extensions: { school_id: params[:school_id] })
+    end
+
+    # 首页展示、金课
+    %i[homepage_show excellent].each do |column|
+      if params[column].present? && params[column].to_s == 'true'
+        subjects = subjects.where(column => true)
+      end
+    end
+
+    # 关键字
+    keyword = params[:keyword].to_s.strip
+    if keyword
+      sql = 'CONCAT(lastname, firstname) LIKE :keyword OR subjects.name LIKE :keyword'
+      subjects = subjects.joins(:user).where(sql, keyword: "%#{keyword}%")
+    end
+
+    custom_sort(subjects, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/unit_apply_query.rb

@@ -0,0 +1,24 @@
+class Admins::UnitApplyQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_at, default_by: :created_at, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    unit_applies = ApplyAddSchool.where(status:0)
+
+    # 关键字模糊查询
+    keyword = params[:keyword].to_s.strip
+    if keyword.present?
+      unit_applies = unit_applies.where("name like ?","%#{keyword}%")
+    end
+
+    custom_sort(unit_applies, params[:sort_by], params[:sort_direction])
+  end
+end
+

app/queries/admins/user_query.rb

@@ -0,0 +1,52 @@
+class Admins::UserQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :created_on, :last_login_on, :experience, :grade, default_by: :created_on, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    users = User.where(type: 'User')
+
+    # 云上实验室
+    users = users.where(laboratory_id: params[:laboratory_id]) if params[:laboratory_id].present?
+
+    # 状态
+    status = params[:status]
+    users = users.where(status: status) if status.present?
+
+    # 职业
+    users = users.joins(:user_extension).where(user_extensions: { identity: params[:identity] }) if params[:identity].present?
+
+    # 授权类型
+    if params[:auto_trial].present?
+      users = users.joins(user_extension: :school).where(schools: { auto_users_trial: params[:auto_trial].to_i == 1 })
+    end
+
+    # 关键字检索
+    keyword = params[:keyword].to_s.strip.presence
+    if keyword
+      sql = 'CONCAT(lastname, firstname) LIKE :keyword OR login LIKE :keyword OR mail LIKE :keyword OR phone LIKE :keyword'
+      users = users.where(sql, keyword: "%#{keyword}%")
+    end
+
+    # 姓名
+    name = params[:name].to_s.strip.presence
+    if name.present?
+      users = users.where('CONCAT(lastname, firstname) LIKE :name', name: "%#{name}%")
+    end
+
+    # 单位ID
+    users = users.joins(:user_extension).where(user_extensions: { school_id: params[:school_id] }) if params[:school_id].present?
+
+    # 学校名称
+    school_name = params[:school_name].to_s.strip.presence
+    users = users.joins(user_extension: :school).where('schools.name LIKE ?', "%#{school_name}%") if school_name
+
+    custom_sort(users, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/admins/user_statistic_query.rb

@@ -0,0 +1,142 @@
+class Admins::UserStatisticQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :study_challenge_count, :finish_challenge_count, :study_shixun_count, :finish_shixun_count,
+               default_by: :finish_shixun_count, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    users = User.where(type: 'User').group(:id)
+
+    users = users.joins(:user_extension).where(user_extensions: { school_id: params[:school_id] }) if params[:school_id].present?
+
+    total = users.count.count
+
+    # 根据排序字段进行查询
+    users = query_by_sort_column(users, params[:sort_by])
+    users = custom_sort(users, params[:sort_by], params[:sort_direction])
+
+    users = users.includes(user_extension: [:school, :department])
+    users = users.limit(page_size).offset(offset).to_a
+    # 查询并组装其它数据
+    users = package_other_data(users)
+
+    [total, users]
+  end
+
+  private
+
+  def package_other_data(users)
+    ids = users.map(&:id)
+
+    study_myshixun   = Myshixun.where(user_id: ids)
+    finish_myshixun  = Myshixun.where(user_id: ids, status: 1)
+    study_challenge  = Game.where(user_id: ids).where(status: [0, 1, 2])
+    finish_challenge = Game.where(user_id: ids).where(status: 2)
+
+    if time_range.present?
+      study_myshixun   = study_myshixun.where(updated_at: time_range)
+      finish_myshixun  = finish_myshixun.where(updated_at: time_range)
+      study_challenge  = study_challenge.where(updated_at: time_range)
+      finish_challenge = finish_challenge.where(updated_at: time_range)
+    end
+
+    study_myshixun_map   = study_myshixun.reorder(nil).group(:user_id).count
+    finish_myshixun_map  = finish_myshixun.reorder(nil).group(:user_id).count
+    study_challenge_map  = study_challenge.reorder(nil).group(:user_id).count
+    finish_challenge_map = finish_challenge.reorder(nil).group(:user_id).count
+    evaluate_count_map   = study_challenge.reorder(nil).group(:user_id).sum(:evaluate_count)
+    cost_time_map        = study_challenge.reorder(nil).group(:user_id).sum(:cost_time)
+
+    users.each do |user|
+      user._extra_data = {
+        study_shixun_count: study_myshixun_map.fetch(user.id, 0),
+        finish_shixun_count: finish_myshixun_map.fetch(user.id, 0),
+        study_challenge_count: study_challenge_map.fetch(user.id, 0),
+        finish_challenge_count: finish_challenge_map.fetch(user.id, 0),
+        evaluate_count: evaluate_count_map.fetch(user.id, 0),
+        cost_time: cost_time_map.fetch(user.id, 0),
+      }
+    end
+
+    users
+  end
+
+  def query_by_sort_column(users, sort_by_column)
+    base_query_column = 'users.*'
+
+    case sort_by_column.to_s
+    when 'study_shixun_count' then
+      users =
+        if time_range.present?
+          users.joins("LEFT JOIN myshixuns ON myshixuns.user_id = users.id "\
+                      "AND myshixuns.updated_at BETWEEN '#{time_range.min}' AND '#{time_range.max}'")
+        else
+          users.left_joins(:myshixuns)
+        end
+
+      users.select("#{base_query_column}, COUNT(*) study_shixun_count")
+    when 'finish_shixun_count' then
+      users =
+        if time_range.present?
+          users.joins("LEFT JOIN myshixuns ON myshixuns.user_id = users.id AND myshixuns.status = 1 AND "\
+                      "myshixuns.updated_at BETWEEN '#{time_range.min}' AND '#{time_range.max}'")
+        else
+          users.joins('LEFT JOIN myshixuns ON myshixuns.user_id = users.id AND myshixuns.status = 1')
+        end
+
+      users.select("#{base_query_column}, COUNT(*) finish_shixun_count")
+    when 'study_challenge_count' then
+      users =
+        if time_range.present?
+          users.joins('LEFT JOIN myshixuns ON myshixuns.user_id = users.id')
+            .joins("LEFT JOIN games ON games.myshixun_id = myshixuns.id "\
+                   "AND games.status IN (0,1,2) AND games.updated_at BETWEEN '#{time_range.min}' AND '#{time_range.max}'")
+        else
+          users.joins('LEFT JOIN myshixuns ON myshixuns.user_id = users.id')
+            .joins("LEFT JOIN games ON games.myshixun_id = myshixuns.id AND games.status IN (0,1,2)")
+        end
+
+      users.select("#{base_query_column}, COUNT(*) study_challenge_count")
+    when 'finish_challenge_count' then
+      users =
+        if time_range.present?
+          users#.joins('LEFT JOIN myshixuns ON myshixuns.user_id = users.id')
+            .joins("LEFT JOIN games ON games.user_id = users.id "\
+                   "AND games.status = 2 AND games.updated_at BETWEEN '#{time_range.min}' AND '#{time_range.max}'")
+        else
+          users#.joins('LEFT JOIN myshixuns ON myshixuns.user_id = users.id')
+            .joins("LEFT JOIN games ON games.user_id = users.id AND games.status = 2")
+        end
+
+      users.select("#{base_query_column}, COUNT(*) finish_challenge_count")
+    else
+      users
+    end
+  end
+
+  def time_range
+    @_time_range ||= begin
+      case params[:date]
+      when 'weekly'    then 1.weeks.ago..Time.now
+      when 'monthly'   then 1.months.ago..Time.now
+      when 'quarterly' then 3.months.ago..Time.now
+      when 'yearly'    then 1.years.ago..Time.now
+      else ''
+      end
+    end
+  end
+
+  def page_size
+    params[:per_page].to_i.zero? ? 20 : params[:per_page].to_i
+  end
+
+  def offset
+    (params[:page].to_i.zero? ? 0 : params[:page].to_i - 1) * page_size
+  end
+end

app/queries/application_query.rb

@@ -0,0 +1,9 @@
+class ApplicationQuery
+  include Callable
+
+  private
+
+  def strip_param(key)
+    params[key].to_s.strip.presence
+  end
+end

app/queries/customer_query.rb

@@ -0,0 +1,30 @@
+class CustomerQuery < ApplicationQuery
+  attr_reader :partner, :user, :params
+
+  def initialize(partner, user, params)
+    @partner = partner
+    @user    = user
+    @params  = params
+  end
+
+  def call
+    customers = manager_group_scope
+
+    keyword = params[:keyword].to_s.strip.presence
+    customers = customers.joins(:school).where('schools.name LIKE ?', "%#{keyword}%") if keyword
+
+    customers
+  end
+
+  private
+
+  def manager_group_scope
+    # 超级管理员 或者 管理员
+    if user.admin_or_business? || partner.admin_partner_manager_group.partner_managers.exists?(user: user)
+      partner.customers
+    else
+      manager_group_ids = user.partner_managers.where(partner: partner).joins(:partner_manager_group).pluck('partner_manager_groups.id')
+      partner.customers.where(partner_manager_group_id: manager_group_ids)
+    end
+  end
+end

app/queries/projects/list_query.rb

@@ -0,0 +1,21 @@
+class Projects::ListQuery < ApplicationQuery
+  include CustomSortable
+
+  attr_reader :params
+
+  sort_columns :updated_on, :created_on, :forked_count, :praises_count, default_by: :updated_on, default_direction: :desc
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    scope = Project.like(params[:search])
+      .with_project_type(params[:project_type])
+      .with_project_category(params[:category_id])
+      .with_project_language(params[:language_id])
+      .includes(:project_category, :project_language, :repository, :owner)
+
+    custom_sort(scope, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/user_query.rb

@@ -0,0 +1,28 @@
+class UserQuery < ApplicationQuery
+  attr_reader :params
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    users = User.where(type: 'User')
+
+    # 真实姓名
+    if name = strip_param(:name)
+      users = users.where('LOWER(CONCAT(users.lastname, users.firstname)) LIKE ?', "%#{name.downcase}%")
+    end
+
+    # 单位名称
+    if school = strip_param(:school)
+      users = users.joins(user_extension: :school).where('schools.name LIKE ?', "%#{school}%")
+    end
+
+    # 职业
+    if (identity = strip_param(:identity)) && UserExtension.identities.keys.include?(identity)
+      users = users.joins(:user_extension).where(user_extensions: { identity: identity })
+    end
+
+    users
+  end
+end

app/queries/users/video_query.rb

@@ -0,0 +1,28 @@
+class Users::VideoQuery < ApplicationQuery
+  include CustomSortable
+
+  sort_columns :published_at, :title, default_by: :published_at, default_direction: :desc
+
+  attr_reader :user, :params
+
+  def initialize(user, params)
+    @user   = user
+    @params = params
+  end
+
+  def call
+    videos = user.videos
+
+    videos =
+      case params[:status]
+      when 'published'  then videos.published
+      when 'processing' then videos.processing
+      else videos.published
+      end
+
+    keyword = params[:keyword].to_s.strip
+    videos = videos.where('title LIKE ?', "%#{keyword}%") if keyword.present?
+
+    custom_sort(videos, params[:sort_by], params[:sort_direction])
+  end
+end

app/queries/weapps/search_query.rb

@@ -0,0 +1,37 @@
+class Weapps::SearchQuery < ApplicationQuery
+  include ElasticsearchAble
+
+  attr_reader :params
+
+  def initialize(params)
+    @params = params
+  end
+
+  def call
+    modal_name.search(keyword, search_options)
+  end
+
+  private
+
+  def search_options
+    hash = {
+      fields: [:name],
+      page: page,
+      per_page: per_page
+    }
+    hash.merge(where: { status: 2 }) if modal_name == Shixun
+
+    hash
+  end
+
+  def modal_name
+    @_modal_name ||= begin
+      case params[:type].to_s
+      when 'subject' then Subject
+      when 'shixun'  then Shixun
+      when 'course'  then Course
+      else Subject
+      end
+    end
+  end
+end

app/queries/weapps/subject_query.rb

@@ -0,0 +1,37 @@
+class Weapps::SubjectQuery < ApplicationQuery
+  include CustomSortable
+  attr_reader :params
+
+  def initialize(current_laboratory, params)
+    @current_laboratory = current_laboratory
+    @params = params
+  end
+
+  def call
+    subjects = @current_laboratory.subjects.unhidden.publiced.show_moblied
+
+    # 课程体系的过滤
+    if params[:sub_discipline_id].present?
+      subjects = subjects.joins(:sub_disciplines).where(sub_disciplines: {id: params[:sub_discipline_id]})
+    elsif params[:discipline_id].present?
+      subjects = subjects.joins(:sub_disciplines).where(sub_disciplines: {discipline_id: params[:discipline_id]})
+    else
+      subjects = subjects.joins(:sub_discipline_containers).where(sub_discipline_containers: {container_type: "Subject"})
+    end
+
+    subjects = subjects.left_joins(:shixuns).select('subjects.id, subjects.name, subjects.excellent, subjects.stages_count, subjects.status, subjects.homepage_show,
+                                                     subjects.shixuns_count, subjects.updated_at, IFNULL(sum(shixuns.myshixuns_count), 0) myshixuns_count')
+                                            .group('subjects.id').order("subjects.homepage_show #{sort_type}, #{order_type} #{sort_type}")
+    subjects
+  end
+
+  private
+
+  def order_type
+    params[:order] || "updated_at"
+  end
+
+  def sort_type
+    params[:sort] || "desc"
+  end
+end