def test_update_order__non_existing_items(self):
item1 = Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=2,
category='scarpe',
)
item2 = Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=1,
category='accessori',
)
user = add_user('*****@*****.**', TEST_USER_PSW)
addr = add_address(user=user)
add_address(user=user, id='429994bf-784e-47cc-a823-e0c394b823e8')
order1 = Order.create(delivery_address=addr, user=user)
order1.add_item(item1, 2).add_item(item2)
order_item_before = [o.json() for o in OrderItem.select()]
# order_uuid = str(order1.uuid)
order = {
'relationships': {
'items': [{
'id': '577ad826-a79d-41e9-a5b2-7955bcf00000',
'type': 'item',
'quantity': 1
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf2222',
'type': 'item',
'quantity': 1
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf9999',
'type': 'item',
'quantity': 2
}],
'delivery_address': {
'type': 'address',
'id': '429994bf-784e-47cc-a823-e0c394b823e8'
},
'user': {
'type': 'user',
'id': '86ba7e70-b3c0-4c9c-8d26-a14f49360e47'
}
}
}
data = format_jsonapi_request('order', order)
path = 'orders/{}'.format(order1.uuid)
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'PATCH',
user.email, TEST_USER_PSW, 'application/json',
json.dumps(data))
order_item_after = [o.json() for o in OrderItem.select()]
assert resp.status_code == BAD_REQUEST
assert order_item_before == order_item_after
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 test_delete_order__success(self):
order1 = Order.create(
uuid=uuid.uuid4(),
total_price=10,
user=self.user1,
)
OrderItem.create(
order=order1.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
order2 = Order.create(
uuid=uuid.uuid4(),
total_price=12,
user=self.user1,
)
OrderItem.create(
order=order2.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
resp = self.app.delete('/orders/{}'.format(order1.uuid))
assert resp.status_code == NO_CONTENT
orders = Order.select()
assert len(orders) == 1
assert Order.get(Order.uuid == order2.uuid)
order_items = OrderItem.select().where(OrderItem.order_id == order1.id)
assert len(order_items) == 0
def order_item_create(id):
current_order = Order.query.filter(Order.id == id).first()
if current_order is None:
abort(404)
if current_order.stoptime and current_order.stoptime < datetime.now():
abort(404)
if current_user.is_anonymous() and not current_order.public:
flash('Please login to see this order.', 'info')
abort(401)
form = AnonOrderItemForm() if current_user.is_anonymous(
) else OrderItemForm()
form.populate(current_order.location)
if form.validate_on_submit():
item = OrderItem()
form.populate_obj(item)
item.order_id = id
if not current_user.is_anonymous():
item.user_id = current_user.id
else:
session['anon_name'] = item.name
db.session.add(item)
db.session.commit()
flash('Ordered %s' % (item.product.name), 'success')
return redirect(url_for('.order', id=id))
return order(id, form=form)
def test_get_orders(self):
order1 = Order.create(
uuid=uuid.uuid4(),
total_price=10,
user=self.user1.id,
)
OrderItem.create(
order=order1.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
order2 = Order.create(
uuid=uuid.uuid4(),
total_price=7,
user=self.user1.id,
)
OrderItem.create(
order=order2.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
resp = self.app.get('/orders/')
assert resp.status_code == OK
assert json.loads(resp.data.decode()) == [order1.json(), order2.json()]
def order_item_create(order_id: int) -> typing.Any:
# type is 'typing.Union[str, Response]', but this errors due to
# https://github.com/python/mypy/issues/7187
"Add item to order from id"
current_order = Order.query.filter(Order.id == order_id).first()
if current_order is None:
abort(404)
if current_order.stoptime and current_order.stoptime < datetime.now():
abort(404)
if current_user.is_anonymous() and not current_order.public:
flash("Please login to see this order.", "info")
abort(401)
form = AnonOrderItemForm() if current_user.is_anonymous() \
else OrderItemForm()
form.populate(current_order.location)
if form.validate_on_submit():
item = OrderItem()
form.populate_obj(item)
item.order_id = order_id
if not current_user.is_anonymous():
item.user_id = current_user.id
else:
session["anon_name"] = item.name
db.session.add(item)
db.session.commit()
flash("Ordered %s" % (item.product.name), "success")
return redirect(url_for("order_bp.order_from_id", order_id=order_id))
return order_from_id(order_id, form=form)
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 update(self, order_id, order_items):
order_items_dict = {}
for item in order_items:
if item.id:
order_items_dict[item.product_id] = OrderItem(
id=item.id,
product_id=item.product_id,
price=item.price,
quantity=item.quantity,
)
else:
order_items_dict[item.product_id] = OrderItem(
product_id=item.product_id,
price=item.price,
quantity=item.quantity,
)
# Step 1: Get current order
order = self.session.query(Order).filter_by(id=order_id).first()
order_update = order
_exist_items = []
_update_items = []
# Step 2: Update items data if exist
i = 0
for order_item in order.order_items:
_product_id = order_item.product_id
_exist_items.append(_product_id)
# Update order item data
if _product_id in order_items_dict:
_item = order_items_dict[_product_id]
order_update.order_items[i].quantity = _item.quantity
order_update.order_items[i].price = _item.price
order_items_dict[_product_id].id = order_item.id
_update_items.append(_product_id)
i = i + 1
# Step 3: Add new item if not exist
for _, orderItem in order_items_dict.items():
if not orderItem.id:
order_update.order_items.append(orderItem)
# Step 4: Delete items
_delete_items = list(set(_exist_items) - set(_update_items)) if len(
_exist_items) >= len(_update_items) else []
if len(_delete_items):
for order_item in order_update.order_items:
if order_item.product_id in _delete_items:
self.session.delete(order_item)
self.session.add(order_update)
self.session.commit()
self.session.refresh(order_update)
self.session.close()
return order.to_dict()
def create_tables():
User.create_table(fail_silently=True)
Item.create_table(fail_silently=True)
Address.create_table(fail_silently=True)
Order.create_table(fail_silently=True)
OrderItem.create_table(fail_silently=True)
Picture.create_table(fail_silently=True)
Favorite.create_table(fail_silently=True)
def put(self, uuid):
try:
order = (Order.select().where(Order.uuid == uuid).where(
Order.user == g.current_user).get())
except Order.DoesNotExist:
return None, NOT_FOUND
parser = reqparse.RequestParser()
parser.add_argument('items', type=is_valid_item_list, required=True)
args = parser.parse_args(strict=True)
total_price = 0
items = args['items']
uuid = [i[0] for i in items]
items_query = Item.select().where(Item.uuid << uuid)
if items_query.count() != len(items) or len(items) == 0:
return None, BAD_REQUEST
for item in items_query:
item_quantity = [x[1] for x in items if x[0] == str(item.uuid)][0]
total_price += float(item.price * item_quantity)
for item in items_query:
item_quantity = [x[1] for x in items if x[0] == str(item.uuid)][0]
if item_quantity > item.availability:
return None, BAD_REQUEST
with database.transaction():
temp_query = OrderItem.select().where(OrderItem.order == order.id)
for order_item in temp_query:
order_item.item.availability = (order_item.item.availability +
order_item.quantity)
order_item.item.save()
OrderItem.delete().where(OrderItem.order == order.id).execute()
for item in items_query:
item_quantity = [
x[1] for x in items if x[0] == str(item.uuid)
][0]
OrderItem.create(order=order,
item=item.id,
quantity=item_quantity,
subtotal=float(item.price * item_quantity))
item.availability = (item.availability - item_quantity)
item.save()
order.total_price = total_price
order.save()
return order.json(), OK
def create_tables():
database.connect()
# Create new table with the same name
Item.create_table()
User.create_table()
Address.create_table()
Order.create_table()
OrderItem.create_table()
Picture.create_table()
database.close()
def drop_tables():
database.connect()
# Initialize db by deleting all tables
Item.drop_table(fail_silently=True)
User.drop_table(fail_silently=True)
Address.drop_table(fail_silently=True)
Order.drop_table(fail_silently=True)
OrderItem.drop_table(fail_silently=True)
Picture.drop_table(fail_silently=True)
database.close()
def changeOrderItemStatus(request):
data = request.POST
pk = data['pk'];
instock = int(data['instock']);
orderitem = OrderItem.objects.get(pk = pk);
order = orderitem.order
orderitem.status = 'I'
if instock < orderitem.quantity:
new_order_item = OrderItem()
new_order_item.quantity = orderitem.quantity - instock
new_order_item.category = orderitem.category
new_order_item.description = orderitem.description
new_order_item.status = 'P'
new_order_item.order = orderitem.order
new_order_item.save()
inform_purchase_agent(subject='سفارش نیازمند خرید است',message=render_to_string('mail/buy_orderitem.html',{'orderitem' : new_order_item}))
if instock == 0:
orderitem.delete()
else:
orderitem.quantity = instock
orderitem.save()
inner_q = Good.objects.filter(category=orderitem.category,user=None)[:instock]
Good.objects.filter(pk__in = inner_q).update(user=order.user)
inform_user(user=order.user, message=render_to_string('mail/orderitem_available.html', {'orderitem': orderitem}),
subject='سفارش شما در انبار موجود است')
#check and change the status of the order
if OrderItem.objects.filter(order= order,status='N').count() == 0:
return HttpResponse('order_changed')
return HttpResponse("success")
def addOrder(request):
c = request.POST
tableData = json.loads( c['tableData']);
today = jDateField();
today = today.to_python(datetime.datetime.now())
order = Order(submitDate=today)
status = OrderItem.ORDER_ITEM_STATUS_CHOICES[0][0]
order.user = request.user
isforall = 'isforall' in request.POST and request.POST['isforall']
if request.user.is_superuser:
order.status = 'A'
if isforall:
status = 'P'
order.user = None
order.save()
#print tableData
for order_item in tableData:
#print order_item[2]
if order_item[3] == '':
category = None
else:
category = Category.objects.filter(pk=order_item[3])[0]
orderitem=OrderItem(order=order,
category=category,
quantity=int(order_item[1]),
description = order_item[4],
status= status #if it's admin and the order belongs to the public ..., if it's admin the order is accepted
)
orderitem.save()
if request.user.is_superuser and isforall:
inform_purchase_agent(subject='سفارش نیازمند خرید است',message=render_to_string('mail/buy_orderitem.html',{'orderitem' : orderitem}))
c = {'rlink' : '../../myorders/' , 'success' : "سفارش شما با موفقیت ثبت شد تا لحظاتی دیگر به فهرست سفارشاتتان خواهید رفت"}
if request.user.is_superuser:
if not isforall :
inform_warehouse_manager( message=render_to_string('mail/order_warehouse_manager.html', {'order': order}),
subject='سفارش نیازمند بررسی است')
else:
inform_admin('سفارش جدید', render_to_string('mail/order_added.html', {'order': order}))
return render_to_response("success.html",c);
def create_order(request,transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.status = Order.SUBMITTED
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.save()
# if the order save succeeded
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price() # now using @property
oi.product = ci.product
oi.save()
# all set, empty cart
cart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated():
from accounts import profile
profile.set(request)
# return the new order object
return order
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('user', type=is_valid_uuid, required=True)
parser.add_argument('items', type=is_valid_item_list, required=True)
args = parser.parse_args(strict=True)
try:
user = User.get(User.uuid == args['user'])
except User.DoesNotExist:
return None, BAD_REQUEST
if user != g.current_user:
return '', UNAUTHORIZED
total_price = 0
items = args['items']
items_uuid = [i[0] for i in items]
items_query = Item.select().where(Item.uuid << items_uuid)
if items_query.count() != len(items) or len(items) == 0:
return None, BAD_REQUEST
for item in items_query:
item_quantity = [x[1] for x in items if x[0] == str(item.uuid)][0]
total_price += float(item.price * item_quantity)
for item in items_query:
item_quantity = [x[1] for x in items if x[0] == str(item.uuid)][0]
if item_quantity > item.availability:
return None, BAD_REQUEST
with database.transaction():
order = Order.create(uuid=uuid.uuid4(),
total_price=total_price,
user=user.id)
for item in items_query:
item_quantity = [
x[1] for x in items if x[0] == str(item.uuid)
][0]
OrderItem.create(order=order,
item=item.id,
quantity=item_quantity,
subtotal=float(item.price * item_quantity))
item.availability = (item.availability - item_quantity)
item.save()
return order.json(), CREATED
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 test_modify_order__success(self):
order1 = self.create_order(self.user1)
order2 = self.create_order(self.user1)
start_availability = self.item2.availability
updates = {'items': json.dumps([[str(self.item2.uuid), 2]])}
resp = self.open_with_auth('/orders/{}'.format(order1.uuid),
'put',
self.user1.email,
'p4ssw0rd',
data=updates)
assert resp.status_code == OK
order1_upd = Order.get(Order.uuid == order1.uuid).json()
total_price = self.item2.price * 2
assert order1_upd['total_price'] == total_price
order2_db = Order.get(Order.uuid == order2.uuid).json()
assert order2_db == order2.json()
order1_items = OrderItem.select().where(OrderItem.order == order1)
assert len(order1_items) == 1
assert str(order1_items[0].item.uuid) == str(self.item2.uuid)
temp_item = Item.get(Item.uuid == self.item2.uuid)
assert temp_item.availability == (start_availability - 2)
def test_delete_order__success(self):
order1 = self.create_order(self.user1)
order2 = self.create_order(self.user1)
items_quantity = {
oi.item.uuid: (oi.item.availability, oi.quantity)
for oi in order1.order_items
}
resp = self.open_with_auth('/orders/{}'.format(str(order1.uuid)),
'delete',
self.user1.email,
'p4ssw0rd',
data='')
assert resp.status_code == NO_CONTENT
orders = Order.select()
assert len(orders) == 1
assert Order.get(Order.uuid == order2.uuid)
order_items = OrderItem.select().where(OrderItem.order == order1)
assert len(order_items) == 0
for item_uuid, (availability, quantity) in items_quantity.items():
item = Item.get(Item.uuid == item_uuid)
assert item.availability == availability + quantity
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 home_page():
form = Orders()
if form.validate_on_submit():
qty = form.orders.data
for order in range(qty):
qry = db.session.query(func.max(Order.number)).first()
if qry[0] is None:
id = 1
else:
id = qry[0] + 1
created_date = set_time(id)
order = Order(number=id, created_date=created_date)
db.session.add(order)
db.session.commit()
for item in range(1, (random.randint(1, max_product_number) + 1)):
prodcut_name = f"Товар - {item}"
order_id = id
product_price = random.randint(100, 9999)
amount = random.randint(1, 10)
order_item = OrderItem(product_name=prodcut_name,
order_id=order_id,
product_price=product_price,
amount=amount)
db.session.add(order_item)
db.session.commit()
flash(f'{qty} orders successfully created', 'success')
return render_template('home.html', form=form, title=title)
def test_delete_order__success_admin_not_own_order(self):
user = add_user('*****@*****.**', TEST_USER_PSW)
addr_A = add_address(user=user)
addr_B = add_address(user=user)
item1 = Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=2,
category='scarpe',
)
order1 = Order.create(delivery_address=addr_A, user=user)
order1.add_item(item1, 2)
order2 = Order.create(delivery_address=addr_B, user=user)
user_B = add_admin_user('*****@*****.**', TEST_USER_PSW)
path = 'orders/{}'.format(order1.uuid)
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'DELETE',
user_B.email, TEST_USER_PSW, None, None)
assert resp.status_code == NO_CONTENT
assert len(Order.select()) == 1
assert len(OrderItem.select()) == 0
assert Order.get(uuid=order2.uuid)
def create_order(request, order_total, transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.status = Order.SUBMITTED
order.user = None
# order.order_total = order_total
order_total.purchased = True
if request.user.is_authenticated():
order.user = request.user
from accounts import profile
user_profile = profile.get_profile(request)
# verificar si campos requeridos estan vacios, si lo estan crear un user_profile para este usuario desde
# aqui, asi no tendria q escribirlo en el form UserProfileForm
if not user_profile.email or not user_profile.shipping_name or user_profile.shipping_city == 0:
profile.set_profile(request)
order.save()
order_total.order = order
order_total.save()
# if the order save succeeded
if order.pk:
# verificar si el usuario tuvo la promo4, para eliminarla
try:
promo4_id = request.session['promo4_id']
del request.session['promo4_id']
promo4 = Promo4.objects.get(id=promo4_id)
promo4.active = False
promo4.save()
except KeyError:
pass
try: # eliminar el codigo de promoion para el usuario
promo_id = request.session['promo3_id']
del request.session['promo3_id']
Promo3.objects.get(id=promo_id).delete()
except KeyError:
pass
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price() # now using @property
oi.product = ci.product
# disminuir del almacen la cant disponible para este prod
ci.product.quantity -= ci.quantity
ci.product.save()
oi.save()
# all set, empty cart
cart.empty_cart(request)
# utils.send_email("Leoshop", "Gracias por preferirnos", user_profile.email)
# return the new order object
return order
def create_charge():
post_data = request.get_json()
amount = round(float(post_data.get('total').strip("$")) * 100)
current_cart = session.get("cart", {})
products = db_session.query(RetailProduct).join(Product).filter(
RetailProduct.id.in_(current_cart.keys()))
id_to_prod = {}
distributor_id = None
for product in products:
if not distributor_id:
distributor_id = product.distributor_id
id_to_prod[product.id] = product
grand_total = 0
for prod_id, qty in current_cart.items():
retail_prod = id_to_prod[prod_id]
price = retail_prod.price
grand_total += price * qty
if grand_total != amount:
return {"something went wrong"}, 400
stripe.api_key = 'sk_test_ZIhkqTdUPX3vIAjGbvgKSBj900rIS9blAJ'
charge = stripe.Charge.create(amount=amount,
currency='usd',
card=post_data.get('token'),
description="order")
response_object = {'status': 'success', 'charge': charge}
user = session["user"]
if charge.status == 'succeeded':
order = Order(distributor_id=distributor_id,
submitted_at=datetime.datetime.now(),
payed_at=datetime.datetime.now(),
name=user['fllname'],
email=user['email'],
zip=user['zipcode'],
address='1 main',
city='Spokane',
state='WA',
phone='44455566')
db_session.add(order)
db_session.commit()
for prod_id, qty in current_cart.items():
retail_prod = id_to_prod[prod_id]
price = retail_prod.price
oi = OrderItem(order_id=order.id,
purchase_price=price,
qty=qty,
retail_product_id=prod_id)
db_session.add(oi)
db_session.commit()
session["cart"] = {}
return jsonify(response_object), 200
def create_order(request, transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST, instance = order)
order = checkout_form.save(commit = False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
# if the order save succeeded
if order.pk:
cart_items = shoppingcart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price
oi.product = ci.product
oi.save()
# all set, empty card
shoppingcart.empty_cart(request)
# save profile info for future orders
if request.user.is_authenticated():
from accounts import profile
profile.set(request)
# return the new order object
return order
def order_add_item():
api_key = request.headers.get('Authorization')
response = UserClient.get_user(api_key)
if not response:
return make_response(jsonify({'message': 'Not logged in'}), 401)
user = response['result']
p_id = int(request.form['product_id'])
qty = int(request.form['qty'])
u_id = int(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.is_open = True
known_order.user_id = u_id
order_item = OrderItem(p_id, qty)
known_order.items.append(order_item)
else:
found = False
# Check if we already have an order item with that product
for item in known_order.items:
if item.product_id == p_id:
found = True
item.quantity += qty
if found is False:
order_item = OrderItem(p_id, qty)
known_order.items.append(order_item)
db.session.add(known_order)
db.session.commit()
response = jsonify({'result': known_order.to_json()})
return response
def create_order(request,transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST, instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.ip_address = request.META.get('REMOTE_ADDR')
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price
oi.product = ci.product
oi.save()
cart.empty_cart(request)
if request.user.is_authenticated():
from accounts import profile
profile.set(request)
return order
def create_order(request ,transaction_id):
order = Order()
checkout_form = CheckoutForm(request.POST , instance=order)
order = checkout_form.save(commit=False)
order.transaction_id = transaction_id
order.user = None
if request.user.is_authenticated():
order.user = request.user
order.status = Order.SUBMITTED
order.save()
# if the order saved succeeded
if order.pk:
cart_items =cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price() # now using @property
oi.product = ci.product
oi.save()
# all set empty cart
cart.deduct_quantity(request)
# save the profile for future orders
if request.user.is_authenticated():
from accounts import profile
profile.set(request)
# return the new order object
return order
def drops_all_tables(database):
"""Doesn't drop unknown tables."""
tables = database.get_tables()
for table in tables:
if table == 'item':
Item.drop_table()
if table == 'order':
Order.drop_table()
if table == 'user':
User.drop_table()
if table == 'orderitem':
OrderItem.drop_table()
if table == 'address':
Address.drop_table()
if table == 'picture':
Picture.drop_table()
if table == 'favorite':
Favorite.drop_table()
def test_create_order__success(self):
Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=4,
category='scarpe',
)
Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=10,
category='accessori',
)
user = add_user('*****@*****.**',
TEST_USER_PSW,
id='e736a9a6-448b-4b92-9e38-4cf745b066db')
add_address(user=user, id='8473fbaa-94f0-46db-939f-faae898f001c')
order = {
'relationships': {
'items': [{
'id': '429994bf-784e-47cc-a823-e0c394b823e8',
'type': 'item',
'quantity': 4
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf03499',
'type': 'item',
'quantity': 10
}],
'delivery_address': {
'type': 'address',
'id': '8473fbaa-94f0-46db-939f-faae898f001c'
},
'user': {
'type': 'user',
'id': 'e736a9a6-448b-4b92-9e38-4cf745b066db'
}
}
}
data = format_jsonapi_request('order', order)
path = 'orders/'
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'POST',
user.email, TEST_USER_PSW, 'application/json',
json.dumps(data))
assert resp.status_code == CREATED
assert len(Order.select()) == 1
assert len(OrderItem.select()) == 2
order = Order.get()
expected_result = EXPECTED_RESULTS['create_order__success']
assert_valid_response(resp.data, expected_result)
def test_create_order__failure_user_auth(self):
Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=4,
category='scarpe',
)
Item.create(
uuid='577ad826-a79d-41e9-a5b2-7955bcf03499',
name='GINO',
price=30.20,
description='svariati GINIIIII',
availability=10,
category='scarpe',
)
user = add_user('*****@*****.**',
TEST_USER_PSW,
id='e736a9a6-448b-4b92-9e38-4cf745b066db')
other_user = add_user('*****@*****.**',
TEST_USER_PSW,
id='d41ad9db-9d60-45c6-9fa6-51f66cd3d99a')
add_address(user=user, id='8473fbaa-94f0-46db-939f-faae898f001c')
order = {
'relationships': {
'items': [{
'id': '429994bf-784e-47cc-a823-e0c394b823e8',
'type': 'item',
'quantity': 4
}, {
'id': '577ad826-a79d-41e9-a5b2-7955bcf03499',
'type': 'item',
'quantity': 10
}],
'delivery_address': {
'type': 'address',
'id': '8473fbaa-94f0-46db-939f-faae898f001c'
},
'user': {
'type': 'user',
'id': str(other_user.uuid)
}
}
}
data = format_jsonapi_request('order', order)
path = 'orders/'
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'POST',
user.email, TEST_USER_PSW, 'application/json',
json.dumps(data))
assert resp.status_code == UNAUTHORIZED
assert len(Order.select()) == 0
assert len(OrderItem.select()) == 0
def create_order(self, user=None, items=None):
'''Parameter format:
items = [
[Instance of Item, quantity],
...
[instance of item, quantity]
]
user = Instance of User
'''
if not user:
user = self.create_user()
if not items:
items = []
for i in range(2):
item = self.create_item()
items.append([item, i + 1])
total_price = 0
for item in items:
total_price += float(item[0].price * item[1])
order = Order.create(
uuid=uuid.uuid4(),
total_price=total_price,
user=user
)
for item in items:
item_quantity = item[1]
item = item[0]
OrderItem.create(
order=order,
item=item,
quantity=item_quantity,
subtotal=float(item.price * item_quantity)
)
return order
def post(self, request, *args, **kwargs):
try:
restaurant = Restaurant.objects.get(pk=kwargs['pk'])
# cookie = COOKIES.get('dishes')
except ObjectDoesNotExist:
return render(request,'Customer/restaurant_detail.html')
# return HttpResponse('NO restaurant found.', status=status.HTTP_404_NOT_FOUND)
dishNameList = request.POST.getlist("dishName")
dishPriceList = request.POST.getlist("dishPrice")
dishQuantityList = request.POST.getlist("dishQ")
tempOrderList = []
totalPrice = 0
for i in range(0, len(dishNameList)):
if(int(str(dishQuantityList[i])) > 0):
oneDish = {}
oneDish['dishName'] = str(dishNameList[i])
oneDish['dishPrice'] = float(str(dishPriceList[i])[1:])
oneDish['dishQuantity'] = int(str(dishQuantityList[i]))
totalPrice = totalPrice + float(str(dishPriceList[i])[1:]) * int(str(dishQuantityList[i]))
tempOrderList.append(oneDish)
location = request.POST.get("location")
deli_type = 1
if(location == ""):
deli_type = 0
order = Order(restaurant = Restaurant.objects.get(pk=kwargs['pk']), buyer = request.user, time = datetime.datetime.now(), location = location, delivery_type = deli_type, total_price = totalPrice, discount = 0, paid = False)
order.save()
for item in tempOrderList:
orderItem = OrderItem(Order = order, Dish = Dish.objects.get(name = item['dishName']), restaurant = Restaurant.objects.get(pk=kwargs['pk']), number = item['dishQuantity'])
orderItem.save()
response = HttpResponseRedirect('/%d/complete' %restaurant.pk)
response.delete_cookie('dishes')
return response
def test_modify_order__success(self):
order1 = Order.create(
uuid=uuid.uuid4(),
total_price=10,
user=self.user1.id,
)
OrderItem.create(
order=order1.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
order2 = Order.create(
uuid=uuid.uuid4(),
total_price=12,
user=self.user1.id,
)
OrderItem.create(
order=order2.id,
item=self.item1.id,
quantity=1,
subtotal=self.item1.price,
)
updates = {'items': json.dumps([[self.item2.uuid, 2]])}
resp = self.app.put('/orders/{}'.format(order1.uuid), data=updates)
assert resp.status_code == OK
order1_upd = Order.get(Order.uuid == order1.uuid).json()
total_price = self.item2.price * 2
assert order1_upd['total_price'] == total_price
order2_db = Order.get(Order.uuid == order2.uuid).json()
assert order2_db == order2.json()
order1_items = OrderItem.select().where(
OrderItem.order_id == order1.id)
assert len(order1_items) == 1
assert str(order1_items[0].item.uuid) == self.item2.uuid
def order_add_item():
if not current_user.is_authenticated:
return jsonify({'message': 'Access Denied'}), 401
p_id = int(request.form['product_id'])
qty = int(request.form['qty'])
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.is_open = True
known_order.user_id = u_id
order_item = OrderItem(p_id, qty)
known_order.items.append(order_item)
else:
found = False
# Check if we already have an order item with that product
for item in known_order.items:
if item.product.id == p_id:
found = True
item.quantity += qty
if found is False:
order_item = OrderItem(p_id, qty)
known_order.items.append(order_item)
db.session.add(known_order)
db.session.commit()
response = jsonify({'result': known_order.to_json()})
return response
def test_update_order__failure_availability(self, mocker):
mocker.patch('views.orders.database', new=self.TEST_DB)
user = add_user('*****@*****.**',
TEST_USER_PSW,
id='90c3e1c1-b51c-4224-b69d-17f84f6a8dfc')
addr = add_address(user=user,
id='8f3b518e-9c17-4103-9a47-b274740726e7')
item = Item.create(
uuid='429994bf-784e-47cc-a823-e0c394b823e8',
name='mario',
price=20.20,
description='svariati mariii',
availability=4,
category='scarpe',
)
order = Order.create(
delivery_address=addr,
user=user,
).add_item(item, 2)
update_order = {
'relationships': {
'items': [{
'id': '429994bf-784e-47cc-a823-e0c394b823e8',
'type': 'item',
'quantity': 5
}]
}
}
post_data = format_jsonapi_request('order', update_order)
path = 'orders/{}'.format(order.uuid)
resp = open_with_auth(self.app, API_ENDPOINT.format(path), 'PATCH',
'*****@*****.**', TEST_USER_PSW,
'application/json', json.dumps(post_data))
assert resp.status_code == BAD_REQUEST
assert OrderItem.select().count() == 1
assert OrderItem.get() == order.order_items[0]
assert order.order_items[0].quantity == 2
def add_order(request):
#TODO: do a create order
if request.method == 'POST':
if 'payment_type' in request.POST:
if request.POST['payment_type'] == 'card':
summ = request.POST['total']
template = loader.get_template("add_order.html")
context = RequestContext(request, {'summary': summ})
return HttpResponse(template.render(context))
elif 'order' in request.POST:
baskets = Basket.objects.filter(
basket_id=request.session.session_key)
order = Orders()
if request.user.is_authenticated():
order.owner = request.user
order.order_id = baskets[0].order_number
order.total_cost = float(request.POST['total'])
order.address = request.POST['address']
order.comments = request.POST['comments']
order.billing_card = request.POST['billing_card']
order.billing_number = request.POST['billing_number']
order.billing_name = request.POST['billing_name']
order.billing_date_mm = request.POST['billing_date_mm']
order.billing_date_yy = request.POST['billing_date_yy']
order.billing_cvv = request.POST['billing_cvv']
order.save()
for basket in baskets:
orderitems = OrderItem()
orderitems.order_id_id = order.order_id
orderitems.order_sess = basket.basket_id
orderitems.goods = basket.item
orderitems.quantity = basket.quantity
orderitems.total_price_per_goods = basket.sum_total
orderitems.partnumber = basket.partnumber
order.orderitem_set.add(orderitems)
orderitems.save()
order.save()
template = loader.get_template("order_success.html")
context = RequestContext(request, {'order_id': order.pk})
return HttpResponse(template.render(context))
def create_order(request):
""" function that takes a POST request and adds a product instance to the current customer's shopping cart """
print('create_order!!!!')
post_data = request.POST.copy()
cart_items = cart.get_cart_items(request)
order = Order()
username = request.session['username']
custom_user = Customer.objects.get(
user = User.objects.get(
username = request.session['username']))
order.user = custom_user
order.email = post_data.get('email',1)
order.phone = post_data.get('phone',1)
order.ip_address = request.META.get('REMOTE_ADDR')
order.save()
for cart_item in cart_items:
product = OrderItem()
product.order = order
product.product = cart_item.product
product.quantity = cart_item.quantity
product.save()
cart.empty_cart(request)
print_order(order.id)
return order
def order_item_create(id):
current_order = Order.query.filter(Order.id == id).first()
if current_order is None:
abort(404)
if current_order.stoptime and current_order.stoptime < datetime.now():
abort(404)
if current_user.is_anonymous() and not current_order.public:
flash('Please login to see this order.', 'info')
abort(401)
form = AnonOrderItemForm() if current_user.is_anonymous() else OrderItemForm()
form.populate(current_order.location)
if form.validate_on_submit():
item = OrderItem()
form.populate_obj(item)
item.order_id = id
if not current_user.is_anonymous():
item.user_id = current_user.id
else:
session['anon_name'] = item.name
db.session.add(item)
db.session.commit()
flash('Ordered %s' % (item.product.name), 'success')
return redirect(url_for('.order', id=id))
return order(id, form=form)
def add_order(request):
#TODO: do a create order
if request.method == 'POST':
if 'payment_type' in request.POST:
if request.POST['payment_type'] == 'card':
summ = request.POST['total']
template = loader.get_template("add_order.html")
context = RequestContext(request, {'summary': summ})
return HttpResponse(template.render(context))
elif 'order' in request.POST:
baskets = Basket.objects.filter(basket_id=request.session.session_key)
order = Orders()
if request.user.is_authenticated():
order.owner = request.user
order.order_id = baskets[0].order_number
order.total_cost = float(request.POST['total'])
order.address = request.POST['address']
order.comments = request.POST['comments']
order.billing_card = request.POST['billing_card']
order.billing_number = request.POST['billing_number']
order.billing_name = request.POST['billing_name']
order.billing_date_mm = request.POST['billing_date_mm']
order.billing_date_yy = request.POST['billing_date_yy']
order.billing_cvv = request.POST['billing_cvv']
order.save()
for basket in baskets:
orderitems = OrderItem()
orderitems.order_id_id = order.order_id
orderitems.order_sess = basket.basket_id
orderitems.goods = basket.item
orderitems.quantity = basket.quantity
orderitems.total_price_per_goods = basket.sum_total
orderitems.partnumber = basket.partnumber
order.orderitem_set.add(orderitems)
orderitems.save()
order.save()
template = loader.get_template("order_success.html")
context = RequestContext(request, {'order_id': order.pk})
return HttpResponse(template.render(context))
def test_order_item(self): orderItem = OrderItem(sticker=self.sticker, order=self.order) orderItem.save() self.assertEqual(orderItem, OrderItem.objects.get(order=self.order.id))
def create_order(request, postdata):
order = Order()
# order.user = None
# if request.user.is_authenticated():
# order.user = request.user
# данные с формы
data = {
u"Имя": postdata["first-name"],
u"Фамилия": postdata["last-name"],
u"Email": postdata["email"],
u"Телефон": postdata["phone"],
u"Время звонка": postdata["call-time"],
u"Область": postdata["region"],
u"Город": postdata["city"],
u"Улица": postdata["street"],
u"Дом": postdata["building"],
u"Квартира": postdata["flat"],
u"Способ доставки": postdata["ship-method"],
u"Номер склада (адрес офиса)": postdata["warehouse"],
u"Комментарий к заказу": postdata["comment"],
u"Дополнительная информация": postdata["additional_info"],
}
# добавление данных в модель заказа
order.first_name = data[u"Имя"]
order.last_name = data[u"Фамилия"]
order.email = data[u"Email"]
order.phone = data[u"Телефон"]
order.call_time = data[u"Время звонка"]
order.region = data[u"Область"]
order.city = data[u"Город"]
order.street = data[u"Улица"]
order.building = data[u"Дом"]
order.flat = data[u"Квартира"]
order.ship_method = data[u"Способ доставки"]
order.office = data[u"Номер склада (адрес офиса)"]
order.additional_info = data[u"Дополнительная информация"]
order.comment = data[u"Комментарий к заказу"]
order.ip_address = request.META.get("REMOTE_ADDR")
order = Order(**data)
order.status = order.SUBMITTED
order.save()
# отправка почты менеджеру
send_mail_manager(data, order)
# отправка почты заказчкику
if data[u"Email"] != "":
send_mail_customer(data, order)
# if the order save succeeded
if order.pk:
cart_items = cart.get_cart_items(request)
for ci in cart_items:
# create order item for each cart item
oi = OrderItem()
oi.order = order
oi.quantity = ci.quantity
oi.price = ci.price # now using @property
oi.product = ci.product
oi.save()
# all set, empty cart
cart.empty_cart(request)
