def create(stock_id):
adder = current_user._get_current_object()
schema = schemas.InventorySchema()
stock = models.Stock.objects.with_id(stock_id)
try:
inventory_data = schema.load(request.get_json())
except Exception as e:
print(e)
response_dict = request.get_json()
response_dict.update(e.messages)
response = render_json(response_dict)
response.status_code = 400
abort(response)
data = inventory_data.data
print('data:', data)
data['adder'] = adder
data['stock'] = stock
item = None
if data['item'] and len(data['item']) > 0:
try:
item = models.Item.objects.with_id(data['item'])
except:
pass
elif len(data['item_upc']) > 0:
item = models.Item.objects(upc=data['item_upc']).first()
if not item:
item = items.add_item(data['item_upc'])
if not item:
return abort(items.get_item_not_found_error())
data['item'] = item
data.pop('item_upc')
inventory = models.Inventory(status='active',
**data)
nutrition = models.Nutrition.objects(item=item).first()
if nutrition:
inventory.serving_size_unit = nutrition.facts.serving_size_unit
inventory.serving_size_quantity = nutrition.facts.serving_size_quantity
inventory.total_serving_size = data['quantity'] * \
nutrition.facts.servings_per_container
inventory.available_serving_size = inventory.total_serving_size
inventory.save()
return render_json(schema.dump(inventory).data)
def get(item_id):
schema = schemas.ItemSchema()
item = models.Item.objects(id=item_id).first()
if not item:
return abort(get_item_error_not_found())
return render_json(schema.dump(item).data)
def list(stock_id):
stock = models.Stock.objects.with_id(stock_id)
consumptions = models.Consumption.objects(
stock=stock).order_by('+consumed_data')
schema = schemas.ConsumptionSchema(many=True)
return render_json(schema.dump(consumptions).data)
def get(stock_id):
schema = schemas.StockSchema()
owner = current_user
stock = models.Stock.objects(id=stock_id, owner__id=owner.id).first()
if not stock:
return abort(get_stock_error_not_found())
return render_json(schema.dump(stock).data)
def list_items(stock_id):
schema = schemas.ItemSchema(many=True)
stock = models.Stock.objects.with_id(stock_id)
inventories = models.Inventory.objects(stock=stock, status='active')
items = set([inventory.item for inventory in inventories])
return render_json(schema.dump(items).data)
def delete(item_id):
owner = current_user._get_current_object()
item = models.Item.objects(id=item_id, owner=owner).first()
if not item:
return abort(get_item_error_not_found())
item.delete()
return render_json()
def delete(stock_id):
owner = current_user._get_current_object()
stock = models.Stock.objects(id=stock_id, owner=owner).first()
if not stock:
return abort(get_stock_error_not_found())
stock.delete()
return render_json()
def list(stock_id):
schema = schemas.InventorySchema(many=True)
stock = models.Stock.objects.with_id(stock_id)
inventories = models.Inventory.objects(
stock=stock,
status='active',
available_serving_size__gt=0)
return render_json(schema.dump(inventories).data)
def all():
json_schema = JSONAPISchema()
schema_list = schemas.__all__
all_schemas = {}
for schema in schema_list:
all_schemas[schema.Meta.type_] = json_schema.dump(schema()).data
return render_json(all_schemas)
def create():
schema = schemas.StockSchema()
try:
stock_data = schema.load(request.get_json())
except Exception as e:
print(e)
response_dict = request.get_json()
response_dict.update(e.messages)
response = render_json(response_dict)
response.status_code = 400
abort(response)
data = stock_data.data
data['building'] = models.Building(id=data['building'])
data['owner'] = models.User(id=current_user.id)
stock = models.Stock(status='active', **data)
stock.save()
return render_json(schema.dump(stock).data)
def get_upc(upc):
schema = schemas.ItemSchema()
item = models.Item.objects(upc=upc).first()
if not item:
item = add_item(upc)
if not item:
return abort(get_item_error_not_found())
return render_json(schema.dump(item).data)
def get_stock_error_not_found():
response_dict = request.get_json()
errors = [{
'status': '404',
'title': 'Stock not found',
'detail': 'Stock not found'
}]
response_dict.update(errors=errors)
response = render_json(response_dict)
response.status_code = 404
return response
def list():
schema = schemas.StockSchema(many=True)
owner_id = current_user.id
building_id = request.args.get('building-id', None)
stocks = []
if building_id:
stocks = models.Stock.objects(owner__id=owner_id,
building__id=building_id)
else:
stocks = models.Stock.objects(owner__id=owner_id)
return render_json(schema.dump(stocks).data)
def get_item_error_not_found():
response_dict = request.get_json()
errors = [{
'status': '404',
'title': 'Item not found',
'detail': 'Item not found'
}]
if not response_dict:
response_dict = {}
response_dict.update(errors=errors)
response = render_json(response_dict)
response.status_code = 404
return response
def user_loader_callback(identity):
try:
user = models.User.objects.with_id(identity)
except Exception as e:
errors = [
{
'status': '403',
'title': 'The user might not have the necessary permissions for a resource',
'detail': 'The user might not have the necessary permissions for a resource'
}
]
response_dict = dict(errors=errors)
response = render_json(response_dict)
response.status_code = 403
abort(response)
# print('user jwt', user)
return user
def consume(stock_id):
stock = models.Stock.objects.with_id(stock_id)
schema = schemas.InventoryConsumingItemSchema()
consumer = current_user._get_current_object()
try:
consuming_data = schema.load(request.get_json()).data
except Exception as e:
print(e)
response_dict = request.get_json()
response_dict.update(e.messages)
response = render_json(response_dict)
response.status_code = 400
abort(response)
item = models.Item.objects.with_id(consuming_data['item'])
inventories = models.Inventory.objects(
stock=stock,
item=item,
status='active',
available_serving_size__gt=0).order_by(
'-expired_date'
)
consuming_size = consuming_data['consuming_size']
for inventory in inventories:
consumption = models.Consumption(
item=item,
stock=stock,
consumer=consumer,
inventory=inventory,
consuming_unit=inventory.serving_size_unit
)
print('consumer:', consumer)
if consuming_size <= inventory.available_serving_size:
print('consume <=', inventory.id, consuming_size)
inventory.available_serving_size -= consuming_size
consumption.consuming_size = consuming_size
consuming_size -= consuming_size
if inventory.available_serving_size == 0:
inventory.status = 'out of inventory'
else:
print('consume > ', inventory.id, inventory.available_serving_size)
consumption.consuming_size = inventory.available_serving_size
consuming_size -= inventory.available_serving_size
inventory.available_serving_size = 0
consumption.status = 'active'
consumption.save()
inventory.consumptions.append(consumption)
inventory.save()
if consuming_size == 0:
break
consuming_data['item'] = item
consuming_data['id'] = None
return render_json(schema.dump(consuming_data).data)
def list():
schema = schemas.ItemSchema(many=True)
items = models.Item.objects(status='active')
return render_json(schema.dump(items).data)
