def testPost3(self):
#when courier comes online, assign it a package
order = Order(orderId=1,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=2,pickup_lat=10.0,pickup_lon=10.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=3,pickup_lat=10.0,pickup_lon=1.0,dropoff_lat=12.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=4,pickup_lat=1.0,pickup_lon=10.0,dropoff_lat=2.0,dropoff_lon=12.0)
order.put()
courier = Courier(courierId=7,lat=2.0,lon=3.0,online=False)
courier.put()
response = self.testapp.post('/courier/7/online')
self.assertEqual(302,response.status_int)
#check that courier 1 is assigned order 1
# courier = db.GqlQuery("SELECT * FROM Courier WHERE courierId = 7").get()
# self.assertEqual(1,courier.orderId)
# self.assertEqual(False,courier.online)
#check order 1 is assigned to courier 1
posOrder = db.GqlQuery("SELECT * FROM Order WHERE orderId = 1").get()
self.assertEqual('enRoute',posOrder.state)
self.assertEqual(7,posOrder.courierId)
#check that the other orders are still unassigned
for id in [2,3,4]:
negOrder = db.GqlQuery("SELECT * FROM Order WHERE orderId = :1",id).get()
self.assertEqual('needPickup',negOrder.state)
self.assertEqual(None,negOrder.courierId)
def testInsertCourier2(self):
#populate with some orders awaiting pickup
order = Order(orderId=1,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=2,pickup_lat=10.0,pickup_lon=10.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=3,pickup_lat=10.0,pickup_lon=1.0,dropoff_lat=12.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=4,pickup_lat=1.0,pickup_lon=10.0,dropoff_lat=2.0,dropoff_lon=12.0)
order.put()
#create a new courier
params = {'id': 1, 'lat': 10.0,'lon':2.0}
response = self.testapp.post('/courier/new', params)
self.assertEqual(302,response.status_int)
#check courier assigned correct order
# courier = db.GqlQuery("SELECT * FROM Courier WHERE courierId = 1").get()
# self.assertEqual(3,courier.orderId)
# self.assertEqual(False,courier.online)
#check that the assigned order is enRoute
posOrder = db.GqlQuery("SELECT * FROM Order WHERE orderId = 3").get()
self.assertEqual(1,posOrder.courierId)
self.assertEqual('enRoute',posOrder.state)
#check that the other orders are still unassigned
for id in [1,2,4]:
negOrder = db.GqlQuery("SELECT * FROM Order WHERE orderId = :1",id).get()
self.assertEqual(None,negOrder.courierId)
self.assertEqual('needPickup',negOrder.state)
#check that other couriers do not exist
courier = db.GqlQuery("SELECT * FROM Courier WHERE courierId = 3").get()
self.assertEqual(None, courier)
def check_new_order(text, res):
global order_id
global order_heap
tokens = text.split()
if tokens and (tokens[0].lower() in start_tokens):
if (len(tokens) == 1):
res['response']['text'] = 'Хз что готовить'
return True
recipe = ' '.join(tokens[1:])
if (recipes.get(recipe) != None):
timestamp = datetime.datetime.now().time()
timestamp = time(timestamp.hour, timestamp.minute,
timestamp.second)
order_id += 1
item = recipes.get(recipe)
if item.second == 0:
order = Order(order_id, recipe, time(0, 7 - item.minute, 0),
timestamp, "ожидает")
else:
order = Order(order_id, recipe,
time(0, 6 - item.minute, 60 - item.second),
timestamp, "ожидает")
heappush(order_heap, order)
res['response'][
'text'] = 'Заказ с блюдом {} добавлен в очередь!'.format(
order.orderName)
return True
return False
def test_a_3_012_order_relationship_product_delete(self):
p_before = len(Product.query.all())
#Creating the product to be deleted
product_del = Product(name="Spoon",
price="5",
in_stock=True,
seller_id=1)
product_del.insert()
p_del_id = product_del.id
p_after = len(Product.query.all())
self.assertEqual(p_after, p_before + 1)
o_before = len(Order.query.all())
#Creating orders to be deleted
o_del_1 = Order(user_id=1, product_id=p_del_id, amount=1)
o_del_2 = Order(user_id=1, product_id=p_del_id, amount=1)
o_del_3 = Order(user_id=1, product_id=p_del_id, amount=1)
o_del_4 = Order(user_id=1, product_id=p_del_id, amount=1)
o_del_1.insert()
o_del_2.insert()
o_del_3.insert()
o_del_4.insert()
self.assertEqual(len(Order.query.all()), o_before + 4)
#Making the delete action
product_del.delete()
o_after = len(Order.query.all())
#Testing values
self.assertEqual(len(Product.query.all()), p_before)
self.assertEqual(o_before, o_after)
self.assertEqual(
len(Order.query.filter(Order.product_id == p_del_id).all()), 0)
print("Test a_3_12:order relationship_product_delete")
def generateOrder(request):
_user = request.user
typeid = request.POST.get("typeid", None)
if not typeid:
return Jsonify({"status":False, "error":"1101", "error_message":u"输入信息不足。"})
typeid = int(typeid)
#itemlist is a list of item number, eg.
#"1101, 1302, 1323, 1333"
itemlist = request.POST.get("itemlist", "")
createtime = datetime.now()
_user = request.user
_addr = Address.objects.filter(user_id=_user['uid']).filter(is_default=1)
if not _addr:
order = Order(user_id=_user['uid'], notes="", fee=0, typeid=typeid, itemList=itemlist, state=12, create_time=createtime, showid="0")
order.save()
newid = createtime.strftime("%Y%m%d")+"0"*(4-len(str(order.oid)))+str(order.oid)
order.showid=newid
order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":order.toDict(), "address":""})
else:
_addr_object = _addr[0]
_addr = _addr_object.toDict()
fee, detail = getDeliveryfee(1)
order = Order(user_id=_user['uid'], notes="", fee=fee, typeid=typeid, itemList=itemlist, state=12, create_time=createtime, addr=_addr_object)
order.save()
newid = createtime.strftime("%Y%m%d")+"0"*(4-len(str(order.oid)))+str(order.oid)
order.showid=newid
order.save()
return Jsonify({"status":True, "error":"", "error_message":"", "order":order.toDict(), "address":_addr_object.toDict(), "detail":detail})
def run(self):
first_customer = Customer(**{
'username': '******',
'email': '*****@*****.**',
'age': 30,
})
second_customer = Customer(**{
'username': '******',
'email': '*****@*****.**',
})
first_order = Order(**{
'name': 'some order',
'customer_id': 1,
})
second_order = Order(**{
'name': 'another order',
'customer_id': 1,
})
db.session.add_all(
[first_customer, second_customer, first_order, second_order])
db.session.commit()
def create_order():
parser = reqparse.RequestParser()
# parser.add_argument('id', type=str)
parser.add_argument('coffee_type', type=str)
parser.add_argument('additions', type=str)
args = parser.parse_args()
# order_id = args.get("id")
coffee_type = args.get("coffee_type")
additions = None
if args.get("additions") is not None:
additions = [i for i in args.get("additions").split(',')]
id = str(int(time.time()))
if coffee_type in coffee.keys():
cost = coffee[coffee_type]
status = "Placed"
payment = "F"
if additions:
orders.append(
Order(id,
coffee_type,
cost,
status,
payment,
additions=additions))
else:
orders.append(Order(id, coffee_type, cost, status, payment))
return jsonify(order_id=id,
coffee_type=coffee_type,
cost=cost,
payment='/payOrder/' + id), 201
return jsonify(coffee_type=False), 404
def testIdleOrders(self):
order = Order(orderId=1,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=2,pickup_lat=11.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
orders = assign.idleOrders()
self.assertEqual(2, orders.count())
def testCouriersIdEnRoute(self):
order = Order(orderId=1,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0,state='enRoute',courierId= 10)
order.put()
order = Order(orderId=2,pickup_lat=11.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=3,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0,state='enRoute',courierId = 5)
order.put()
couriers = assign.couriersIdEnRoute()
self.assertEqual(set([10,5]), set(couriers))
def test_fetch_all_orders(self):
""" Test fetching all Orders """
date = datetime.now()
order = Order(customer_id=1, date=date, shipped=True)
order.save()
order2 = Order(customer_id=2, date=date, shipped=False)
order2.save()
Order.all()
self.assertEqual(len(Order.all()), 2)
def testOrdersEnroute(self):
order = Order(orderId=1,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0,state='enRoute')
order.put()
order = Order(orderId=2,pickup_lat=11.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=3,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0,state='enRoute')
order.put()
q = assign.ordersEnRoute()
self.assertEqual(2,q.count())
for order in q:
self.assertIn(order.orderId, [1,3])
def setUp(self):
""" Runs before each test """
server.init_db()
db.drop_all() # clean up the last tests
db.create_all() # create new tables
date = datetime.now()
Item(order_id=1, product_id=1, name='hammer', quantity=1, price=11.50).save()
Item(order_id=1, product_id=2, name='toilet paper', quantity=2, price=2.50).save()
Item(order_id=2, product_id=3, name='beer', quantity=2, price=10.50).save()
order = Order(customer_id=1, date=date, shipped=True).save()
order = Order(customer_id=2, date=date, shipped=True).save()
self.app = server.app.test_client()
def testFormMatrix(self):
courier = Courier(courierId=1,lat=2.0,lon=3.0,online=True)
courier.put()
courier = Courier(courierId=3,lat=14.0,lon=13.0,online=True)
courier.put()
order = Order(orderId=4,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=5,pickup_lat=11.0,pickup_lon=11.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
orders = assign.idleOrders()
couriers = assign.availableCouriers()
matrix = self.mkres.form_matrix(orders, couriers)
def test_0a_1_3_1_MyModel(self):
db_drop_and_create_all()
# Creating the user
user_to_del = User(username="******", password="******")
db.session.add(user_to_del)
db.session.commit()
self.assertEqual(len(User.query.all()), 1)
prod_to_del1 = Product(name="abc", price=456, seller_id=user_to_del.id)
prod_to_del2 = Product(name="abcdef",
price=4567,
seller_id=user_to_del.id)
db.session.add_all([prod_to_del1, prod_to_del2])
db.session.commit()
self.assertEqual(len(Product.query.all()), 2)
order_to_del1 = Order(user_id=user_to_del.id,
product_id=prod_to_del1.id,
amount=1)
order_to_del2 = Order(user_id=user_to_del.id,
product_id=prod_to_del2.id,
amount=3)
order_to_del3 = Order(user_id=user_to_del.id,
product_id=prod_to_del2.id,
amount=5)
db.session.add_all([order_to_del1, order_to_del2, order_to_del3])
db.session.commit()
self.assertEqual(len(Order.query.all()), 3)
#img_to_delete1=Image(seller_id=1,name="abc",formatting = "png")
#img_to_delete2=Image(seller_id=1,name="abce",formatting = "jpg")
#db.session.add_all([img_to_delete1,img_to_delete2])
#db.session.commit()
#self.assertEqual(len(Image.query.all()),2)
# Trying to delete
#img_to_delete2.delete()
#self.assertEqual(len(Image.query.all()),1)
order_to_del3.delete()
self.assertEqual(len(Order.query.all()), 2)
prod_to_del2.delete()
self.assertEqual(len(Order.query.all()), 1)
self.assertEqual(len(Product.query.all()), 1)
user_to_del.delete()
#self.assertEqual(len(Image.query.all()),0)
self.assertEqual(len(Order.query.all()), 0)
self.assertEqual(len(Product.query.all()), 0)
self.assertEqual(len(User.query.all()), 0)
print("Test 0a_1_3_1 : MyModel: relationships")
def testAssignDelivery2(self):
#have orders, but no couriers
order = Order(orderId=1,pickup_lat=1.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
order = Order(orderId=2,pickup_lat=11.0,pickup_lon=1.0,dropoff_lat=2.0,dropoff_lon=2.0)
order.put()
assign.assignDelivery()
posOrder = db.GqlQuery("SELECT * FROM Order WHERE orderId = 1").get()
self.assertEqual(None,posOrder.courierId)
self.assertEqual('needPickup',posOrder.state)
posOrder = db.GqlQuery("SELECT * FROM Order WHERE orderId = 2").get()
self.assertEqual(None,posOrder.courierId)
self.assertEqual('needPickup',posOrder.state)
def order():
errors = []
if request.method == "POST":
try:
pizzaNames = request.form.getlist("itemName")
pizzaQuantities = request.form.getlist("itemQuantity")
pizzaPrices = request.form.getlist("itemPrice")
totalPrice = request.form.getlist("totalPrice")
orderData = {}
for i, pizza in enumerate(pizzaNames):
orderData[pizza] = {
"quantity": pizzaQuantities[i],
"price": pizzaPrices[i]
}
order = Order(user_id=current_user.id,
orderData=json.dumps(orderData),
total=float(totalPrice[0]))
db.session.add(order)
db.session.commit()
except Exception as error:
# errors.append(
# "Unable to add Order to database"
# )
# print(errors)
db.session.flush()
db.session.rollback()
print(error)
return redirect("/order")
else:
return render_template("order.html")
def order_update():
if not current_user.is_authenticated:
return jsonify({'message': 'Access Denied'}), 401
items = request.form['items']
u_id = int(current_user.id)
# Find open order
known_order = Order.query.filter_by(user_id=u_id, is_open=1).first()
if known_order is None:
# Create the order
known_order = Order()
known_order.create()
# Delete any exiting order items
known_order.items = []
for item in items:
order_item = OrderItem(item.product.id, item.quantity)
known_order.items.append(order_item)
db.session.add(known_order)
db.session.commit()
response = jsonify({'result': known_order.to_json()})
return response
def populate():
p1 = Person('Alice')
p2 = Person('Anamika')
p3 = Person('Annie')
p4 = Person('Anson')
p5 = Person('Bob')
p6 = Person('Carol')
p7 = Person('Don')
p8 = Person('Evi')
session.add_all([p1, p2, p3, p4, p5, p6, p7, p8])
orders = [(p1, 'veggies', 120), (p2, 'veggies', 20), (p3, 'veggies', 120),
(p4, 'veggies', 10), (p5, 'veggies', 280), (p1, 'ketchup', 80),
(p1, 'spices', 220), (p1, 'tissues', 50), (p1, 'notebooks', 90),
(p5, 'ketchup', 80)]
for person, name, price in orders:
order = Order(person, name, price)
session.add(order)
p1 = Project('BSNL billing', 'alice')
p2 = Project('BSNL payroll', 'bob')
p3 = Project('ABC Institute', 'bob')
pu1 = ProjectUser(p1, 'alice')
pu2 = ProjectUser(p1, 'carol')
pu3 = ProjectUser(p1, 'don')
pu4 = ProjectUser(p2, 'alice')
pu5 = ProjectUser(p2, 'carol')
pu6 = ProjectUser(p3, 'don')
pu7 = ProjectUser(p3, 'carol')
session.add_all([p1, p2, p3, pu1, pu2, pu3, pu4, pu5, pu6, pu7])
session.commit()
def confirm_order():
if len(session['items']) is 0:
flash('Cart is empty.')
return redirect(url_for('index'))
for i in session['items']:
product = Product.query.filter_by(id=i).first()
product.status = 'sold'
user = User.query.filter_by(id=product.user_id).first()
order = Order(product_id=product.id, title=product.title,description=product.description,
price=product.price, category=product.category, image_link=product.image_link, status='not_fulfiled',
buyer_id=current_user.id, seller_id=product.user_id, ad_fee_paid='No')
db.session.add(order)
db.session.commit()
body = 'Hi, {}!<br><br> You have found a buyer for the following item.<br><hr>{}<br>'.format(user.first_name,
product.title)
if product.ad_fee_paid == 'No':
fees = '<br>Since you have an outstanding balance of R10 on this ad, please settle as soon as possible to be' \
' able to interact with your buyer. Please note this is a once off fee. Once settled, you will be able to ' \
'interact with unlimited number of buyers for the item.'
else:
fees = '<br>Please find your buyer\'s info below.<br>First Name: {}<br>Last Name: {}<br>' \
'Email: {}<br>'.format(current_user.first_name, current_user.last_name, current_user.email)
body += fees
msg = Message('You\'ve got a buyer! | PyraSpace.com', sender='*****@*****.**', recipients=[user.email],
html=body)
send_email(app, msg)
session.pop('items')
flash('Order Successfully Placed! Please check your email ({}) for our email.'.format(current_user.email))
return redirect(url_for('index'))
def create_order():
user_authenticated_id = get_jwt_identity()
helper_id = request.form.get('helper_id')
description = request.form.get('description')
long_description = request.form.get('long_description')
order = Order(description=description,
long_description=long_description,
helper_id=helper_id,
status_id=1)
order.save()
documentURL = request.form.get('files')
if documentURL:
filename = 'Documents URL'
document = Document(name=filename,
url=documentURL,
order=order,
user_id=user_authenticated_id)
document.save()
DBManager.commitSession()
orderSerialized = order.serialize()
if orderSerialized:
new_order_mail(order.helper, order)
# Añadir los documentos al objeto
orderSerialized["documents"] = list(
map(lambda document: document.serialize(), order.documents))
return jsonify({"status": "ok", "order": orderSerialized})
def add_order_item():
data = request.get_json()
products = data['products']
total_price = 0
new_order_public_id = str(uuid.uuid4())
new_order = Order(
public_id=new_order_public_id,
customer_id=data['customer_id'],
store_id=data['store_id'],
date=datetime.datetime.utcnow(),
payment_method=data['payment_method'],
payment_confirmation_id=data['payment_confirmation_id']
)
print(new_order)
db.session.add(new_order)
db.session.commit()
for product in products:
new_product = OrderItem(
public_id=str(uuid.uuid4()),
product_id=product['product_id'],
quantity=product['quantity'],
price=product['price'],
order_obj=new_order
)
total_price = total_price + (product['quantity']*product['price'])
db.session.add(new_product)
db.session.commit()
new_order = Order.query.filter_by(public_id=new_order_public_id).first()
new_order.amount = total_price
db.session.commit()
return jsonify({'message': 'order created'})
def place_order(self, confirmation, menu):
"""
Places an (already confirmed) order for immediate delivery.
- parameter confirmation: The previously confirmed items requested.
- parameter menu: The menu where the order was placed.
- returns: An `Order` object that can be used to track the order.
Example
-------
>>> sprig = Sprig()
>>> sprig.login("Reflejo@gmail", "3x4mpl3")
>>> menu = sprig.menu()
>>> confirm = sprig.confirm(menu, {menu.items[0]: 1})
>>> sprig.place_order(confirm, menu)
<Order [address=home status=unstarted]>
"""
params = {
"meal_id": menu.meal_id,
"cart_id": confirmation.id,
"menu_id": menu.id,
"menu_tracker_id": menu.tracker_id,
"async": True,
"city": self.user.default_address.city,
"delivery_address_id": self.user.default_address.id,
}
order = self._request("order", params)
return Order(order)
def cart():
form = OrderForm()
data = []
sum = 0
selected_meals = {}
user = User.objects.filter(name='guest').first()
if 'data' in session:
data = session['data']
selected_meals = {int(key): int(value) for key, value in data.items() if value != 0 and key != ''}
meals = Meal.objects(__raw__={"meal_id": {"$in": list(selected_meals.keys())}})
data = []
for meal in meals:
sum += int(meal.price) * int(selected_meals[meal.meal_id])
data.append({'meal_id': meal.meal_id, 'title': meal.title,
'price': meal.price, 'qnt': selected_meals[meal.meal_id]})
if request.method == "POST":
if 'logged_in' in session and session['logged_in']:
form.name.data = session['name']
form.email.data = session["username"]
user = User.objects.filter(name=session['name']).first()
order = Order(date=datetime.now(), sum=sum, status='ordered', user=user,
phone=form.phone.data, address=form.address.data)
order.save()
user.orders.append(order)
user.save()
for key, value in selected_meals.items():
meal = MealWithCount(meal=Meal.objects.filter(meal_id=key).first(), count=value)
meal.save()
order.meals.append(meal)
order.save()
return redirect('/order_done/')
return render_template("cart.html", data=data, form=form)
def create_order():
"""
Creates an Order object based on the JSON posted
"""
check_content_type('application/json')
order = Order()
json_post = request.get_json()
order.deserialize(json_post)
order.save()
message = order.serialize()
current_order_id = message['id']
# Want to get the items from POST and create items associated with order
items = json_post['items']
items_response = []
for item_dict in items:
item = Item()
item.deserialize(item_dict, current_order_id)
item.save()
items_response.append(item.serialize())
message['items'] = items_response
# location_url = url_for('get_orders', order_id=order.id, _external=True)
return make_response(jsonify(message), status.HTTP_201_CREATED,
{
# 'Location': location_url
})
def createOrder():
orderType = Side[request.form['order_type'].upper()]
price = int(request.form['price'])
quantity = int(request.form['quantity'])
order = Order(session['username'], price, quantity, orderType)
orderBook.add(order)
return redirect('/')
def order_submit(request):
if request.method != 'POST':
return HttpResponseNotAllowed(['POST'])
market_abbrev = request.POST['market']
amount = float(request.POST['amount'])
market_order = ('market_order' in request.POST.keys)
price = float(request.POST['price'])
order_type = request.POST['type']
market = Market.objects.get(abbrev=market_abbrev)
order = Order()
order.market = market
order.amount = amount
order.type = order_type
if market_order:
order.market_order = True
else:
order.market_order = False
order.price = price
order.save()
market.market_api.api_execute_order(order)
return render_to_response('trader/json/success_plain.json',
content_type="application/json",
context_instance=RequestContext(request))
def postShoppingCart():
new_order = json.loads(request.data)
sales_tax = new_order["total"] * 0.05
order_number = random.randint(1, 99999999)
payment_id = random.randint(1, 99999999)
order = Order(order_number=order_number,
payment_id=payment_id,
total=new_order["total"],
sale_tax=sales_tax,
status=True,
client_id=new_order["client_id"])
db.session.add(order)
db.session.commit()
id_list = list(map(lambda item: item["id"], new_order["products"]))
product_list = db.session.query(Product).filter(Product.id.in_(id_list))
order_query = Order.query.filter_by(id=order.id).first()
for product in product_list:
order_query.products.append(product)
product_stock = Inventory.query.filter_by(
product_id=product['id']).update({
'supplier_stock_per_product':
Inventory.supplier_stock_per_product - product['quantity']
})
db.session.add(order_query)
db.session.commit()
return jsonify({"exitoso": order_query.serialize()}), 200
def track(self, last_computed_at=None):
"""
Returns the ongoing order which contains driver's information,
order status and ETAs.
- returns: An `Order` object containing driver's location and ETAs.
Example
-------
>>> sprig = Sprig()
>>> sprig.login("Reflejo@gmail", "3x4mpl3")
>>> order = sprig.track()
>>> order
<Order [address=home status=started]>
>>> order.driver_location
{u'latitude': 37.173097520694, u'longitude': -122.290945646912}
"""
address = self.user.default_address
params = {"city": address.city}
if last_computed_at:
params["last_computed_at"] = last_computed_at
order = self._request("track", query=params)
return Order(order)
def checkout(request, step=0):
if (request.method == 'POST'):
if request.user.is_authenticated():
now = datetime.datetime.utcnow().replace(tzinfo=utc)
current_user = request.user
current_order = Order(date_time=now, user=current_user)
current_order.save()
for i in range(1, 6):
print(request.POST)
try:
item_quantity = int(request.POST['item_quantity_' +
str(i)])
except:
item_quantity = None
if not item_quantity is None:
item_id = request.POST['item_options_' +
str(i)].split(' ')[1]
print(item_id)
current_sticker = Sticker.objects.get(pk=int(item_id))
print(current_sticker)
order_item = OrderItem(order=current_order,
sticker=current_sticker,
quantity=item_quantity)
order_item.save()
return redirect('/order/' + str(current_order.id) + '/1')
def create_order():
user_authenticated_id = get_jwt_identity()
helper_id = request.form.get('helper_id')
description = request.form.get('description')
order = Order(description=description, helper_id=helper_id, status_id=1)
order.save()
if os.environ.get('AWS_S3_BUCKET_NAME'):
files = request.files
for key in files:
file = files[key]
if file:
url_document = upload_file_to_s3(
file, os.environ.get('AWS_S3_BUCKET_NAME'))
if url_document:
document = Document(name=file.filename,
url=url_document,
order=order,
user_id=user_authenticated_id)
document.save()
else:
print("Faltan las credenciales de AWS")
DBManager.commitSession()
orderSerialized = order.serialize()
if orderSerialized:
new_order_mail(order.helper, order)
#Añadir los documentos al objeto
orderSerialized["documents"] = list(
map(lambda document: document.serialize(), order.documents))
return jsonify({"status": "ok", "order": orderSerialized})
