29662909844

Committed 18 Jul 2026 10:08PM UTC coverage: 90.356%. First build

Build # 29662909844

Build Type

Pull #8067

github

Committed by

web-flow

Commit Message

Merge b5fbfae23 into 35deb772c

Pull Request Pull Request #8067: V2.10.1

Coverage Stats

1156 of 2380 branches covered (48.57%)

Branch coverage included in aggregate %.

1187 of 1268 new or added lines in 107 files covered. (93.61%)

46952 of 50863 relevant lines covered (92.31%)

133.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.01

/app/controllers/admin/users_controller.rb

module Admin
  class UsersController < ApplicationController
    DEFAULT_FIELDS = [:id, :user_name, :email, :id_number, :type, :first_name, :last_name].freeze
    SEARCHABLE_FIELDS = %w[user_name first_name last_name email id_number].freeze
    SORTABLE_FIELDS = %w[user_name first_name last_name email id_number type].freeze
    before_action { authorize! }

    respond_to :html
    layout 'assignment_content'

    def index
      respond_to do |format|
        format.html
        format.json do
          users_scope = sorted_users(filtered_users(visible_users))

          per_page = (params[:per_page] || 100).to_i
          current_page = (params[:page] || 1).to_i
          total_count = users_scope.count
          total_pages = [(total_count.to_f / per_page).ceil, 1].max
          offset_value = (current_page - 1) * per_page
          records = users_scope.limit(per_page).offset(offset_value)

          render json: {
            users: records.pluck_to_hash(*DEFAULT_FIELDS),
            total_pages: total_pages
          }
        end
      end
    end

    def new
      @user = User.new
    end

    def create
      user_params = params.require(:user)
      user_params[:type] = nil unless [EndUser.name, AdminUser.name].include? user_params[:type]
      @user = User.create(user_params.permit(*DEFAULT_FIELDS))
      respond_with @user, location: -> { admin_users_path }
    end

    def edit
      @user = record
    end

    def update
      @user = record
      user_params = params.require(@user.model_name.to_s.underscore)
      @user.update(user_params.permit(:user_name, :email, :id_number, :first_name, :last_name))
      respond_with @user, location: -> { edit_admin_user_path(@user) }
    end

    def upload
      begin
        data = process_file_upload(['.csv'])
      rescue StandardError => e
        flash_message(:error, e.message)
      else
        @current_job = UploadUsersJob.perform_later(EndUser,
                                                    data[:contents],
                                                    data[:encoding])
        session[:job_id] = @current_job.job_id
      end
      redirect_to action: 'index'
    end

    protected

    def implicit_authorization_target
      OpenStruct.new policy_class: Admin::UserPolicy
    end

    private

    # Do not make AutotestUser users visible
    def visible_users
      User.where.not(type: :AutotestUser)
    end

    # Apply column/type filters from the `filtered` param to the given scope.
    def filtered_users(scope)
      return scope if params[:filtered].blank?

      JSON.parse(params[:filtered]).each do |f|
        next if f['value'].blank?

        if SEARCHABLE_FIELDS.include?(f['id'])
          term = "%#{User.sanitize_sql_like(f['value'].strip)}%"
          scope = scope.where("#{f['id']} ILIKE ?", term)
        elsif f['id'] == 'type' && f['value'] != 'all'
          scope = scope.where(type: f['value'])
        end
      end

      scope
    end

    # Apply ordering from the `sorted` param to the given scope.
    # Falls back to ordering by user_name when no valid sort is provided.
    def sorted_users(scope)
      return scope.order(:user_name) if params[:sorted].blank?

      sort_configs = JSON.parse(params[:sorted])
      order_clauses = sort_configs.filter_map do |sort_config|
        next unless SORTABLE_FIELDS.include?(sort_config['id'])

        direction = sort_config['desc'] ? 'DESC' : 'ASC'
        "#{sort_config['id']} #{direction}"
      end

      return scope.order(:user_name) if order_clauses.empty?

      scope.order(Arel.sql(order_clauses.join(', ')))
    end

    def flash_interpolation_options
      { resource_name: @user.user_name.presence || @user.model_name.human,
        errors: @user.errors.full_messages.join('; ') }
    end
  end
end

