44c900ff-012a-42f1-a488-05d9a2e3b55c

Committed 01 Oct 2025 05:35PM UTC coverage: 72.7% (+9.8%) from 62.871%

Build # 44c900ff-012a-42f1-a488-05d9a2e3b55c

Build Type

Pull #757

circleci

Committed by

regineheberlein

Commit Message

Use reduce to make this method shorter; don't need bangs here

Co-authored-by: Jane Sandberg <sandbergja@users.noreply.github.com>

Pull Request Pull Request #757: refactor helper_methods

Run Details

16 of 70 new or added lines in 2 files covered. (22.86%)

6 existing lines in 1 file now uncovered.

245 of 337 relevant lines covered (72.7%)

430.61 hits per line

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

23.89

/helper_methods.rb

#!/usr/bin/env ruby
require 'archivesspace/client'

def aspace_login()
  #configure access
  @config = ArchivesSpace::Configuration.new({
    base_uri: ENV.fetch('ASPACE_URL', nil),
    base_repo: "",
    username: ENV.fetch('ASPACE_USER', nil),
    password: ENV.fetch('ASPACE_PASSWORD', nil),
    #page_size: 50,
    throttle: 0,
    verify_ssl: false
  })
  #log in
  @client = ArchivesSpace::Client.new(@config).login
end

def aspace_staging_login()
  #configure access
  @config = ArchivesSpace::Configuration.new({
    base_uri: ENV.fetch('ASPACE_STAGING_URL', nil),
    base_repo: "",
    username: ENV.fetch('ASPACE_USER', nil),
    password: ENV.fetch('ASPACE_PASSWORD', nil),
    #page_size: 50,
    throttle: 0,
    verify_ssl: false,
  })

  #log in
  @client = ArchivesSpace::Client.new(@config).login
end

def get_all_repo_uris
  repositories = @client.get('/repositories').parsed
  repositories.map {|repo| repo['uri']}
end

def get_repo_id_from_uri(uri)
  uri.gsub('/repositories/', '')
end

def get_resource_ids_for_all_repos
  get_all_repo_uris.reduce([]) do |resource_ids, repo|
    repo_ids = @client.get("#{repo}/resources", {query:{all_ids:true}}).parsed
    resource_ids.concat repo_ids
  end
end

def get_resource_uris_for_all_repos
  @uris = get_all_repo_uris.map do |repo|
    ids = @client.get("#{repo}/resources", {
    query: {
      all_ids: true
    }}).parsed
    ids.map do |id|
      "#{repo}/resources/#{id}"
    end
  end
  @uris.flatten
end

def add_ids_to_array(repo, record_type)
  @ids = []
  @ids << @client.get("repositories/#{repo}/#{record_type}", {
    query: {
      all_ids: true
    }}).parsed
  @ids = @ids.flatten
end

def get_resource_uris_for_specific_repos(repos = [])
  @uris = []
  repos.each do |repo|
    add_ids_to_array(repo, 'resources')
    @ids.each do |id|
      @uris << "repositories/#{repo}/resources/#{id}"
    end
  end
  @uris
end

def get_all_resource_records_for_institution(resolve = [])
  repos = get_all_repo_uris
  repos.map do |repo|
    repo_id = get_repo_id_from_uri(repo)
    resource_ids = add_ids_to_array(repo_id, 'resources')
    count_ids = resource_ids.count
    paginate_endpoint(resource_ids, count_ids, "#{repo}/resources", resolve)
  end.flatten
end

def paginate_endpoint(ids, count_ids, endpoint, resolve)
  @results = []
  @results = []
  count_processed_records = 0
  while count_processed_records < count_ids do
    last_record = [count_processed_records+249, count_ids].min
    @results << @client.get(endpoint, {
            query: {
              id_set: ids[count_processed_records..last_record],
              resolve: resolve
            }
          }).parsed
    count_processed_records = last_record
  end
  @results.flatten
  @results.flatten
end

def get_all_records_of_type_in_repo(record_type, repo, resolve = [])
  get_paginated_records(record_type, repo, resolve)
  @results.flatten!
end

def construct_endpoint(repo, record_type)
  endpoint = 'repositories/'+repo.to_s+'/'+record_type.to_s
end

def get_paginated_records(record_type, repo, resolve)
  endpoint = construct_endpoint(repo, record_type)
  ids = []
  ids << @client.get(endpoint, {
    query: {
     all_ids: true
    }}).parsed
  count_ids = ids.flatten!.count
  paginate_endpoint(ids, count_ids, endpoint, resolve)
end

def get_single_resource_by_eadid(repo, eadid, resolve = [])
  record_type = 'resources'
  collections_all = get_all_records_of_type_in_repo(record_type, repo, resolve)
  record_type = 'resources'
  collections_all = get_all_records_of_type_in_repo(record_type, repo, resolve)
  selected_resources = collections_all.select do |c|
    c['ead_id'] == eadid
  end
