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 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 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_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 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 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 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 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_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_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())
