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 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 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 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 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 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 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_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 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 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, 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 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 create(self, order_items):
order = Order(order_items=[
OrderItem(
product_id=order_item.product_id,
price=order_item.price,
quantity=order_item.quantity,
) for order_item in order_items
])
self.session.add(order)
self.session.commit()
self.session.refresh(order)
self.session.close()
return order.to_dict()
def handle_order_item():
# POST request
if request.method == 'POST':
body = request.get_json()
user1 = OrderItem(order_id=body['order_id'],
product_id=body['product_id'],
quantity=body['quantity'],
unit_price=body['unit_price'],
special_instructions=body['special_instructions'])
db.session.add(user1)
db.session.commit()
return "ok", 200
# GET request
if request.method == 'GET':
all_people = OrderItem.query.all()
all_people = list(map(lambda x: x.serialize(), all_people))
return jsonify(all_people), 200
return "Invalid Method", 404
def orders():
print(request.form)
if "user_id" not in session:
return redirect("/")
order = None
if not "curr_order" in session:
order = Order(user_id=session["user_id"])
db.session.add(order)
db.session.commit()
session["curr_order"] = order.id
else:
order = Order.query.get(session["curr_order"])
for item in request.form:
item_id = int(item.split("_")[0])
new_item = OrderItem(product_id=item_id, order_id=order.id, qty=request.form[item])
db.session.add(new_item)
db.session.commit()
return redirect("/orders/confirmation")
def add_item_to_cart(item_id, order_id):
#Grab quantity num from HTML form on previous page, if any,
#and convert to integer
quantity = int(request.form.get('quantity'))
check_orders = OrderItem.query.filter(
OrderItem.order_id == order_id).filter(
OrderItem.item_id == item_id).first()
## todo: fix
if check_orders:
check_orders.quantity += quantity
db.session.commit()
else:
item_to_add = OrderItem(item_id=item_id,
order_id=order_id,
quantity=quantity)
db.session.add(item_to_add)
db.session.commit()
return redirect('/')
def cart(self):
item = self.get_argument('item')
cart_id = self.get_cookie('cart_id')
user = self.get_cookie('user')
if not cart_id:
c = Cart(user_id = user)
db_session.add(c)
db_session.commit()
self.set_cookie('cart_id', '%d' % c.id)
cart_id = c.id
cart = Cart.query.filter_by(id = int(cart_id)).one()
# print "----", cart_id
if item:
product = Product.query.filter_by(id = int(item)).one()
qty = self.get_argument('qty')
a = OrderItem.query.filter_by(cart_id = int(cart.id), item_id = int(product.id)).first()
if a:
a.qty = qty
else: a = OrderItem(item_id = product.id, cart_id=int(cart.id), qty = qty)
db_session.add(a)
db_session.commit()
def perform(self, vendor_id=None, docs=None):
amazon = Vendor.query.filter_by(name='Amazon').one()
for doc in docs:
order_number = doc.pop('order_number')
vendor_sku = doc.pop('msku')
fnsku = doc.pop('fnsku')
# Get the order
order = Order.query.filter_by(source_id=vendor_id, dest_id=amazon.id, order_number=order_number).first() \
or Order(source_id=vendor_id, dest_id=amazon.id, order_number=order_number)
db.session.add(order)
# Get the listings
listing = Listing.query.filter_by(vendor_id=order.source_id,
sku=vendor_sku).one()
amz_listing = Listing.query.filter(
Listing.vendor_id == amazon.id,
Listing.extra['fnsku'].astext == fnsku).one()
# Get the inventories
src_inv = listing.inventory
dest_inv = Inventory.query.filter_by(listing_id=amz_listing.id, owner_id=listing.vendor.id).first() \
or Inventory(listing=amz_listing, owner=listing.vendor)
db.session.add(dest_inv)
# Get the order item
item = OrderItem.query.filter_by(order_id=order.id, source_id=src_inv.id, dest_id=dest_inv.id).first() \
or OrderItem(order=order, source=src_inv, destination=dest_inv)
item.update(doc)
# If this is a new order item, send_inventory()
if item.id is None:
item.send_inventory()
db.session.add(item)
db.session.commit()
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 orders():
print(request.form)
if "user_id" not in session:
return redirect("/")
# get current order, or make new one
order = None
if not "curr_order" in session:
order = Order(user_id=session["user_id"])
db.session.add(order)
db.session.commit()
session["curr_order"] = order.id
else:
order = Order.query.get(session["curr_order"])
# create order items from form
for item in request.form:
# split id from key with .split("_")
item_id = int(item.split("_")[0])
new_item = OrderItem(product_id=item_id, order_id=order.id, qty=request.form[item])
db.session.add(new_item)
db.session.commit()
return redirect("/orders/confirmation")
def perform(self, vendor_id=None, order_id=None, items=None):
amazon = Vendor.query.filter_by(name='Amazon').one()
vendor = Vendor.query.filter_by(id=vendor_id).one()
for item_doc in items:
sku = item_doc['sku']
amz_listing = Listing.query.filter_by(vendor_id=amazon.id, sku=sku).first() \
or Listing(vendor=amazon, sku=sku)
item = OrderItem.query.filter(
OrderItem.order_id == order_id,
OrderItem.extra['order_item_id'].astext
== item_doc['order_item_id']).first() or OrderItem(
order_id=order_id)
item.quantity = item_doc.pop('qty_shipped')
item.received = item.quantity
item.source = Inventory.query.filter_by(owner_id=vendor.id, listing_id=amz_listing.id).first() \
or Inventory(owner=vendor, listing=amz_listing)
item.destination = None
item.update(item_doc)
db.session.add(item)
db.session.commit()
def place_order():
""" Place order for delivery for the items currently in the user's cart"""
session = connect()
try:
user_id = current_user.id
except AttributeError:
return "Error getting user ID"
# Query for cart contents
items = session.query(Cart).filter_by(user_id=user_id).all()
# Redirect user if no items in order
if not items:
flash("No items in order!")
return redirect(url_for('show_cart'))
# Make sure customer's address is valid
address = get_address(current_user.address_id)
destination = get_address_string(address)
if validate_address(destination) is False:
flash("Address is invalid or outside delivery radius!")
return redirect(url_for('show_cart'))
# Create new entry in order table
order_time = datetime.datetime.now()
delivery_time = order_time + datetime.timedelta(0, get_delivery_time())
new_order = Order(user_id=user_id,
order_time=order_time,
delivery_time=delivery_time)
session.add(new_order)
order = session.query(Order).filter_by(order_time=order_time).one()
# Add each item to order_item table and remove from cart
for i in items:
order_item = OrderItem(order_id=order.id,
menu_item_id=i.menu_item_id,
quantity=i.quantity)
session.add(order_item)
session.delete(i)
session.commit()
ordered_items = session.query(OrderView).filter_by(order_id=order.id).all()
# Calculate totals
subtotal = 0.0
for item in ordered_items:
subtotal += float(item.price) * item.quantity
if subtotal > 0:
fee = DELIVERY_FEE
else:
fee = 0
tax = (subtotal + fee) * 0.07
total = subtotal + fee + tax
subtotal = "{0:.2f}".format(subtotal)
fee = "{0:.2f}".format(fee)
tax = "{0:.2f}".format(tax)
total = "{0:.2f}".format(total)
# Convert delivery time to EST and format for display
delivery_time = delivery_time - datetime.timedelta(hours=4)
delivery_time = delivery_time.strftime('%I:%M %p')
# Form URL for delivery map
origin = encode_string(RESTAURANT_ADDRESS)
destination = encode_string(destination)
map_url = 'https://www.google.com/maps/embed/v1/directions?origin='
map_url += origin
map_url += '&destination='
map_url += destination
map_url += '&key='
map_url += APP_KEY
return render_template('orderComplete.html',
delivery_time=delivery_time,
items=ordered_items,
subtotal=subtotal,
fee=fee,
tax=tax,
total=total,
map_url=map_url,
title="Order Complete")
def checkout():
form = OrderForm(request.form)
if request.method == 'POST' and form.validate():
tran = Transaction()
form.populate_obj(tran)
tran.type = 'order'
tran.total_amount = session['all_total_price']
tran.payment_status = 'unpaid'
tran.save()
tran.generate_txn_number()
if 'discount_id' in session:
tran.discount_id = session['discount_id']
tran.discounted_amount = session['discounted_price']
tran.save()
# save order items
for key, product in session['cart_item'].items():
# check if there is an existing order
order = Order.query.filter_by(
transaction_id=tran.id,
registry_id=product['registry_id'],
registry_type=product['registry_type']).first()
if not order:
order = Order()
order.registry_id = product['registry_id']
order.registry_type = product['registry_type']
order.transaction_id = tran.id
order.status = 'pending'
order.save()
order.generate_order_number()
order.save()
item = OrderItem(order_id=order.id,
reg_product_id=key,
quantity=product['quantity'],
unit_price=product['unit_price'],
total_price=product['total_price'])
item.save()
# initialize payments
paystack = PaystackPay()
amount = tran.discounted_amount if tran.discounted_amount else tran.total_amount
response = paystack.fetch_authorization_url(email=tran.email,
amount=amount)
if response.status_code == 200:
json_response = response.json()
tran.update(payment_txn_number=json_response['data']['reference'])
return redirect(json_response['data']['authorization_url'])
else:
flash('Something went wrong. Please try again', 'error')
return redirect(url_for('.checkout'))
products = session['cart_item']
return render_template('frontend/checkout.html',
form=form,
products=products)
async def _handler_function(self, request):
remote_ip = request.transport.get_extra_info('peername')
if request.body_exists:
# Checking possible user_id and shop_id errors and responding accordingly
data = await request.post()
if len(data) == 0:
try:
data = await request.json()
except json.decoder.JSONDecodeError:
logger.info(
f'Remote ip {remote_ip} tried to make an order with the following data:'
f' "{await request.text()}". Failed. Some error occurred'
)
return self._create_response(
422, {'error': 'Unable to process submitted data.'})
failed_log_string = f'Remote ip {remote_ip} tried to make an order with the following data: ' \
f'"{dict(data)}". Failed. '
try:
user_id = int(data.get('user_id'))
if user_id < 1:
raise ValueError
except (ValueError, TypeError):
logger.info(failed_log_string +
'Some error in "user_id" field occurred.')
return self._create_response(
400,
{'error': '"user_id" parameter is in the wrong format.'})
# Checking possible books errors and responding accordingly
books = data.get('books')
if books is None:
logger.info(failed_log_string + '"books" field wa not found.')
return self._create_response(
400, {'error': '"books" field is required.'})
try:
books_json = json.loads(books)
# Checking if all shops from the request are present
# and creating book_ids dict with shop ids as keys and available books as values
shop_ids = set([int(book['shop_id']) for book in books_json])
shops = self.session.query(shop_book_association_table).filter(
shop_book_association_table.c.shop_id.in_(shop_ids))
book_ids = {}
for shop_id, book_id in shops:
if shop_id in book_ids:
book_ids[shop_id].append(book_id)
else:
book_ids[shop_id] = [book_id]
if len(shop_ids) != len(book_ids):
logger.info(
failed_log_string +
'Some (or all) of the shops could not be identified.')
return self._create_response(
400, {'error': 'Unable to identify all of the shops.'})
# Creating books_dict that contains shop and book ids as keys and quantity as values
books_dict = {}
for book in books_json:
if book['id'] not in book_ids[book['shop_id']]:
logger.info(
failed_log_string +
'Book with id={book["id"]} is not available '
'at the store with id={book["shop_id"]}.')
return self._create_response(
400, {
'error':
f'Book with id={book["id"]} is not available '
f'at the store with id={book["shop_id"]}.'
})
quantity = int(book['quantity'])
if quantity < 1:
logger.info(
failed_log_string +
f'Quantity for book with id={book["id"]} is less than one.'
)
return self._create_response(
400,
{'error': '"quantity" can\'t be less than one.'})
shop_book_str = f"{book['shop_id']}:{book['id']}"
if shop_book_str not in books_dict:
books_dict[shop_book_str] = quantity
else:
books_dict[shop_book_str] += quantity
except (json.decoder.JSONDecodeError, KeyError, ValueError):
logger.info(failed_log_string +
f'Some error in "books" field occurred.')
return self._create_response(
400,
{'error': '"books" parameter is in the wrong format.'})
# Creating new order object
order = Order(reg_date=date.today(), user_id=user_id)
self.session.add(order)
try:
self.session.flush()
except IntegrityError:
logger.info(
failed_log_string +
f'Some error occurred while trying to create an order.')
return self._create_response(400,
{'error': 'Some error occurred.'})
# Creating order items objects for previously created order
order_items = []
for shop_book_id, book_quantity in books_dict.items():
shop_id, book_id = shop_book_id.split(':')
order_items.append(
OrderItem(order_id=order.id,
book_id=book_id,
shop_id=shop_id,
book_quantity=book_quantity))
self.session.add_all(order_items)
# Committing all changes to the db
try:
self.session.commit()
logger.info(
f'Remote ip {remote_ip} successfully made an order '
f'with the following data: "{dict(data)}".')
return self._create_response(201, {'success': True})
except IntegrityError:
pass
logger.info(
f'Remote ip {remote_ip} tried to make an order. Some error occurred'
)
return self._create_response(500, {'error': 'Some error occurred.'})
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 setup(self):
self.li = OrderItem('Mocca', 5)
from base import Session, engine, Base
from models import Order, OrderItem
# 2 - generate database schema
Base.metadata.create_all(engine)
# 3 - create a new session
session = Session()
order_items = [{
"product_id": 1,
"price": 15000999,
"quantity": 123
}, {
"product_id": 2,
"price": 200000,
"quantity": 123
}]
order = Order(order_items=[
OrderItem(
product_id=order_item['product_id'],
price=order_item['price'],
quantity=order_item['quantity'],
) for order_item in order_items
])
session.add(order)
session.commit()
session.refresh(order)
session.close()
def add_item(self, item, quantity):
order_item = OrderItem(order=self.order,
product=item,
quantity=quantity)
self.save_changes(order_item)
item2 = Item(name='pear', price=12.8) order1 = Order(name='20180101') order2 = Order(name='20180102') order1.items.append(item1) # order1/item1 item2.orders.append(order1) # order1/item2 order2.items.append(item2) # order2/item2 session.add(item1) session.add(item2) session.add(order1) session.add(order2) session.commit() order = Order(name='00000001') item1 = Item(name='apple1', price=2.5) item2 = Item(name='pear1', price=1.8) oi = OrderItem(order=order, item=item1, item_count=2) session.add(oi) oi = OrderItem(order=order, item=item2, item_count=5) session.add(oi) session.commit() # Insert User, Product, ShoppingCart john = User(name='john') cpu = Product(name='CPU', price=300.00) motherboard = Product(name='Motherboard', price=150.00) coffee_machine = Product(name='Coffee Machine', price=30.00) john_shopping_cart_computer = ShoppingCart(owner=john) john_shopping_cart_kitchen = ShoppingCart(owner=john) john_shopping_cart_computer.products.append(cpu) john_shopping_cart_computer.products.append(motherboard) john_shopping_cart_kitchen.products.append(coffee_machine)
