def unscrub_emails(project):
partners = load_identifier_list_of_type(project)
# alle Lieferanten durchgehen
for partner in partners:
sigel = 'DE-' + partner.capitalize()
logging.info('processing partner {}'.format(sigel))
# Die URL für die API zusammensetzen
partner_json = get_partner(sigel)
# Prüfen, ob die Abfrage erfolgreich war (Status-Code ist dann 200)
if partner_json is not None:
# Dieser boolean entscheidet, ob der Code des Partners geändert wurde.
changed_code = False
try:
# die ISO-Details auslesen
email_address = partner_json['partner_details'][
'profile_details']['iso_details']['email_address']
if len(email_address) == 59:
logging.warning("email of partner {} os potentially cut")
if 'SCRUBBED_' in email_address:
partner_json['partner_details']['profile_details'][
'iso_details'][
'email_address'] = email_address.replace(
'SCRUBBED_', '')
update_partner(partner_json)
else:
logging.info(
'email of partner {} does not need to be unscrubbed'.
format(sigel))
except KeyError:
logging.warning('no email address in iso details in partner ' +
sigel)
def add_sys_list_checker(list_filter):
checklist = load_identifier_list_of_type('package')
line_checker = LineChecker(method_name='has_title_sys_id',
checklist=checklist,
mode='remove')
list_filter.add_line_checker(line_checker)
return list_filter
def set_pin_old(project):
api_key = os.environ['ALMA_SCRIPT_API_KEY']
users = load_identifier_list_of_type(project)
logging.info(
'succesfully updated user | {} | {} | {} | {} | {} | {}'.format(
'user_id', 'gender', 'title', 'first_name', 'last_name', 'email'))
for user_id in users:
user = get_user(user_id)
if user is not None:
first_name = user['first_name']
last_name = user['last_name']
gender = user['gender']['value']
title = user['user_title']['value']
logging.debug(user)
birth_date_parts = user['birth_date'].split('-')
logging.debug(birth_date_parts)
pin_code = birth_date_parts[2].replace(
'Z', '') + birth_date_parts[1] + birth_date_parts[0]
user['pin_number'] = pin_code
email = ''
if len(user['contact_info']['emails']) > 0:
for email in user['contact_info']['emails']:
if email['preferred'] == True:
email = email['email_address']
update_successful = update_user(user)
# Prüfen, ob Anfrage erfolgreich war und alles in die Log-Datei schreiben
if update_successful:
logging.info(
'succesfully updated user | {} | {} | {} | {} | {} | {}'.
format(user_id, gender, title, first_name, last_name,
email))
def extend_partner_names(project):
# Datei mit den Lieferanten eines Typs laden
partners = load_identifier_list_of_type(project)
# alle Lieferanten durchgehen
for partner in partners:
partner_json = get_partner(partner)
# Prüfen, ob die Abfrage erfolgreich war
if partner_json is not None:
try:
if partner_json['partner_details']['profile_details'][
'profile_type'] == 'SLNP':
symbol = partner_json['partner_details'][
'profile_details']['iso_details']['iso_symbol']
if 'DE-' in symbol:
symbol = symbol.replace('DE-', '')
symbol = 'DE-' + symbol.capitalize()
partner_json['partner_details']['profile_details'][
'iso_details']['iso_symbol'] = symbol
name = partner_json['partner_details']['name']
if not name.startswith('DE-'):
partner_json['partner_details'][
'name'] = '{} ({})'.format(symbol, name)
update_partner(partner_json)
else:
logging.warning(
'could not update partner {}: no SLNP'.format(partner))
except KeyError:
logging.error('no iso details for partner {}'.format(partner))
def set_pin_and_password(project):
users = load_identifier_list_of_type(project)
logging.info(
'succesfully updated user | {} | {} | {} | {} | {} | {} | {}'.format(
'user_id', 'gender', 'title', 'first_name', 'last_name',
'passphrase', 'email'))
for user_id in users:
user = get_user(user_id)
if user is not None:
first_name = user['first_name']
last_name = user['last_name']
gender = user['gender']['value']
title = user['user_title']['value']
birth_date = user['birth_date']
pin_code = calculate_standard_pin(birth_date)
passphrase = ''.join(
random.SystemRandom().choice(string.ascii_uppercase +
string.ascii_lowercase +
string.digits) for _ in range(12))
user['pin_number'] = pin_code
user['password'] = passphrase
email = ''
if len(user['contact_info']['email']) > 0:
for email in user['contact_info']['email']:
if email['preferred'] == True:
email = email['email_address']
update_successful = update_user(user)
# Prüfen, ob Anfrage erfolgreich war und alles in die Log-Datei schreiben
if update_successful:
logging.info(
'succesfully updated user | {} | {} | {} | {} | {} | {} | {}'
.format(user_id, gender, title, first_name, last_name,
passphrase, email))
def set_hash(project):
users = load_identifier_list_of_type(project)
number_of_threads = 6
length_of_chunks = math.ceil(len(users) / number_of_threads)
list_chunks = list(chunks(users, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=set_hash_for_chunk, args=(chunk, 'test'))
thread.start()
def check_pin(project, update=False):
users = load_identifier_list_of_type(project)
number_of_threads = 10
length_of_chunks = math.ceil(len(users) / number_of_threads)
list_chunks = list(chunks(users, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=check_pin_for_chunk, args=(chunk, update))
thread.start()
def clean_addresses(project):
users = load_identifier_list_of_type(project)
number_of_threads = 2
length_of_chunks = math.ceil(len(users) / number_of_threads)
list_chunks = list(chunks(users, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=clean_first_lines_for_chunk,
args=(chunk, 'test'))
thread.start()
def set_email_addresses(project, email):
users = load_identifier_list_of_type(project)
number_of_threads = 10
length_of_chunks = math.ceil(len(users) / number_of_threads)
list_chunks = list(chunks(users, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=set_eamil_addresses_for_chunk,
args=(list_chunks[chunk_index], email))
thread.start()
def set_pin_pw_and_addresses(project, set_passphrase=False):
users = load_identifier_list_of_type(project)
number_of_threads = 10
length_of_chunks = math.ceil(len(users) / number_of_threads)
list_chunks = list(chunks(users, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=set_pin_pw_and_addresses_for_chunk,
args=(list_chunks[chunk_index], set_passphrase))
thread.start()
def transfer_konsol_note(project):
po_references = load_identifier_list_of_type(project)
number_of_threads = 10
length_of_chunks = math.ceil(len(po_references) / number_of_threads)
list_chunks = list(chunks(po_references, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=transfer_konsol_note_for_chunk,
args=(chunk, 'test'))
thread.start()
def correct_process_type(project, department):
item_list = list_reader_service.load_identifier_list_of_type(project)
number_of_threads = 8
length_of_chunks = math.ceil(len(item_list) / number_of_threads)
list_chunks = list(chunks(item_list, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=correct_process_type_for_chunk,
args=(chunk, department))
thread.start()
def add_id_checker(list_filter,
action='append',
list='springer_robotics_auswahl'):
checklist = load_identifier_list_of_type(list)
line_checker = LineChecker(method_name='contains',
checklist=checklist,
mode=action,
field='020 ',
format='aseq_L')
list_filter.add_line_checker(line_checker)
return list_filter
def generate_output(input_file, project):
marks = list_reader_service.load_identifier_list_of_type(project)
file = open('data/input/{}'.format(input_file), 'r',
encoding='utf-8').read()
table = []
for mark in marks:
entry = {}
entry['mark'] = mark
entry['count'] = file.count(mark)
table.append(entry)
output_file = 'data/output/{}_out.xlsx'.format(project)
new_table = pd.DataFrame(table)
new_table.to_excel(output_file)
def update_vendors(type):
# Datei mit den Lieferanten eines Typs laden
vendors = load_identifier_list_of_type('vendor_' + type)
# API-Key aus den Umgebungsvariablen lesen
api_key = os.environ['ALMA_SCRIPT_API_KEY']
# alle Lieferanten durchgehen
for vendor_line in vendors:
# Die URL für die API zusammensetzen
url = '{}acq/vendors/{}?apikey={}'.format(alma_api_base_url,
vendor_line, api_key)
# GET-Abfrage ausführen
get = requests.get(url=url, headers={'Accept': 'application/json'})
# Kodierung auf UTF-8 festsetzen
get.encoding = 'utf-8'
# Prüfen, ob die Abfrage erfolgreich war (Status-Code ist dann 200)
if get.status_code == 200:
# Den Inhalt der Antwort als Text auslesen
info = get.text
# In dem Text den Typ auf Inactive ändern
payload = info.replace(
'"status":{"value":"ACTIVE","desc":"Active"}',
'"status":{"value":"INACTIVE","desc":"Inactive"}')
# Update als PUT-Abfrage ausführen. URL ist die gleiche, Encoding ist wieder utf-8, Inhalt ist JSON
update = requests.put(url=url,
data=payload.encode('utf-8'),
headers={'Content-Type': 'application/json'})
# Antwort-Encoding ist wieder UTF-8
update.encoding = 'utf-8'
# Prüfen, ob Anfrage erfolgreich war und alles in die Log-Datei schreiben
if update.status_code == 200:
logging.info(
'succesfully updated vendor {}'.format(vendor_line))
else:
logging.warning('problem updating vendor {}:{}'.format(
vendor_line, update.text))
else:
logging.error(get.text)
def make_staff__users(project):
# Datei mit den Benutzerkennungen laden
users = load_identifier_list_of_type(project)
# alle Nutzer durchgehen
for user_id in users:
user = get_user(user_id)
# Prüfen, ob die Abfrage erfolgreich war (Status-Code ist dann 200)
if user is not None:
# Prüfen, ob der Nutzer Public ist
if user['record_type']['value'] == 'PUBLIC':
user['record_type']['value'] = 'STAFF'
user['record_type']['desc'] = 'Staff'
update_user(user)
else:
logging.info('user {} not public'.format(user))
def delete_home_library(project):
users = list_reader_service.load_identifier_list_of_type(project)
# users = set_reader_service.collect_ids_from_set(set_id)
# logging.info('retrieved {} user entries'.format(len(users)))
# ids = []
# for member in users:
# ids.append(member['id'])
logging.info('retrieved {} user ids'.format(len(users)))
# list_reader_service.save_identifier_list_of_type('DeleteHomeLibrary', ids, 'users')
# logging.info('saved {} user entries'.format(len(users)))
number_of_threads = 1
length_of_chunks = math.ceil(len(users) / number_of_threads)
list_chunks = list(chunks(users, length_of_chunks))
for chunk_index, chunk in enumerate(list_chunks):
thread = Thread(target=delete_home_library_for_chunk,
args=(chunk, 'test'))
thread.start()
def update_partners_resending_due_interval(project):
# Datei mit den Lieferanten eines Typs laden
partners = load_identifier_list_of_type(project)
# alle Lieferanten durchgehen
for partner in partners:
partner_json = get_partner(partner)
# Prüfen, ob die Abfrage erfolgreich war
if partner_json is not None:
try:
iso_details = partner_json['partner_details'][
'profile_details']['iso_details']
iso_details['resending_overdue_message_interval'] = 21
except KeyError:
logging.error('no iso details for partner {}'.format(partner))
update_partner(partner_json)
def correct_capizalization_in_symbols(project):
# Datei mit den Lieferanten eines Typs laden
partners = load_identifier_list_of_type(project)
# alle Lieferanten durchgehen
for partner in partners:
partner_json = get_partner(partner)
# Prüfen, ob die Abfrage erfolgreich war
if partner_json < 300:
try:
symbol = partner_json['partner_details']['profile_details'][
'iso_details']['iso_symbol']
symbol = symbol.replace('DE-', '')
symbol = symbol.capitalize()
symbol = 'DE-' + symbol
partner_json['partner_details']['profile_details'][
'iso_details']['iso_symbol'] = symbol
except KeyError:
logging.error('no iso details for partner {}'.format(partner))
update_partner(partner)
def update_partners(project):
# Datei mit den Lieferanten eines Typs laden
partners = load_identifier_list_of_type(project)
# alle Lieferanten durchgehen
for partner in partners:
logging.info('processing partner {}'.format(partner))
partner_json = get_partner(partner)
if partner_json is not None:
# Dieser boolean entscheidet, ob der Code des Partners geändert wurde.
changed_code = False
try:
# die ISO-Details auslesen
iso_details = partner_json['partner_details'][
'profile_details']['iso_details']
# den Server setzen
iso_details['ill_server'] = 'zfl2-test.hbz-nrw.de'
# den Port setzen
iso_details['ill_port'] = '33242'
# das Resending overdue message interval setzen
iso_details['resending_overdue_message_interval'] = 21
# das iso-Symbol auslesen
iso_symbol = iso_details['iso_symbol']
# falls noch kein DE- im Symbol ist, dieses ergänzen
if 'DE-' in iso_symbol:
iso_symbol = iso_symbol.replace('DE-', '')
iso_symbol = iso_symbol.capitalize()
iso_symbol = 'DE-' + iso_symbol
else:
iso_symbol = 'DE-' + partner.capitalize()
# ggf. die Schrägstriche entfernen
iso_symbol = iso_symbol.replace("/", "-")
# den code entsprechend ändern und den boolean entsprechend setzen
# if (partner_json['partner_details']['code'] == iso_symbol.upper()):
changed_code = True
logging.debug('changing code from {} to {}'.format(
iso_symbol.upper(), iso_symbol))
partner_json['partner_details']['code'] = iso_symbol
iso_details['iso_symbol'] = iso_symbol
logging.debug('set iso symbol for partner {} to {}'.format(
partner, iso_symbol))
changed_code = True
name = partner_json['partner_details']['name']
# if '(DE-' not in name:
# name = name.split(' (')[0] + ' (' + iso_symbol + ')'
# else:
# name = name.replace(iso_symbol.upper(), iso_symbol)
if 'DE-' not in name:
name = iso_symbol + ' (' + name.split(' (')[1]
else:
name = name.replace(iso_symbol.upper(), iso_symbol)
partner_json['partner_details']['name'] = name
except KeyError:
logging.error('no iso details for partner {}'.format(partner))
# generelle Partner details setzen
partner_details = partner_json['partner_details']
partner_details['borrowing_supported'] = True
partner_details['lending_supported'] = True
partner_details['borrowing_workflow'] = 'DEFAULT_BOR_WF'
partner_details['lending_workflow'] = 'DEFAULT_LENDING_WF'
# Adressen durchgehen, alle bis auf die preferred löschen
for address in partner_json['contact_info']['address']:
logging.debug('is preferred address ? {}'.format(
address['preferred']))
if not address['preferred']:
logging.debug('removing non-preferred address')
partner_json['contact_info']['address'].remove(address)
# E-Mails durchgehen, alle bis auf die preferred löschen, die preferred zusätzlich in den iso-details eintragen
for email in partner_json['contact_info']['email']:
logging.debug('is preferred email ? {}'.format(
email['preferred']))
if email['preferred']:
logging.debug(
'setting iso-email address to preferred address')
partner_json['partner_details']['profile_details'][
'iso_details']['email_address'] = email[
'email_address']
else:
logging.debug('removing non-preferred email-address')
partner_json['contact_info']['email'].remove(email)
# Update der Adressdaten anhand von Google Maps Ergebnissen
# google_data = get_google_data(address_block)
# if google_data is not None:
# for address_data in google_data['result']['address_components']:
# if 'country' in address_data['types']:
# if address_data['short_name'] == 'DE':
# partner_json['contact_info']['address'][0]['country'] = {"value": "DEU"}
# elif 'locality' in address_data['types']:
# partner_json['contact_info']['address'][0]['city'] = address_data['long_name']
# wenn der Partner code ersetzt wurde, kein Update des Partners durchführen, sondern einen neuen Partner anlegen
if changed_code:
# URL für POST (ohne Partner-Code)
save_new_partner(partner_json)
# wenn der Partner-Code nicht ersetzt wurde, ein einfaches Update durchführen.
else:
update_partner(partner_json)
def delete_partners(project):
partners = load_identifier_list_of_type(project)
for partner in partners:
delete_partner(partner)
def set_pin_pw_and_addresses_for_chunk(chunk, set_passphrase=False):
users_already_set = load_identifier_list_of_type("users_already_set")
for user in chunk:
user = user.strip()
if user == '':
continue
user_json = get_user(user)
if user_json is not None:
user_json = clean_title(user_json)
if user_json['primary_id'] in users_already_set:
logging.info("user {} already set.".format(user))
continue
first_name = ''
try:
first_name = user_json['first_name']
except KeyError:
logging.warning("no first name given")
last_name = user_json['last_name']
gender = user_json['gender']['value']
title = user_json['user_title']['value']
pin_new = False
try:
user_json['pin_number'] = calculate_standard_pin(
user_json['birth_date'])
pin_new = True
except:
logging.warning(
'could not load birthday for user {}'.format(user))
passphrase = ''
if set_passphrase:
passphrase = ''.join(
random.SystemRandom().choice(string.ascii_uppercase +
string.ascii_lowercase +
string.digits)
for _ in range(12))
user_json['password'] = passphrase
email = ''
if len(user_json['contact_info']['email']) > 0:
for email in user_json['contact_info']['email']:
if email['preferred'] == True:
email = email['email_address']
if len(user_json['contact_info']['address']) > 0:
for address in user_json['contact_info']['address']:
changed = False
postal_code_changed = False
if address['preferred']:
address_lines = []
for i in range(1, 6):
address_lines.append(address['line' + str(i)])
for address_item in list(address_lines):
if address_item is None:
address_lines.remove(address_item)
elif postalcode_regexp.match(address_item):
changed = True
postal_code_changed = True
address[
'postal_code'] = postalcode_regexp.findall(
address_item)[0]
address['city'] = postalcode_regexp.split(
address_item)[2].strip()
address_lines.remove(address_item)
elif 'Herr' in address_item:
changed = True
address_lines.remove(address_item)
elif 'Frau' in address_item:
changed = True
address_lines.remove(address_item)
if postal_code_changed:
logging.info(
'rearranged postal code for user {}'.format(
user))
else:
logging.info(
'no rearrangement of postal code for user {}'.
format(user))
if changed:
for i in range(0, 5):
if i < len(address_lines):
address['line' +
str(i + 1)] = address_lines[i]
else:
address['line' + str(i + 1)] = ''
else:
logging.info(
'no address changes for user {}'.format(user))
else:
logging.debug('not preferred address')
else:
logging.warning('no addresses given for user {}'.format(user))
update_success = update_user(user_json)
# Prüfen, ob Anfrage erfolgreich war und alles in die Log-Datei schreiben
if update_success:
logging.info(
'succesfully updated user | {} | {} | {} | {} | {} | {} | {} | {}'
.format(user, gender, title, first_name, last_name, email,
pin_new, passphrase))
else:
logging.warning('problem updating user {}'.format(user))
else:
logging.warning('could not retrieve user {}'.format(user))
import os
import requests
from service.list_reader_service import load_identifier_list_of_type
# Script that takes a list of Ids from the data/input folder and replaces the public record_type by staff ones
if __name__ == '__main__':
vendors = load_identifier_list_of_type('vendor')
api_key = os.environ['ALMA_ACQ_API_KEY']
total = 0
not_in_alma = 0
for vendor in vendors:
url = 'https://api-eu.hosted.exlibrisgroup.com/almaws/v1/acq/vendors/{}?apikey={}'.format(vendor, api_key)
get = requests.get(url=url, headers={'Accept': 'application/json'})
get.encoding = 'utf-8'
if get.status_code == 200:
print('vendor {} found in alma'.format(vendor))
else:
not_in_alma = not_in_alma + 1
def with_set():
marks = list_reader_service.load_identifier_list_of_type("p2e")
marks = list(dict.fromkeys(marks))
list_reader_service.save_identifier_list_of_type('p2e', marks, 'p2e')
def set_liable_for_vat():
# Datei mit den Lieferanten mit suffix finance laden
vendors = load_identifier_list_of_type('vendors_finance')
# API-Key aus den Umgebungsvariablen lesen
api_key = os.environ['ALMA_SCRIPT_API_KEY']
# alle Lieferanten durchgehen
for vendor_line in vendors:
time.sleep(0.05)
# Die URL für die API zusammensetzen
url = '{}acq/vendors/{}?apikey={}'.format(alma_api_base_url,
vendor_line, api_key)
# GET-Abfrage ausführen
get = requests.get(url=url, headers={'Accept': 'application/json'})
# Kodierung auf UTF-8 festsetzen
get.encoding = 'utf-8'
# Prüfen, ob die Abfrage erfolgreich war (Status-Code ist dann 200)
if get.status_code == 200:
# Den Inhalt der Antwort als Text auslesen
info = get.text
# In dem Text den Typ auf Inactive ändern
payload = info.replace('"liable_for_vat":false,',
'"liable_for_vat":true,')
if '"country":{"value":"DE"' in payload:
payload = payload.replace(
'"country":{"value":"DE","desc":""}',
'"country":{"value":"DEU","desc":"Germany"}')
if '"country":{"value":"Germany"' in payload:
payload = payload.replace(
'"country":{"value":"Germany","desc":""}',
'"country":{"value":"DEU","desc":"Germany"}')
if '"country":{"value":"Deutschland"' in payload:
payload = payload.replace(
'"country":{"value":"Deutschland","desc":""}',
'"country":{"value":"DEU","desc":"Germany"}')
if '"country":{"value":"Schweiz"' in payload:
payload = payload.replace(
'"country":{"value":"Schweiz","desc":""}',
'"country":{"value":"CHE","desc":"Germany"}')
if '"country":{"value":"Japan"' in payload:
payload = payload.replace(
'"country":{"value":"Japan","desc":""}',
'"country":{"value":"JPN","desc":"Germany"}')
if '"country":{"value":"Belgien"' in payload:
payload = payload.replace(
'"country":{"value":"Belgien","desc":""}',
'"country":{"value":"BEL","desc":"Germany"}')
# Update als PUT-Abfrage ausführen. URL ist die gleiche, Encoding ist wieder utf-8, Inhalt ist JSON
update = requests.put(url=url,
data=payload.encode('utf-8'),
headers={'Content-Type': 'application/json'})
# Antwort-Encoding ist wieder UTF-8
update.encoding = 'utf-8'
# Prüfen, ob Anfrage erfolgreich war und alles in die Log-Datei schreiben
if update.status_code == 200:
logging.info(
'succesfully updated liable for vat for vendor {}'.format(
vendor_line))
else:
logging.warning(
'problem updating liable for vat for vendor {}:{}'.format(
vendor_line, update.text))
else:
logging.error(get.text)
def deactivate_non_used_vendors(type):
# Datei mit den Lieferanten eines Typs laden
vendors = load_identifier_list_of_type('vendor_' + type)
# API-Key aus den Umgebungsvariablen lesen
api_key = os.environ['ALMA_SCRIPT_API_KEY']
# alle Lieferanten durchgehen
for vendor_line in vendors:
# Die URL für die API zusammensetzen
url = '{}acq/vendors/{}/po-lines?apikey={}'.format(
alma_api_base_url, vendor_line, api_key)
# Die GET-Abfrage ausführen
get_list = requests.get(url=url,
headers={'Accept': 'application/json'})
# Die Kodierung der Antwort auf UTF-8 festlegen
get_list.encoding = 'utf-8'
# Prüfen, ob die Abfrage erfolgreich war (Status-Code ist dann 200)
if get_list.status_code == 200:
# Die Antwort als Json auslesen, den Wert aus dem Feld 'total_record_count' auslesen und prüfen, ob dieser
# 0 ist (= keine Rechnungen am Lieferanten)
if (get_list.json()['total_record_count'] == 0):
# Die URL für die API zusammensetzen
url = 'acq/vendors/{}?apikey={}'.format(
alma_api_base_url, vendor_line, api_key)
# Die GET-Abfrage ausführen
get = requests.get(url=url,
headers={'Accept': 'application/json'})
# Die Kodierung der Antwort auf UTF-8 festlegen
get.encoding = 'utf-8'
# Prüfen, ob die Abfrage erfolgreich war (Status-Code ist dann 200)
if get.status_code == 200:
# Die Antwort als json auslesen, den Wert aus dem Feld 'status/value' auslesen und Prüfen, ob dieser
# 'ACTIVE' ist (aktiver Lieferant)
if get.json()['status']['value'] == 'ACTIVE':
# den Inhalt der Antwort als Text auslesen
info = get.text
# den Status-Wert "Active" durch "Inactive" ersetzen
payload = info.replace(
'"status":{"value":"ACTIVE","desc":"Active"}',
'"status":{"value":"INACTIVE","desc":"Inactive"}')
# Update als PUT-Abfrage ausführen. URL ist die gleiche, Encoding ist wieder utf-8, Inhalt ist JSON
update = requests.put(
url=url,
data=payload.encode('utf-8'),
headers={'Content-Type': 'application/json'})
# Die Kodierung der Antwort auf UTF-8 festlegen
update.encoding = 'utf-8'
# Prüfen, ob Anfrage erfolgreich war und alles in die Log-Datei schreiben
if update.status_code == 200:
logging.info(
'succesfully updated vendor {}'.format(
vendor_line))
else:
logging.error(
'problem updating vendor {}:{}'.format(
vendor_line, update.text))
else:
logging.info('account {} is already inactive'.format(
vendor_line))
else:
logging.error(get.text)
else:
logging.warning('account {} still has {} po-lines'.format(
vendor_line,
get_list.json()['total_record_count']))
else:
logging.error(get_list.text)
def fill_financial_code():
# Datei mit den Lieferanten mit suffix finance laden
vendors = load_identifier_list_of_type('vendors_finance')
# API-Key aus den Umgebungsvariablen lesen
api_key = os.environ['ALMA_SCRIPT_API_KEY']
# alle Lieferanten durchgehen
for vendor_line in vendors:
time.sleep(0.05)
# Die URL für die API zusammensetzen
url = '{}acq/vendors/{}?apikey={}'.format(alma_api_base_url,
vendor_line, api_key)
# GET-Abfrage ausführen
get = requests.get(url=url, headers={'Accept': 'application/json'})
# Kodierung auf UTF-8 festsetzen
get.encoding = 'utf-8'
# Prüfen, ob die Abfrage erfolgreich war (Status-Code ist dann 200)
if get.status_code == 200:
# Den Inhalt der Antwort als JSON-Objekt auslesen
get_json = get.json()
try:
if get_json['financial_sys_code'] != '':
logging.info(
'financial code already set for vendor {}'.format(
vendor_line))
# den SAP-Kreditoren-Wert aus dem Feld 'additional_code' auslesen
except KeyError:
logging.debug(
'no financial code set for vendor {}'.format(vendor_line))
try:
financial_code = get_json['additional_code']
except KeyError:
logging.error(
'no additional code in vendor {}'.format(vendor_line))
continue
# den ausgelesenen Wert in das Feld 'financial_sys_code' schreiben
get_json['financial_sys_code'] = financial_code
# get_json['additional_code'] = ""
for index, currency in enumerate(get_json['currency']):
if currency['value'] == 'DEM':
get_json['currency'].pop(index)
for address in get_json['contact_info']['address']:
if address['country']['value'] == 'Deutschland':
address['country']['value'] = 'DEU'
# den aktualisierten Lieferanten per PUT-Abfrage nach Alma schreiben (gleiche url wie bei der Abfrage,
# das JSON-object wird über json.dumps in einen Text umgewandelt.
update = requests.put(url=url,
data=json.dumps(get_json),
headers={'Content-Type': 'application/json'})
# die Kodierung der Antwort setzen
update.encoding = 'utf-8'
# Prüfen, ob die Abfrage erfolgreich war (Status Code 200) und alles in die Log-Datei schreiben
if update.status_code == 200:
logging.info(
'succesfully updated vendor {}'.format(vendor_line))
else:
logging.error('problem updating vendor {}:{}'.format(
vendor_line, update.text))
else:
logging.error(get.text)
