def showDetailsOfBook(productID):
details = Product.getDetailsOfProduct(productID)
if (details['status'] == 0):
details['data'][0]['rate'] = Product.getRateOfProduct(productID)
if (flask_login.current_user.is_authenticated):
return render_template(
'shop-details.html',
user=flask_login.current_user,
details=details['data'][0],
userMark=flask_login.current_user.getUserMarkTo(productID),
quantityInCart=Cart.getQuantityOfProductInCart(
flask_login.current_user.userID, productID))
else:
return render_template('shop-details.html',
user=flask_login.current_user,
details=details['data'][0])
elif (details['status'] == 2):
return render_template('shop-details.html',
user=flask_login.current_user,
error=details['message'])
elif (details['status'] == 1): #TODO: ERROR
return render_template('shop-details.html',
user=flask_login.current_user,
error=details['message'])
else:
return redirect(url_for('showBooks', page=1))
def delete(self, id=""):
if str(request.url_rule) == '/api/product/<string:id>/delete':
product = Product.deleteProduct(id)
productIsDelete = Invoice.isProductDelete(product)
result = {
"message":
"le produit ne peut pas être supprimer car il est dans un ou plusieurs invoice",
"success": False,
"inInvoice": False
}
if not product:
result[
"message"] = "le produit n'existe pas, il ne peut pas y avoir de suppresion"
result["success"] = False
if productIsDelete:
product.delete()
result["message"] = "la suppression a bien été faites"
result["success"] = True
result["inInvoice"] = True
return jsonify(result)
return Response(status=404)
def put(self, id=""):
body = dict(request.form)
picture = ""
if request.files:
picture = request.files['picture']
updated = Product.updateProduct(id, body, picture)
if updated["count"] == 0:
result = {
'message': f"data produit {id} not update",
'success': False
}
return jsonify(result)
result = {
'message': f"data produit {id} update",
'path': {
'path': f"/product/{id}",
'name': "Product",
'params': {
'id': id
}
},
'success': True,
'updated': updated
}
return jsonify(result)
def post(self):
body = dict(request.form)
picture = request.files['picture']
product = Product.createProduct(body, picture)
return redirect('http://localhost:8080/products')
def setRate():
user = flask_login.current_user
if (user.is_authenticated):
productID = request.args.get('productID', type=int)
mark = request.args.get('mark', type=int)
result = Product.addNewRate(user.userID, productID, mark)
return jsonify(result)
return jsonify({'status': 120, 'message': 'Not auth'})
async def insert_product(product: schema.Product = Depends(get_product_form),
image: UploadFile = File(...),
db: Session = Depends(get_db)):
try:
db_product = ProductDB(**product.dict())
db.add(db_product)
db.commit()
if image:
fileName = save_upload_file(image, db_product.id)
product_db = db.query(ProductDB).filter(
ProductDB.id == db_product.id)
product_db.update({ProductDB.image: fileName})
db.commit()
return db_product.as_dict()
except Exception as e:
return {"product": "nok", "error": str(e)}
def create_product():
data = request.get_json()
new_product = Product(title=data['title'],
imageUrl=data['imageUrl'],
description=data['description'],
price=data['price'])
db.session.add(new_product)
db.session.commit()
return jsonify({'message': 'The product has been added !!'})
def testBooksByTags():
tags = request.args.get('tags', type=str)
tagsArray = tags.split(',')
if (len(tagsArray) == 0):
return jsonify({
'status': 3,
'message': 'Empty array of tags(',
'data': []
})
return jsonify(Product.getAllProductsFilteredByTags(tagsArray))
def create_product():
now = datetime.datetime.utcnow()
entity = Product(id=request.json['id'],
name=request.json['name'],
created_at=now,
updated_at=now,
weight=int(request.json['weight']),
time_to_build=int(request.json['time_to_build']),
selling_price=int(request.json['selling_price']),
num_employee_required=int(
request.json['num_employee_required']),
mold_id=int(request.json['mold_id']),
photo_url=None)
entity.colors = [
Color.query.filter_by(id=c).first() for c in request.json['colors']
]
db.session.add(entity)
db.session.commit()
return jsonify(entity.to_dict()), 201
def update_product(id):
entity = Product.query.get(id)
if not entity:
abort(404)
entity = Product(
name=request.json['name'],
type=request.json['type'],
weight=request.json['weight'],
time_to_build=request.json['time_to_build'],
selling_price=request.json['selling_price'],
color=request.json['color'],
created_at=datetime.datetime.strptime(request.json['created_at'],
"%Y-%m-%d").date(),
updated_at=datetime.datetime.strptime(request.json['updated_at'],
"%Y-%m-%d").date(),
mold_id=request.json['mold_id'],
id=id)
db.session.merge(entity)
db.session.commit()
return jsonify(entity.to_dict()), 200
def test_add_product(self):
product = Product(title='Bounty',
price=200,
description='Tasty coconut')
qty = 2
products = self.cart.products
products[product] = qty
self.cart.add_product(product, qty)
self.assertEqual(self.cart.products,
products,
msg='Product lists do not match')
def products(current_user, id=None):
if request.method == 'GET':
all_products = Product.query.all()
return jsonify(products_schema.dump(all_products)), 200
elif request.method == 'POST':
data = request.json
if not ('name' in data and 'price' in data and 'cost' in data):
return jsonify({"error": "Bad request. Missing fields."}), 400
product = Product(data['name'], data['price'], data['cost'])
db.session.add(product)
db.session.commit()
return jsonify({"message": "Product was registered"}), 200
elif request.method == 'PUT':
data = request.json
if not data:
return jsonify({"error":
"Bad request. Updating without fields."}), 400
old_product = Product.query.filter_by(id=id).first()
if not old_product:
return jsonify({"error": "Product not found."}), 404
if 'name' in data:
old_product.name = data['name']
if 'price' in data:
old_product.price = data['price']
if 'cost' in data:
old_product.cost = data['cost']
db.session.commit()
return jsonify({"message": "Product was updated"}), 200
elif request.method == 'DELETE':
product = Product.query.filter_by(id=id).first()
if not product:
return jsonify({"error": "Product not found."}), 404
db.session.delete(product)
db.session.commit()
return jsonify({"message": "Product was removed"}), 200
def setUp(self) -> None:
user = User(login='******',
name='Alexandr',
age=19,
email='*****@*****.**',
password='******')
self.testing_product = Product(title='Mars',
price=45,
description="Elon Musk's favorite!")
products = {
Product(title='Twix',
price=50,
description='Two chocolate sticks...'):
2,
Product(title='Sneakers', price=60, description='Contains nuts!'):
5,
self.testing_product:
1,
}
self.cart = Cart(user, products)
def test_create_product_none_arguments(self):
try:
product = Product(None, 5.30, 3.48)
self.fail("Exception was expected.")
except:
pass
try:
product = Product("arroz", None, 3.48)
self.fail("Exception was expected.")
except:
pass
try:
product = Product("arroz", 5.30, None)
self.fail("Exception was expected.")
except:
pass
try:
product = Product(None, None, None)
self.fail("Exception was expected.")
except:
pass
def test_create_product_empty_string_arguments(self):
try:
product = Product("", 5.30, 3.48)
self.fail("Exception was expected.")
except:
pass
try:
product = Product("arroz", "", 3.48)
self.fail("Exception was expected.")
except:
pass
try:
product = Product("arroz", 5.30, "")
self.fail("Exception was expected.")
except:
pass
try:
product = Product("", "", "")
self.fail("Exception was expected.")
except:
pass
def showBooks(page):
if (page < 1):
return render_template('books.html',
error='Incorrect page',
user=flask_login.current_user)
OFFSET = 8
userQuerySearch = request.args.get('q', default=None, type=str)
tagsFilter = request.args.getlist('tags')
tagsFilterStr = None
if (userQuerySearch is not None):
userQuerySearch = Security.escape_sql(userQuerySearch)
result = Product.getAllProfuctsFilteredByQuery(userQuerySearch, page,
OFFSET)
countOfRows = Product.getQuantityOfRowsInTable(
'select count(*) as "count" from Товар where title like "%{0}% " \
or author like "%{0}%" order by rate;'.format(
userQuerySearch))['count']
elif (tagsFilter):
countOfRows = Product.getQuantityOfRowsInTable(
sqlQueryHelper.buildSqlQueryByTags(
'select count(*) as "count" from Товар', tagsFilter))['count']
result = Product.getAllProductsFilteredByTags(tagsFilter, page, OFFSET)
tagsFilterStr = tagsHelper.makeArrayOfTagsToStr(tagsFilter)
tagsFilterStr = Security.escape_sql(tagsFilterStr)
else:
countOfRows = Product.getQuantityOfRowsInTable(
'select count(*) as "count" from Товар;')['count']
result = Product.getAllProfuctsFilteredById(page, OFFSET)
if (result['status'] == 0):
countOfPages = countOfRows // OFFSET
if (countOfRows % OFFSET > 0):
countOfPages += 1
countOfPagesRange = pageHelper.getRangeOfPages(countOfPages, page)
return render_template(
'books.html', #TODO : IF STATUS
products=result['data'],
countOfPagesRange=countOfPagesRange,
user=flask_login.current_user,
q=userQuerySearch,
currentPage=page,
tagsAlreadySearched=tagsFilterStr)
elif (result['status'] == 2):
return render_template('books.html',
error='Not found',
user=flask_login.current_user,
q=userQuerySearch,
tagsAlreadySearched=tagsFilterStr)
elif (result['status'] == 1):
return render_template('books.html',
error='SQL runtime error',
user=flask_login.current_user)
return render_template('books.html',
error='ERROR',
user=flask_login.current_user)
def test_create_product_basic(self):
try:
product = Product("arroz", 5.30, 3.48)
except:
self.fail("Exception was not expected.")
def searchAdvanced():
availableTags = Product.getAvailableTags()
return render_template('advanced-search.html',
user=flask_login.current_user,
tags=availableTags['data'])
def testBooks(page):
return jsonify(Product.getAllProfuctsFilteredByRate(page, 5))
def showDetailsOfBookAPI(productID):
return Product.getDetailsOfProduct(productID)
def getAvailableTagsAPI():
return jsonify(Product.getAvailableTags())
def test_product_string_representation(self):
product = Product("arroz", 10.23, 9.33)
self.assertEqual("< Product : arroz >", product.__repr__())
def get(self, id="", filename=""):
if str(request.url_rule) == '/api/product/<string:id>':
product = Product.getProduct(id)
result = {
"message": 'recuperation du produit' + str(product["name"]),
"success": True,
"count": 1,
"result": product,
'form': {
"name": {
"type": "text",
"placeholder": "Enter name...",
"name": "name",
"label": "Name",
"value": product['name']
},
"stock": {
"type": "number",
"placeholder": "Enter stock...",
"name": "stock",
"label": "Stock",
"value": product['stock']
},
"picture": {
"type": "file",
"placeholder": "Enter picture...",
"name": "picture",
"label": "Picture",
},
"price": {
"type": "number",
"step": "any",
"placeholder": "Enter price...",
"name": "price",
"label": "Price",
"value": product['price']
}
}
}
return jsonify(result)
elif str(request.url_rule) == '/api/products':
products = Product.getAllProducts()
result = {
"message": 'recuperation des produits',
"success": True,
"count": len(products),
"results": products,
"unitName": "Product"
}
return jsonify(result)
elif str(request.url_rule
) == '/api/product/<string:id>/image/<string:filename>':
return Product.getImage(id)
elif str(request.url_rule) == '/api/product/form':
result = {
"name": {
"type": "text",
"placeholder": "Enter name...",
"name": "name",
"label": "Name",
},
"stock": {
"type": "number",
"placeholder": "Enter stock...",
"name": "stock",
"label": "Stock",
},
"picture": {
"type": "file",
"placeholder": "Enter picture...",
"name": "picture",
"label": "Picture",
},
"price": {
# "type": "float",
"type": "number",
"step": "any",
"placeholder": "Enter price...",
"name": "price",
"label": "Price",
}
}
return jsonify(result)
return Response(status=404)
