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)