def test_trans(self): inv = InventoryMovement() inv.from_inv_id = 1 inv.to_inv_id = 2 inv.quantity = Decimal(1) inv.itemgroup_id = 1 inv.prod_id = 'AAAA' inv.timestamp = datetime(2016, 1, 1) inv.type = InvMovementType.SALE self.api.save(inv) trans = list(self.api.list_transactions( 1, inv.timestamp.date(), inv.timestamp.date())) self.assertEquals(1, len(trans)) self.assertDictEqual( json.loads(json_dumps(inv)), json.loads(json_dumps(trans[0])) ) current_quantities = self.api.get_current_quantity(1) self.api.take_snapshot_to_date(inv.itemgroup_id, inv.timestamp.date()) self.assertDictEqual( current_quantities, self.api.get_current_quantity(1)) inv.timestamp = datetime(2016, 1, 2) self.api.save(inv) self.assertDictEqual({1: Decimal(-2), 2: Decimal(2)}, self.api.get_current_quantity(1))
def test_create_invoice(self): sale = Sale() sale.timestamp = datetime.datetime(2015, 1, 1, 0, 0, 0) sale.client_id = 'NA' sale.seller_codename = 'boya' sale.seller_ruc = '123' sale.seller_inv_uid = 1 sale.invoice_code = '123' sale.pretax_amount_usd = Decimal('123') sale.tax_usd = Decimal('123') sale.status = Status.NEW sale.user_id = 'yu' sale.payment_format = PaymentFormat.CASH result = self.test_app.post('/import/client_sale', params=json_dumps(sale)) self.assertEquals(200, result.status_code) sales = list(self.dbapi.search(Sale)) self.assertEquals(1, len(sales)) self.assertEquals(sale.timestamp, sales[0].timestamp) self.assertEquals(Status.NEW, sales[0].status) result = self.test_app.delete('/import/client_sale', params=json_dumps(sale)) self.assertEquals(200, result.status_code) self.assertEquals(1, result.json['deleted']) sales = list(self.dbapi.search(Sale)) self.assertEquals(1, len(sales)) self.assertEquals(sale.timestamp, sales[0].timestamp) self.assertEquals(Status.DELETED, sales[0].status)
def main(): dbapi = DBApiGeneric(sessionmanager) transactionapi = InventoryApi(FileService(TRANSACTION_PATH)) with dbapi.session: for ig in dbapi.search(ProdItemGroup): trans = transactionapi.list_transactions(ig.uid, START, END) print json_dumps([ig, list(trans)])
def delete_invoice(uid): inv = invapi.get_doc(uid) old_status = inv.meta.status invapi.delete(inv) if workerqueue is not None: obj = doc_to_workobject(inv, objtype=WorkObject.INV, action=WorkObject.DELETE) workerqueue(work=json_dumps(obj)) if old_status == Status.COMITTED: obj = doc_to_workobject(inv, objtype=WorkObject.INV_TRANS, action=WorkObject.DELETE) workerqueue(work=json_dumps(obj)) return {'status': inv.meta.status}
def postear_invoice(uid): inv = invapi.get_doc(uid) invapi.commit(inv) if workerqueue is not None: obj = doc_to_workobject(inv, objtype=WorkObject.INV_TRANS, action=WorkObject.CREATE) workerqueue(work=json_dumps(obj)) return {'status': inv.meta.status}
def get_item_full(item_id): itemgroup = dbapi.get(item_id, ProdItemGroup) items = dbapi.search(ProdItem, itemgroupid=itemgroup.uid) prices_by_item = {} for x in items: prices_by_item[x.prod_id] = dbapi.search(PriceList, prod_id=x.prod_id) return json_dumps(make_full_items(itemgroup, items, prices_by_item))
def ver_ventas_no_efectivos(): start, end = parse_start_end_date(request.query) end += datetime.timedelta(hours=23) sales = dbapi.db_session.query(NNota).filter( NNota.timestamp >= start).filter(NNota.timestamp <= end).filter( NNota.payment_format != PaymentFormat.CASH) sales = map(InvMetadata.from_db_instance, sales) payments = list(paymentapi.list_payments(start, end)) result = {} for x in sales: if x.client.codigo not in result: result[x.client.codigo] = {} result[x.client.codigo]['sales'] = [] result[x.client.codigo]['payments'] = [] result[x.client.codigo]['sales'].append(x) unused_payments = [] for x in payments: if x.client_id in result: result[x.client_id]['payments'].append(x) else: unused_payments.append(x) result['unused_payments'] = unused_payments return json_dumps({ 'unused_payments': unused_payments, 'sales': result.items() })
def create_invoice(): json_content = request.body.read() if not json_content: return '' content = json_loads(json_content) inv, options = parse_invoice_and_options(content) fix_inv_by_options(dbapi, inv, options) if inv.meta.timestamp is None: inv.meta.timestamp = datetime.datetime.now() # at this point, inv should no longer change if options.crear_cliente: # create client if not exist client = inv.meta.client if not dbapi.get(Client, client.codigo): dbapi.save(client) inv = invapi.save(inv) # increment the next invoice's number if options.incrementar_codigo: user = User(username=inv.meta.user) dbapi.update(user, {'last_factura': int(inv.meta.codigo) + 1}) dbapi.db_session.commit() if workerqueue is not None: obj = doc_to_workobject(inv, objtype=WorkObject.INV, action=WorkObject.CREATE) workerqueue(work=json_dumps(obj)) return {'codigo': inv.meta.uid}
def put(self, pkey): content_dict = json.loads(bottle.request.body.read()) with self.dbapi.session: obj = self.clazz() setattr(obj, self.clazz.pkey.name, pkey) count = self.dbapi.update(obj, content_dict=content_dict) return json_dumps({'modified': count})
def save_inv(content, ddate, directory, prefix): fname = '{}-{}.txt'.format(prefix, ddate.isoformat()) fullpath = os.path.join(directory, fname) with open(fullpath, 'w') as f: for x in content: f.write(json_dumps(x.serialize())) f.write('\n')
def do_work(): context = zmq.Context() receiver = context.socket(zmq.SUB) receiver.connect('tcp://localhost:{}'.format(ZEROMQ_PORT)) receiver.setsockopt(zmq.SUBSCRIBE, '') externalapi = ExternalApi('http://45.55.88.99:99/api/', 'nota', 'yu', 'yu') print 'worker ready' while True: s = receiver.recv_pyobj() if s.command == Command.SAVE: with open(s.path) as f: data = json_loads(f.read()) options = InvoiceOptions() options.incrementar_codigo = False options.revisar_producto = False options.crear_cliente = True data['options'] = options del data.timestamp serialized = json_dumps(data.serialize()) codigo = externalapi.save(serialized).json()['codigo'] with sessionmanager as session: session.query(NPedidoTemporal).filter_by( id=s.uid).update({ NPedidoTemporal.status: 'uploaded', NPedidoTemporal.external_id: codigo}) session.flush() elif s.command == Command.COMMIT: t = Invoice(InvMetadata, []) with sessionmanager as session: temp = session.query(NPedidoTemporal).filter_by(id=s.uid).first() if temp.external_id is not None: t.meta.uid = temp.external_id externalapi.commit(t)
def post(self): content_dict = json.loads(bottle.request.body.read()) with self.dbapi.session: obj = self.clazz() obj.merge_from(content_dict) pkey = self.dbapi.create(obj) return json_dumps({'key': pkey})
def create(self, invmo): datestr = invmo.meta.timestamp.date().isoformat() name = '{}/{}-{}-{}'.format(datestr, invmo.meta.inventory_codename, invmo.meta.trans_type, invmo.meta.inventory_docid) path = self.fileservice.make_fullpath(name) invmo.meta.items_location = path self.dbapi.create(invmo.meta) self.fileservice.put_file(name, json_dumps(invmo.serialize())) # execute transactions def make_inv_movement(itemgroupcant): inv = InventoryMovement() inv.from_inv_id = invmo.meta.origin inv.to_inv_id = invmo.meta.dest inv.quantity = itemgroupcant.cant inv.prod_id = itemgroupcant.itemgroup.prod_id inv.itemgroup_id = itemgroupcant.itemgroup.uid inv.timestamp = invmo.meta.timestamp inv.type = invmo.meta.trans_type inv.reference_id = invmo.meta.uid return inv transactions = map(make_inv_movement, invmo.items) self.inventoryapi.bulk_save(transactions) return invmo
def delete_ingreso(ingreso_id): trans = transapi.get_doc(ingreso_id) old_status = trans.meta.status transapi.delete(trans) if forward_transaction is not None and old_status == Status.COMITTED: obj = doc_to_workobject(trans, action=WorkObject.DELETE, objtype=WorkObject.TRANS) forward_transaction(work=json_dumps(obj)) return {'status': trans.meta.status}
def purchase_fitered(uid): purchase = get_purchase_full(dbapi, uid) map(normal_filter, purchase.items) total = sum(i.item.price_rmb * i.item.quantity for i in purchase.items) purchase.meta.total_rmb = total res = purchase.serialize() res['units'] = {x.uid: x for x in dbapi.search(Unit)} return json_dumps(res)
def get_universal_prod_with_declared(): all_prod = dbapi.search(UniversalProd) all_declared = dbapi.search(DeclaredGood) return json_dumps({ 'prod': all_prod, 'declared': all_declared })
def log_price_list_change(self, clazz, action, pkey, content): content = { 'old': pkey, 'new': content } change_log = _make_log(ActionType.MODIFY_PROD, content) fname = make_date_name(change_log.meta.date, change_log.meta.batch) self.fileservice.append_file(fname, json_dumps(change_log))
def get_account_transactions_mult_days(): start, end = parse_start_end_date(request.query) # FIXME: remove this hack if override_transaction_getter: result = override_transaction_getter(start, end) else: result = get_transactions(dbapi, paymentapi, invapi, imgserver, start, end) return json_dumps(result)
def get_prod_quantity(uid): current_record = inventoryapi.get_current_quantity(uid) bodegas = dbapi.search(Bodega) return json_dumps({ 'inv': bodegas, 'itemgroup_id': uid, 'quantity': current_record })
def eliminar_factura(): almacen_id = int(request.forms.get('almacen_id')) codigo = request.forms.get('codigo').strip() ref = request.forms.get('motivo') if not ref: abort(400, 'escriba el motivo') user = get_user(request) db_instance = get_inv_db_instance(dbapi.db_session, almacen_id, codigo) if db_instance is None: alm = dbapi.get(almacen_id, Store) db_instance = dbapi.db_session.query(NNota).filter_by( almacen_ruc=alm.ruc, codigo=codigo).first() if db_instance is None: return eliminar_factura_form('Factura no existe') if db_instance.status == Status.DELETED: # already deleted redirect('/app/nota/{}'.format(db_instance.id)) old_status = db_instance.status comment = Comment( user_id=user['username'], timestamp=datetime.datetime.now(), comment=ref, objtype='notas', objid=str(db_instance.id), ) dbapi.create(comment) doc = invapi.get_doc_from_file(db_instance.items_location) doc.meta.status = db_instance.status try: invapi.delete(doc) except ValueError: abort(400) if workqueue is not None: obj = doc_to_workobject(doc, objtype=WorkObject.INV, action=WorkObject.DELETE) workqueue(work=json_dumps(obj)) if old_status == Status.COMITTED: obj = doc_to_workobject(doc, objtype=WorkObject.INV_TRANS, action=WorkObject.DELETE) workqueue(work=json_dumps(obj)) redirect('/app/nota/{}'.format(db_instance.id))
def get_price_by_id(almacen_id, prod_id): if int(almacen_id) == 3: almacen_id = 1 prod = dbapi.getone(PriceList, prod_id=prod_id, almacen_id=almacen_id) if prod is None: abort(404) use_thousandth = request.query.get('use_thousandth', '1') if int(use_thousandth): mult_thousand(prod) return json_dumps(prod.serialize())
def save(self, log): if not os.path.exists(self.root): os.makedirs(self.root) filename = os.path.join( self.root, log.timestamp.date().isoformat() + '.actionlog') with open(filename, 'a') as f: with LockClass(f): f.write(json_dumps(log.serialize())) f.write('\n') f.flush()
def postear_ingreso(ingreso_id): trans = transapi.get_doc(ingreso_id) transapi.commit(trans) if forward_transaction is not None: if trans.meta.trans_type == TransType.EXTERNAL: trans.meta.dest = 4 # policentro trans.meta.trans_type = TransType.TRANSFER obj = doc_to_workobject(trans, action=WorkObject.CREATE, objtype=WorkObject.TRANS) forward_transaction(work=json_dumps(obj)) return {'status': trans.meta.status}
def get_daily_stats_fine(day): day = datetime.datetime.strptime(day, '%Y-%m-%d').date() report = invmanager.get(day) if report is None: return None return json_dumps({ 'total': report.total_value, 'count': report.total_count, 'by_client': report.by_client, 'by_type': report.by_type, })
def write_inv_json(inv): options = InvoiceOptions() options.no_alm_id = True options.usar_decimal = True inv_data = inv.serialize() inv_data['options'] = options inv_str = json_dumps(inv_data) fname = os.path.join(JSON_DIR, inv.meta.codigo + '.json') with open(fname, 'w') as f: f.write(inv_str) print >> sys.stderr, ('escrito en el disco')
def write_inv_json(inv): options = InvoiceOptions() options.no_alm_id = True options.usar_decimal = True inv_data = inv.serialize() inv_data['options'] = options inv_str = json_dumps(inv_data) fname = os.path.join(JSON_DIR, inv.meta.codigo + '.json') with open(fname, 'w') as f: f.write(inv_str) print >>sys.stderr, ('escrito en el disco')
def test_create_item(self): content = { "prod": {"prod_id": "ASB", "name": "nombre", "desc": "", "base_unit": "unidad"}, "items": [ { "unit": "unidad", "multiplier": 1, "prices": { "1": {"display_name": "nombre display", "price1": 100, "price2": 100, "cant": 0}, "2": {"display_name": "nombre display", "price1": 100, "price2": 100, "cant": 0}, }, }, { "unit": "paquete", "multiplier": 100, "prices": { "1": {"display_name": "nombre display", "price1": 100, "price2": 100, "cant": 0}, "2": {"display_name": "nombre display", "price1": 100, "price2": 100, "cant": 0}, }, }, ], "new_unit": [], } with self.sessionmanager: result, _ = validate_full_item(content, self.dbapi) self.assertTrue(result) create_full_item_from_dict(self.dbapi, content) self.sessionmanager.session.commit() print json_dumps(self.dbapi.search(PriceList)) self.assertEquals(4, len(self.dbapi.search(PriceList))) self.assertEquals(1, len(self.dbapi.search(ProdItemGroup))) self.assertEquals(2, len(self.dbapi.search(ProdItem))) all_items = self.dbapi.search(ProdItem) ids = set(x.itemgroupid for x in all_items) self.assertEquals(1, len(ids)) result, _ = validate_full_item(content, self.dbapi) self.assertFalse(result)
def searchprice(almacen_id): alm = dbapi.get(almacen_id, Store) prefijo = get_property_or_fail(request.query, 'prefijo') result = list(dbapi.search(PriceList, **{ 'nombre-prefix': prefijo, 'almacen_id': alm.bodega_id})) # FIXME remove this hack when client side is ready use_thousandth = request.query.get('use_thousandth', 1) if int(use_thousandth): map(mult_thousand, result) return json_dumps(result)
def get_trans_by_date(): start, end = parse_start_end_date( request.query, start_name='start_date', end_name='end_date') status = request.query.get('status') other_filters = {} for x in ('origin', 'dest'): t = request.query.get(x) if t: other_filters[x] = t result = transapi.search_metadata_by_date_range( start, end, status, other_filters) return json_dumps(list(result))
def fix_inv(uid, old_path): inv = invapi.get_doc_from_file(old_path) alm_id = 1 if inv.meta.almacen_id == 3 else inv.meta.almacen_id for i in inv.items: if i.prod.almacen_id is None: new_prod = dbapi.getone(prod_id=i.prod.prod_id, almacen_id=alm_id) i.prod.almacen_id = new_prod.almacen_id i.prod.upi = new_prod.upi i.prod.multiplicador = new_prod.multiplicador invapi.filemanager.put_file(old_path, json_dumps(inv)) print 'invoice ', uid, 'saved ', old_path
def get_account_deposit_with_img(): today = datetime.datetime.today() thisyear = today - datetime.timedelta(days=365) turned_in = sorted(get_turned_in_cash(dbapi, thisyear, today, imgserver), key=lambda x: x.date, reverse=True) result = defaultdict(list) for x in turned_in: if getattr(x, 'img', None): if len(result['with_deposit']) < 10: result['with_deposit'].append(x) else: result['without_deposit'].append(x) return json_dumps(result)
def get_trans_by_date(): start, end = parse_start_end_date(request.query, start_name='start_date', end_name='end_date') status = request.query.get('status') other_filters = {} for x in ('origin', 'dest'): t = request.query.get(x) if t: other_filters[x] = t result = transapi.search_metadata_by_date_range( start, end, status, other_filters) return json_dumps(list(result))
def get_price_list(): fname = os.path.join(DIR, 'prodlist.json') if os.path.exists(fname): with open(fname) as f: all_items = json.loads(f.read()) all_items = map(PriceList.deserialize, all_items) print 'loaded from disk' else: with sessionmanager: all_items = list(getallitems()) with open(fname, 'w') as f: f.write(json_dumps(all_items)) f.flush() print 'price list saved to disk' return all_items
def get_checks(): save_date = request.query.get('save_date') save_date_end = request.query.get('save_date_end') deposit_date = request.query.get('deposit_date') deposit_date_end = request.query.get('deposit_date_end') if save_date: save_date = (save_date, save_date_end) if deposit_date: deposit_date = (deposit_date, deposit_date_end) checks = paymentapi.list_checks(save_date, deposit_date) for x in checks: x.imgdeposit = imgserver.get_url_path(x.imgdeposit) x.imgcheck = imgserver.get_url_path(x.imgcheck) x.value = Decimal(x.value) / 100 return json_dumps({'result': checks})
def get_sales(): """ start=<start>&end=<end> """ start_date, end_date = parse_start_end_date(request.query) if not end_date: end_date = datetime.date.today() end_date = end_date + datetime.timedelta(hours=23) query = dbapi.db_session.query(NNota.almacen_id, func.sum( NNota.total)).filter(NNota.timestamp >= start_date).filter( NNota.timestamp <= end_date).filter( NNota.status != Status.DELETED).group_by(NNota.almacen_id) result = [] for aid, total in query: result.append((aid, Decimal(total) / 100)) return json_dumps({'result': result})
def get_barcoded_item(bcode): bcode = str(int(bcode)) pos = 0 for i, x in enumerate(bcode): if x == '0': pos = i break cant = int(bcode[:pos]) pid = int(bcode[pos:-1]) price = dbapi.get(pid, PriceList) if price is None: price = dbapi.get(bcode[pos:], PriceList) if price is None: abort(404) result = {} mult_thousand(price) result['prod'] = price result['cant'] = cant return json_dumps(result)
def save(self, transaction): session = self.db_session.session upi = getattr(transaction, 'upi', None) filter_by = ({ 'bodega_id': transaction.bodega_id, 'prod_id': transaction.prod_id } if upi is None else { 'id': upi }) cont = session.query(NContenido).filter_by(**filter_by).first() if cont is None: # product does not exist in bodega cont = NContenido(prod_id=transaction.prod_id, bodega_id=transaction.bodega_id, precio=0, precio2=0, cant=transaction.delta) try: session.add(cont) session.flush() except IntegrityError: session.rollback() prod = NProducto(codigo=transaction.prod_id, nombre=transaction.name) prod.contenidos.append(cont) session.add(prod) session.flush() else: cont.cant += transaction.delta session.flush() transaction.upi = cont.id transaction.prod_id = cont.prod_id transaction.bodega_id = cont.bodega_id prod = transaction.prod_id fecha = transaction.fecha.date().isoformat() data = json_dumps(transaction.serialize()) self.fileservice.append_file(os.path.join(prod, fecha), data)
def do_work(): context = zmq.Context() receiver = context.socket(zmq.SUB) receiver.connect('tcp://localhost:{}'.format(ZEROMQ_PORT)) receiver.setsockopt(zmq.SUBSCRIBE, '') externalapi = ExternalApi('http://45.55.88.99:99/api/', 'nota', 'yu', 'yu') print 'worker ready' while True: s = receiver.recv_pyobj() if s.command == Command.SAVE: with open(s.path) as f: data = json_loads(f.read()) options = InvoiceOptions() options.incrementar_codigo = False options.revisar_producto = False options.crear_cliente = True data['options'] = options del data.timestamp serialized = json_dumps(data.serialize()) codigo = externalapi.save(serialized).json()['codigo'] with sessionmanager as session: session.query(NPedidoTemporal).filter_by(id=s.uid).update({ NPedidoTemporal.status: 'uploaded', NPedidoTemporal.external_id: codigo }) session.flush() elif s.command == Command.COMMIT: t = Invoice(InvMetadata, []) with sessionmanager as session: temp = session.query(NPedidoTemporal).filter_by( id=s.uid).first() if temp.external_id is not None: t.meta.uid = temp.external_id externalapi.commit(t)
def save(self, doc): del doc.meta.timestamp response = self.save_data(json_dumps(doc.serialize())) codigo = response.json()['codigo'] doc.meta.ref = 'transferencia externa: {}'.format(codigo) return doc
def get_pago_with_id(uid): elm = dbapi.db_session.query(NPayment).filter_by(uid=uid).first() if elm is None: response.status = 404 return '' return json_dumps(Payment().merge_from(elm).serialize())
def get_all_payments(): start, end = parse_start_end_date(request.query) result = list(paymentapi.list_payments(start, end)) return json_dumps({'result': result})
def get_all_gastos(): day = parse_iso(request.query.get('date')) result = dbapi.search(Spent, inputdate=day) return json_dumps(result)
def get_account_transactions_mult_days(): start, end = parse_start_end_date(request.query) result = get_transactions(dbapi, paymentapi, invapi, imgserver, start, end) return json_dumps(result)
def main(): x = sys.argv[1] print json_dumps(transapi.get_doc(x))
def delete(self, pkey): with self.dbapi.session: obj = self.clazz() setattr(obj, self.clazz.pkey.name, pkey) count = self.dbapi.delete(obj) return json_dumps({'deleted': count})
def get(self, pkey): with self.dbapi.session: return json_dumps(self.dbapi.get(pkey, self.clazz).serialize())
def get_invoice(inv_id): doc = invapi.get_doc(inv_id) if doc is None: abort(404, 'Nota no encontrado') return return json_dumps(doc.serialize())
def test_create_item(self): content = { "prod": { 'prod_id': 'ASB', 'name': 'nombre', 'desc': '', 'base_unit': 'unidad', }, "items": [ { 'unit': 'unidad', 'multiplier': 1, 'prices': { "1": { 'display_name': 'nombre display', 'price1': 100, 'price2': 100, 'cant': 0 }, "2": { 'display_name': 'nombre display', 'price1': 100, 'price2': 100, 'cant': 0 } }, }, { 'unit': 'paquete', 'multiplier': 100, 'prices': { "1": { 'display_name': 'nombre display', 'price1': 100, 'price2': 100, 'cant': 0 }, "2": { 'display_name': 'nombre display', 'price1': 100, 'price2': 100, 'cant': 0 } } }, ], "new_unit": [] } with self.sessionmanager: result, _ = validate_full_item(content, self.dbapi) self.assertTrue(result) create_full_item_from_dict(self.dbapi, content) self.sessionmanager.session.commit() print json_dumps(self.dbapi.search(PriceList)) self.assertEquals(4, len(self.dbapi.search(PriceList))) self.assertEquals(1, len(self.dbapi.search(ProdItemGroup))) self.assertEquals(2, len(self.dbapi.search(ProdItem))) self.assertEquals(4, len(self.dbapi.search(Inventory))) self.assertEquals(2, len(self.dbapi.search(PriceList, upi=1))) all_items = self.dbapi.search(ProdItem) ids = set(x.itemgroupid for x in all_items) self.assertEquals(1, len(ids)) result, _ = validate_full_item(content, self.dbapi) self.assertFalse(result)
def search(self): with self.dbapi.session: args = bottle.request.query content = self.dbapi.search(self.clazz, **args) return json_dumps({'result': [c.serialize() for c in content]})
def get_ingreso(ingreso_id): ing = transapi.get_doc(ingreso_id) if ing is None: abort(404, 'Ingreso No encontrada') return return json_dumps(ing.serialize())