def update_order(order_id):
data = request.get_json()
get_order = Order.query.get(order_id)
if data.get('amount'):
get_order.amount = data['amount']
if data.get('products'):
get_order.amount = data['products']
get_order.createdAt = date()
db.session.add(get_order)
db.session.commit()
order_schema = OrderSchema()
order = order_schema.dump(get_order)
return make_response(jsonify({"order": order}))
def create_order():
data = request.get_json()
if 'products' in data:
products = data['products']
if not products:
return make_response("empty order", 400)
for product in products:
r = requests.get(os.environ['INVENTORY_ADDRESS'] +
'/api/products/' + str(product['id']))
if not r.json()['product']:
return make_response("non existent product", 404)
if r.json()['product']['stock'] < int(product['quantity']):
return make_response(
"not enough stock for product" + str(product['id']), 400)
new_stock = int(r.json()['product']['stock']) - int(
product['quantity'])
requests.put(os.environ['INVENTORY_ADDRESS'] + '/api/products/' +
str(product['id']),
json={'stock': str(new_stock)})
order_schema = OrderSchema()
order = order_schema.load(data)
result = order_schema.dump(order.create())
return make_response(jsonify({"order": result}), 200)
class TestOrder(BaseTest):
items_to_order = ItemsToOrderSchema()
order_schema = OrderSchema()
item_schema = ItemSchema()
def setUp(self):
BaseTest.setUp(self)
with self.app_context():
new_item = self.item_schema.load({
"name": "test_name",
"price": "22.43"
})
new_item1 = self.item_schema.load({
"name": "test_name1",
"price": "23.47"
})
new_item1.upsert_item()
new_item.upsert_item()
order = OrderModel(
items_list=[
ItemsToOrders(item_id=1, quantity=3),
ItemsToOrders(item_id=2, quantity=2),
],
status="pending",
)
order.save_to_db()
def test_order(self):
with self.app_context():
print(self.order_schema.dump(OrderModel.find_all(), many=True))
def test_set_status(self):
with self.app_context():
order1 = OrderModel.find_by_id(1)
order1.set_status("failed")
self.assertEqual("failed", order1.status)
def test_amount(self):
with self.app_context():
order1 = OrderModel.find_by_id(1)
self.assertEqual(11527, order1.amount)
def test_description(self):
with self.app_context():
order1 = OrderModel.find_by_id(1)
self.assertListEqual(["3 x test_name1", "2 x test_name"],
order1.description)
from collections import Counter
import stripe
from flask_restful import Resource
from flask import request
from models.item import ItemModel
from models.order import OrderModel, ItemsInOrder
from schemas.order import OrderSchema
order_schema = OrderSchema()
list_orders_schema = OrderSchema(many=True)
class Order(Resource):
@classmethod
def post(cls):
"""
Expect a token and a list of item ids from the request body.
Construct an order and talk to the Strip API to make a charge.
"""
data = request.get_json(
) # token + list of item ids [1, 2, 4, 4, 5, 2, 1, 1, 4]
items = []
item_id_quantities = Counter(data["item_ids"])
# Iterate over items and retrieve them from the database
for _id, count in item_id_quantities.most_common(
): # [(1,3),(2,2),(4,3),(5,1)]
item = ItemModel.find_by_id(_id)
if not item:
return {"message": "Item {} Not Found.".format(_id)}, 404
from flask_restful import Resource
from flask import request
from model.item import ItemModel
from model.order import OrderModel, ItemsInOrder
from schemas.order import OrderSchema
from collections import Counter
order_schema = OrderSchema()
class Order(Resource):
@classmethod
def post(cls):
data = request.get_json()
items = []
item_quantity = Counter(data["items"])
for name, count in item_quantity.most_common():
res = ItemModel.find_by_name(name)
if not res:
return {"msg": "Item not present {}".format(name)}, 404
items.append(
ItemsInOrder(item_id=ItemModel.find_id(name), quantity=count))
print(items)
order = OrderModel(items=items, status="pending")
order.save_to_db() #save orders to database
order.change_status("failed")
order.request_with_stripe() #send the order details to stripe
print("Payment Done")
from collections import Counter
from flask import request
from flask_restful import Resource
from stripe import error
from libs.strings import gettext
from models.item import ItemModel
from models.order import OrderModel, ItemsInOrder
from schemas.order import OrderSchema
order_schema = OrderSchema()
multiple_order_schema = OrderSchema(many=True)
class Order(Resource):
@classmethod
def get(cls):
# return multiple_order_schema.dump(OrderModel.find_all()), 200
return order_schema.dump(OrderModel.find_all(), many=True), 200
@classmethod
def post(cls):
"""
Expect a token and a list of item ids from the request body.
Construct a order to talk with Strip API to make a charge.
"""
data = request.get_json() # token + list of item ids
items = []
item_id_quantities = Counter(data["item_ids"])
# iterate from list of items and retrieve from the database
@app.route("/orders", methods=["GET"])
def route_order_get_all():
orders = Order.query.all
return jsonify({"orders":[i.as_dict() for i in orders()]})
@app.route("/orders/<int:order_id>", methods=["GET"])
def route_order_get_by_id(order_id):
order = Order.query.filter(Order.id == order_id).first()
if not order:
return abort(400, "The order with id: {0} does not exists".format(order_id))
return jsonify(order.as_dict())
@app.route("/orders", methods=["POST"])
@marshal_with(OrderSchema())
@use_kwargs(
{
"name": fields.Str(),
"description": fields.Str(),
"buyer_id": fields.Int(),
"seller_id": fields.Int(),
"lineitems": fields.List(fields.Dict(), required=True),
}
)
def route_order_create(name, description, buyer_id, seller_id, lineitems):
buyer = Company.query.filter(Company.id == buyer_id).first()
seller = Company.query.filter(Company.id == seller_id).first()
order_items = []
order = Order(
name=name,
from flask_restful import Resource
from flask import request
from flask_jwt_extended import jwt_required, fresh_jwt_required
from models.order import OrderModel
from schemas.order import OrderSchema
from libs.strings import gettext
order_schema = OrderSchema()
order_list_schema = OrderSchema(many=True)
class Order(Resource):
@classmethod
def get(cls, name: str):
order = OrderModel.find_by_name(name)
if order:
return order_schema.dump(order), 200
return {"message": gettext("order_not_found")}, 404
class OrderList(Resource):
@classmethod
def get(cls):
return {"items": order_list_schema.dump(OrderModel.find_all())}, 200
from collections import Counter
from flask import request
from flask_restful import Resource
from stripe import error
from models.item import ItemModel
from models.order import OrderModel, ItemsInOrder
from schemas.order import OrderSchema
orderSchema = OrderSchema()
orderListSchema = OrderSchema(many=True)
class Order(Resource):
@classmethod
def post(cls):
"""
Expects a token and a list of item ids from the request body.
Constructs an order and talks to the Stripe API to make a charge.
"""
data = request.get_json()
items = []
item_id_quantities = Counter(data["items_id"])
for _id, count in item_id_quantities.most_common():
item = ItemModel.find_by_id(_id)
if not item:
return {"message": f"Item {_id} Not Found."}, 404
items.append(ItemsInOrder(item_id=_id, quantity=count))
def get_orders_by_user(user_id):
get_orders = Order.query.filter(Order.idUser == user_id)
order_schema = OrderSchema(many=True)
orders = order_schema.dump(get_orders)
return make_response(jsonify({"orders": orders}))
def get_one_order(order_id):
get_order = Order.query.get(order_id)
order_schema = OrderSchema()
order = order_schema.dump(get_order)
return make_response(jsonify({"order": order}))
def get_all_orders():
get_orders = Order.query.all()
order_schema = OrderSchema(many=True)
orders = order_schema.dump(get_orders)
return make_response(jsonify({"orders": orders}))