end

#pass in eadids as array
def get_uris_by_eadids(eadids, resolve = [])
  selected_resources = get_resources_by_eadids(eadids, resolve)
  uris = selected_resources.flatten.map do |resource|
    "#{resource['uri']}, #{resource['ead_id']}"
  end
end

#pass in eadids as array
def get_resources_by_eadids(eadids, resolve = [])
  selected_resources = []
  selected_resources << get_all_resource_records_for_institution.select do |resource|
    eadids.include? resource['ead_id']
  end
  selected_resources
end

def get_person_by_id_as_xml(repo_id, agent_id)
endpoint_name = '/repositories/' + repo_id.to_s + '/archival_contexts/people/' + agent_id.to_s + '.xml'
@client.get(endpoint_name.to_s).parsed
end

#expect this method to take up to 30 minutes
def get_all_top_container_records_for_institution(resolve = [])
  repos = get_all_repo_uris
  repos.map do |repo_uri|
    repo_id = get_repo_id_from_uri(repo_uri)
    container_ids = add_ids_to_array(repo_id, 'top_containers')
    count_ids = container_ids.count
    paginate_endpoint(container_ids, count_ids, "#{repo_uri}/top_containers", resolve)
  end.flatten
end

def get_users
  endpoint_name = '/users'
  ids = @client.get('/users', {
    query: {
     all_ids: true
    }}).parsed.join(',')
  users = @client.get('/users', {
    query: {
      id_set: ids
    }
    }).parsed
end

def get_user_permissions
  ids = @client.get('/users', {
      query: {
       all_ids: true
      }}).parsed
  ids.map { |id| @client.get("/users/#{id}").parsed }
end

def add_agent_maintenance_history(record, text)
  if record['agent_maintenance_histories'].nil?
    record['agent_maintenance_histories'] = [{
      "maintenance_event_type"=>"updated",
      "maintenance_agent_type"=>"machine",
      "agent"=>"system",
      "event_date"=>"#{Time.now}",
      "descriptive_note"=>text.to_s,
      "created_by"=>"aspace_helpers",
      "publish"=>true,
      "jsonmodel_type"=>"agent_maintenance_history"
    }]
  else
    record['agent_maintenance_histories'] << {
      "maintenance_event_type"=>"updated",
      "maintenance_agent_type"=>"machine",
      "agent"=>"system",
      "event_date"=>"#{Time.now}",
      "descriptive_note"=>text.to_s,
      "created_by"=>"aspace_helpers",
      "publish"=>true,
      "jsonmodel_type"=>"agent_maintenance_history"
    }
  end
end

def add_resource_revision_statement(record, text)
  record['revision_statements'] << {
    "date"=>"#{Time.now}",
    "created_by"=>"system",
    "last_modified_by"=>"aspace_helpers",
    "create_time"=>"#{Time.now}",
    "description"=>text.to_s,
    "publish"=>true,
    "jsonmodel_type"=>"revision_statement"
  }
end

def get_index_of_resource_uri(uri)
  repo = uri.gsub('repositories/', '').gsub(%r{/resources/.+}, '')
  uris = get_resource_uris_for_specific_repos([repo])
  uris.index(uri)
end

#input_ids and record_types_to_prefetch are passed in as arrays
def get_resolved_objects_from_ids(repository_id, input_ids, record_type, record_types_to_prefetch)
  all_records = []
  count_processed_records = 0
  count_ids = input_ids.count
  while count_processed_records < count_ids
      last_record = [count_processed_records+29, count_ids].min
      all_records << @client.get("/repositories/#{repository_id}/#{record_type}",
              query: {
                id_set: input_ids[count_processed_records..last_record],
                resolve: record_types_to_prefetch
              }).parsed
      count_processed_records = last_record
  end
  all_records = all_records.flatten
end

