def apply_fund_to_cart(system_id, cart_id, fund_codes): try: with session_scope() as session: cart_rec = retrieve_record(session, Cart, did=cart_id) ord_recs = retrieve_records(session, Order, cart_id=cart_id) for code in fund_codes: fund_rec = retrieve_record(session, Fund, code=code, system_id=system_id) fund_audn, fund_mat, fund_branch, fund_lib = valid_fund_ids( fund_rec) for orec in ord_recs: audn_match = False mat_match = False library_match = False if orec.audn_id in fund_audn: audn_match = True if orec.matType_id in fund_mat: mat_match = True if cart_rec.library_id in fund_lib: library_match = True for oloc in orec.locations: if oloc.branch_id in fund_branch: mlogger.debug('OrdRec-Fund branch {} match'.format( oloc.branch_id)) if audn_match and library_match and mat_match: # update mlogger.debug( 'Complete match. Updating OrderLocation.') update_record(session, OrderLocation, oloc.did, fund_id=fund_rec.did) else: mlogger.debug( 'Incomplete match: lib={}, audn={}, ' 'mat={}.'.format(library_match, audn_match, mat_match)) except Exception as exc: _, _, exc_traceback = sys.exc_info() tb = format_traceback(exc, exc_traceback) mlogger.error('Unhandled error on applying funds to cart.' f'Traceback: {tb}') raise BabelError(exc)
def get_ids_for_order_boxes_values(values_dict): try: kwargs = {} with session_scope() as session: if values_dict['langCbx'].get() not in ('', 'keep current'): rec = retrieve_record(session, Lang, name=values_dict['langCbx'].get()) kwargs['lang_id'] = rec.did if values_dict['vendorCbx'].get() not in ('', 'keep current'): rec = retrieve_record(session, Vendor, name=values_dict['vendorCbx'].get()) kwargs['vendor_id'] = rec.did if values_dict['mattypeCbx'].get() not in ('', 'keep current'): rec = retrieve_record(session, MatType, name=values_dict['mattypeCbx'].get()) kwargs['matType_id'] = rec.did if values_dict['audnCbx'].get() not in ('', 'keep current'): rec = retrieve_record(session, Audn, name=values_dict['audnCbx'].get()) kwargs['audn_id'] = rec.did if 'poEnt' in values_dict: if values_dict['poEnt'].get().strip() != '': kwargs['poPerLine'] = values_dict['poEnt'].get().strip() if 'noteEnt' in values_dict: if values_dict['noteEnt'].get().strip() != '': kwargs['note'] = values_dict['noteEnt'].get().strip() if 'commentEnt' in values_dict: if 'commentEnt' in values_dict: if values_dict['commentEnt'].get().strip() != '': kwargs['comment'] = values_dict['commentEnt'].get( ).strip() return kwargs except Exception as exc: _, _, exc_traceback = sys.exc_info() tb = format_traceback(exc, exc_traceback) mlogger.error('Unhandled error on getting ids in cart.' f'Traceback: {tb}') raise BabelError(exc)
def get_cart_data_for_order_sheet(cart_id): try: data_set = [] with session_scope() as session: cart_rec = retrieve_record(session, Cart, did=cart_id) order_recs = retrieve_records(session, Order, cart_id=cart_id) for rec in order_recs: data = [] data.append(rec.resource.other_no) data.append(rec.resource.isbn) data.append(rec.resource.title) data.append(rec.resource.author) total_cost = 0 total_qty = 0 for loc in rec.locations: total_cost += loc.qty * rec.resource.price_disc total_qty += loc.qty data.append(f'{rec.resource.price_disc:.2f}') data.append(total_qty) data.append(total_cost) data.append(rec.oid) data.append(cart_rec.blanketPO) data_set.append(data) session.expunge_all() return data_set except Exception as exc: _, _, exc_traceback = sys.exc_info() tb = format_traceback(exc, exc_traceback) mlogger.error('Unhandled error cart data retrieval.' f'Traceback: {tb}') raise BabelError(exc)
def determine_carts_linked(session, cart_ids): """ Determines if all orders in relevant cart have corresponding Sierra order and bib number and updates cart linked status args: cart_ids: list of cart_ids that had their orders updated with oid """ mlogger.debug('Updating carts linked status.') # determine time period when wlos were assigned for cart_id in cart_ids: cart_rec = retrieve_record(session, Cart, did=cart_id) # check if all orders have oid if cart_rec: linked = True for o in cart_rec.orders: if o.oid is None: mlogger.debug(f'Order did={o.did} missing oid.') linked = False if linked: mlogger.debug( f'Cart {cart_rec.name} (did={cart_rec.did}) linked.') update_record(session, Cart, cart_rec.did, linked=True) else: mlogger.debug( f'Cart {cart_rec.name} (did={cart_rec.did}) not linked.') else: mlogger.debug( f'Cart with did={cart_id} not linked (missing record).')
def add_sierra_ids_to_orders(source_fh, system_id): mlogger.debug(f'Linking IDs initiated system_id-{system_id}.') sids = get_sierra_ids(source_fh, system_id) try: unique_carts = set() with session_scope() as session: for sid in sids: wlo, oid, bid = sid ord_rec = retrieve_record(session, Order, wlo=wlo) if ord_rec: # record affected cart_id unique_carts.add(ord_rec.cart_id) # update ord rec update_record(session, Order, ord_rec.did, oid=oid, bid=bid) mlogger.debug(f'Record updated: order_id={ord_rec.did}, ' f'wlo={wlo}, oid={oid}, bid={bid}') session.flush() # check which carts are linked determine_carts_linked(session, unique_carts) mlogger.debug('Linking completed.') except Exception as exc: _, _, exc_traceback = sys.exc_info() tb = format_traceback(exc, exc_traceback) mlogger.error('Unhandled error on linking IDs.' f'Traceback: {tb}') raise BabelError(exc)
def assign_blanketPO_to_cart(cart_id): try: with session_scope() as session: cart_rec = retrieve_record(session, Cart, did=cart_id) if cart_rec.blanketPO is None: res = retrieve_unique_vendor_codes_from_cart( session, cart_id, cart_rec.system_id) vendor_codes = [code[0] for code in res] blanketPO = create_blanketPO(vendor_codes) unique = True n = 0 while unique: try: update_record(session, Cart, cart_id, blanketPO=blanketPO) session.flush() unique = False except IntegrityError: session.rollback() n += 1 blanketPO = create_blanketPO(vendor_codes, n) except Exception as exc: _, _, exc_traceback = sys.exc_info() tb = format_traceback(exc, exc_traceback) mlogger.error('Unhandled error on assigning blanketPo to cart.' f'Traceback: {tb}') raise BabelError(exc)
def determine_needs_validation(cart_id): with session_scope() as session: cart_rec = retrieve_record(session, Cart, did=cart_id) # ignore status 'finlized' and 'archived' if cart_rec.status_id in (2, 4): return False else: return True
def get_orders_by_id(order_ids=[]): orders = [] with session_scope() as session: for did in order_ids: instance = retrieve_record(session, Order, did=did) if instance: orders.append(instance) session.expunge_all() return orders
def get_record(model, **kwargs): with session_scope() as session: instance = retrieve_record(session, model, **kwargs) try: session.expunge_all() # return instance except UnmappedInstanceError: pass finally: return instance
def has_library_assigned(cart_id): """ args: cart_id: int, datastore Cart.did returns: boolean: True is library assigned, False if not """ with session_scope() as session: rec = retrieve_record(session, Cart, did=cart_id) if rec.library_id: return True else: return False
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 create_fund_joiner_objs(session, **kwargs): """ Preps record objects for FundBranchJoiner, FundLibraryJoiner, FundAudnJoiner, and FundMatTypeJoiner args: branches: list of str libraries: list of str audns: list of str matTypes: list of str returns: tuple of branches, libraries, audns, matTypes record objects """ branches = [] for code in kwargs['branches']: rec = retrieve_record(session, Branch, code=code, system_id=kwargs['system_id']) branches.append(FundBranchJoiner(branch_id=rec.did)) libraries = [] for name in kwargs['libraries']: rec = retrieve_record(session, Library, name=name) libraries.append(FundLibraryJoiner(library_id=rec.did)) audns = [] for name in kwargs['audns']: rec = retrieve_record(session, Audn, name=name) audns.append(FundAudnJoiner(audn_id=rec.did)) matTypes = [] for name in kwargs['matTypes']: rec = retrieve_record(session, MatType, name=name) matTypes.append(FundMatTypeJoiner(matType_id=rec.did)) return (branches, libraries, audns, matTypes)
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 validate_fund(session, fund_id, system_id, library_id, audn_id, mattype_id, branch_id): valid = True params = [library_id, audn_id, mattype_id, branch_id] for p in params: if p is None: return True fund_rec = retrieve_record(session, Fund, did=fund_id) fund_audn, fund_mat, fund_branch, fund_lib = valid_fund_ids(fund_rec) if library_id not in fund_lib: valid = False if audn_id not in fund_audn: valid = False if mattype_id not in fund_mat: valid = False if branch_id not in fund_branch: valid = False return valid
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 get_branch_code(session, branch_id): rec = retrieve_record(session, Branch, did=branch_id) return rec.code
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 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 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 get_shelf_rec_id(session, shelf_code): rec = retrieve_record(session, ShelfCode, code=shelf_code) return rec.did
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 get_fund_rec_id(session, fund_code): rec = retrieve_record(session, Fund, code=fund_code) return rec.did
def get_branch_rec_id(session, branch_code): rec = retrieve_record(session, Branch, code=branch_code) return rec.did
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 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 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 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)