1	module Admin	1✔
2	class UsersController < ApplicationController	1✔
3	DEFAULT_FIELDS = [:id, :user_name, :email, :id_number, :type, :first_name, :last_name].freeze	1✔
4	SEARCHABLE_FIELDS = %w[user_name first_name last_name email id_number].freeze	1✔
5	SORTABLE_FIELDS = %w[user_name first_name last_name email id_number type].freeze	1✔
6	before_action { authorize! }	41✔
7
8	respond_to :html	1✔
9	layout 'assignment_content'	1✔
10
11	def index	1✔
12	respond_to do \|format\|	8✔
13	format.html	8✔
14	format.json do	8✔
15	users_scope = sorted_users(filtered_users(visible_users))	7✔
16
17	per_page = (params[:per_page] \|\| 100).to_i	7✔
18	current_page = (params[:page] \|\| 1).to_i	7✔
19	total_count = users_scope.count	7✔
20	total_pages = [(total_count.to_f / per_page).ceil, 1].max	7✔
21	offset_value = (current_page - 1) * per_page	7✔
22	records = users_scope.limit(per_page).offset(offset_value)	7✔
23
24	render json: {	7✔
25	users: records.pluck_to_hash(*DEFAULT_FIELDS),
26	total_pages: total_pages
27	}
28	end
29	end
30	end
31
32	def new	1✔
33	@user = User.new	1✔
34	end
35
36	def create	1✔
37	user_params = params.require(:user)	4✔
38	user_params[:type] = nil unless [EndUser.name, AdminUser.name].include? user_params[:type]	4✔
39	@user = User.create(user_params.permit(*DEFAULT_FIELDS))	4✔
40	respond_with @user, location: -> { admin_users_path }	6✔
41	end
42
43	def edit	1✔
44	@user = record	1✔
45	end
46
47	def update	1✔
48	@user = record	3✔
49	user_params = params.require(@user.model_name.to_s.underscore)	3✔
50	@user.update(user_params.permit(:user_name, :email, :id_number, :first_name, :last_name))	3✔
51	respond_with @user, location: -> { edit_admin_user_path(@user) }	5✔
52	end
53
54	def upload	1✔
55	begin
56	data = process_file_upload(['.csv'])	5✔
57	rescue StandardError => e
58	flash_message(:error, e.message)	2✔
59	else
60	@current_job = UploadUsersJob.perform_later(EndUser,	3✔
61	data[:contents],
62	data[:encoding])
63	session[:job_id] = @current_job.job_id	3✔
64	end
65	redirect_to action: 'index'	5✔
66	end
67
68	protected	1✔
69
70	def implicit_authorization_target	1✔
71	OpenStruct.new policy_class: Admin::UserPolicy	214✔
72	end
73
74	private	1✔
75
76	# Do not make AutotestUser users visible
77	def visible_users	1✔
78	User.where.not(type: :AutotestUser)	7✔
79	end
80
81	# Apply column/type filters from the `filtered` param to the given scope.
82	def filtered_users(scope)	1✔
83	return scope if params[:filtered].blank?	7✔
84
85	JSON.parse(params[:filtered]).each do \|f\|	1✔
86	next if f['value'].blank?	1✔
87
88	if SEARCHABLE_FIELDS.include?(f['id'])	1✔
89	term = "%#{User.sanitize_sql_like(f['value'].strip)}%"	1✔
90	scope = scope.where("#{f['id']} ILIKE ?", term)	1✔
NEW 91	elsif f['id'] == 'type' && f['value'] != 'all'	×
NEW 92	scope = scope.where(type: f['value'])	×
93	end
94	end
95
96	scope	1✔
97	end
98
99	# Apply ordering from the `sorted` param to the given scope.
100	# Falls back to ordering by user_name when no valid sort is provided.
101	def sorted_users(scope)	1✔
102	return scope.order(:user_name) if params[:sorted].blank?	7✔
103
104	sort_configs = JSON.parse(params[:sorted])	2✔
105	order_clauses = sort_configs.filter_map do \|sort_config\|	2✔
106	next unless SORTABLE_FIELDS.include?(sort_config['id'])	3✔
107
108	direction = sort_config['desc'] ? 'DESC' : 'ASC'	3✔
109	"#{sort_config['id']} #{direction}"	3✔
110	end
111
112	return scope.order(:user_name) if order_clauses.empty?	2✔
113
114	scope.order(Arel.sql(order_clauses.join(', ')))	2✔
115	end
116
117	def flash_interpolation_options	1✔
118	{ resource_name: @user.user_name.presence \|\| @user.model_name.human,	7✔
119	errors: @user.errors.full_messages.join('; ') }
120	end
121	end
122	end

MarkUsProject / Markus / 29662909844

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous