00dbc10b-d747-4ad7-b211-7b26d753abbb

Committed 14 Aug 2025 01:25PM UTC coverage: 0.483% (-94.9%) from 95.343%

Build # 00dbc10b-d747-4ad7-b211-7b26d753abbb

Build Type

push

circleci

Committed by

web-flow

Commit Message

Merge pull request #5181 from pulibrary/dependabot/bundler/activestorage-7.2.2.2

Bump activestorage from 7.2.2.1 to 7.2.2.2

Run Details

47 of 9721 relevant lines covered (0.48%)

0.01 hits per line

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

0.0

/app/models/requests/submission.rb

# frozen_string_literal: true
require 'email_validator'

module Requests
  class Submission
    include ActiveModel::Validations

    validates :email, presence: true, email: true, length: { minimum: 5, maximum: 50 }
    validates :user_name, presence: true, length: { minimum: 1, maximum: 50 }
    validates :user_barcode, allow_blank: true, presence: true, length: { minimum: 5, maximum: 14 },
                             format: { with: /(^\d{14}$)/i, message: "Please supply a valid library barcode" }
    validate :item_validations

    def initialize(params, patron)
      @patron = patron
      @items = selected_items(params[:requestable])
      @bib = params[:bib]
      @services = []
      @success_messages = []
    end

    # :reek:DuplicateMethodCall
    def self.new_from_hash(original_hash)
      requestable = original_hash['items']&.map(&:with_indifferent_access) || []
      patron = Patron.new(user: User.find_by(uid: original_hash['patron']['netid']), patron_hash: original_hash['patron'].with_indifferent_access)
      new({ requestable:, bib: original_hash['bib'] }, patron)
    end

    attr_reader :patron, :success_messages

    def email
      @patron.active_email
    end

    delegate :source, to: :@patron

    def user_name
      @patron.netid
    end

    attr_reader :items

    def filter_items_by_service(service)
      @items.select { |item| item["type"] == service }
    end

    def selected_items(requestable_list)
      items = requestable_list.select { |r| r unless r[:selected] == 'false' || !r.key?('selected') }
      items.map { |item| categorize_by_delivery_and_location(item) }
    end

    def item_validations
      validates_with Requests::SelectedItemsValidator
    end

    def user_barcode
      @patron.barcode
    end

    attr_reader :bib

    def id
      @bib[:id]
    end

    def partner_item?(item)
      Requests.config[:recap_partner_locations].keys.include? item["location_code"]
    end

    def service_types
      @types ||= @items.map { |item| item['type'] }.uniq
      @types
    end

    def process_submission
      @services = service_types.map do |type|
        service_by_type(type)
      end
      @services.each(&:handle)

      @success_messages = generate_success_messages(@success_messages)

      @services
    end

    def service_errors
      return [] if @services.blank?
      @services.map(&:errors).flatten
    end

    def pick_up_location
      Requests::BibdataService.delivery_locations.dig(items.first&.dig('pick_up'), "library") || {}
    end

    def marquand?
      items.first["holding_library"] == 'marquand'
    end

    def edd?(item)
      delivery_mode = delivery_mode(item)
      delivery_mode.present? && delivery_mode == "edd"
    end

    # Convert the submission to a hash that is compatible that
    # Sidekiq can safely serialize to JSON for redis.  This means:
    #   * No application-specific objects (unless they are activerecord db objects)
    #   * No ActiveSupport::HashWithIndifferentAccess objects, we can only have Hash objects
    #   * The keys of the hash must all be strings, not symbols
    # See https://github.com/sidekiq/sidekiq/wiki/Best-Practices#1-make-your-job-parameters-small-and-simple
    def to_h
      {
        bib: bib.to_hash.stringify_keys,
        email: email,
        errors: errors.messages.stringify_keys,
        items: items.map { |hash| hash.to_hash.stringify_keys },
        patron: patron.to_h.to_hash.stringify_keys,
        pick_up_location: pick_up_location.to_hash.stringify_keys,
        user_barcode:,
        user_name:
      }.stringify_keys
    end

    private

      def service_by_type(type)
        case type
        when 'on_shelf', 'marquand_in_library', 'annex', 'annex_in_library'
          Requests::Submissions::HoldItem.new(self, service_type: type)
        when 'recap', 'recap_edd', 'recap_in_library', 'recap_marquand_in_library', 'recap_marquand_edd'
          Requests::Submissions::Recap.new(self, service_type: type)
        when 'clancy_in_library'
          Requests::Submissions::Clancy.new(self)
        when 'clancy_edd'
          Requests::Submissions::ClancyEdd.new(self)
        when 'digitize', 'annex_edd', 'marquand_edd', 'clancy_unavailable_edd'
          Requests::Submissions::DigitizeItem.new(self, service_type: type)
        when *inter_library_services
          Requests::Submissions::Illiad.new(self, service_type: type)
        else
          Requests::Submissions::Generic.new(self, service_type: type)
        end
      end

      def categorize_by_delivery_and_location(item)
        library_code = item["library_code"]
        if recap_no_items?(item)
          item["type"] = "recap_no_items"
        elsif print?(item) && library_code == 'annex'
          item["type"] = "annex"
        elsif off_site?(library_code)
          raise Exception, "#{self.class}: Item does not have a delivery mode" unless delivery_mode(item)
          item["type"] = library_code
          item["type"] += "_edd" if edd?(item)
          item["type"] += "_in_library" if in_library?(item)
        elsif item["type"] == "paging"
          item["type"] = "digitize" if edd?(item)
        elsif edd?(item) && library_code.present?
          item["type"] = "digitize"
        elsif print?(item) && library_code.present?
          item["type"] = "on_shelf"
        end
        item
      end

      def in_library?(item)
        delivery_mode = delivery_mode(item)
        delivery_mode.present? && delivery_mode == "in_library"
      end

      def recap_no_items?(item)
        item["library_code"] == 'recap' && (item["type"] == "digitize_fill_in" || item["type"] == "recap_no_items")
      end

      def off_site?(library_code)
        library_code == 'recap' || library_code == 'marquand' || library_code == 'clancy' || library_code == 'recap_marquand' || library_code == 'clancy_unavailable' || library_code == 'annex'
      end

      def print?(item)
        delivery_mode = delivery_mode(item)
        delivery_mode.present? && delivery_mode == "print"
      end

      def delivery_mode(item)
        item["delivery_mode_#{item['item_id']}"]
      end

      def inter_library_services
        ['ill']
      end

      def generate_success_messages(success_messages)
        @services.each do |service|
          success_messages << service.success_message
          service.send_mail
        end
        success_messages
      end
  end
