def save_data(model, did=None, **kwargs):
kwargs = convert4datastore(kwargs)
try:
with session_scope() as session:
if did:
update_record(session, model, did, **kwargs)
else:
insert_or_ignore(session, model, **kwargs)
except IntegrityError as e:
mlogger.error(f'DB IntegrityError while saving {model.__name__} '
f'record with parameters {kwargs}')
raise BabelError(e)
def copy_distribution_data(distr_record, user_id):
try:
with session_scope() as session:
# create new name
# check if used and adjust
exists = True
n = 0
while exists:
new_name = f'{distr_record.name}-copy({n})'
rec = retrieve_record(
session, DistSet,
name=new_name,
user_id=user_id,
system_id=distr_record.system_id)
if not rec:
exists = False
n += 1
# prep copy of distrgrids & gridlocations
grids = []
for grid in distr_record.distgrids:
locs = []
for loc in grid.gridlocations:
locs.append(
GridLocation(
branch_id=loc.branch_id,
shelfcode_id=loc.shelfcode_id,
qty=loc.qty))
grids.append(
DistGrid(
name=grid.name,
gridlocations=locs))
rec = insert(
session,
DistSet,
name=new_name,
system_id=distr_record.system_id,
user_id=user_id,
distgrids=grids)
mlogger.debug(f'Added new record: {rec}')
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error(
'Unhandled error in copy distribution.'
f'Traceback: {tb}')
raise BabelError(exc)
def delete_data(record):
try:
# check if can be deteled without consequences first
with session_scope() as session:
model = type(record)
delete_record(session, model, did=record.did)
mlogger.debug('Deleted {} record did={}'.format(
model.__name__, record.did))
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error cart deletion.' f'Traceback: {tb}')
raise BabelError(exc)
def save_displayed_order_data(tracker_values):
try:
with session_scope() as session:
for v in tracker_values:
order = v['order']
locs = v['grid']['locs']
okwargs = {}
locations = []
for l in locs:
mlogger.debug('Saving orderLoc data: order_id:{}, '
'loc_id:{}, frm_id:{}'.format(
order['order_id'], l['loc_id'],
l['unitFrm'].winfo_id()))
lkwargs = {}
if l['loc_id'] is not None:
lkwargs['did'] = l['loc_id']
if l['branchCbx'].get() != '':
rec_id = get_branch_rec_id(session,
l['branchCbx'].get())
lkwargs['branch_id'] = rec_id
if l['shelfCbx'].get() != '':
rec_id = get_shelf_rec_id(session, l['shelfCbx'].get())
lkwargs['shelfcode_id'] = rec_id
if l['qtyEnt'].get() != '':
lkwargs['qty'] = int(l['qtyEnt'].get())
if l['fundCbx'].get() != '':
rec_id = get_fund_rec_id(session, l['fundCbx'].get())
lkwargs['fund_id'] = rec_id
# validate here
if lkwargs:
locations.append(OrderLocation(**lkwargs))
mlogger.debug(
'Saving orderLoc data, params: {}'.format(lkwargs))
okwargs = get_ids_for_order_boxes_values(order)
okwargs['locations'] = locations
mlogger.debug('Saving order data (id:{}), params: {}'.format(
order['order_id'], okwargs))
update_record(session, Order, order['order_id'], **okwargs)
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error on saving cart data.'
f'Traceback: {tb}')
raise BabelError(exc)
def update_fund(**kwargs):
"""
Adds a new fund with all related data
args:
system_id: int, datastore did of NYPL or BPL
fund_code: str, Sierra fund code
describ: str, fund brief description
libraries: list, 'branches', 'research' (NYPL only)
audns: list, list of 'a', 'j', 'y' values applicable for the fund
matTypes: list, material types applicable for the fund
"""
try:
for k, v in kwargs.items():
if not v:
if k == 'libraries':
kwargs[k] = []
elif k == 'audns':
kwargs[k] = []
elif k == 'branches':
kwargs[k] = []
elif k == 'matTypes':
kwargs[k] = []
else:
kwargs[k] = None
mlogger.info('Existing fund new parameters: {}'.format(kwargs))
with session_scope() as session:
branches, libraries, audns, matTypes = create_fund_joiner_objs(
session, **kwargs)
update_record(session,
Fund,
kwargs['did'],
code=kwargs['code'],
describ=kwargs['describ'],
audns=audns,
branches=branches,
matTypes=matTypes,
libraries=libraries)
fund_rec = retrieve_record(session, Fund, did=kwargs['did'])
mlogger.info(f'Updated record {fund_rec}')
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error in Fund update.' f'Traceback: {tb}')
raise BabelError(exc)
def find_matches(cart_id, progbar=None, status_var=None):
with session_scope() as session:
if status_var:
status_var.set('Searching...')
if progbar:
count = count_records(session, Order, cart_id=cart_id)
progbar['value'] = 0
progbar['maximum'] = count
cart_rec = retrieve_record(session, Cart, did=cart_id)
ord_recs = retrieve_records(session, Order, cart_id=cart_id)
for rec in ord_recs:
keyword = None
if rec.resource.isbn:
keyword = rec.resource.isbn
babel_dup = babel_resource_match(session,
cart_rec.system_id,
cart_rec.library_id,
isbn=keyword)
elif rec.resource.upc:
keyword = rec.resource.upc
babel_dup = babel_resource_match(upc=keyword)
else:
catalog_dup = False
babel_dup = False
catalog_dup = catalog_match(cart_rec.system_id, keyword)
mlogger.debug(
f'Found following order matches: catalog={catalog_dup}, '
f'babel={babel_dup}')
update_record(session,
Resource,
rec.resource.did,
dup_catalog=catalog_dup,
dup_babel=babel_dup,
dup_timestamp=datetime.now())
if progbar:
progbar['value'] += 1
progbar.update()
if status_var:
status_var.set('Search completed.')
def copy_grid_data(grid_record):
mlogger.debug(
f'Copying grid record did={grid_record.did}, name={grid_record.name}')
try:
with session_scope() as session:
# create new name
# check if used and adjust
exists = True
n = 0
while exists:
new_name = f'{grid_record.name}-copy({n})'
rec = retrieve_record(
session, DistGrid,
distset_id=grid_record.distset_id,
name=new_name)
if not rec:
exists = False
n += 1
# compile location data
locs = []
for loc in grid_record.gridlocations:
locs.append(
GridLocation(
branch_id=loc.branch_id,
shelfcode_id=loc.shelfcode_id,
qty=loc.qty))
# # insert to datastore
rec = insert(
session, DistGrid,
distset_id=grid_record.distset_id,
name=new_name,
gridlocations=locs)
mlogger.debug(
f'Added new record {rec}')
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error(
'Unhandled error in copy grid.'
f'Traceback: {tb}')
raise BabelError(exc)
def create_name_index(model, **kwargs):
"""
Creates an value/id index of the model
args:
model: datatstore class, babel datastore table
kwargs: dict, filters to be applied to query
returns:
idx: dict, {column value: datastore id}
"""
idx = {}
with session_scope() as session:
instances = retrieve_records(session, model, **kwargs)
for i in instances:
if i.name is None:
idx[i.did] = ''
else:
idx[i.did] = i.name
return idx
def get_carts_data(system_id, user='******', status=''):
data = []
try:
with session_scope() as session:
recs = get_cart_data_view_records(session, system_id, user, status)
for r in recs:
data.append([
r.cart_id, r.cart_name, f'{r.cart_date:%y-%m-%d %H:%M}',
r.cart_status, r.cart_owner, r.linked
])
return data
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error on cart data retrieval.'
f'Traceback: {tb}')
raise BabelError(exc)
def tabulate_funds(cart_id):
"""
Calculates amount alocated per fund in the cart
args:
cart_id: int, datastore cart did
returns:
tally: list of tuples(code, amount)
"""
tally = []
df = get_cart_details_as_dataframe(cart_id)
for fund, value in df.groupby('fund'):
amount = (value['price'] * value['qty']).sum()
amount = f'{amount:.2f}'
tally.append(f'{fund}:${amount}')
with session_scope() as session:
update_record(session, Cart, did=cart_id, updated=datetime.now())
return tally
def assign_wlo_to_cart(cart_id):
try:
with session_scope() as session:
# determne how many wlo are needed and reserve them
last_wlo_rec = retrieve_last_record(session, Wlos)
order_count = count_records(session, Order, cart_id=cart_id)
wlo_numbers = wlo_pool(last_wlo_rec.did, order_count)
orders = retrieve_records(session, Order, cart_id=cart_id)
for o in orders:
if o.wlo is None:
wlo = wlo_numbers.__next__()
update_record(session, Order, o.did, wlo=wlo)
insert(session, Wlos, did=wlo)
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error on assigning wlo to cart.'
f'Traceback: {tb}')
raise BabelError(exc)
def export_orders_to_marc_file(fh, saving_status, cart_rec, progbar):
# this has to be rewritten to make it more transparent
# and easier to maintain
try:
progbar['value'] = 0
# overwrite existing files
if os.path.isfile(fh):
try:
os.remove(fh)
except WindowsError as e:
raise BabelError(f'File in use. Error: {e}')
with session_scope() as session:
rec_count = count_records(session, Order, cart_id=cart_rec.did)
progbar['maximum'] = rec_count
selector = retrieve_record(session, User, did=cart_rec.user_id)
blanketPO = cart_rec.blanketPO
# determine some global values
if cart_rec.system_id == 1:
oclc_code = 'BKL'
selector_code = selector.bpl_code
elif cart_rec.system_id == 2:
oclc_code = 'NYP'
selector_code = selector.nyp_code
lib_rec = retrieve_record(session,
Library,
did=cart_rec.library_id)
library_code = lib_rec.code
ord_recs = retrieve_records(session, Order, cart_id=cart_rec.did)
for order in ord_recs:
mat_rec = retrieve_record(session,
MatType,
did=order.matType_id)
ven_rec = retrieve_record(session, Vendor, did=order.vendor_id)
if cart_rec.system_id == 1:
order.mat_bib = mat_rec.bpl_bib_code
order.mat_ord = mat_rec.bpl_ord_code
order.vendor = ven_rec.bpl_code
elif cart_rec.system_id == 2:
order.mat_bib = mat_rec.nyp_bib_code
order.mat_ord = mat_rec.nyp_ord_code
order.vendor = ven_rec.nyp_code
# retrieve joined values
rec = retrieve_record(session, Audn, did=order.audn_id)
order.audn = rec.code
rec = retrieve_record(session, Lang, did=order.lang_id)
order.lang = rec.code
copies = 0
locs = []
funds = []
for loc in order.locations:
rec = retrieve_record(session, Branch, did=loc.branch_id)
branch = rec.code
try:
rec = retrieve_record(session,
ShelfCode,
did=loc.shelfcode_id)
shelfcode = rec.code
shelf_with_audn = rec.includes_audn
except AttributeError:
shelfcode = ''
shelf_with_audn = False
try:
rec = retrieve_record(session, Fund, did=loc.fund_id)
fund = rec.code
except AttributeError:
fund = ''
copies += loc.qty
if shelf_with_audn:
loc_str = f'{branch}{order.audn}{shelfcode}/{loc.qty}'
else:
if shelfcode is None:
loc_str = f'{branch}/{loc.qty}'
else:
loc_str = f'{branch}{shelfcode}/{loc.qty}'
locs.append(loc_str)
fund_str = f'{fund}/{loc.qty}'
funds.append(fund_str)
order.copies = str(copies)
order.locs = ','.join(locs)
order.funds = ','.join(funds)
order.order_date = datetime.strftime(date.today(), '%m-%d-%Y')
make_bib(fh, oclc_code, library_code, blanketPO, selector_code,
order)
progbar['value'] += 1
progbar.update()
saving_status.set('Data saved to MARC file successfully.')
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error on saving to MARC.' f'Traceback: {tb}')
raise BabelError(exc)
def get_records(model, **kwargs):
with session_scope() as session:
instances = retrieve_records(session, model, **kwargs)
session.expunge_all()
return instances
def get_codes(model, **kwargs):
values = []
with session_scope() as session:
res = get_column_values(session, model, 'code', **kwargs)
values = [x.code for x in res]
return values
def validate_cart_data(cart_id):
issues = OrderedDict()
iss_count = 0
with session_scope() as session:
cart_rec = retrieve_record(session, Cart, did=cart_id)
if cart_rec.system_id == 1 and cart_rec.library_id != 1:
iss_count += 1
issues[0] = "BPL cart library parameter must be set to 'branches'"
elif cart_rec.system_id == 2:
if not cart_rec.library_id or cart_rec.library_id == 3:
iss_count += 1
issues[0] = 'NYPL carts must specify library'
n = 0
order_records = retrieve_records(session, Order, cart_id=cart_id)
for o in order_records:
ord_issues = []
n += 1
if not o.lang_id:
iss_count += 1
ord_issues.append('language')
if not o.audn_id:
iss_count += 1
ord_issues.append('audience')
if not o.vendor_id:
iss_count += 1
ord_issues.append('vendor')
if not o.matType_id:
iss_count += 1
ord_issues.append('material type')
if not o.resource.title:
iss_count += 1
ord_issues.append('title')
if not o.resource.price_disc:
iss_count += 1
ord_issues.append('discount price')
grid_issues = OrderedDict()
m = 0
if o.locations:
for l in o.locations:
m += 1
loc_issues = []
if not l.branch_id:
iss_count += 1
loc_issues.append('branch')
if not l.shelfcode_id:
iss_count += 1
loc_issues.append('shelf code')
if not l.qty:
iss_count += 1
loc_issues.append('quantity')
if not l.fund_id:
iss_count += 1
loc_issues.append('fund')
else:
# verify fund here
valid_fund = validate_fund(session, l.fund_id,
cart_rec.system_id,
cart_rec.library_id,
o.audn_id, o.matType_id,
l.branch_id)
if not valid_fund:
loc_issues.append('(incorrect) fund')
if loc_issues:
grid_issues[m] = loc_issues
else:
iss_count += 1
ord_issues.append('locations')
if ord_issues or grid_issues:
issues[n] = (ord_issues, grid_issues)
return iss_count, issues
def apply_grid_to_selected_orders(order_ids, grid_id, append=False):
"""
Datastore transaction that appends or replaces current
OrderLocation records
args:
order_ids: list, list of datastore order dids
grid_id: int, datastore DistGrid.did
append: boolean, True appends to existing locations,
False replaces existing locations
"""
with session_scope() as session:
# retrieve grid location data
grid_rec = retrieve_record(session, DistGrid, did=grid_id)
if append:
# add to existing locations
for oid in order_ids:
ord_rec = retrieve_record(session, Order, did=oid)
for gloc in grid_rec.gridlocations:
# find duplicates and merge
dup = False
for oloc in ord_rec.locations:
if oloc.branch_id == gloc.branch_id and \
oloc.shelfcode_id == gloc.shelfcode_id:
# add quantity to existing oloc
dup = True
mlogger.debug(
'Updating existing '
f'OrderLocation.did={oloc.did} '
f'with new qty={oloc.qty + gloc.qty}')
update_record(session,
OrderLocation,
oloc.did,
order_id=oid,
branch_id=oloc.branch_id,
shelfcode_id=oloc.shelfcode_id,
qty=oloc.qty + gloc.qty,
fund_id=oloc.fund_id)
if not dup:
mlogger.debug(
f'Inserting new OrderLocation for Order.did={oid} '
f'based on DistGrid.did={gloc.did}')
insert_or_ignore(session,
OrderLocation,
order_id=oid,
branch_id=gloc.branch_id,
shelfcode_id=gloc.shelfcode_id,
qty=gloc.qty)
else:
# replace existing locations
for oid in order_ids:
# delete exiting locaations
loc_recs = retrieve_records(session,
OrderLocation,
order_id=oid)
for oloc in loc_recs:
mlogger.debug(f'Deleting OrderLocation.did={oloc.did} '
f'of order.did={oid}')
delete_record(session, OrderLocation, did=oloc.did)
for gloc in grid_rec.gridlocations:
mlogger.debug(f'Inserting new OrderLocation based on '
f'DistGrid.did={gloc.did}')
insert_or_ignore(session,
OrderLocation,
order_id=oid,
branch_id=gloc.branch_id,
shelfcode_id=gloc.shelfcode_id,
qty=gloc.qty)
def create_cart(
cart_name, system_id, profile_id,
resource_data, progbar):
try:
with session_scope() as session:
# create Cart record
name_exists = True
n = 0
while name_exists and n < 10:
name_exists = retrieve_record(
session, Cart, name=cart_name)
if name_exists:
n += 1
if '(' in cart_name:
end = cart_name.index('(')
cart_name = cart_name[:end]
cart_name = f'{cart_name}({n})'
if system_id == 1:
library_id = 1
else:
library_id = None
cart_rec = insert(
session, Cart,
name=cart_name,
created=datetime.now(),
updated=datetime.now(),
library_id=library_id,
system_id=system_id,
user_id=profile_id)
progbar['value'] += 1
progbar.update()
# create Resource records
for d in resource_data:
ord_rec = insert(
session, Order,
cart_id=cart_rec.did,
comment=d.comment)
insert(
session, Resource,
order_id=ord_rec.did,
title=d.title,
add_title=d.add_title,
author=d.author,
series=d.series,
publisher=d.publisher,
pub_date=d.pub_date,
pub_place=d.pub_place,
summary=d.summary,
isbn=d.isbn,
upc=d.upc,
other_no=d.other_no,
price_list=d.price_list,
price_disc=d.price_disc,
desc_url=d.desc_url,
misc=d.misc)
progbar['value'] += 1
progbar.update()
session.flush()
created_cart_id = cart_rec.did
return created_cart_id
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error(
f'Unhandled on sheet ingest. Traceback: {tb}')
raise BabelError(exc)
def get_data_by_identifier(keyword, keyword_type):
if keyword_type == 'bib #':
param = Order.bid
elif keyword_type == 'order #':
param = Order.oid
elif keyword_type == 'wlo #':
param = Order.wlo
elif keyword_type == 'ISBN':
param = Resource.isbn
elif keyword_type == 'UPC':
param = Resource.upc
elif keyword_type == 'other #':
param = Resource.other_no
elif keyword_type == 'blanketPO':
param = Cart.blanketPO
else:
raise AttributeError('Invalid keyword_type passed')
mlogger.debug(f'Basic search params: {keyword}, type {param}')
try:
with session_scope() as session:
recs = (session.query(Cart, Order, Resource).join(
Order, Cart.did == Order.cart_id).join(
Resource, Order.did == Resource.order_id).filter(
param == keyword).all())
results = []
for cart_rec, ord_rec, res_rec in recs:
# cart
cart = cart_rec.name
owner = get_owner(session, cart_rec.user_id)
system = get_system_name(session, cart_rec.system_id)
library = get_library_name(session, cart_rec.library_id)
status = get_status_name(session, cart_rec.status_id)
created = cart_rec.created
blanketPO = cart_rec.blanketPO
# order
oid = ord_rec.oid
bid = ord_rec.bid
wlo = ord_rec.wlo
po = ord_rec.poPerLine
lang = get_lang_name(session, ord_rec.lang_id)
audn_name, audn_code = get_audn_name_and_code(
session, ord_rec.audn_id)
vendor = get_vendor_code(session, ord_rec.vendor_id, system)
mattype = get_mattype_name(session, ord_rec.matType_id)
locs = []
for loc in ord_rec.locations:
branch = get_branch_code(session, loc.branch_id)
shelfcode = get_shelfcode(session, loc.shelfcode_id,
audn_code)
qty = loc.qty
fund = get_fund_code(session, loc.fund_id)
locs.append(f'{branch}{shelfcode}({qty})/{fund}')
# resouce
title = res_rec.title
author = res_rec.author
isbn = res_rec.isbn
upc = res_rec.upc
other_no = res_rec.other_no
unit = dict(title=title,
author=author,
isbn=isbn,
upc=upc,
other_no=other_no,
bid=bid,
oid=oid,
wlo=wlo,
owner=owner,
cart=cart,
created=created,
system=system,
library=library,
status=status,
vendor=vendor,
lang=lang,
audn_name=audn_name,
mattype=mattype,
po=po,
locs=', '.join(locs))
results.append(unit)
session.expunge_all()
return results
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error during Basic search.'
f'Traceback: {tb}')
raise BabelError('Unable to retrieve records.')
def insert_fund(**kwargs):
"""
Adds a new fund with all related data
args:
system_id: int, datastore did of NYPL or BPL
fund_code: str, Sierra fund code
describ: str, fund brief description
libraries: list, 'branches', 'research' (NYPL only)
audns: list, list of 'a', 'j', 'y' values applicable for the fund
matTypes: list, material types applicable for the fund
"""
try:
for k, v in kwargs.items():
if not v:
if k == 'libraries':
kwargs[k] = ['']
elif k == 'audns':
kwargs[k] = []
elif k == 'branches':
kwargs[k] = []
elif k == 'matTypes':
kwargs[k] = []
else:
kwargs[k] = None
mlogger.info('New fund record parameters: {}'.format(kwargs))
with session_scope() as session:
# check if exists first
rec = retrieve_record(session,
Fund,
code=kwargs['code'],
system_id=kwargs['system_id'])
if rec:
msg = 'Fund record with code: {} already exists.'.format(
kwargs['code'])
mlogger.error(msg)
raise BabelError('Database Error', msg)
else:
branches, libraries, audns, matTypes = create_fund_joiner_objs(
session, **kwargs)
fund_rec = insert(session,
Fund,
code=kwargs['code'],
describ=kwargs['describ'],
system_id=kwargs['system_id'],
audns=audns,
branches=branches,
matTypes=matTypes,
libraries=libraries)
mlogger.info(f'Added new record {fund_rec}')
session.expunge_all()
return fund_rec
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error in add Fund.' f'Traceback: {tb}')
raise BabelError(exc)
def save_grid_data(**kwargs):
"""
used in GridView
"""
locs = []
for loc in kwargs['gridlocs']:
branch_id = get_id_from_index(loc['branch'], kwargs['branch_idx'])
shelf_id = get_id_from_index(loc['shelf'], kwargs['shelf_idx'])
if loc['gridloc_id']:
locs.append(
GridLocation(
did=loc['gridloc_id'],
distgrid_id=loc['distgrid_id'],
branch_id=branch_id,
shelfcode_id=shelf_id,
qty=loc['qty']))
else:
if loc['distgrid_id']:
locs.append(
GridLocation(
distgrid_id=loc['distgrid_id'],
branch_id=branch_id,
shelfcode_id=shelf_id,
qty=loc['qty']
))
else:
locs.append(
GridLocation(
branch_id=branch_id,
shelfcode_id=shelf_id,
qty=loc['qty']
))
with session_scope() as session:
try:
record = None
if kwargs['grid_did']:
update_record(
session,
DistGrid,
kwargs['grid_did'],
name=kwargs['name'],
distset_id=kwargs['distset_id'],
gridlocations=locs)
record = retrieve_record(
session,
DistGrid,
name=kwargs['name'],
distset_id=kwargs['distset_id'])
mlogger.debug(
f'Updated record {record}')
else:
record = insert(
session,
DistGrid,
name=kwargs['name'],
distset_id=kwargs['distset_id'],
gridlocations=locs)
mlogger.debug(
f'Added new record {record}')
session.expunge_all()
return record
except IntegrityError as e:
raise BabelError(e)
except InternalError as e:
raise BabelError(e)
def get_cart_details_as_dataframe(cart_id):
with session_scope() as session:
stmn = retrieve_cart_details_view_stmn(cart_id)
df = read_sql(stmn, session.bind)
return df
def save_new_dist_and_grid(system_id,
profile_id,
grids,
branch_idx,
shelf_idx,
dist=None,
grid=None):
"""
args:
system_id: int, did from System table
profile_id: int, did from User table
grids: dict, grids element of CartView tracker
dist: str, name of the new DistSet record
grid: str, name of the new DistGrid record
"""
try:
mlogger.debug('Creating new dist/grid from CartView. '
f'system: {system_id}, profile: {profile_id}, '
f'dist: {dist}, grid: {grid}')
if profile_id is not None:
with session_scope() as session:
dist_rec = insert_or_ignore(session,
DistSet,
system_id=system_id,
user_id=profile_id,
name=dist)
mlogger.debug(f'Dist_rec: {dist_rec}')
# check if given grid already exists
grid_rec = retrieve_record(session,
DistGrid,
name=grid,
distset_id=dist_rec.did)
mlogger.debug(f'Grid_rec: {grid_rec}')
# determine new gridLocations
locations = []
locs = grids['locs']
for l in locs:
if grid_rec:
locations.append(
GridLocation(distgrid_id=grid_rec.did,
branch_id=get_id_from_index(
l['branchCbx'].get(), branch_idx),
shelfcode_id=get_id_from_index(
l['shelfCbx'].get(), shelf_idx),
qty=int(l['qtyEnt'].get())))
else:
locations.append(
GridLocation(branch_id=get_id_from_index(
l['branchCbx'].get(), branch_idx),
shelfcode_id=get_id_from_index(
l['shelfCbx'].get(), shelf_idx),
qty=int(l['qtyEnt'].get())))
mlogger.debug(f'New locations: {locations}')
if grid_rec:
mlogger.debug('Updating existing grid_rec.')
update_record(session,
DistGrid,
grid_rec.did,
name=grid,
distset_id=dist_rec.did,
gridlocations=locations)
else:
mlogger.debug('Inserting new grid_rec.')
insert(session,
DistGrid,
name=grid,
distset_id=dist_rec.did,
gridlocations=locations)
except ValueError as e:
mlogger.error('User attempted to save new grid with incorrect values.'
f'Error: {e}')
raise BabelError('Your new grid includes invalid values.\n'
'Please make sure branch, shelf, and qty are valid.')
def create_cart_copy(cart_id, system, user, profile_idx, cart_name, status):
"""
Creates a copy of a cart
args:
cart_id: int, datastore cart did
system: str, NYPL or BPL
user: str, profile/user name
profile_idx: dict, dictionary of user_id (key) and names
cart_name: str, new cart name
status: tkinter StringVar
"""
valid = True
if not cart_id:
valid = False
status.set('Invalid cart id')
elif not system:
valid = False
status.set('Failed. Missing system parameter.')
elif not user:
valid = False
status.set('Failed. Missing profile prameter.')
elif not cart_name:
valid = False
status.set('Failed. Missing new cart name.')
try:
with session_scope() as session:
if cart_id and system and user and cart_name:
# verify name/user not used:
if system == 'BPL':
system_id = 1
elif system == 'NYPL':
system_id = 2
rec = retrieve_record(session,
Cart,
system_id=system_id,
user_id=get_id_from_index(
user, profile_idx),
name=cart_name)
if rec:
valid = False
status.set('Failed. A cart with the same name'
'already exists.\nPlease change the name.')
if valid:
# create copy of the original cart
old_orders = retrieve_records(session, Order, cart_id=cart_id)
new_orders = []
for order in old_orders:
resource = Resource(title=order.resource.title,
add_title=order.resource.add_title,
author=order.resource.author,
series=order.resource.series,
publisher=order.resource.publisher,
pub_place=order.resource.pub_place,
summary=order.resource.summary,
isbn=order.resource.isbn,
upc=order.resource.upc,
other_no=order.resource.other_no,
price_list=order.resource.price_list,
price_disc=order.resource.price_disc,
desc_url=order.resource.desc_url,
misc=order.resource.misc)
new_orders.append(
Order(lang_id=order.lang_id,
audn_id=order.audn_id,
vendor_id=order.vendor_id,
matType_id=order.matType_id,
poPerLine=order.poPerLine,
note=order.note,
comment=order.comment,
resource=resource))
insert(session,
Cart,
name=cart_name,
user_id=get_id_from_index(user, profile_idx),
system_id=system_id,
orders=new_orders)
status.set('Cart copied successfully.')
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error on cart copy.' f'Traceback: {tb}')
raise BabelError(exc)
def apply_globals_to_cart(cart_id, widgets):
try:
with session_scope() as session:
# order data
okwargs = get_ids_for_order_boxes_values(widgets)
# locations
dist_id, grid_name = widgets['globgrid']
grid_rec = retrieve_record(session,
DistGrid,
distset_id=dist_id,
name=grid_name)
mlogger.debug(f'Applying globally grid {grid_rec}')
# resource data
rkwargs = {}
discount = None
if 'discEnt' in widgets:
if widgets['discEnt'].get() != '':
discount = Decimal(widgets['discEnt'].get())
if 'priceEnt' in widgets:
if widgets['priceEnt'].get() != '':
list_price = Decimal(widgets['priceEnt'].get())
rkwargs['price_list'] = list_price
if discount:
rkwargs['price_disc'] = list_price - (
(list_price * discount) / Decimal(100))
else:
rkwargs['price_disc'] = list_price
mlogger.debug('Global update to prices: {}, discount: {}'.format(
rkwargs, discount))
ord_recs = retrieve_records(session, Order, cart_id=cart_id)
for rec in ord_recs:
if grid_rec:
olocs = []
for l in grid_rec.gridlocations:
olocs.append(
OrderLocation(order_id=rec.did,
branch_id=l.branch_id,
shelfcode_id=l.shelfcode_id,
qty=l.qty))
okwargs['locations'] = olocs
update_record(session, Order, rec.did, **okwargs)
if rkwargs:
update_record(session, Resource, rec.resource.did,
**rkwargs)
session.flush()
if discount is not None:
rkwargs['price_disc'] = rec.resource.price_list - (
(rec.resource.price_list * discount) / Decimal(100))
update_record(session, Resource, rec.resource.did,
**rkwargs)
rkwargs = {}
except Exception as exc:
_, _, exc_traceback = sys.exc_info()
tb = format_traceback(exc, exc_traceback)
mlogger.error('Unhandled error on applying globals to cart.'
f'Traceback: {tb}')
raise BabelError(exc)