1	#!/usr/bin/env ruby
2	require 'archivesspace/client'	1✔
3
4	def aspace_login()	1✔
5	#configure access
6	@config = ArchivesSpace::Configuration.new({	5✔
7	base_uri: ENV.fetch('ASPACE_URL', nil),
8	base_repo: "",
9	username: ENV.fetch('ASPACE_USER', nil),
10	password: ENV.fetch('ASPACE_PASSWORD', nil),
11	#page_size: 50,
12	throttle: 0,
13	verify_ssl: false
14	})
15	#log in
16	@client = ArchivesSpace::Client.new(@config).login	5✔
17	end
18
19	def aspace_staging_login()	1✔
20	#configure access
21	@config = ArchivesSpace::Configuration.new({	×
22	base_uri: ENV.fetch('ASPACE_STAGING_URL', nil),
23	base_repo: "",
24	username: ENV.fetch('ASPACE_USER', nil),
25	password: ENV.fetch('ASPACE_PASSWORD', nil),
26	#page_size: 50,
27	throttle: 0,
28	verify_ssl: false,
29	})
30
31	#log in
32	@client = ArchivesSpace::Client.new(@config).login	×
33	end
34
35	def get_all_repo_uris	1✔
NEW 36	repositories = @client.get('/repositories').parsed	×
NEW 37	repositories.map {\|repo\| repo['uri']}	×
38	end
39
40	def get_repo_id_from_uri(uri)	1✔
NEW 41	uri.gsub('/repositories/', '')	×
42	end
43
44	def get_resource_ids_for_all_repos	1✔
NEW 45	get_all_repo_uris.reduce([]) do \|resource_ids, repo\|	×
NEW 46	repo_ids = @client.get("#{repo}/resources", {query:{all_ids:true}}).parsed	×
NEW 47	resource_ids.concat repo_ids	×
48	end
49	end
50
51	def get_resource_uris_for_all_repos	1✔
NEW 52	@uris = get_all_repo_uris.map do \|repo\|	×
NEW 53	ids = @client.get("#{repo}/resources", {	×
54	query: {
55	all_ids: true
56	}}).parsed
NEW 57	ids.map do \|id\|	×
NEW 58	"#{repo}/resources/#{id}"	×
59	end
60	end
NEW 61	@uris.flatten	×
62	end
63
64	def add_ids_to_array(repo, record_type)	1✔
NEW 65	@ids = []	×
NEW 66	@ids << @client.get("repositories/#{repo}/#{record_type}", {	×
67	query: {
68	all_ids: true
69	}}).parsed
NEW 70	@ids = @ids.flatten	×
71	end
72
73	def get_resource_uris_for_specific_repos(repos = [])	1✔
NEW 74	@uris = []	×
NEW 75	repos.each do \|repo\|	×
NEW 76	add_ids_to_array(repo, 'resources')	×
NEW 77	@ids.each do \|id\|	×
NEW 78	@uris << "repositories/#{repo}/resources/#{id}"	×
79	end
80	end
NEW 81	@uris	×
82	end
83
84	def get_all_resource_records_for_institution(resolve = [])	1✔
NEW 85	repos = get_all_repo_uris	×
NEW 86	repos.map do \|repo\|	×
NEW 87	repo_id = get_repo_id_from_uri(repo)	×
NEW 88	resource_ids = add_ids_to_array(repo_id, 'resources')	×
NEW 89	count_ids = resource_ids.count	×
NEW 90	paginate_endpoint(resource_ids, count_ids, "#{repo}/resources", resolve)	×
91	end.flatten
92	end
93
94	def paginate_endpoint(ids, count_ids, endpoint, resolve)	1✔
NEW 95	@results = []	×
NEW 96	@results = []	×
97	count_processed_records = 0	×
98	while count_processed_records < count_ids do	×
99	last_record = [count_processed_records+249, count_ids].min	×
100	@results << @client.get(endpoint, {	×
101	query: {
102	id_set: ids[count_processed_records..last_record],
103	resolve: resolve
104	}
105	}).parsed
106	count_processed_records = last_record	×
107	end
NEW 108	@results.flatten	×
NEW 109	@results.flatten	×
110	end
111
112	def get_all_records_of_type_in_repo(record_type, repo, resolve = [])	1✔
NEW 113	get_paginated_records(record_type, repo, resolve)	×
NEW 114	@results.flatten!	×
115	end
116
117	def construct_endpoint(repo, record_type)	1✔
NEW 118	endpoint = 'repositories/'+repo.to_s+'/'+record_type.to_s	×
119	end
120
121	def get_paginated_records(record_type, repo, resolve)	1✔
NEW 122	endpoint = construct_endpoint(repo, record_type)	×
123	ids = []	×
124	ids << @client.get(endpoint, {	×
125	query: {
126	all_ids: true
127	}}).parsed
UNCOV 128	count_ids = ids.flatten!.count	×
129	paginate_endpoint(ids, count_ids, endpoint, resolve)	×
130	end
131
132	def get_single_resource_by_eadid(repo, eadid, resolve = [])	1✔
NEW 133	record_type = 'resources'	×
NEW 134	collections_all = get_all_records_of_type_in_repo(record_type, repo, resolve)	×
NEW 135	record_type = 'resources'	×
NEW 136	collections_all = get_all_records_of_type_in_repo(record_type, repo, resolve)	×
137	selected_resources = collections_all.select do \|c\|	×
138	c['ead_id'] == eadid	×
139	end
140	end
141
142	#pass in eadids as array
143	def get_uris_by_eadids(eadids, resolve = [])	1✔
NEW 144	selected_resources = get_resources_by_eadids(eadids, resolve)	×
NEW 145	uris = selected_resources.flatten.map do \|resource\|	×
NEW 146	"#{resource['uri']}, #{resource['ead_id']}"	×
147	end
148	end
149
150	#pass in eadids as array
151	def get_resources_by_eadids(eadids, resolve = [])	1✔
152	selected_resources = []	×
NEW 153	selected_resources << get_all_resource_records_for_institution.select do \|resource\|	×
NEW 154	eadids.include? resource['ead_id']	×
155	end
NEW 156	selected_resources	×
157	end
158
159	def get_person_by_id_as_xml(repo_id, agent_id)	1✔
160	endpoint_name = '/repositories/' + repo_id.to_s + '/archival_contexts/people/' + agent_id.to_s + '.xml'	×
161	@client.get(endpoint_name.to_s).parsed	×
162	end
163
164	#expect this method to take up to 30 minutes
165	def get_all_top_container_records_for_institution(resolve = [])	1✔
NEW 166	repos = get_all_repo_uris	×
NEW 167	repos.map do \|repo_uri\|	×
NEW 168	repo_id = get_repo_id_from_uri(repo_uri)	×
NEW 169	container_ids = add_ids_to_array(repo_id, 'top_containers')	×
NEW 170	count_ids = container_ids.count	×
NEW 171	paginate_endpoint(container_ids, count_ids, "#{repo_uri}/top_containers", resolve)	×
172	end.flatten
173	end
174
175	def get_users	1✔
UNCOV 176	endpoint_name = '/users'	×
NEW 177	ids = @client.get('/users', {	×
178	query: {
179	all_ids: true
180	}}).parsed.join(',')
NEW 181	users = @client.get('/users', {	×
182	query: {
183	id_set: ids
184	}
185	}).parsed
186	end
187
188	def get_user_permissions	1✔
UNCOV 189	ids = @client.get('/users', {	×
190	query: {
191	all_ids: true
192	}}).parsed
193	ids.map { \|id\| @client.get("/users/#{id}").parsed }	×
194	end
195
196	def add_agent_maintenance_history(record, text)	1✔
UNCOV 197	if record['agent_maintenance_histories'].nil?	×
198	record['agent_maintenance_histories'] = [{	×
199	"maintenance_event_type"=>"updated",
200	"maintenance_agent_type"=>"machine",
201	"agent"=>"system",
202	"event_date"=>"#{Time.now}",
203	"descriptive_note"=>text.to_s,
204	"created_by"=>"aspace_helpers",
205	"publish"=>true,
206	"jsonmodel_type"=>"agent_maintenance_history"
207	}]
208	else
209	record['agent_maintenance_histories'] << {	×
210	"maintenance_event_type"=>"updated",
211	"maintenance_agent_type"=>"machine",
212	"agent"=>"system",
213	"event_date"=>"#{Time.now}",
214	"descriptive_note"=>text.to_s,
215	"created_by"=>"aspace_helpers",
216	"publish"=>true,
217	"jsonmodel_type"=>"agent_maintenance_history"
218	}
219	end
220	end
221
222	def add_resource_revision_statement(record, text)	1✔
UNCOV 223	record['revision_statements'] << {	×
224	"date"=>"#{Time.now}",
225	"created_by"=>"system",
226	"last_modified_by"=>"aspace_helpers",
227	"create_time"=>"#{Time.now}",
228	"description"=>text.to_s,
229	"publish"=>true,
230	"jsonmodel_type"=>"revision_statement"
231	}
232	end
233
234	def get_index_of_resource_uri(uri)	1✔
NEW 235	repo = uri.gsub('repositories/', '').gsub(%r{/resources/.+}, '')	×
NEW 236	uris = get_resource_uris_for_specific_repos([repo])	×
UNCOV 237	uris.index(uri)	×
238	end
239
240	#input_ids and record_types_to_prefetch are passed in as arrays
241	def get_resolved_objects_from_ids(repository_id, input_ids, record_type, record_types_to_prefetch)	1✔
242	all_records = []	×
243	count_processed_records = 0	×
244	count_ids = input_ids.count	×
245	while count_processed_records < count_ids	×
246	last_record = [count_processed_records+29, count_ids].min	×
247	all_records << @client.get("/repositories/#{repository_id}/#{record_type}",	×
248	query: {
249	id_set: input_ids[count_processed_records..last_record],
250	resolve: record_types_to_prefetch
251	}).parsed
252	count_processed_records = last_record	×
253	end
254	all_records = all_records.flatten	×
255	end

pulibrary / aspace_helpers / 44c900ff-012a-42f1-a488-05d9a2e3b55c

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