Example #1
0
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)
Example #2
0
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})
Example #3
0
    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()
Example #4
0
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')
Example #5
0
 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)
Example #6
0
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")
Example #7
0
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')
Example #8
0
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')
Example #9
0
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})
Example #10
0
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)
Example #11
0
 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]
Example #12
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)
Example #13
0
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)
Example #14
0
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)
Example #16
0
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)
Example #17
0
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 []
Example #18
0
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={})
Example #19
0
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)
Example #20
0
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})
Example #21
0
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)
Example #22
0
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')
Example #23
0
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]
Example #24
0
 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()
Example #25
0
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)]
Example #26
0
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
Example #27
0
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)
Example #28
0
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")
Example #29
0
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)
Example #30
0
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)
Example #31
0
 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()
Example #32
0
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)
Example #33
0
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)
Example #34
0
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()
Example #35
0
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
Example #36
0
    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))
Example #37
0
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)
Example #38
0
 def get_slug_field(self):
     return Order.get_slug_field()
Example #39
0
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))
Example #40
0
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/')
Example #41
0
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)
Example #42
0
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))