end

1	# frozen_string_literal: true
2	require 'email_validator'	×
3
4	module Requests	×
5	class Submission	×
6	include ActiveModel::Validations	×
7
8	validates :email, presence: true, email: true, length: { minimum: 5, maximum: 50 }	×
9	validates :user_name, presence: true, length: { minimum: 1, maximum: 50 }	×
10	validates :user_barcode, allow_blank: true, presence: true, length: { minimum: 5, maximum: 14 },	×
11	format: { with: /(^\d{14}$)/i, message: "Please supply a valid library barcode" }	×
12	validate :item_validations	×
13
14	def initialize(params, patron)	×
15	@patron = patron	×
16	@items = selected_items(params[:requestable])	×
17	@bib = params[:bib]	×
18	@services = []	×
19	@success_messages = []	×
20	end	×
21
22	# :reek:DuplicateMethodCall
23	def self.new_from_hash(original_hash)	×
24	requestable = original_hash['items']&.map(&:with_indifferent_access) \|\| []	×
25	patron = Patron.new(user: User.find_by(uid: original_hash['patron']['netid']), patron_hash: original_hash['patron'].with_indifferent_access)	×
26	new({ requestable:, bib: original_hash['bib'] }, patron)	×
27	end	×
28
29	attr_reader :patron, :success_messages	×
30
31	def email	×
32	@patron.active_email	×
33	end	×
34
35	delegate :source, to: :@patron	×
36
37	def user_name	×
38	@patron.netid	×
39	end	×
40
41	attr_reader :items	×
42
43	def filter_items_by_service(service)	×
44	@items.select { \|item\| item["type"] == service }	×
45	end	×
46
47	def selected_items(requestable_list)	×
48	items = requestable_list.select { \|r\| r unless r[:selected] == 'false' \|\| !r.key?('selected') }	×
49	items.map { \|item\| categorize_by_delivery_and_location(item) }	×
50	end	×
51
52	def item_validations	×
53	validates_with Requests::SelectedItemsValidator	×
54	end	×
55
56	def user_barcode	×
57	@patron.barcode	×
58	end	×
59
60	attr_reader :bib	×
61
62	def id	×
63	@bib[:id]	×
64	end	×
65
66	def partner_item?(item)	×
67	Requests.config[:recap_partner_locations].keys.include? item["location_code"]	×
68	end	×
69
70	def service_types	×
71	@types \|\|= @items.map { \|item\| item['type'] }.uniq	×
72	@types	×
73	end	×
74
75	def process_submission	×
76	@services = service_types.map do \|type\|	×
77	service_by_type(type)	×
78	end	×
79	@services.each(&:handle)	×
80
81	@success_messages = generate_success_messages(@success_messages)	×
82
83	@services	×
84	end	×
85
86	def service_errors	×
87	return [] if @services.blank?	×
88	@services.map(&:errors).flatten	×
89	end	×
90
91	def pick_up_location	×
92	Requests::BibdataService.delivery_locations.dig(items.first&.dig('pick_up'), "library") \|\| {}	×
93	end	×
94
95	def marquand?	×
96	items.first["holding_library"] == 'marquand'	×
97	end	×
98
99	def edd?(item)	×
100	delivery_mode = delivery_mode(item)	×
101	delivery_mode.present? && delivery_mode == "edd"	×
102	end	×
103
104	# Convert the submission to a hash that is compatible that
105	# Sidekiq can safely serialize to JSON for redis. This means:
106	# * No application-specific objects (unless they are activerecord db objects)
107	# * No ActiveSupport::HashWithIndifferentAccess objects, we can only have Hash objects
108	# * The keys of the hash must all be strings, not symbols
109	# See https://github.com/sidekiq/sidekiq/wiki/Best-Practices#1-make-your-job-parameters-small-and-simple
110	def to_h	×
111	{	×
112	bib: bib.to_hash.stringify_keys,	×
113	email: email,	×
114	errors: errors.messages.stringify_keys,	×
115	items: items.map { \|hash\| hash.to_hash.stringify_keys },	×
116	patron: patron.to_h.to_hash.stringify_keys,	×
117	pick_up_location: pick_up_location.to_hash.stringify_keys,	×
118	user_barcode:,	×
119	user_name:	×
120	}.stringify_keys	×
121	end	×
122
123	private	×
124
125	def service_by_type(type)	×
126	case type	×
127	when 'on_shelf', 'marquand_in_library', 'annex', 'annex_in_library'	×
128	Requests::Submissions::HoldItem.new(self, service_type: type)	×
129	when 'recap', 'recap_edd', 'recap_in_library', 'recap_marquand_in_library', 'recap_marquand_edd'	×
130	Requests::Submissions::Recap.new(self, service_type: type)	×
131	when 'clancy_in_library'	×
132	Requests::Submissions::Clancy.new(self)	×
133	when 'clancy_edd'	×
134	Requests::Submissions::ClancyEdd.new(self)	×
135	when 'digitize', 'annex_edd', 'marquand_edd', 'clancy_unavailable_edd'	×
136	Requests::Submissions::DigitizeItem.new(self, service_type: type)	×
137	when *inter_library_services	×
138	Requests::Submissions::Illiad.new(self, service_type: type)	×
139	else	×
140	Requests::Submissions::Generic.new(self, service_type: type)	×
141	end	×
142	end	×
143
144	def categorize_by_delivery_and_location(item)	×
145	library_code = item["library_code"]	×
146	if recap_no_items?(item)	×
147	item["type"] = "recap_no_items"	×
148	elsif print?(item) && library_code == 'annex'	×
149	item["type"] = "annex"	×
150	elsif off_site?(library_code)	×
151	raise Exception, "#{self.class}: Item does not have a delivery mode" unless delivery_mode(item)	×
152	item["type"] = library_code	×
153	item["type"] += "_edd" if edd?(item)	×
154	item["type"] += "_in_library" if in_library?(item)	×
155	elsif item["type"] == "paging"	×
156	item["type"] = "digitize" if edd?(item)	×
157	elsif edd?(item) && library_code.present?	×
158	item["type"] = "digitize"	×
159	elsif print?(item) && library_code.present?	×
160	item["type"] = "on_shelf"	×
161	end	×
162	item	×
163	end	×
164
165	def in_library?(item)	×
166	delivery_mode = delivery_mode(item)	×
167	delivery_mode.present? && delivery_mode == "in_library"	×
168	end	×
169
170	def recap_no_items?(item)	×
171	item["library_code"] == 'recap' && (item["type"] == "digitize_fill_in" \|\| item["type"] == "recap_no_items")	×
172	end	×
173
174	def off_site?(library_code)	×
175	library_code == 'recap' \|\| library_code == 'marquand' \|\| library_code == 'clancy' \|\| library_code == 'recap_marquand' \|\| library_code == 'clancy_unavailable' \|\| library_code == 'annex'	×
176	end	×
177
178	def print?(item)	×
179	delivery_mode = delivery_mode(item)	×
180	delivery_mode.present? && delivery_mode == "print"	×
181	end	×
182
183	def delivery_mode(item)	×
184	item["delivery_mode_#{item['item_id']}"]	×
185	end	×
186
187	def inter_library_services	×
188	['ill']	×
189	end	×
190
191	def generate_success_messages(success_messages)	×
192	@services.each do \|service\|	×
193	success_messages << service.success_message	×
194	service.send_mail	×
195	end	×
196	success_messages	×
197	end	×
198	end	×
199	end	×

pulibrary / orangelight / 00dbc10b-d747-4ad7-b211-7b26d753abbb

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