def setUp(self):
self.item = ItemModel(
id=1,
name="Brightside",
description="This is Mr. Brightside -The Killers",
price=350,
image="bright-side.jpg",
continent="Europe",
in_stock=1,
class_="Mammal")
def insert(name, price, stock, username):
if ItemHandler.find_by_name(name, username) is not None:
raise ItemExists
else:
newitem = ItemModel(name, price, stock, username)
ItemHandler.save_to_db(newitem)
return True
def delete(self, item_id, current_user):
item = ItemModel.find_by_id(item_id, user_id=current_user.id)
if not item:
return {"message": "Item not found"}, 404
item.delete()
return {}, 200
def update_item(item_id, user_info):
"""
Update an item, find by its id
Protected
:param item_id: item id
:param user_info: decoded access token
:return:
"""
data = request.get_json()
# Validate json
schema = ItemSchema(dump_only=('slug', 'id'))
errors = schema.validate(data)
if len(errors) > 0:
raise ValidationError('Post data error', errors)
# Validate item id
item = ItemModel.get_user_item(item_id, user_info.get('id'))
if item is None:
raise ValidationError('Item not found!')
# Validate item name
slug = slugify(data['name'])
if slug != item.slug:
valid = ItemModel.validate_slug(slug)
if not valid:
raise ValidationError('An item with the same name has already been added. Please try another name.')
# Validate category id
category = CategoryModel.find(category_id=data['category_id'])
if category is None:
raise ValidationError('Invalid category Id')
item.name = data['name']
item.description = data['description']
item.category_id = data['category_id']
item.slug = slugify(item.name)
db.session.add(item)
db.session.commit()
item_schema = ItemSchema()
result = item_schema.dump(item)
return send_success(result.data)
def post(self):
try:
# Query for the user
user = UserModel.query.filter_by(
username=current_user.username).first_or_404()
# Make a new item
new_item = ItemModel(**self.args)
# Relate the item back to the user?
new_item.user_id = current_user.id
# Add to db
db.session.add(new_item)
db.session.commit()
except:
# Make the item
new_item = ItemModel(**self.args)
# JSONify the item
jsonified_item = item_schema.dump(new_item)[0]
try:
# Get the guest cart
guest_cart = session["items"]
# Add the item
guest_cart.append(jsonified_item)
# Update session
session["items"] = guest_cart
except:
# If we need to make a new session instance of items
session["items"] = []
# Add the item to the guest cart
guest_cart = session["items"]
guest_cart.append(jsonified_item)
# Set the session equal to the guest cart
session["items"] = guest_cart
return jsonify(message='Cart item successfully created!')
def get_items():
"""
Get a list of items
:return:
"""
mode = request.args.get('mode')
limit = request.args.get('limit')
if mode == 'latest':
items = ItemModel.get_last_n_items(limit)
else:
items = ItemModel.get_all_items()
items_schema = ItemSchema(many=True, load_only=('user_id', 'description',))
result = items_schema.dump(items)
return send_success(result.data)
def get_allWishlistItems(user_id):
pid_list = WishlistModel.getWishListProductIDs(user_id)
WishlistModel.wishlistitems = []
for pid in pid_list:
query = "SELECT Buyable_item_.* FROM Buyable_item_ WHERE Buyable_item_.Product_ID = %s"
result = MySQLdatabase.ExcecuteSafeSelectQuery(query, pid)
for i in result:
WishlistModel.wishlistitems.append(
ItemModel(i[0], i[1], i[2], i[4], i[7], i[5], i[3], i[6]))
return WishlistModel.wishlistitems
def get_allFavouritesItems(user_id):
pid_list = FavouritesModel.getFavouritesProductIDs(user_id)
FavouritesModel.favouritesitems = []
for pid in pid_list:
query = "SELECT Buyable_item_.* FROM Buyable_item_ WHERE Buyable_item_.Product_ID = %s"
result = MySQLdatabase.ExcecuteSafeSelectQuery(query, pid)
for i in result:
FavouritesModel.favouritesitems.append(
ItemModel(i[0], i[1], i[2], i[4], i[7], i[5], i[3], i[6]))
return FavouritesModel.favouritesitems
def setUp(self):
itemlst = []
self.Item = ItemModel(id=0,
name='testobject',
description='im an testobject',
price=400,
image='idontknowanypath',
continent='Europe',
in_stock=4,
class_='Mammal')
def create_item(user_info):
"""
Add an item
Protected
:param user_info: decoded access token
:return:
"""
data = request.get_json()
# Validate json
schema = ItemSchema(dump_only=('slug', 'id'))
errors = schema.validate(data)
if len(errors) > 0:
raise ValidationError('Post data error', errors)
# Validate item name
valid = ItemModel.validate_slug(slugify(data['name']))
if not valid:
raise ValidationError('An item with the same name has already been added. Please try another name.')
# Validate category id
category = CategoryModel.find(category_id=data['category_id'])
if category is None:
raise ValidationError('Invalid category Id')
item = ItemModel(name=data['name'], description=data['description'], category_id=data['category_id'],
user_id=user_info['id'], slug=slugify(data['name']))
db.session.add(item)
db.session.commit()
item_schema = ItemSchema()
result = item_schema.dump(item)
return send_success(result.data)
def get_item(item_id):
"""
Get details for an item. Find by its id
:param item_id: item id
:return:
"""
item = ItemModel.find(item_id)
if item is None:
raise ValidationError('Item not found!')
item_schema = ItemSchema()
result = item_schema.dump(item)
return send_success(result.data)
def delete_item(item_id, user_info):
"""
Delete an item, find by its id
Protected
:param item_id: item id
:param user_info: decoded access token
:return:
"""
# Validate item id
item = ItemModel.get_user_item(item_id, user_info.get('id'))
if item is None:
raise ValidationError('Item not found!')
db.session.delete(item)
db.session.commit()
return send_success(None)
def put(self, item_id, current_user):
parser = reqparse.RequestParser()
parser.add_argument(
'name',
type=non_empty_string,
location='form',
help="Name of the item (must be a non-empty string)")
parser.add_argument('description',
type=str,
help="Description of the item",
location='form')
parser.add_argument('rate', type=int, location='form')
parser.add_argument('image', type=FileStorage, location='files')
parser.add_argument('delete_image', type=bool, location='form')
args = parser.parse_args()
args = {key: value for key, value in args.items() if value is not None}
item = ItemModel.find_by_id(item_id, user_id=current_user.id)
if not item:
return {"message": "Item not found"}, 404
if args.pop('delete_image', None):
item.delete_image()
if not args.get('image'):
args.pop('image', None)
elif not isinstance(args['image'], string_types):
try:
image_url = GCBucket.save_to_google_cloud(args['image'])
except Exception as exc:
logger.error("Cannot save image. Exception message: {}".format(
str(exc)))
image_url = None
if image_url:
args['image'] = image_url
else:
args.pop('image', None)
item.update_fields(save=True, **args)
return item.json(), 200
def post(self, current_user):
parser = reqparse.RequestParser()
parser.add_argument('name',
type=non_empty_string,
required=True,
location='form',
help="Name of the item is required")
parser.add_argument('description',
type=str,
help="Description of the item",
location='form')
parser.add_argument('image', type=FileStorage, location='files')
args = parser.parse_args()
if not args['image']:
args.pop('image', None)
elif not isinstance(args['image'], string_types):
try:
image_url = GCBucket.save_to_google_cloud(args['image'])
except Exception as exc:
logger.error("Cannot save image. Exception message: {}".format(
str(exc)))
image_url = None
if image_url:
args['image'] = image_url
else:
args.pop('image', None)
item = ItemModel.find_by_name(args['name'], user_id=current_user.id)
if item:
item.update_fields(rate=item.rate + 1, **args)
else:
item = ItemModel(**args, user_id=current_user.id)
try:
item.save()
except:
return {'message': 'Error writing in database'}, 500
return item.json(), 201
class TestItem(unittest.TestCase):
def setUp(self):
self.item = ItemModel(
id=1,
name="Brightside",
description="This is Mr. Brightside -The Killers",
price=350,
image="bright-side.jpg",
continent="Europe",
in_stock=1,
class_="Mammal")
def test_init(self):
self.assertEqual(self.item.id, 1)
self.assertEqual(self.item.name, "Brightside")
self.assertEqual(self.item.description,
"This is Mr. Brightside -The Killers")
self.assertEqual(self.item.price, 350)
self.assertEqual(self.item.image, "bright-side.jpg")
self.assertEqual(self.item.continent, "Europe")
self.assertEqual(self.item.in_stock, 1)
self.assertEqual(self.item.class_, "Mammal")
def test_toDict(self):
dictionary = {
"id": 1,
"name": "Brightside",
"description": "This is Mr. Brightside -The Killers",
"price": 350,
"image": "bright-side.jpg",
"continent": "Europe",
"in_stock": 1,
"class": "Mammal"
}
self.assertEqual(self.item.toDict(), dictionary)
@mock.patch("app.models.ItemModel.MySQLdatabase")
def test_get_all_items(self, mock_msqldb):
mock_msqldb.ExcecuteSafeSelectQuery = mock.MagicMock(return_value=[
(1, "testItem", "This is a test item", 240, 115, "Asia", "Fish",
"random_route.jpg"),
])
items = ItemModel.get_all_items()
self.assertEqual(items[0].id, 1)
#check_Stock --else
@mock.patch("app.models.ItemModel.MySQLdatabase")
def test_check_StockTrue(self, mock_msqldb):
mock_msqldb.ExcecuteSafeSelectQuery = mock.MagicMock(
return_value=[(100, )])
test = ItemModel.check_Stock(5, 5)
self.assertTrue(test)
# Vraag : 1 functie of 2 funties?
#check_Stock --if
@mock.patch("app.models.ItemModel.MySQLdatabase")
def test_check_StockFalse(self, mock_msqldb):
mock_msqldb.ExcecuteSafeSelectQuery = mock.MagicMock(
return_value=[(3, )])
test = ItemModel.check_Stock(5, 5)
self.assertFalse(test)
#update_Stock() -todo
#all filter functions -todo
def test_hasId(self):
self.assertTrue(self.item.hasId("1"))
def test_hasName(self):
self.assertTrue(self.item.hasName("BrightSide"))
def test_hasDescription(self):
self.assertTrue(
self.item.hasDescription("This is Mr. Brightside -The Killers"))
def test_inPriceRange(self):
self.assertTrue(self.item.inPriceRange(0, 500))
def test_hasContinent(self):
self.assertTrue(self.item.hasContinent("Europe"))
def test_inStock(self):
self.assertTrue(self.item.inStock(1))
def test_hasClassification(self):
self.assertTrue(self.item.hasClassification("Mammal"))
def get_all():
item = ItemHandler.get_all(token_auth.current_user().username)
data = ItemModel.to_dict(item)
return jsonify(data)
def get(self, item_id, current_user):
item = ItemModel.find_by_id(item_id, user_id=current_user.id)
if not item:
return {"message": "Item not found"}, 404
return item.json()
from random import randint
from faker import Faker
from app.models import ItemModel
from app import db
if __name__ == '__main__':
fake = Faker()
db.create_all()
for e in range(30):
f_name = fake.sentence(nb_words=3)[:-1]
f_description = fake.sentence()
f_created_date = fake.date_time()
f_last_edit_date = fake.date_time_between_dates(
datetime_start=f_created_date)
f_rate = randint(1, 100)
item = ItemModel(
name=f_name,
description=f_description,
created_date=f_created_date,
last_edit_date=f_last_edit_date,
rate=f_rate,
)
db.session.add(item)
db.session.commit()
print("Database populated")
