def commitorder(request): token=request.session.get("token") dict={} try: user = User.objects.get(token=token) try: cartlist = Cart.objects.filter(user=user,is_delete=False) # 此处应该添加支付成功接口 # === 先忽略 adsid = request.GET.get("adsid") address = UserAddress.objects.get(id=adsid) paytype = request.GET.get("paytype") total_price = request.GET.get("total_price") ispay = True order = Order(user=user,address=address,pay_type=paytype,is_pay=ispay,order_price=total_price) order.save() cartlist.update(is_delete=True,order=order) for i in order.cart_set.all(): # print(i.product.prod_id,i.product.prod_sales,i.prod_num) p = Product.objects.get(prod_id=i.product.prod_id) p.prod_sales = p.prod_sales + i.prod_num p.prod_num = p.prod_num - i.prod_num p.save() dict["status"] = "success" except Exception as e : print(e) dict["status"] = "error" except User.DoesNotExist: dict["status"] = "nologin" return JsonResponse(dict)
def basket(request): if request.user.is_authenticated() == False: if request.method == 'POST': form = AddToBasketForm(request.POST) if form.is_valid(): return redirect('/login/?redirect=/shop/product/%s/?count=%s&' % (form.cleaned_data['Product'], form.cleaned_data['Count'])) return redirect('Login') if request.user.is_active == False: return redirect('Active') else: error = [] userAccount = UserAccount.objects.get(User = request.user) if request.method == 'POST': form = AddToBasketForm(request.POST) if form.is_valid(): try: product = Product.objects.get(id = form.cleaned_data['Product']) order = Order(Product = product, Number = form.cleaned_data['Count'], Container = userAccount.Basket) order.save() return redirect('Basket') except ObjectDoesNotExist: return HttpResponseNotFound("Product not found") else: error.append('Something went wrong') content = render(request, 'basket.html',{'order_list': userAccount.Basket.order_set.all(), 'shinf_list': userAccount.shippinginformation_set.all() }) return render(request,'index.html', {'error_list': error, 'content': content.content})
def setUp(self): """ """ self.tax = TaxClass(name="20%", rate=Decimal('20.0')) self.tax.save() self.p1 = Product.objects.create(name="Product 1", slug="product-1") self.p2 = Product.objects.create(name="Product 2", slug="product-2") self.p1.save() self.p2.save() price1 = ProductPrice(product=self.p1, _unit_price=Decimal('10.0'), currency='CZK', tax_class=self.tax, tax_included=self.tax_included) price2 = ProductPrice(product=self.p2, _unit_price=Decimal('100.0'), currency='CZK', tax_class=self.tax, tax_included=self.tax_included) price1.save() price2.save() self.cart = Order() self.cart.save() item1 = OrderItem(order=self.cart, product=self.p1, quantity=1) item2 = OrderItem(order=self.cart, product=self.p2, quantity=1) item1.save() item2.save() self.cart.recalculate_totals() self.cart.save()
def checkout(request): if request.method == "POST": item_json = request.POST.get('itemsJson', '') name = request.POST.get('name', '') amount = request.POST.get('amount', '') email = request.POST.get('email', '') address = request.POST.get('address1', '') + \ " " + request.POST.get('address2', '') city = request.POST.get('city', '') state = request.POST.get('state', '') zip_code = request.POST.get('zip_code', '') phone = request.POST.get('phone', '') order = Order(item_json=item_json, name=name, amount=amount, email=email, address=address, city=city, state=state, zip_code=zip_code, phone=phone) order.save() update = OrderUpdate(order_id=order.order_id, update_desc="The order has been placed.") update.save() id = order.order_id message = 'Your order has been placed successfully. Thank you for ordering with us. Your order id is ' return render(request, 'shop/checkout.html', { 'id': id, 'name': name, 'msg': message }) else: return render(request, 'shop/checkout.html')
def post(self, request): if request.POST.get('email'): name = request.POST.get('name') phone = request.POST.get('phone') email = request.POST.get('email') customer = Customer(name=name, phone=phone, email=email) customer.save() qrcode_path = customer.qrcode_create() customer.qrcode = qrcode_path customer.save() order = Order(customer=customer, ) order.save() cart = request.session.get('cart') if cart: for product_id, quantity in cart.items(): cart = Cart(product_id=product_id, quantity=quantity, order=order, complete=True) cart.save() del request.session['cart'] request.session.save() cart = order.cart_set.all() context = {'cart': cart, 'order': order} return render(request, 'shop/order.html', context)
def checkout(request): if request.method == 'POST': # listing out the data given by user to place order . itemsJSon = request.POST.get('itemsJson', '') # listing out the data given by user to place order . name = request.POST.get('name', '') # listing out the data given by user to place order . amount = request.POST.get('amount', '') # listing out the data given by user to place order . email = request.POST.get('email', '') # listing out the data given by user to place order . phone = request.POST.get('phone', '') # listing out the data given by user to place order . address = request.POST.get('address1', '') + \ " " + request.POST.get('address2', '') # listing out the data given by user to place order . state = request.POST.get('state', '') # listing out the data given by user to place order . city = request.POST.get('city', '') # listing out the data given by user to place order . zip_code = request.POST.get('zip_code', '') order = Order(itemJSon=itemsJSon, amount=amount, name=name, email=email, phone=phone, address=address, state=state, city=city, zip_code=zip_code) # passig value at order class order.save() # saving the data in table global id_order id_order = order.order_id thanks = True return render(request, "shop/payment.html", {'thanks': thanks, 'id': id_order, }) return render(request, "shop/checkout.html")
def checkout(request): if request.method == 'POST': items_json = name = request.POST.get('itemsJson', '') name = request.POST.get('name', '') email = request.POST.get('email', '') phone = request.POST.get('phone', '') address = request.POST.get('address1', '') + " " + request.POST.get( 'address2', '') city = request.POST.get('city', '') state = request.POST.get('state', '') zip_code = request.POST.get('zip_code', '') order = Order(items_json=items_json, name=name, email=email, phone=phone, address=address, city=city, state=state, zip_code=zip_code) order.save() update = Update(order_id=order.id, update_desc="The order has been placed") update.save() thank = True order_id = order.id context = {'thank': thank, 'order_id': order_id} return render(request, 'shop/checkout.html', context) return render(request, 'shop/checkout.html')
def checkout(request): if request.method == "POST": itemJson = request.POST.get('itemJson') name = request.POST.get('name') email = request.POST.get('email') address = request.POST.get('address1') + " " + request.POST.get( 'address2') city = request.POST.get('city') state = request.POST.get('state') zip_code = request.POST.get('zipcode', '') order = Order(itemJson=itemJson, name=name, email=email, address=address, city=city, state=state, zip_code=zip_code) order.save() orderupdate = OrderUpdate(order_id=order.order_id, order_desc="Your order has been received") orderupdate.save() thank = True return render(request, 'shop/checkout.html', { 'thank': thank, 'id': order.order_id }) return render(request, 'shop/checkout.html')
def checkout(request): if request.method == 'POST': address = request.POST.get('address') customer = request.session.get('register_user') cart = request.session.get('cart') # list of customer order product with quantity ids = list(request.session.get('cart').keys()) products = Watch.objects.filter(id__in=ids) print(address, customer, products, cart) for product in products: order = Order( product=product, price=product.watch_price, address=address, ) request.session['cart'] = {} order.placeOrder() # request paytm to trasfer user amount param_dict = { # Local variable checksum error 37:43 video # yYzRdS69774940605473 'MID': 'qofSIN69628291597131', 'ORDER_ID': 'order.order_id', 'TXN_AMOUNT': '1', 'CUST_ID': 'email', 'INDUSTRY_TYPE_ID': 'Retail', 'WEBSITE': 'WEBSTAGING', 'CHANNEL_ID': 'WEB', # Change Callback_URl to your ip 'CALLBACK_URL': 'http://127.0.0.1:8000/pages/handlerequest/', } param_dict['CHECKSUMHASH'] = checksum.generate_checksum( param_dict, MERCHANT_KEY) return render(request, 'pages/paytm.html', {'param_dict': param_dict})
def checkout(request): products1 = product.objects.all() params1 = {'pro': products1} if request.method == "POST": name = request.POST.get('name', '') email = request.POST.get('email', "") amount = request.POST.get('amount', "") address = request.POST.get('address', "") address2 = request.POST.get('address2', "") city = request.POST.get('city', '') state = request.POST.get('state', '') zip_code = request.POST.get('zip', '') order = Order(name=name, email=email, add=address, add2=address2, city=city, state=state, zip_code=zip_code, price=amount) order.save() update = Update(order_id=order.order_id, update_desc="The order has been placed") update.save() return render(request, 'shop/checkout.html', params1) return render(request, 'shop/checkout.html', params1)
def get_user_order(self): user_order = Order.objects.filter(user = self.request.user).filter(order_status = "A") if not user_order: user_order = Order(user = self.request.user) user_order.save() return user_order else: return user_order[0]
def setUp(self) -> None: self.product = Product.objects.get(id=1) self.product2 = Product.objects.get(id=2) self.user = MyUser.objects.get(id=1) self.user2 = MyUser.objects.get(id=2) self.test_order = Order(user=self.user, product=self.product, amount=10) self.test_order.save() self.user_test_zero_money = MyUser.objects.get(id=3) self.product_test_zero_amount = Product.objects.get(id=3) Order.objects.create(user=self.user_test_zero_money, product=self.product_test_zero_amount, amount=100)
def _add_team_id(customer, default_team_id): team_ids = {} to_put = [] def _add_team_id_for_manager(manager_email): regio_manager = RegioManager.get(RegioManager.create_key(manager_email)) if regio_manager and regio_manager.team_id: team_ids[manager_email] = regio_manager.team_id to_put.append(customer) if customer.manager: _add_team_id_for_manager(customer.manager.email()) if customer.manager.email() in team_ids: customer.team_id = team_ids[customer.manager.email()] else: customer.team_id = default_team_id for order in Order.all().ancestor(customer): to_put.append(order) if order.manager: if order.manager.email() not in team_ids: _add_team_id_for_manager(order.manager.email()) if order.manager.email() in team_ids: order.team_id = team_ids[order.manager.email()] else: order.team_id = default_team_id else: order.team_id = default_team_id for charge in Charge.all().ancestor(customer): to_put.append(charge) if charge.manager: if charge.manager.email() not in team_ids: _add_team_id_for_manager(charge.manager.email()) if charge.manager.email() in team_ids: charge.team_id = team_ids[charge.manager.email()] else: charge.team_id = default_team_id else: charge.team_id = default_team_id else: customer.team_id = default_team_id for order in Order.all().ancestor(customer): to_put.append(order) order.team_id = default_team_id for charge in Charge.all().ancestor(customer): to_put.append(charge) charge.team_id = default_team_id if to_put: db.put(to_put)
def cart_buy(request): cart = Cart(request) if request.user.is_authenticated: ordered_items = Item.objects.filter( id__in=map(int, cart.cart.keys())).all() for i in ordered_items: order = Order(profile=request.user.profile, item=i) order.save() cart.clear() return JsonResponse({"response": "OK"}) else: return JsonResponse({"response": "REDIRECT"})
def cart_pay_success(request): '''Logics after a successful payment was made ''' items = [] order = None cart = get_object_or_404(Cart, owner=request.user) cart_items = CartItem.objects.filter(cart=cart) d_result = CartItem.objects.filter(cart_id=cart.cart_id).aggregate( Sum('quantity'), Sum('price')) # This is also to prevent resubmit when user refreshes the payment sucessful page if (not d_result['quantity__sum']) or (not d_result['price__sum']): return HttpResponseRedirect(reverse("shop:shop_home")) #with transaction.Atomic(): # Create a payment record payment = Payment.objects.create( description="Credit payment", amount=d_result['price__sum'] if d_result['price__sum'] else 0, comment="stripe payment") # Create an order order = Order(owner=request.user) order.description = "Online purchase" order.quantity = d_result['quantity__sum'] if d_result[ 'quantity__sum'] else 0 order.total = d_result['price__sum'] if d_result['price__sum'] else 0 order.payment = payment order.comment = "paid by stripe" order.save() # Populate order items to OrderItem table (?? using map()) for item in cart_items: OrderItem.objects.create(order_id=order.order_id, product_id=item.product.id, quantity=item.quantity, price=item.price) # Remove all items from the cart CartItem.objects.filter(cart=cart).delete() # codeset 2 is Product Category categories = CodeValue.objects.filter( code_set_id=2).order_by('display_sequence') items = OrderItem.objects.filter(order=order) o_result = OrderItem.objects.filter(order=order).aggregate(Sum('price')) context = { 'items': items, 'categories': categories, 'page_title': "Payment Successful", 'order_total': o_result['price__sum'] if o_result['price__sum'] else 0, } return render(request, "shop/cart_pay_success.html", context)
def order_create(): form = OrderCreateForm() if form.validate_on_submit(): cart = Cart() if len(cart) == 0: return redirect(url_for('index')) order = Order(form.name.data, form.phone.data, form.address.data) order.create(cart) cart.clear() return render_template('shop/cart/created.html', form=form, order=order) return render_template('shop/cart/create.html', form=form)
def get_order_items(): # get the order items for this customer from the latest order that isn't signed yet service_user = users.get_current_user() customer = get_customer(service_user) if not customer: return [] order_key = Order.create_key(customer.id, Order.CUSTOMER_STORE_ORDER_NUMBER) order = Order.get(order_key) if order: sln_settings = get_solution_settings(service_user) lang = sln_settings.main_language remaining_length, sub_order = get_subscription_order_remaining_length( customer.id, customer.subscription_order_number) subscription_order_charge_date = format_date( datetime.datetime.utcfromtimestamp(sub_order.next_charge_date), locale=lang) order_items = list(OrderItem.list_by_order(order_key)) order_items_updated = list() to_put = list() to_get = list( set([Product.create_key(o.product_code) for o in order_items] + [Product.create_key(Product.PRODUCT_EXTRA_CITY)])) products = {p.code: p for p in db.get(to_get)} # update the order items if necessary. for order_item in order_items: if products[ order_item. product_code].is_subscription_extension and order_item.count != remaining_length: order_item.count = remaining_length to_put.append(order_item) order_items_updated.append(order_item) if to_put: db.put(to_put) extra_city_price = format_price( products[Product.PRODUCT_EXTRA_CITY].price, sln_settings.currency) service_visible_in_translation = translate( lang, SOLUTION_COMMON, 'service_visible_in_app', subscription_expiration_date=subscription_order_charge_date, amount_of_months=remaining_length, extra_city_price=extra_city_price, app_name='%(app_name)s') return [ OrderItemTO.create(i, service_visible_in_translation) for i in order_items_updated ] else: return []
def cart_clean(request): template = 'shop/cart_clean.html' if request.user.is_authenticated: number = time.time_ns() name = request.user.email acc = User.objects.get(email=name) cart_objects = Cart.objects.all().filter(user=acc) for obj in cart_objects: order = Order(user=obj.user, product=obj.product, pr_count=obj.pr_count, number=number) order.save() Cart.objects.all().filter(user=acc).delete() return render(request, template, context={})
def place_order(request): """ Place order with the active cart of the logged user Cart will be inactive after """ logged_user = request.user cart = get_logged_user_cart(logged_user) order = Order(cart=cart, date=datetime.datetime.now()) order.save() cart.active = False cart.save() serializer = OrderSerializer(order) return Response(serializer.data)
def page(request, pk): try: mod = Product.objects.get(id=pk) except Product.DoesNotExist: raise Product.DoesNotExist user = request.user if request.POST: if "cancel" in request.POST: return HttpResponseRedirect(reverse_lazy('index')) else: form = NewConcreteOrderForm(request.POST) if request.user.is_authenticated(): if form.is_valid(): p = Order( user=user, module=mod, information=mod.information, paid=False, ) if mod.on_sale: mod.on_sale = False mod.save() p.painting = False # TODO: remove all paint color logic from template view etc p.save() new_message = ContactMessage( user=user, notified=False, text= u"""Congratulations, the order has been created correctly and it is in the state %s. Soon you will receive confirmation of the states changes . Thanks""" % p.state) new_message.save() mod.quitar_of_sale() mod.save() messages.success( request, '¡Order created <b>correctly</b>, thanks!') return HttpResponseRedirect(reverse_lazy('panel')) else: return render(request, 'shop/create_order.html', {'form': form, 'pk': pk}) else: form = NewConcreteOrderForm() return render(request, 'shop/create_order.html', {'form': form, 'pk': pk})
def cancel_charge(customer_id, order_number, charge_id): """Cancels a charge so adjustments can be made to the order. Rolls back the next charge date of the subscription order. Args: customer_id: order_number: charge_id: Returns: None """ to_put = list() now_ = now() charge, order, customer = db.get([Charge.create_key(charge_id, order_number, customer_id), Order.create_key(customer_id, order_number), Customer.create_key(customer_id)]) charge.date_cancelled = now_ charge.status = Charge.STATUS_CANCELLED to_put.append(charge) order_items = list(OrderItem.list_by_order(order.key())) if order.is_subscription_order: months = 0 for item in order_items: product = item.product if product.is_subscription and product.price > 0: months += item.count if not product.is_subscription and product.extra_subscription_months > 0: months += product.extra_subscription_months if months > 0: next_charge_datetime = datetime.datetime.utcfromtimestamp(now()) - relativedelta(months=months) order.next_charge_date = get_epoch_from_datetime(next_charge_datetime) else: order.next_charge_date = Order.default_next_charge_date() else: extra_months = 0 for item in order_items: product = item.product if not product.is_subscription and product.extra_subscription_months > 0: extra_months += product.extra_subscription_months if extra_months > 0: sub_order = Order.get_by_order_number(customer_id, customer.subscription_order_number) next_charge_datetime = datetime.datetime.utcfromtimestamp(sub_order.next_charge_date) - relativedelta( months=extra_months) sub_order.next_charge_date = get_epoch_from_datetime(next_charge_datetime) to_put.append(sub_order) db.put(to_put)
def checkout(request): if request.method == 'POST': item_json = request.POST.get('itemsJson', '') amount = request.POST.get('amount', '') name = request.POST.get('name', '') email = request.POST.get('email', '') address = request.POST.get('address', '') + request.POST.get( 'address2', '') city = request.POST.get('city', '') state = request.POST.get('state', '') zip_code = request.POST.get('zip_code', '') phone = request.POST.get('phone', '') od = request.POST.get('id', '') order = Order(item_json=item_json, amount=amount, name=name, email=email, address=address, city=city, state=state, zip_code=zip_code, phone=phone) order.save() thank = True update = OrderUpdate(order_id=order.order_id, update_desc="The Order has been placed.") update.save() id = order.order_id return render(request, 'shop/checkout.html', { "thank": thank, "id": id }) return render(request, 'shop/checkout.html')
def load_unsinged_orders(): service_user = users.get_current_user() customer = get_customer(service_user) if not customer: logging.error("Customer not found for %s", service_user) return [] return [OrderTO.fromOrderModel(order) for order in Order.list_unsigned(customer) if order.order_number != Order.CUSTOMER_STORE_ORDER_NUMBER]
def load_orders(): service_user = users.get_current_user() customer = get_customer(service_user) if not customer: logging.error("Customer not found for %s", service_user) return [] return [OrderTO.fromOrderModel(order) for order in Order.list_signed(customer)]
def remove_from_order(item_id): service_user = users.get_current_user() customer = get_customer(service_user) azzert(customer) customer_store_order_key = Order.create_key( customer.id, Order.CUSTOMER_STORE_ORDER_NUMBER) order_item_key = OrderItem.create_key(customer.id, Order.CUSTOMER_STORE_ORDER_NUMBER, item_id) order_item, order = db.get([order_item_key, customer_store_order_key]) if not order_item: logging.warn( "Customer %s tried to delete an already deleted item (%s)", service_user.email(), item_id) return RETURNSTATUS_TO_SUCCESS azzert(order) # Subtract the price from this product, then remove the product. vat = order_item.count * order_item.price * order.vat_pct / 100 total = order_item.count * order_item.price total_inc_vat = total + vat order.amount -= total order.total_amount -= total_inc_vat order.vat -= vat order_item.delete() order.put() return RETURNSTATUS_TO_SUCCESS
def account(): user = db.session.query(User).filter( User.mail == session['username']).scalar() if session.pop('ordered', None): order = Order( date=date.today().strftime('%d.%m.%Y'), sum=session['order_summ'], status=1, mail=session['username'], phone=session['phone'], address=session['address'], user_id=user.id, ) # в cart записаны id блюд # если блюда в заказе повторяются, то в таблицк для M2M будет только одна запись, # напимер Заказ_6 - Блюдо_3, несмотря на то что Блюдо_3 было заказано два раза for id in set(session.get('cart', [])): meal = db.session.query(Meal).filter(Meal.id == id).scalar() a = Association_orders_meals(meal_num=session['cart'].count(id)) a.meal = meal order.meals.append(a) db.session.add(order) db.session.commit() # заказ записан, удаляем из сессии # всё, кроме 'cart' можно удалить при формировании заказа, удаляю здесь, # на ввсякий случай после commit() в БД session.pop('cart') session.pop('order_summ') session.pop('username') session.pop('phone') session.pop('address') orders = db.session.query(Order).filter(Order.user_id == user.id).order_by( Order.date.desc()).all() return render_template('account.html', orders=orders)
def checkout(request): if request.method == "POST": items_json = request.POST.get('itemsJson') name2 = request.POST.get('name2', '') email = request.POST.get('email', '') address = request.POST.get('address1', '') + \ " | " + request.POST.get('address2', '') city = request.POST.get('city', '') state = request.POST.get('state', '') zip_code = request.POST.get('zip_code', '') phone2 = request.POST.get('phone2', '') order = Order(items_json=items_json, name2=name2, email=email, address=address, city=city, state=state, zip_code=zip_code, phone2=phone2) #order.save() #update= OrdersUpdate(order_id= order.order_id, update_desc="The order has been placed") #update.save() #thank = True #id = order.order_id"" return render(request, "checkout.html", {'thank': thank, 'id': id}) return render(request, "checkout.html")
def confirm_order(request, order_id=None): if order_id: """ order is already confirmed, it's just the reload """ order = get_object_or_404(Order, pk=order_id) if order.user.id != request.user.id: """ This is not the user's order, someone tries to hack us """ return HttpResponseForbidden() context = { 'order': order, 'updated': True } else: """ register order """ basket = get_object_or_404(Basket, session_id=request.session.session_key) try: order = Order.register(basket) ipgeobases = IPGeoBase.objects.by_ip(request.META.get('REMOTE_ADDR')) if ipgeobases.exists(): ipgeobase = ipgeobases[0] order.city = ipgeobase.city order.save() """ wait for 5 minutes to let user supply comments and other stuff """ notify_manager.apply_async((order.id,), countdown=300) notify_user_order_new_mail.apply_async((order.id,), countdown=300) notify_user_order_new_sms.delay(order.id) basket.delete() context = { 'order': order } except Exception as e: return HttpResponseServerError("Failed to register order: %s" % e) return render(request, 'shop/order_confirmation.html', context)
class OrderPdfHandler(webapp.RequestHandler): def get(self): from shop.models import Customer from shop.view import generate_order_or_invoice_pdf service_user = users.get_current_user() customer_id = long(self.request.get("customer_id")) order_number = self.request.get("order_number") download = self.request.get("download", "false") == "true" self.response.headers['Content-Type'] = 'application/pdf' self.response.headers['Content-Disposition'] = str( '%s; filename=order_%s.pdf' % ("attachment" if download else "inline", order_number)) try: customer = Customer.get_by_id(customer_id) except CustomerNotFoundException, exception: logging.exception(exception) self.abort(500) return if customer.service_email != service_user.email(): logging.error("%s attempted to download order of %s", service_user, customer.service_email) self.abort(403) return order = Order.get_by_key_name(order_number, parent=customer) generate_order_or_invoice_pdf(self.response.out, customer, order)
def trans(customer_key): customer, order = db.get( [customer_key, Order.create_key(customer_key.id(), order_number)]) if order.manager: customer.manager = order.manager customer.put()
def sale(request): cart = Cart.objects.all() #incart = Cart.objects.raw('SELECT * FROM shop_cart INNER JOIN shop_product WHERE shop_cart.product_id = shop_product.id') if (cart.count() > 0): cart_list = [] price = 0 print(cart) order = Order() order.save() for item in cart: product = Product.objects.filter(pk=item.product_id)[0] price += product.price * item.amount order.products.add(product) op = Order_Product.objects.filter(order_id=order.id).filter( product_id=item.product_id)[0] op.amount = item.amount op.save() order.total_price = price order.save() Cart.objects.raw('DELETE FROM shop_cart') Cart.objects.all().delete() context = { 'product': Product.objects.all(), 'type': ProductType.objects.all(), 'msg': 'Create order id : %s successfully' % order.id, } #return redirect(to='index') return render(request, template_name='shop/index.html', context=context)
def checkout(update: Update, context: CallbackContext): query = update.callback_query query.answer() chat_id = query.from_user.id username = query.from_user.username customer = Customer.objects.filter(telegram_id=chat_id).values_list("pk") customer_id = str(customer[0]).replace('(', '').replace(')', '').replace(',', '') cart_raw = Cart.objects.filter(customer=customer_id).values_list( "product", "quantity") cart_dict = dict(cart_raw) price_ = list() list_clear = list() for key, val in cart_dict.items(): name = Product.objects.filter(pk=key).values_list("name") quantity = val newtup = (name[0], quantity) list_clear.append(newtup) price = Product.objects.filter(pk=key).values_list("price") price_str = float(''.join(str(el) for el in price[0])) total = price_str * int(val) price_.append(total) total_ = 0 for item in price_: total_ = total_ + item list_str = "\n".join(str(item) for item in list_clear) cart_clear = list_str.replace('(', '').replace(')', '').replace(',', '') for item in cart_dict.items(): q = item[1] p = item[0] o = Order(quantity=q, created_at=datetime.datetime.now(), total=total_, customer_id=customer_id, product_id=p) o.save() context.bot.send_message( chat_id=update.effective_chat.id, text=f"<b>*Checkout*" f":</b>\n-------------\n" f"<u>{cart_clear}</u>\nTotal = <b>{total_}</b>" f"\n------------- \n Pay to SBER Account Number : 123123123", parse_mode=telegram.ParseMode.HTML)
def __save_order_to_db(cart, client, address): order = Order() order = add_order_products_to_order(order, cart) order.client = client order.address = address order.order_date = datetime.datetime.now() order.save()
def get_subscription_order(customer_id): customer = Customer.get_by_id(customer_id) if not customer.subscription_order_number: raise NoSubscriptionException(customer) order = Order.get_by_order_number(customer.id, customer.subscription_order_number) if not order.status == Order.STATUS_SIGNED: raise BusinessException( 'The customer his subscription order has not been signed yet.') return order
def done(self, form_list, **kwargs): cart = Cart(self.request) cart.create_cart() order = Order(cart=cart.cart) client = form_list[0].save(commit=False) address = form_list[1].save() client.shipping_address = address billing_address = address if condition_step_3(self): billing_address = form_list[2].save() client.billing_address = billing_address client.save() order.client = client payment_option = self.get_cleaned_data_for_step("4").get("payment_options", None) print ("PAYMENT {0}".format(self.get_cleaned_data_for_step("4"))) language = translation.get_language().upper() if payment_option == "PayPal": result = self.create_paypalpayment(cart) order.payment = result.paypal_payment_db order.save() # we need to do the checkout after saving the order, # if something went wrong cart.check_out() mail_result = EMailTemplate.objects.send("{0}_ORDER_SUCCESS_PAYPAL".format(language), client.email, {"order": order, "billing_address": billing_address, "shipping_address": address, "paypal_url": order.payment.approval_url}) if result.payment.error: logger.error("PayPal payment went wrong! Errors: {0}".format(result.payment.error)) return render(self.request, "cuescience_shop/failure_paypal.html", {"order": order}) elif not result.payment.errors and order.payment.approval_url: return render(self.request, "cuescience_shop/success_paypal.html", {"order": order}) elif payment_option == "Prepayment": payment = PrePayment() payment.save() order.payment = payment order.save() cart.check_out() mail_result = EMailTemplate.objects.send("{0}_ORDER_SUCCESS_PREPAYMENT".format(language), client.email, {"order": order, "billing_address": billing_address, "shipping_address": address}) return render(self.request, "cuescience_shop/success.html", {"order": order}) return render_to_response("cuescience_shop/cart/index.html", RequestContext(self.request))
def confirm(request): user = request.user detail_id = request.session['detail_id'] detail = DeliveryDetail.objects.filter(id=detail_id)[0] cur_basket = request.session['basket'] cart = get_cart(cur_basket) if request.method == 'POST': order = Order(user_id=user.id, full_sum=cur_basket['sum'] + detail.tax, delivery=detail.__unicode__(), order_date=datetime.now(), detail='prepare', code=Order.code_generator()) order.save() for item in cart: item.order_id = order.id item.save() order.save() del request.session['basket'] return redirect('shop.views.index') days = 0 for item in cart: if item.item.available == 'order' or item.count > item.item.count: if item.item.delivery_period > days: days = item.item.delivery_period days += detail.delivery_period summary = cur_basket['sum'] + detail.tax context = {'user': user, 'detail': detail, 'cart': cart, 'days': days, 'summary': summary} return render(request, 'shop/confirm.html', context)
def get_slug_field(self): return Order.get_slug_field()
def not_login(request, next_='/'): form_ = NotLoginForm() for_cat_menu = Category.objects.all() if ('next' in request.GET) and request.GET['next'].strip(): next_ = request.GET['next'] if not request.user.is_authenticated(): request.session.set_expiry(None) if 'key' not in request.session: request.session['last_date'] = str(datetime.datetime.now()) request.session.save() request.session['key'] = request.session.session_key for_cart = CartElement.objects.filter(cart__key=request.session['key'], cart__status=True) else: return HttpResponseRedirect(reverse_lazy('cart')) l = len(for_cart) if request.method == 'POST': form_ = NotLoginForm(request.POST) if form_.is_valid(): # print('Save order') p = form_.save_person() # print(p) owner_ = get_object_or_404(Client, user__username='******') cart_ = Cart.objects.filter(owner__user__username='******', key=request.session['key'], status=True) comment = form_.cleaned_data['comment'] if not cart_: cart_ = Cart(owner=owner_, datetime=datetime.datetime.now(), key=request.session['key']) cart_.save() else: for item in cart_: if item.status: cart_ = item break # Пока берем первую запись не являющуюся заказом new_order = Order(list=cart_, datetime=datetime.datetime.now(), status='NEW', comment=comment, person=p) new_order.save() cart_.status = False cart_.summ = summ_in_cart(for_cart) cart_.save() # print(" Sending mail") for_order = CartElement.objects.filter(cart__id=new_order.list.id) # user = request.user to = [p.email] from_email = settings.DEFAULT_FROM_EMAIL subject_ = 'Новый заказ - ' + str(new_order.id) text_content = render_to_string('bshop/email/neworder.txt', {'first_name': p.first_name, 'summ_in_cart': summ_in_cart(for_cart), 'order': new_order, 'positions': for_order}) html_content = render_to_string('bshop/email/neworder.html', {'first_name': p.first_name, 'summ_in_cart': summ_in_cart(for_cart), 'order': new_order, 'positions': for_order}) # print(to, from_email, subject_, html_content) send_email(to, from_email, subject_, text_content, html_content) to = [settings.ADMIN_EMAIL] send_email(to, from_email, subject_, text_content, html_content) return HttpResponseRedirect(reverse_lazy('orders')) template = loader.get_template('bshop/notlogin.html') context = {'menu': for_cat_menu, 'path': request.path, 'user': request.user, 'session': request.session, 'cart_length':l, 'summ_in_cart': summ_in_cart(for_cart), 'next': next_, 'form': form_} return HttpResponse(template.render(context, request))
def order(request, step='1'): c = get_common_context(request) if step == '1': if request.user.is_authenticated(): return HttpResponseRedirect('/order/2/') else: if request.method == "GET": auth_form = AuthenticationForm() register_form = RegisterForm() c['auth_form'] = auth_form c['register_form'] = register_form return render_to_response('order_1.html', c, context_instance=RequestContext(request)) else: request.session['is_order'] = True return register(request) else: if not request.user.is_authenticated(): return HttpResponseRedirect('/order/1/') if step == '2': c['items'] = c['cart_working'].get_content(request.user) return render_to_response('order_2.html', c, context_instance=RequestContext(request)) elif step == '3': from shop.forms import Step3Form if request.method == 'GET': user_profile = request.user.get_profile() form = Step3Form(initial={ 'fio': user_profile.fio, 'phone': user_profile.phone, 'index': user_profile.index, 'city': user_profile.city, 'street': user_profile.street, 'house': user_profile.house, }) else: form = Step3Form(request.POST) if form.is_valid(): Order.get_or_create(request.user) return HttpResponseRedirect('/order/4/') c['form'] = form return render_to_response('order_3.html', c, context_instance=RequestContext(request)) elif step == '4': if request.method == 'GET': return render_to_response('order_4.html', c, context_instance=RequestContext(request)) else: o = Order.get_recent(request.user) if o: o.delivery = request.POST['delivery'] o.save() return HttpResponseRedirect('/order/5/') else: return HttpResponseRedirect('/order/2/') elif step == '5': if request.method == 'GET': return render_to_response('order_5.html', c, context_instance=RequestContext(request)) else: o = Order.get_recent(request.user) if o: o.send() c['order_send'] = True return render_to_response('order_5.html', c, context_instance=RequestContext(request)) else: return HttpResponseRedirect('/order/2/') else: return HttpResponseRedirect('/cart/')
class CartModelsWithTaxTestCase(TestCase): """ """ tax_included=True def setUp(self): """ """ self.tax = TaxClass(name="20%", rate=Decimal('20.0')) self.tax.save() self.p1 = Product.objects.create(name="Product 1", slug="product-1") self.p2 = Product.objects.create(name="Product 2", slug="product-2") self.p1.save() self.p2.save() price1 = ProductPrice(product=self.p1, _unit_price=Decimal('10.0'), currency='CZK', tax_class=self.tax, tax_included=self.tax_included) price2 = ProductPrice(product=self.p2, _unit_price=Decimal('100.0'), currency='CZK', tax_class=self.tax, tax_included=self.tax_included) price1.save() price2.save() self.cart = Order() self.cart.save() item1 = OrderItem(order=self.cart, product=self.p1, quantity=1) item2 = OrderItem(order=self.cart, product=self.p2, quantity=1) item1.save() item2.save() self.cart.recalculate_totals() self.cart.save() def test_tax_detail(self): tax_detail = self.cart.tax_detail self.assertEqual("%.2f" % float(tax_detail['20%']), "%.2f" % 18.33) def test_get_subtotal(self): """ """ subtotal = self.cart.sub_total self.assertEqual("%.2f" % float(subtotal), "%.2f" % 91.67) def test_get_total(self): """ """ total = self.cart.total self.assertEqual("%.2f" % float(total), "%.2f" % 110.0) def test_tax(self): """ """ tax = self.cart.tax self.assertEqual("%.2f" % float(tax), "%.2f" % 18.33) def test_get_qty_of_items(self): """ """ qty = self.cart.items_qty() self.assertEqual(qty, 2) def test_get_items_count(self): """ """ n = self.cart.items_count() self.assertEqual(n, 2)
def cart(request): if not request.user.is_authenticated(): request.session.set_expiry(None) if 'key' not in request.session: request.session['last_date'] = str(datetime.datetime.now()) request.session.save() request.session['key'] = request.session.session_key # session = request.session['key'] # print(request.session['last_date'], session) for_cart = CartElement.objects.filter(cart__key=request.session['key'], cart__status=True) else: for_cart = CartElement.objects.filter(cart__owner__user__username=request.user.username, cart__status=True) l = len(for_cart) all_product_not_archive = True data_ = dict() formset = [] form = CommentForm() if l: """form_data = { 'form-TOTAL_FORMS': str(l), 'form-INITIAL_FORMS:': str(l), 'form-MAX_NUM_FORMS': str(l), }""" CartFormSet = formset_factory(CartForm, max_num=l, can_delete=True) if request.method == 'POST': formset = CartFormSet(request.POST, request.FILES) if formset.is_valid(): # print('Update cart') on_delete = False for i in range(len(for_cart)): # print(for_cart[i].quantity, for_cart[i].id, formset[i].cleaned_data['quantity']) if (for_cart[i].quantity != formset[i].cleaned_data['quantity']): # print(for_cart[i].quantity, formset[i].cleaned_data['quantity']) try: cart_element = CartElement.objects.get(id=for_cart[i].id) product = get_object_or_404(Product, id=cart_element.product.id) if cart_element.is_preorder: # print('preorder change') cart_element.quantity = formset[i].cleaned_data['quantity'] cart_element.save() elif not cart_element.is_preorder: # print('Edit in stock') if cart_element.quantity > formset[i].cleaned_data['quantity']: # print('Is in dec quantity', cart_element.quantity, formset[i].cleaned_data['quantity']) # print('Old - ', product.quantity_in_reserv) product.quantity_in_reserv -= int(cart_element.quantity) - int(formset[i].cleaned_data['quantity']) if product.quantity_in_reserv < 0: product.quantity_in_reserv = 0 product.save() # print('New - ', product.quantity_in_reserv) cart_element.quantity = formset[i].cleaned_data['quantity'] else: # print('Is in add quantity') if (product.quantity - product.quantity_in_reserv) >= (formset[i].cleaned_data['quantity'] - cart_element.quantity): # print('Is Ok in rexize quantity') product.quantity_in_reserv += formset[i].cleaned_data['quantity'] - cart_element.quantity cart_element.quantity = formset[i].cleaned_data['quantity'] product.save() cart_element.save() except: pass if formset[i].cleaned_data['DELETE']: try: cart_element = CartElement.objects.get(id=for_cart[i].id) product = get_object_or_404(Product, id=cart_element.product.id) # print(product) if not product.is_preorder and (product.quantity_in_reserv - cart_element.quantity) >= 0: product.quantity_in_reserv -= cart_element.quantity product.save() cart_element.delete() on_delete = True except: pass if on_delete: return HttpResponseRedirect(reverse_lazy('cart')) if 'Order' in request.POST: # print('Is Place order') # Переполучаем корзину, т.к. она могла обновиться на форме и обработана выше. if not request.user.is_authenticated(): for_cart = CartElement.objects.filter(cart__key=request.session['key'], cart__status=True) else: for_cart = CartElement.objects.filter(cart__owner__user__username=request.user.username, cart__status=True) # Проверки на наличие в корзине товара со статусом не доступен к заказу (обход запреда нажатия html кнопок) for i in for_cart: if not i.product.is_not_arhive: return HttpResponseRedirect(reverse_lazy('cart')) #Если есть, редиректим на страницу корзины form = CommentForm(request.POST) if form.is_valid(): comment = form.cleaned_data['comment'] if request.user.is_authenticated: cart_ = Cart.objects.filter(owner__user__username=request.user.username, status=True) if cart_: for item in cart_: if item.status: cart_ = item break # Пока берем первую запись не являющуюся заказом new_order = Order(list=cart_, datetime=datetime.datetime.now(), status='NEW', comment=comment) new_order.save() cart_.status = False cart_.summ = summ_in_cart(for_cart) cart_.save() # print(" Sending mail") for_order = CartElement.objects.filter(cart__id=new_order.list.id) user = request.user to = [user.email] from_email = settings.DEFAULT_FROM_EMAIL subject_ = 'Новый заказ - ' + str(new_order.id) text_content = render_to_string('bshop/email/neworder.txt', {'first_name': request.user.first_name, 'username': user.username, 'summ_in_cart': summ_in_cart(for_cart), 'order': new_order, 'positions': for_order}) html_content = render_to_string('bshop/email/neworder.html', {'first_name': request.user.first_name, 'username': user.username, 'summ_in_cart': summ_in_cart(for_cart), 'order': new_order, 'positions': for_order}) # print(to, from_email, subject_, html_content) send_email(to, from_email, subject_, text_content, html_content) to = [settings.ADMIN_EMAIL] send_email(to, from_email, subject_, text_content, html_content) return HttpResponseRedirect(reverse_lazy('orders')) else: # Нужно авторизовать или зарегистрировать пользователя, после чего добавить ему товар из сессии # и отправить на страницу оформления заказа # Скорее всего решается требованием работы со страницей потверждения заказа только автотизованного пользователя return HttpResponseRedirect(reverse_lazy('login')) return HttpResponseRedirect(reverse_lazy('cart')) else: init_ = [] for i in for_cart: if not i.product.is_not_arhive: all_product_not_archive = False init_.append({'quantity': i.quantity}) # formset = CartFormSet(form_data, initial=init_) formset = CartFormSet(initial=init_) data_ = dict(pairs=zip(for_cart, formset)) template = loader.get_template('bshop/cart.html') for_cat_menu = Category.objects.all() context = {'menu': for_cat_menu, 'path': request.path, 'user': request.user, 'session': request.session, 'cart_length':l, 'summ_in_cart': summ_in_cart(for_cart), 'formset': formset, 'data': data_, 'form': form, 'alert_archive': all_product_not_archive} return HttpResponse(template.render(context, request))