c1a44d6d-deb4-411b-9cac-c394d34cf10a

Committed 01 Oct 2025 02:26PM UTC coverage: 72.271% (+9.4%) from 62.871%

Build # c1a44d6d-deb4-411b-9cac-c394d34cf10a

Build Type

Pull #757

circleci

Committed by

regineheberlein

Commit Message

method has been renamed

Pull Request Pull Request #757: refactor helper_methods

Run Details

16 of 72 new or added lines in 2 files covered. (22.22%)

6 existing lines in 1 file now uncovered.

245 of 339 relevant lines covered (72.27%)

428.07 hits per line

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

23.48

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

pulibrary / aspace_helpers / c1a44d6d-deb4-411b-9cac-c394d34cf10a

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