def test_unserialization():
item = ItemModel('item_name', 10, True, '12345')
serialized = item.serialize()
assert item == ItemModel.unserialize(serialized)
def unlock(self, filter, user, etag):
item_model = ItemModel(self.data_layer)
filter[LOCK_USER] = user
# filter[ETAG] = etag
item = item_model.find_one(filter)
if item:
updates = {LOCK_USER: None, 'lock_time': None}
item_model.update(filter, updates)
def test_store_relationship(self):
with self.app_context():
store = StoreModel('test_store')
item = ItemModel('test', 19.99, 1)
store.save_to_db()
item.save_to_db()
self.assertEqual(item.store.name, 'test_store')
def test_store_relationship(self):
with self.app_context():
store = StoreModel('test')
item = ItemModel('test_item', 19.99, 1)
store.save_to_db()
item.save_to_db()
self.assertEqual(store.items.count(), 1)
self.assertEqual(store.items.first().name, 'test_item')
def test_serialization():
item = ItemModel('item_name', 10, True, '12345')
expected_serialization = {'name': 'item_name',
'quantity': 10,
'usable': True,
'user_id': '12345'}
assert item.serialize() == expected_serialization
def test_item_json(self):
item = ItemModel('test', 19.99, 1)
expected = {
'name': 'test',
'price': 19.99
}
self.assertEqual(item.json(), expected,
f'The JSON export of the item is incorrect. '
f'Received {item.json()}, expected {expected}')
def test_put_update_item(self):
with self.app() as client:
with self.app_context():
StoreModel('test').save_to_db()
ItemModel('test', 19, 1).save_to_db()
self.assertEqual(ItemModel.find_by_name('test').price, 19)
response = client.put('/item/test', data={'name': 'test', 'price': 17, 'store_id': 1})
self.assertEqual(response.status_code, 200)
self.assertDictEqual({'name': 'test', 'price': 17}, json.loads(response.data))
self.assertEqual(ItemModel.find_by_name('test').price, 17)
def lock(self, filter, user, etag):
item_model = ItemModel(self.data_layer)
item = item_model.find_one(filter)
if item and self._can_lock(item, user):
# filter[ETAG] = etag
updates = {LOCK_USER: user, 'lock_time': utcnow()}
item_model.update(filter, updates)
item[LOCK_USER] = user
else:
raise SuperdeskError('Item locked by another user')
return item
def test_item_json(self):
item = ItemModel('test', 19.99)
expected = {
'name': 'test',
'price': 19.99
}
self.assertEqual(
item.json(),
expected,
"The JSON export of the item is incorrect. Received {}, expected {}.".format(item.json(), expected))
def put(self, name):
data = Item.parser.parse_args()
item = ItemModel.find_by_name(name)
if item:
item.price = data['price']
else:
item = ItemModel(name, **data)
item.save_to_db()
return item.json()
def post(self, name):
if ItemModel.find_by_name(name):
return {'message': "An item with name '{}' already exists.".format(name)}
data = Item.parser.parse_args()
item = ItemModel(name, data['price'], data['store_id'])
try:
item.save_to_db()
except:
return {"message": "An error occurred inserting the item."}
return item.json()
def post(self, name):
if ItemModel.find_by_name(name):
return {'message': "An item with name '{}' already exists.".format(name)}, 400
data = Item.parser.parse_args()
item = ItemModel(name, **data)
try:
item.save_to_db()
except:
return {"message": "An error occurred inserting the item."}, 500
return item.json(), 201
def test_store_json_with_item(self):
with self.app_context():
store = StoreModel('test')
item = ItemModel('test_item', 19.99, 1)
store.save_to_db()
item.save_to_db()
expected = {
'name': 'test',
'items': [{'name': 'test_item', 'price': 19.99}]
}
self.assertDictEqual(store.json(), expected)
def test_put_update_item(self):
with self.app() as c:
with self.app_context():
StoreModel('test').save_to_db()
c.put('/item/test', data={'price': 17.99, 'store_id': 1})
r = c.put('/item/test', data={'price': 18.99, 'store_id': 1})
self.assertEqual(r.status_code, 200)
self.assertEqual(ItemModel.find_by_name('test').price, 18.99)
def get(self):
user_id = get_jwt_identity()
items = [item.json() for item in ItemModel.find_all()]
if user_id:
return {'items': items}, 200
return {
'items': [item['name'] for item in items],
'message': 'More data available if you log in.'
}, 200
def test_put_item(self):
with self.app() as c:
with self.app_context():
StoreModel('test').save_to_db()
r = c.put('/item/test', data={'price': 17.99, 'store_id': 1})
self.assertEqual(r.status_code, 200)
self.assertEqual(ItemModel.find_by_name('test').price, 17.99)
self.assertDictEqual(d1={'name': 'test', 'price': 17.99},
d2=json.loads(r.data))
def delete(self, name):
claims = get_jwt_claims()
if not claims['is_admin']:
return {'message': 'Admin privilege required.'}, 401
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {'message': 'Item deleted.'}
return {'message': 'Item not found.'}, 404
def test_crud(self):
with self.app_context():
item = ItemModel('test', 19.99)
self.assertIsNone(ItemModel.find_by_name('test'),
"Found an item with name {}, but expected not to.".format(item.name))
item.save_to_db()
self.assertIsNotNone(ItemModel.find_by_name('test'))
item.delete_from_db()
self.assertIsNone(ItemModel.find_by_name('test'))
def test_crud(self):
with self.app_context():
store = StoreModel('test')
store.save_to_db()
item = ItemModel('test', 19.99, 1)
self.assertIsNone(ItemModel.find_by_name('test'), "Found an item with name 'test' before save_to_db")
item.save_to_db()
self.assertIsNotNone(ItemModel.find_by_name('test'),
"Did not find an item with name 'test' after save_to_db")
item.delete_from_db()
self.assertIsNone(ItemModel.find_by_name('test'), "Found an item with name 'test' after delete_from_db")
def put(self, name):
data = Item.parser.parse_args()
item = ItemModel.find_by_name(name)
if item is None:
item = ItemModel(name, data['price'], data['store_id'])
else:
item.price = data['price']
item.save_to_db()
return item.json()
def get(self):
"""
Here we get the JWT identity, and then if the user is logged in (we were able to get an identity)
we return the entire item list.
Otherwise we just return the item names.
This could be done with e.g. see orders that have been placed, but not see details about the orders
unless the user has logged in.
"""
user_id = get_jwt_identity()
items = [item.json() for item in ItemModel.find_all()]
if user_id:
return {'items': items}, 200
return {
'items': [item['name'] for item in items],
'message': 'More data available if you log in.'
}, 200
def get(self, id):
items = ItemModel.find_by_user(id)
if items:
return {"items": list(map(lambda x: x.json(), items))}
return {"message": "Item not found"}, 404
def delete(self, name):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {"message": "item {} deleted".format(name)}
def delete(self, name):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {"message": ITEM_DELETED}, 200
return {"message": ITEM_NOT_FOUND}, 404
def delete(self, name):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {"message": "Item Deleted."}, 200
def get(self, name):
#item = self.get_item_by_name(name)
item = ItemModel.get_item_by_name(name)
if item:
return item.json()
return {'message': 'item not found'}, 404
def get(self, name):
item = ItemModel.find_by_name(name) #could also be Item.find_by_name
if item is not None:
return item.json()
else:
return {"message": "item not found"}, 404
def get(self, name):
item = ItemModel.find_by_name(name)
if item:
#because now it returns an item object
return item.json()
return {'message':'Item not found!'}, 404
def get(self, name):
res = ItemModel.findByName(name)
if res:
return res.json(), 200
else:
return {"item": "item not found"}, 404
def get(self, name):
item = ItemModel.findByName(name)
if item:
return item.json()
return {'message': 'Item doesn\'t exist'}, 404
def test_store_json_with_item(self):
with self.app_context():
store = StoreModel('test')
item = ItemModel('test_item', 19.99, 1)
store.save_to_db()
item.save_to_db()
expected = {
'name': 'test',
'items': [{
'name': 'test_item',
'price': 19.99
}]
}
self.assertDictEqual(store.json(), expected)
with self.app_context():
item = ItemModel('test', 19.99, 1)
self.assertIsNone(
ItemModel.find_by_name('test'),
"Found an item iwth name {}, but expected not to.".format(
item.name))
item.save_to_db()
self.assertIsNotNone(ItemModel.find_by_name('test'))
item.delete_from_db()
self.assertIsNone(ItemModel.find_by_name('test'))
def test_crud(self):
with self.app_context():
item = ItemModel('test', 19.99)
item.save_to_db()
self.assertIsNone(ItemModel.find_by_name('test'))
self.assertIsNotNone(ItemModel.find_by_name('test'))
def test_crud(self):
item = ItemModel("test", 19.99)
self.
def delete(self, name: str):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return "", 204
def get(self, name):
item = ItemModel.find_by_name(name)
if item:
return item.json(
) # as ItemModel returns a object and not a dictionary
return {"message": "item not founddd"}, 404
def delete(self, name):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {'message': 'Item was deleted'}
return {'message': 'Item not existing'}
def get(self, name):
item = ItemModel.find_by_name(name)
if item:
return item.json()
return {"message": f"Item with name {name} not found."}, 404
def get(self, name):
item = ItemModel.find_by_name(name)
if item:
return item_schema.dump(item), 200
return {"message": ITEM_NOT_FOUND}, 404
today = datetime.date.today()
weekday = today.weekday()
start_delta = datetime.timedelta(days=weekday, weeks=1)
start_of_previous_week = today - start_delta
start = start_of_previous_week + datetime.timedelta(days=0)
end = start_of_previous_week + datetime.timedelta(days=6)
return start, end
with app.app_context():
previousWeekStart, previousWeekEnd = getPreviousWeekDateTime()
categories = CategoryModel.get_all()
for category in categories:
categoryTypes = CategoryTypeModel.find_by_categoryID(category.id)
for categoryType in categoryTypes:
items = ItemModel.find_by_category_type(categoryType.id)
availableItemQuantity = 0
for item in items:
availableItemQuantity += item.quantity
queueItems = QueueItemModel.find_by_categoryTypeID(categoryType.id)
userQueueItems = {}
requestedQuantity = 0
for queueItem in queueItems:
requestedQuantity += queueItem.request.quantity
if queueItem.userID not in userQueueItems:
userQueueItems[queueItem.userID] = [queueItem]
else:
userQueueItems[queueItem.userID].append(queueItem)
queueItem.allocation = 0
queueItem.save_to_db()
if availableItemQuantity >= requestedQuantity:
def get(self, name):
item = ItemModel.find_by_name(name)
if item:
return item.json()
return {'message': 'Item not found'}, 404
def delete(self, name):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {'message': 'Item deleted.'}
return {'message': 'Item not found.'}, 404
def get(self):
return {'items': [x.json() for x in ItemModel.find_all()]}
def get(self, item_name):
item = ItemModel.find_by_name(item_name)
if item:
return item.json()
return {'message': f"{item_name} is not existed in database."}, 404
def get(self):
return {"items": item_list_schema.dump(ItemModel.find_all())}, 200
def test_json(self):
i = ItemModel('Name', 10.00)
expected = {'name': 'Name', 'price': 10.00}
self.assertDictEqual(expected, i.json(), "JSON received does not match expected. Received {} expected {}".format(i.json(), expected))
def get(self, name):
item = ItemModel.find_by_name(name)
if item:
return item.json()
return {"message": "Item not found"}, 404
def get(cls):
return {'items': [x.json() for x in ItemModel.find_all()]}, 200
def get(self, name):
item = ItemModel.find_by_name(name)
if item:
return item.json()
return {'message' : 'Item not found'}, 404
def delete(cls, name: str):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {'message': ITEM_DELETED}
return {'message': ITEM_NOT_FOUND}
def delete(self, name):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {'message' : 'Item deleted'}
def get(cls, name: str):
item = ItemModel.find_by_name(name)
if item:
return item.json()
return {'message': ITEM_NOT_FOUND}, 404
def delete(cls, name: str):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {"message": ITEM_DELETED}, 200
return {"message": ITEM_DELETED}, 404
def delete(self, name):
item = ItemModel.findByName(name)
if item is None:
return {'message': f'Item with name \'{name}\' doesn\'t exist'}
item.delete()
return {'message': f'Item with name \'{name}\' Deleted'}
def delete(self, name):
item = ItemModel.find_by_name(name)
if item:
item.delete_from_db()
return {"message": "Item Was Successfully Deleted"}
def delete(self, name):
item = ItemModel.find_by_name(name)
if item is None:
return {"message": "Item does not exists"}
item.delete_from_db()
return {"message": "Item deleted successfully."}
def get(self, name): # defining methods that the resouce is going to accept
item = ItemModel.find_by_name(name)
if item:
return item.json()
return {'message': 'Item not found'}, 404
