17344128193

Committed 30 Aug 2025 01:05PM UTC coverage: 64.405% (-0.02%) from 64.423%

Build # 17344128193

Build Type

push

github

Committed by

web-flow

Commit Message

Remove duplicate and unused methods in User and Work models (#4786)

* Initial plan

* Remove duplicate and unused methods as requested in issue #632

Co-authored-by: benwbrum <199961+benwbrum@users.noreply.github.com>

* Conditionalize ES spec for non-ES installations

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: benwbrum <199961+benwbrum@users.noreply.github.com>
Co-authored-by: Ben W. Brumfield <benwbrum@gmail.com>

Run Details

1790 of 3303 branches covered (54.19%)

Branch coverage included in aggregate %.

5 of 8 new or added lines in 8 files covered. (62.5%)

7 existing lines in 1 file now uncovered.

7928 of 11786 relevant lines covered (67.27%)

103.76 hits per line

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

70.11

/app/controllers/document_sets_controller.rb

class DocumentSetsController < ApplicationController

  DEFAULT_WORKS_PER_PAGE = 15

  before_action :authorized?
  before_action :set_document_set, only: [:show, :edit, :update, :destroy]

  respond_to :html

  def transfer_form
  end

  def transfer
    source_set = @collection.document_sets.where(slug: params[:source_set]).first
    target_set = @collection.document_sets.where(slug: params[:target_set]).first

    if source_set == target_set
      flash[:error] = t('.source_and_target_can_not_be_the_same')
      render :action => 'transfer_form', :layout => false
      flash.clear
    else
      if params[:status_filter] == 'all'
        works = source_set.works
      else
        works = source_set.works.joins(:work_statistic).where('work_statistics.complete' => 100)
      end

      works.each do |work|
        unless work.document_sets.include? target_set
          work.document_sets << target_set
        end
        if params[:transfer_type] == 'move'
          work.document_sets.delete(source_set)
        end
      end

      ajax_redirect_to document_sets_path(:collection_id => @collection)
    end
  end

  def index
    page = params[:page].presence || 1

    if params[:search]
      @works = @collection.search_works(params[:search]).order(:title).paginate(page: page, per_page: 20)
    else
      @works = @collection.works.order(:title).paginate(page: page, per_page: 20)
    end
  end

  def show
    @collection = @document_set.collection
  end

  def new
    @document_set = DocumentSet.new
    @document_set.collection = @collection
    respond_with(@document_set)
  end

  def edit
    respond_with(@document_set)
  end

  def edit_set_collaborators
    @collaborators = @document_set.collaborators
    @noncollaborators = User.where.not(id: @collaborators.select(:id)).order(:display_name).limit(100)
  end

  def search_collaborators
    query = "%#{params[:term].to_s.downcase}%"
    excluded_ids = @document_set.collaborators.pluck(:id) + [@document_set.owner.id]
    users = User.where('LOWER(real_name) LIKE :search OR LOWER(email) LIKE :search', search: query)
                .where.not(id: excluded_ids)
                .limit(100)

    render json: { results: users.map { |u| { text: "#{u.display_name} #{u.email}", id: u.id } } }
  end

  def create
    @document_set = DocumentSet.new(document_set_params)
    if current_user.account_type != "Staff"
      @document_set.owner = current_user
    else
      extant_collection = current_user.all_owner_collections.detect { |c| c.owner.account_type != "Staff" }
      @document_set.owner = extant_collection.owner
    end
    if @document_set.save
      flash[:notice] = t('.document_created')
      ajax_redirect_to collection_settings_path(@document_set.owner, @document_set)
    else
      render action: 'new'
    end

  end

  def assign_works
    set_work_map = params.to_unsafe_hash[:work_assignment]
    set_work_map&.each_key do |work_id|
      work = @collection.works.find(work_id)
      work.document_sets.clear
      set_work_map[work_id].each_pair do |set_id, add_set|
        work.document_sets << @collection.document_sets.find(set_id) if add_set == 'true'
      end
    end

    # set next untranscribed page for each set now that works may have been added or removed
    @collection.document_sets.each(&:set_next_untranscribed_page)

    redirect_to action: :index, collection_id: @collection.id, page: params[:page]
  end

  def assign_to_set
    unless @collection
      @collection = DocumentSet.friendly.find(params[:collection_id])
    end
    new_ids = params[:work].keys.map {|id| id.to_i}
    ids = @collection.work_ids + new_ids
    @collection.work_ids = ids
    @collection.save!
    redirect_to collection_works_list_path(@collection.owner, @collection)
  end

  def update_works
    document_set = DocumentSet.friendly.find(update_works_params[:document_set_id])
    @result = DocumentSet::UpdateWorks.new(
      document_set: document_set,
      work_params: update_works_params[:works]
    ).call

    respond_to(&:turbo_stream)
  end

  def remove_from_set
    @collection = DocumentSet.friendly.find(params[:collection_id])
    ids = params[:work].keys.map {|id| id.to_i}
    new_ids = @collection.work_ids - ids
    @collection.work_ids = new_ids
    @collection.save!
    redirect_to collection_works_list_path(@collection.owner, @collection)
  end

  def update
    @result = DocumentSet::Update.new(
      document_set: @document_set,
      document_set_params: document_set_params,
      user: current_user
    ).call

    @document_set = @result.document_set

    respond_to do |format|
      template = case params[:scope]
                 when 'edit_privacy'
                   @collaborators = @document_set.collaborators
                   @works_to_restrict_count = works_to_restrict_count
                   'document_sets/update_privacy'
                 else
                   'document_sets/update_general'
                 end

      format.turbo_stream { render template }
    end
  end

  def settings
    @document_set ||= @collection
  end

  def settings_privacy
    @document_set ||= @collection
    @collaborators = @document_set.collaborators
    @works_to_restrict_count = works_to_restrict_count
  end

  def settings_works
    filtered_set_works
    @document_set ||= @collection

    respond_to do |format|
      format.html
      format.turbo_stream
    end
  end

  def add_set_collaborator
    collaborator = User.find(params[:collaborator_id])
    @collection.collaborators << collaborator
    if collaborator.notification.add_as_collaborator && SMTP_ENABLED
      begin
        UserMailer.collection_collaborator(collaborator, @collection).deliver!
      rescue StandardError => e
        print "SMTP Failed: Exception: #{e.message}"
      end
    end

    redirect_to collection_edit_set_collaborators_path(@collection.owner, @collection, @document_set)
  end

  def remove_set_collaborator
    collaborator = User.find(params[:collaborator_id])
    @collection.collaborators.delete(collaborator)

    redirect_to collection_edit_set_collaborators_path(@collection.owner, @collection, @document_set)
  end

  def destroy
    @document_set.destroy
    redirect_to action: 'index', collection_id: @document_set.collection_id
  end

  private

  def authorized?
    unless user_signed_in? && @collection && current_user.like_owner?(@collection)
      ajax_redirect_to dashboard_path
    end
  end

  def set_document_set
    unless (defined? @document_set) && @document_set
      id = params[:document_set_id] || params[:id]
      @document_set = DocumentSet.friendly.find(id)
    end
  end

  def document_set_params
    params.require(:document_set).permit(:visibility, :owner_user_id, :collection_id, :title, :description, :picture, :slug)
  end

  def filtered_set_works
    @ordering = (params[:order] || 'ASC').downcase.to_sym
    @ordering = [:asc, :desc].include?(@ordering) ? @ordering : :desc

    set_works = @collection.works
    collection_works = @collection.collection.works

    works_scope = if params[:show] == 'included'
                    set_works
                  elsif params[:show] == 'not_included'
                    collection_works.where.not(id: set_works.select(:id))
                  else
                    collection_works
                  end

    works_scope = works_scope.includes(:work_statistic).reorder(title: @ordering)

    if params[:search]
      query = "%#{params[:search].to_s.downcase}%"
      works_scope = works_scope.where(
        'LOWER(works.title) LIKE :search OR LOWER(works.searchable_metadata) like :search',
        search: "%#{query}%"
      )
    end

    works_scope = works_scope.distinct.paginate(page: params[:page], per_page: DEFAULT_WORKS_PER_PAGE)
    @works = works_scope
    @set_work_ids = set_works.pluck(:id)
  end

  def update_works_params
    params.permit(:document_set_id, works: {})
  end

  def works_to_restrict_count
    @document_set.works
                 .joins(:work_statistic)
                 .where(work_statistics: { complete: 100 }, restrict_scribes: false)
                 .count
  end
end

1	class DocumentSetsController < ApplicationController	1✔
2
3	DEFAULT_WORKS_PER_PAGE = 15	1✔
4
5	before_action :authorized?	1✔
6	before_action :set_document_set, only: [:show, :edit, :update, :destroy]	1✔
7
8	respond_to :html	1✔
9
10	def transfer_form	1✔
11	end
12
13	def transfer	1✔
14	source_set = @collection.document_sets.where(slug: params[:source_set]).first	×
15	target_set = @collection.document_sets.where(slug: params[:target_set]).first	×
16
17	if source_set == target_set	×
18	flash[:error] = t('.source_and_target_can_not_be_the_same')	×
19	render :action => 'transfer_form', :layout => false	×
20	flash.clear	×
21	else	×
22	if params[:status_filter] == 'all'	×
23	works = source_set.works	×
24	else	×
25	works = source_set.works.joins(:work_statistic).where('work_statistics.complete' => 100)	×
26	end
27
28	works.each do \|work\|	×
29	unless work.document_sets.include? target_set	×
30	work.document_sets << target_set	×
31	end
32	if params[:transfer_type] == 'move'	×
33	work.document_sets.delete(source_set)	×
34	end
35	end
36
37	ajax_redirect_to document_sets_path(:collection_id => @collection)	×
38	end
39	end
40
41	def index	1✔
42	page = params[:page].presence \|\| 1	14✔
43
44	if params[:search]	14✔
45	@works = @collection.search_works(params[:search]).order(:title).paginate(page: page, per_page: 20)	1✔
46	else	13✔
47	@works = @collection.works.order(:title).paginate(page: page, per_page: 20)	13✔
48	end
49	end
50
51	def show	1✔
52	@collection = @document_set.collection	×
53	end
54
55	def new	1✔
56	@document_set = DocumentSet.new	3✔
57	@document_set.collection = @collection	3✔
58	respond_with(@document_set)	3✔
59	end
60
61	def edit	1✔
62	respond_with(@document_set)	×
63	end
64
65	def edit_set_collaborators	1✔
66	@collaborators = @document_set.collaborators	3✔
67	@noncollaborators = User.where.not(id: @collaborators.select(:id)).order(:display_name).limit(100)	3✔
68	end
69
70	def search_collaborators	1✔
71	query = "%#{params[:term].to_s.downcase}%"	×
72	excluded_ids = @document_set.collaborators.pluck(:id) + [@document_set.owner.id]	×
73	users = User.where('LOWER(real_name) LIKE :search OR LOWER(email) LIKE :search', search: query)	×
74	.where.not(id: excluded_ids)
75	.limit(100)
76
77	render json: { results: users.map { \|u\| { text: "#{u.display_name} #{u.email}", id: u.id } } }	×
78	end
79
80	def create	1✔
81	@document_set = DocumentSet.new(document_set_params)	3✔
82	if current_user.account_type != "Staff"	3✔
83	@document_set.owner = current_user	3✔
84	else	×
NEW 85	extant_collection = current_user.all_owner_collections.detect { \|c\| c.owner.account_type != "Staff" }	×
86	@document_set.owner = extant_collection.owner	×
87	end
88	if @document_set.save	3✔
89	flash[:notice] = t('.document_created')	3✔
90	ajax_redirect_to collection_settings_path(@document_set.owner, @document_set)	3✔
91	else	×
92	render action: 'new'	×
93	end
94
95	end
96
97	def assign_works	1✔
98	set_work_map = params.to_unsafe_hash[:work_assignment]	1✔
99	set_work_map&.each_key do \|work_id\|	1!
100	work = @collection.works.find(work_id)	7✔
101	work.document_sets.clear	7✔
102	set_work_map[work_id].each_pair do \|set_id, add_set\|	7✔
103	work.document_sets << @collection.document_sets.find(set_id) if add_set == 'true'	14✔
104	end
105	end
106
107	# set next untranscribed page for each set now that works may have been added or removed
108	@collection.document_sets.each(&:set_next_untranscribed_page)	1✔
109
110	redirect_to action: :index, collection_id: @collection.id, page: params[:page]	1✔
111	end
112
113	def assign_to_set	1✔
114	unless @collection	×
115	@collection = DocumentSet.friendly.find(params[:collection_id])	×
116	end
117	new_ids = params[:work].keys.map {\|id\| id.to_i}	×
118	ids = @collection.work_ids + new_ids	×
119	@collection.work_ids = ids	×
120	@collection.save!	×
121	redirect_to collection_works_list_path(@collection.owner, @collection)	×
122	end
123
124	def update_works	1✔
125	document_set = DocumentSet.friendly.find(update_works_params[:document_set_id])	3✔
126	@result = DocumentSet::UpdateWorks.new(	3✔
127	document_set: document_set,
128	work_params: update_works_params[:works]
129	).call
130
131	respond_to(&:turbo_stream)	3✔
132	end
133
134	def remove_from_set	1✔
135	@collection = DocumentSet.friendly.find(params[:collection_id])	×
136	ids = params[:work].keys.map {\|id\| id.to_i}	×
137	new_ids = @collection.work_ids - ids	×
138	@collection.work_ids = new_ids	×
139	@collection.save!	×
140	redirect_to collection_works_list_path(@collection.owner, @collection)	×
141	end
142
143	def update	1✔
144	@result = DocumentSet::Update.new(	7✔
145	document_set: @document_set,
146	document_set_params: document_set_params,
147	user: current_user
148	).call
149
150	@document_set = @result.document_set	7✔
151
152	respond_to do \|format\|	7✔
153	template = case params[:scope]	7✔
154	when 'edit_privacy'	2✔
155	@collaborators = @document_set.collaborators	2✔
156	@works_to_restrict_count = works_to_restrict_count	2✔
157	'document_sets/update_privacy'	2✔
158	else	5✔
159	'document_sets/update_general'	5✔
160	end
161
162	format.turbo_stream { render template }	14✔
163	end
164	end
165
166	def settings	1✔
167	@document_set \|\|= @collection	9✔
168	end
169
170	def settings_privacy	1✔
171	@document_set \|\|= @collection	3✔
172	@collaborators = @document_set.collaborators	3✔
173	@works_to_restrict_count = works_to_restrict_count	3✔
174	end
175
176	def settings_works	1✔
177	filtered_set_works	5✔
178	@document_set \|\|= @collection	5✔
179
180	respond_to do \|format\|	5✔
181	format.html	5✔
182	format.turbo_stream	5✔
183	end
184	end
185
186	def add_set_collaborator	1✔
187	collaborator = User.find(params[:collaborator_id])	2✔
188	@collection.collaborators << collaborator	2✔
189	if collaborator.notification.add_as_collaborator && SMTP_ENABLED	2✔
190	begin	1✔
191	UserMailer.collection_collaborator(collaborator, @collection).deliver!	1✔
192	rescue StandardError => e
193	print "SMTP Failed: Exception: #{e.message}"	×
194	end
195	end
196
197	redirect_to collection_edit_set_collaborators_path(@collection.owner, @collection, @document_set)	2✔
198	end
199
200	def remove_set_collaborator	1✔
201	collaborator = User.find(params[:collaborator_id])	×
202	@collection.collaborators.delete(collaborator)	×
203
204	redirect_to collection_edit_set_collaborators_path(@collection.owner, @collection, @document_set)	×
205	end
206
207	def destroy	1✔
208	@document_set.destroy	3✔
209	redirect_to action: 'index', collection_id: @document_set.collection_id	3✔
210	end
211
212	private	1✔
213
214	def authorized?	1✔
215	unless user_signed_in? && @collection && current_user.like_owner?(@collection)	57✔
216	ajax_redirect_to dashboard_path	1✔
217	end
218	end
219
220	def set_document_set	1✔
221	unless (defined? @document_set) && @document_set	10✔
222	id = params[:document_set_id] \|\| params[:id]	7✔
223	@document_set = DocumentSet.friendly.find(id)	7✔
224	end
225	end
226
227	def document_set_params	1✔
228	params.require(:document_set).permit(:visibility, :owner_user_id, :collection_id, :title, :description, :picture, :slug)	10✔
229	end
230
231	def filtered_set_works	1✔
232	@ordering = (params[:order] \|\| 'ASC').downcase.to_sym	5✔
233	@ordering = [:asc, :desc].include?(@ordering) ? @ordering : :desc	5!
234
235	set_works = @collection.works	5✔
236	collection_works = @collection.collection.works	5✔
237
238	works_scope = if params[:show] == 'included'	5✔
239	set_works	1✔
240	elsif params[:show] == 'not_included'	4✔
241	collection_works.where.not(id: set_works.select(:id))	1✔
242	else	3✔
243	collection_works	3✔
244	end
245
246	works_scope = works_scope.includes(:work_statistic).reorder(title: @ordering)	5✔
247
248	if params[:search]	5✔
249	query = "%#{params[:search].to_s.downcase}%"	1✔
250	works_scope = works_scope.where(	1✔
251	'LOWER(works.title) LIKE :search OR LOWER(works.searchable_metadata) like :search',
252	search: "%#{query}%"
253	)
254	end
255
256	works_scope = works_scope.distinct.paginate(page: params[:page], per_page: DEFAULT_WORKS_PER_PAGE)	5✔
257	@works = works_scope	5✔
258	@set_work_ids = set_works.pluck(:id)	5✔
259	end
260
261	def update_works_params	1✔
262	params.permit(:document_set_id, works: {})	6✔
263	end
264
265	def works_to_restrict_count	1✔
266	@document_set.works	5✔
267	.joins(:work_statistic)
268	.where(work_statistics: { complete: 100 }, restrict_scribes: false)
269	.count
270	end
271	end

benwbrum / fromthepage / 17344128193

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