13528664866

Committed 25 Feb 2025 06:48PM UTC coverage: 59.626% (-2.2%) from 61.822%

Build # 13528664866

Build Type

Pull #4471

github

Committed by

web-flow

Commit Message

Merge 279229e31 into 3b7156fe3

Pull Request Pull Request #4471: Search test

Run Details

1548 of 3188 branches covered (48.56%)

Branch coverage included in aggregate %.

84 of 457 new or added lines in 18 files covered. (18.38%)

1 existing line in 1 file now uncovered.

7065 of 11257 relevant lines covered (62.76%)

78.7 hits per line

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

28.57

/app/controllers/work_controller.rb

class WorkController < ApplicationController
  # require 'ftools'
  include XmlSourceProcessor
  include ElasticSearchable

  protect_from_forgery :except => [:set_work_title,
                                   :set_work_description,
                                   :set_work_physical_description,
                                   :set_work_document_history,
                                   :set_work_permission_description,
                                   :set_work_location_of_composition,
                                   :set_work_author,
                                   :set_work_transcription_conventions]
  # tested
  before_action :authorized?, only: [
    :edit,
    :pages_tab,
    :delete,
    :new,
    :create,
    :edit_scribes,
    :add_scribe,
    :remove_scribe,
    :search_scribes
  ]

  # no layout if xhr request
  layout Proc.new { |controller| controller.request.xhr? ? false : nil }, only: [:new, :create, :configurable_printout, :edit_scribes, :remove_scribe]

  def metadata_overview_monitor
    @is_monitor_view = true
    render :template => "transcribe/monitor_view"
  end

  def configurable_printout
    @bulk_export = BulkExport.new
    @bulk_export.collection = @collection
    @bulk_export.work = @work
    @bulk_export.text_pdf_work = true
    @bulk_export.report_arguments['include_contributors'] = true
    @bulk_export.report_arguments['include_metadata'] = true
    @bulk_export.report_arguments['preserve_linebreaks'] = false
  end

  def search
    search_page = (search_params[:page] || 1).to_i
    @term = search_params[:term]
    @breadcrumb_scope={work: true}

    page_size = 10

  # call elasticsearch with the work scope to get the results
    query_config = {
      type: 'work',
      work_id: @work.id
    }
    search_data = elastic_search_results(
      @term,
      search_page,
      page_size,
      search_params[:filter],
      query_config
    )

    if search_data
      inflated_results = search_data[:inflated]
      @full_count = search_data[:full_count] # Used by All tab
      @type_counts = search_data[:type_counts]

      # Used for pagination, currently capped at 10k
      #
      # TODO: ES requires a scroll/search_after query for result sets larger
      #       than 10k.
      #
      #       To setup support we just need to add a composite tiebreaker field
      #       to the schemas
      @filtered_count = [ 10000, search_data[:filtered_count] ].min

      # Inspired by display controller search
      @search_string = "\"#{@term || ""}\""

      @search_results = WillPaginate::Collection.create(
        search_page,
        page_size,
        @filtered_count) do |pager|
          pager.replace(inflated_results)
        end
    end

  end

  def describe
    @layout_mode = cookies[:transcribe_layout_mode] || @collection.default_orientation
    @metadata_array = JSON.parse(@work.metadata_description || '[]')
  end

  def needs_review_checkbox_checked
    params[:work] && params[:work]['needs_review'] == '1'
  end

  def save_description
    @field_cells = request.params[:fields]
    @metadata_array = @work.process_fields(@field_cells)
    @layout_mode = cookies[:transcribe_layout_mode] || @collection.default_orientation

    if params['save_to_incomplete'] && !needs_review_checkbox_checked
      @work.description_status = Work::DescriptionStatus::INCOMPLETE
    elsif params['save_to_needs_review'] || needs_review_checkbox_checked
      @work.description_status = Work::DescriptionStatus::NEEDS_REVIEW
    elsif (params['save_to_transcribed'] && !needs_review_checkbox_checked) || params['approve_to_transcribed']
      @work.description_status = Work::DescriptionStatus::DESCRIBED
    else
      # unexpected state
    end



    if @work.save
      # TODO record_description_deed(@work)
      if @work.saved_change_to_description_status?
        record_deed(@work, DeedType::DESCRIBED_METADATA, current_user)
      else
        record_deed(@work, DeedType::EDITED_METADATA, current_user)
      end

      flash[:notice] = t('.work_described')
      render :describe
    else
      render :describe
    end

  end

  def description_versions
    # @selected_version = @page_version.present? ? @page_version : @page.page_versions.first
    # @previous_version = params[:compare_version_id] ? PageVersion.find(params[:compare_version_id]) : @selected_version.prev
    selected_version_id = params[:metadata_description_version_id]
    if selected_version_id
      @selected_version= MetadataDescriptionVersion.find(selected_version_id)
    else
      @selected_version= @work.metadata_description_versions.first
    end
    # NB: Unlike in page versions (which are created when we first create the page), metadata description versions may be nil
    compare_version_id = params[:compare_version_id]
    if compare_version_id
      @previous_version = MetadataDescriptionVersion.find(compare_version_id)
    else
      if @selected_version.version_number > 1
        @previous_version = @work.metadata_description_versions.second
      else
        @previous_version = @selected_version
      end
    end
    # again, both may be blank here
  end

  def delete
    @work.destroy
    redirect_to dashboard_owner_path
  end

  def edit
    @collections = current_user.collections
    # set subjects to true if there are any articles/page_article_links
    @subjects = !@work.articles.blank?
    @scribes = @work.scribes
  end

  def edit_scribes
    @scribes = @work.scribes
    @nonscribes = User.where.not(id: @scribes.pluck(:id)).limit(100)
  end

  def search_scribes
    query = "%#{params[:term].to_s.downcase}%"
    excluded_ids = @work.scribes.pluck(:id) + [@work.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 add_scribe
    scribe = User.find_by(id: params[:scribe_id])
    @work.scribes << scribe

    if scribe.notification.add_as_collaborator && SMTP_ENABLED
      begin
        UserMailer.work_collaborator(scribe, @work).deliver!
      # :nocov:
      rescue StandardError => e
        print "SMTP Failed: Exception: #{e.message}"
      end
      # :cov:
    end

    redirect_to work_edit_scribes_path(@collection, @work)
  end

  def remove_scribe
    scribe = User.find_by(id: params[:scribe_id])
    @work.scribes.delete(scribe)

    redirect_to work_edit_scribes_path(@collection, @work)
  end

  def update_work
    @work.update(work_params)
    redirect_to work_edit_path(work_id: @work.id)
  end

  # tested
  def create
    @work = Work.new
    @work.title = params[:work][:title]
    @work.collection_id = params[:work][:collection_id]
    @work.description = params[:work][:description]
    @work.owner = current_user
    @collections = current_user.all_owner_collections

    if @work.save
      record_deed(@work, DeedType::WORK_ADDED, work.owner)
      flash[:notice] = t('.work_created')
      ajax_redirect_to(work_pages_tab_path(:work_id => @work.id, :anchor => 'create-page'))
    else
      render :new
    end
  end

  def update
    work = Work.find(params[:id])
    @collection ||= work.collection

    result = Work::Update.new(work: work, work_params: work_params).call

    @work = result.work
    if result.success?
      if result.original_collection_id != result.collection.id
        record_deed(@work, DeedType::WORK_ADDED, @work.owner)
        @collection = @work.collection
      end

      flash[:notice] = t('.work_updated')
      redirect_to edit_collection_work_path(@work.collection.owner, @collection, @work)
    else
      @scribes = @work.scribes
      @nonscribes = User.where.not(id: @scribes.select(:id))
      @collections = current_user.collections
      @subjects = @work.articles.any?

      render :edit, status: :unprocessable_entity
    end
  end

  def revert
    work = Work.find_by(id: params[:work_id])
    work.update_attribute(:transcription_conventions, nil)
    render :plain => work.collection.transcription_conventions
  end

  def update_featured_page
    @work.update(featured_page: params[:page_id])
    redirect_back fallback_location: @work
  end

  def document_sets_select
    document_sets = current_user.document_sets.where(collection_id: params[:collection_id])

    render partial: 'document_sets_select', locals: { document_sets: document_sets }
  end

  protected

  def record_deed(work, deed_type, user)
    deed = Deed.new
    deed.work = work
    deed.deed_type = deed_type
    deed.collection = work.collection
    deed.user = user
    deed.save!
    update_search_attempt_contributions
  end

  private

  def authorized?
    if !user_signed_in? || !current_user.owner
      ajax_redirect_to dashboard_path
    elsif @work && !current_user.like_owner?(@work)
      ajax_redirect_to dashboard_path
    end
  end

  def search_params
    params.permit(:term, :page, :filter, :work_id, :collection_id, :user_id)
  end

  def work_params
    params.require(:work).permit(
      :title,
      :description,
      :collection_id,
      :supports_translation,
      :slug,
      :ocr_correction,
      :transcription_conventions,
      :author,
      :recipient,
      :location_of_composition,
      :identifier,
      :pages_are_meaningful,
      :physical_description,
      :document_history,
      :permission_description,
      :translation_instructions,
      :scribes_can_edit_titles,
      :restrict_scribes,
      :picture,
      :genre,
      :source_location,
      :source_collection_name,
      :source_box_folder,
      :in_scope,
      :editorial_notes,
      :document_date,
      :term,
      document_set_ids: []
    )
  end

end

1	class WorkController < ApplicationController	1✔
2	# require 'ftools'
3	include XmlSourceProcessor	1✔
4	include ElasticSearchable	1✔
5
6	protect_from_forgery :except => [:set_work_title,	1✔
7	:set_work_description,
8	:set_work_physical_description,
9	:set_work_document_history,
10	:set_work_permission_description,
11	:set_work_location_of_composition,
12	:set_work_author,
13	:set_work_transcription_conventions]
14	# tested
15	before_action :authorized?, only: [	1✔
16	:edit,
17	:pages_tab,
18	:delete,
19	:new,
20	:create,
21	:edit_scribes,
22	:add_scribe,
23	:remove_scribe,
24	:search_scribes
25	]
26
27	# no layout if xhr request
28	layout Proc.new { \|controller\| controller.request.xhr? ? false : nil }, only: [:new, :create, :configurable_printout, :edit_scribes, :remove_scribe]	6!
29
30	def metadata_overview_monitor	1✔
31	@is_monitor_view = true	×
32	render :template => "transcribe/monitor_view"	×
33	end
34
35	def configurable_printout	1✔
36	@bulk_export = BulkExport.new	×
37	@bulk_export.collection = @collection	×
38	@bulk_export.work = @work	×
39	@bulk_export.text_pdf_work = true	×
40	@bulk_export.report_arguments['include_contributors'] = true	×
41	@bulk_export.report_arguments['include_metadata'] = true	×
42	@bulk_export.report_arguments['preserve_linebreaks'] = false	×
43	end
44
45	def search	1✔
NEW 46	search_page = (search_params[:page] \|\| 1).to_i	×
NEW 47	@term = search_params[:term]	×
NEW 48	@breadcrumb_scope={work: true}	×
49
NEW 50	page_size = 10	×
51
52	# call elasticsearch with the work scope to get the results
53	query_config = {
NEW 54	type: 'work',	×
55	work_id: @work.id
56	}
NEW 57	search_data = elastic_search_results(	×
58	@term,
59	search_page,
60	page_size,
61	search_params[:filter],
62	query_config
63	)
64
NEW 65	if search_data	×
NEW 66	inflated_results = search_data[:inflated]	×
NEW 67	@full_count = search_data[:full_count] # Used by All tab	×
NEW 68	@type_counts = search_data[:type_counts]	×
69
70	# Used for pagination, currently capped at 10k
71	#
72	# TODO: ES requires a scroll/search_after query for result sets larger
73	# than 10k.
74	#
75	# To setup support we just need to add a composite tiebreaker field
76	# to the schemas
NEW 77	@filtered_count = [ 10000, search_data[:filtered_count] ].min	×
78
79	# Inspired by display controller search
NEW 80	@search_string = "\"#{@term \|\| ""}\""	×
81
NEW 82	@search_results = WillPaginate::Collection.create(	×
83	search_page,
84	page_size,
85	@filtered_count) do \|pager\|
NEW 86	pager.replace(inflated_results)	×
87	end
88	end
89
90	end
91
92	def describe	1✔
93	@layout_mode = cookies[:transcribe_layout_mode] \|\| @collection.default_orientation	×
94	@metadata_array = JSON.parse(@work.metadata_description \|\| '[]')	×
95	end
96
97	def needs_review_checkbox_checked	1✔
98	params[:work] && params[:work]['needs_review'] == '1'	×
99	end
100
101	def save_description	1✔
102	@field_cells = request.params[:fields]	×
103	@metadata_array = @work.process_fields(@field_cells)	×
104	@layout_mode = cookies[:transcribe_layout_mode] \|\| @collection.default_orientation	×
105
106	if params['save_to_incomplete'] && !needs_review_checkbox_checked	×
107	@work.description_status = Work::DescriptionStatus::INCOMPLETE	×
108	elsif params['save_to_needs_review'] \|\| needs_review_checkbox_checked	×
109	@work.description_status = Work::DescriptionStatus::NEEDS_REVIEW	×
110	elsif (params['save_to_transcribed'] && !needs_review_checkbox_checked) \|\| params['approve_to_transcribed']	×
111	@work.description_status = Work::DescriptionStatus::DESCRIBED	×
112	else
113	# unexpected state
114	end
115
116
117
118	if @work.save	×
119	# TODO record_description_deed(@work)	×
120	if @work.saved_change_to_description_status?	×
121	record_deed(@work, DeedType::DESCRIBED_METADATA, current_user)	×
122	else	×
123	record_deed(@work, DeedType::EDITED_METADATA, current_user)	×
124	end
125
126	flash[:notice] = t('.work_described')	×
127	render :describe	×
128	else	×
129	render :describe	×
130	end
131
132	end
133
134	def description_versions	1✔
135	# @selected_version = @page_version.present? ? @page_version : @page.page_versions.first
136	# @previous_version = params[:compare_version_id] ? PageVersion.find(params[:compare_version_id]) : @selected_version.prev
137	selected_version_id = params[:metadata_description_version_id]	×
138	if selected_version_id	×
139	@selected_version= MetadataDescriptionVersion.find(selected_version_id)	×
140	else	×
141	@selected_version= @work.metadata_description_versions.first	×
142	end
143	# NB: Unlike in page versions (which are created when we first create the page), metadata description versions may be nil
144	compare_version_id = params[:compare_version_id]	×
145	if compare_version_id	×
146	@previous_version = MetadataDescriptionVersion.find(compare_version_id)	×
147	else	×
148	if @selected_version.version_number > 1	×
149	@previous_version = @work.metadata_description_versions.second	×
150	else	×
151	@previous_version = @selected_version	×
152	end
153	end
154	# again, both may be blank here
155	end
156
157	def delete	1✔
158	@work.destroy	2✔
159	redirect_to dashboard_owner_path	2✔
160	end
161
162	def edit	1✔
163	@collections = current_user.collections	27✔
164	# set subjects to true if there are any articles/page_article_links
165	@subjects = !@work.articles.blank?	27✔
166	@scribes = @work.scribes	27✔
167	end
168
169	def edit_scribes	1✔
170	@scribes = @work.scribes	5✔
171	@nonscribes = User.where.not(id: @scribes.pluck(:id)).limit(100)	5✔
172	end
173
174	def search_scribes	1✔
175	query = "%#{params[:term].to_s.downcase}%"	×
176	excluded_ids = @work.scribes.pluck(:id) + [@work.owner.id]	×
177	users = User.where('LOWER(real_name) LIKE :search OR LOWER(email) LIKE :search', search: query)	×
178	.where.not(id: excluded_ids)
179	.limit(100)
180
181	render json: { results: users.map { \|u\| { text: "#{u.display_name} #{u.email}", id: u.id } } }	×
182	end
183
184	def add_scribe	1✔
185	scribe = User.find_by(id: params[:scribe_id])	2✔
186	@work.scribes << scribe	2✔
187
188	if scribe.notification.add_as_collaborator && SMTP_ENABLED	2✔
189	begin
190	UserMailer.work_collaborator(scribe, @work).deliver!	1✔
191	# :nocov:
192	rescue StandardError => e
193	print "SMTP Failed: Exception: #{e.message}"
194	end
195	# :cov:
196	end
197
198	redirect_to work_edit_scribes_path(@collection, @work)
199	end
200
201	def remove_scribe
202	scribe = User.find_by(id: params[:scribe_id])
203	@work.scribes.delete(scribe)
204
205	redirect_to work_edit_scribes_path(@collection, @work)
206	end
207
208	def update_work
209	@work.update(work_params)
210	redirect_to work_edit_path(work_id: @work.id)
211	end
212
213	# tested
214	def create
215	@work = Work.new
216	@work.title = params[:work][:title]
217	@work.collection_id = params[:work][:collection_id]
218	@work.description = params[:work][:description]
219	@work.owner = current_user
220	@collections = current_user.all_owner_collections
221
222	if @work.save
223	record_deed(@work, DeedType::WORK_ADDED, work.owner)
224	flash[:notice] = t('.work_created')
225	ajax_redirect_to(work_pages_tab_path(:work_id => @work.id, :anchor => 'create-page'))
226	else
227	render :new
228	end
229	end
230
231	def update
232	work = Work.find(params[:id])
233	@collection \|\|= work.collection
234
235	result = Work::Update.new(work: work, work_params: work_params).call
236
237	@work = result.work
238	if result.success?
239	if result.original_collection_id != result.collection.id
240	record_deed(@work, DeedType::WORK_ADDED, @work.owner)
241	@collection = @work.collection
242	end
243
244	flash[:notice] = t('.work_updated')
245	redirect_to edit_collection_work_path(@work.collection.owner, @collection, @work)
246	else
247	@scribes = @work.scribes
248	@nonscribes = User.where.not(id: @scribes.select(:id))
249	@collections = current_user.collections
250	@subjects = @work.articles.any?
251
252	render :edit, status: :unprocessable_entity
253	end
254	end
255
256	def revert
257	work = Work.find_by(id: params[:work_id])
258	work.update_attribute(:transcription_conventions, nil)
259	render :plain => work.collection.transcription_conventions
260	end
261
262	def update_featured_page
263	@work.update(featured_page: params[:page_id])
264	redirect_back fallback_location: @work
265	end
266
267	def document_sets_select
268	document_sets = current_user.document_sets.where(collection_id: params[:collection_id])
269
270	render partial: 'document_sets_select', locals: { document_sets: document_sets }
271	end
272
273	protected
274
275	def record_deed(work, deed_type, user)
276	deed = Deed.new
277	deed.work = work
278	deed.deed_type = deed_type
279	deed.collection = work.collection
280	deed.user = user
281	deed.save!
282	update_search_attempt_contributions
283	end
284
285	private
286
287	def authorized?
288	if !user_signed_in? \|\| !current_user.owner
289	ajax_redirect_to dashboard_path
290	elsif @work && !current_user.like_owner?(@work)
291	ajax_redirect_to dashboard_path
292	end
293	end
294
295	def search_params
296	params.permit(:term, :page, :filter, :work_id, :collection_id, :user_id)
297	end
298
299	def work_params
300	params.require(:work).permit(
301	:title,
302	:description,
303	:collection_id,
304	:supports_translation,
305	:slug,
306	:ocr_correction,
307	:transcription_conventions,
308	:author,
309	:recipient,
310	:location_of_composition,
311	:identifier,
312	:pages_are_meaningful,
313	:physical_description,
314	:document_history,
315	:permission_description,
316	:translation_instructions,
317	:scribes_can_edit_titles,
318	:restrict_scribes,
319	:picture,
320	:genre,
321	:source_location,
322	:source_collection_name,
323	:source_box_folder,
324	:in_scope,
325	:editorial_notes,
326	:document_date,
327	:term,
328	document_set_ids: []
329	)
330	end
331
332	end

benwbrum / fromthepage / 13528664866

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