示例#1
0
def one_page_checkout(request, template_name="lfs/checkout/one_page_checkout.html"):
    """
    One page checkout form.
    """
    cart = lfs.cart.utils.get_cart(request)
    if cart is None:
        return HttpResponseRedirect(reverse('lfs_cart'))

    shop = lfs.core.utils.get_default_shop(request)
    if request.user.is_anonymous() and shop.checkout_type == CHECKOUT_TYPE_AUTH:
        return HttpResponseRedirect(reverse("lfs_checkout_login"))

    customer = lfs.customer.utils.get_or_create_customer(request)
    invoice_address = customer.selected_invoice_address
    shipping_address = customer.selected_shipping_address
    bank_account = customer.selected_bank_account
    credit_card = customer.selected_credit_card

    if request.method == "POST":
        checkout_form = OnePageCheckoutForm(data=request.POST)
        iam = AddressManagement(customer, invoice_address, "invoice", request.POST)
        sam = AddressManagement(customer, shipping_address, "shipping", request.POST)
        bank_account_form = BankAccountForm(instance=bank_account, data=request.POST)
        credit_card_form = CreditCardForm(instance=credit_card, data=request.POST)

        if shop.confirm_toc and ("confirm_toc" not in request.POST):
            toc = False
            if checkout_form.errors is None:
                checkout_form.errors = {}
            checkout_form.errors["confirm_toc"] = _(u"Please confirm our terms and conditions")
        else:
            toc = True

        if checkout_form.is_valid() and bank_account_form.is_valid() and iam.is_valid() and sam.is_valid() and toc:
            # Save addresses
            iam.save()

            # If there the shipping address is not given, the invoice address
            # is copied.
            if request.POST.get("no_shipping", "") == "":
                sam.save()
            else:
                if customer.selected_shipping_address:
                    customer.selected_shipping_address.delete()
                shipping_address = deepcopy(customer.selected_invoice_address)
                shipping_address.id = None
                shipping_address.save()
                customer.selected_shipping_address = shipping_address

            # Save payment method
            customer.selected_payment_method_id = request.POST.get("payment_method")

            # Save bank account
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_BANK:
                customer.selected_bank_account = bank_account_form.save()

            # Save credit card
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_CREDIT_CARD:
                customer.selected_credit_card = credit_card_form.save()

            customer.save()

            # process the payment method
            result = lfs.payment.utils.process_payment(request)

            if result["accepted"]:
                return HttpResponseRedirect(result.get("next_url", reverse("lfs_thank_you")))
            else:
                if "message" in result:
                    checkout_form._errors[result.get("message_location")] = result.get("message")

    else:
        checkout_form = OnePageCheckoutForm()
        iam = AddressManagement(customer, invoice_address, "invoice")
        sam = AddressManagement(customer, shipping_address, "shipping")
        bank_account_form = BankAccountForm(instance=bank_account)
        credit_card_form = CreditCardForm(instance=credit_card)

    # Payment
    try:
        selected_payment_method_id = request.POST.get("payment_method")
        selected_payment_method = PaymentMethod.objects.get(pk=selected_payment_method_id)
    except PaymentMethod.DoesNotExist:
        selected_payment_method = lfs.payment.utils.get_selected_payment_method(request)

    valid_payment_methods = lfs.payment.utils.get_valid_payment_methods(request)
    display_bank_account = any([pm.type == lfs.payment.settings.PM_BANK for pm in valid_payment_methods])
    display_credit_card = any([pm.type == lfs.payment.settings.PM_CREDIT_CARD for pm in valid_payment_methods])

    return render_to_response(template_name, RequestContext(request, {
        "checkout_form": checkout_form,
        "bank_account_form": bank_account_form,
        "credit_card_form": credit_card_form,
        "invoice_address_inline": iam.render(request),
        "shipping_address_inline": sam.render(request),
        "shipping_inline": shipping_inline(request),
        "payment_inline": payment_inline(request, bank_account_form),
        "selected_payment_method": selected_payment_method,
        "display_bank_account": display_bank_account,
        "display_credit_card": display_credit_card,
        "voucher_number": lfs.voucher.utils.get_current_voucher_number(request),
        "cart_inline": cart_inline(request),
        "settings": settings,
    }))
示例#2
0
def one_page_checkout(request, template_name="lfs/checkout/one_page_checkout.html"):
    """
    One page checkout form.
    """
    OnePageCheckoutForm = lfs.core.utils.import_symbol(ONE_PAGE_CHECKOUT_FORM)

    cart = lfs.cart.utils.get_cart(request)
    if cart is None:
        return HttpResponseRedirect(reverse('lfs_cart'))

    initial_address = {}
    shop = lfs.core.utils.get_default_shop(request)
    if request.user.is_anonymous():
        if shop.checkout_type == CHECKOUT_TYPE_AUTH:
            return HttpResponseRedirect(reverse("lfs_checkout_login"))
    else:
        initial_address['email'] = request.user.email

    customer = lfs.customer.utils.get_or_create_customer(request)

    invoice_address = customer.selected_invoice_address
    shipping_address = customer.selected_shipping_address
    bank_account = customer.selected_bank_account
    credit_card = customer.selected_credit_card

    if request.method == "POST":
        checkout_form = OnePageCheckoutForm(data=request.POST)
        iam = AddressManagement(customer, invoice_address, "invoice", request.POST, initial=initial_address)
        sam = AddressManagement(customer, shipping_address, "shipping", request.POST, initial=initial_address)
        bank_account_form = BankAccountForm(instance=bank_account, data=request.POST)
        credit_card_form = CreditCardForm(instance=credit_card, data=request.POST, prefix="credit_card")

        if shop.confirm_toc and ("confirm_toc" not in request.POST):
            toc = False
            if checkout_form.errors is None:
                checkout_form._errors = {}
            checkout_form.errors["confirm_toc"] = _(u"Please confirm our terms and conditions")
        else:
            toc = True

        # Prevent checkout if voucher is not valid (any more)
        voucher_number = request.POST.get("voucher")
        if voucher_number:
            try:
                voucher = Voucher.objects.get(number=voucher_number)
            except Voucher.DoesNotExist:
                is_valid_voucher = False
            else:
                is_valid_voucher = voucher.is_effective(request, cart)[0]
        else:
            is_valid_voucher = True

        if is_valid_voucher and checkout_form.is_valid() and bank_account_form.is_valid() and iam.is_valid() and sam.is_valid() and toc:
            if CHECKOUT_NOT_REQUIRED_ADDRESS == 'shipping':
                iam.save()
                if request.POST.get("no_shipping", "") == "":
                    # If the shipping address is given then save it.
                    sam.save()
                else:
                    # If the shipping address is not given, the invoice address is copied.
                    if customer.selected_invoice_address:
                        if customer.selected_shipping_address:
                            # it might be possible that shipping and invoice addresses are same object
                            if customer.selected_shipping_address.pk != customer.selected_invoice_address.pk:
                                customer.selected_shipping_address.delete()
                        shipping_address = deepcopy(customer.selected_invoice_address)
                        shipping_address.id = None
                        shipping_address.pk = None
                        shipping_address.save()
                        customer.selected_shipping_address = shipping_address
            else:
                sam.save()
                if request.POST.get("no_invoice", "") == "":
                    iam.save()
                else:
                    if customer.selected_shipping_address:
                        if customer.selected_invoice_address:
                            # it might be possible that shipping and invoice addresses are same object
                            if customer.selected_invoice_address.pk != customer.selected_shipping_address.pk:
                                customer.selected_invoice_address.delete()
                        invoice_address = deepcopy(customer.selected_shipping_address)
                        invoice_address.id = None
                        invoice_address.pk = None
                        invoice_address.save()
                        customer.selected_invoice_address = invoice_address
            customer.sync_selected_to_default_addresses()

            # Save payment method
            customer.selected_payment_method_id = request.POST.get("payment_method")

            # Save bank account
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_BANK:
                customer.selected_bank_account = bank_account_form.save()

            # Save credit card
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_CREDIT_CARD:
                customer.selected_credit_card = credit_card_form.save()

            customer.save()

            # process the payment method
            result = lfs.payment.utils.process_payment(request)

            if result["accepted"]:
                return HttpResponseRedirect(result.get("next_url", reverse("lfs_thank_you")))
            else:
                if "message" in result:
                    checkout_form._errors[result.get("message_location")] = result.get("message")

    else:
        checkout_form = OnePageCheckoutForm()
        iam = AddressManagement(customer, invoice_address, "invoice", initial=initial_address)
        sam = AddressManagement(customer, shipping_address, "shipping", initial=initial_address)
        bank_account_form = BankAccountForm(instance=bank_account)
        credit_card_form = CreditCardForm(instance=credit_card, prefix="credit_card")

    # Payment
    try:
        selected_payment_method_id = request.POST.get("payment_method")
        selected_payment_method = PaymentMethod.objects.get(pk=selected_payment_method_id)
    except PaymentMethod.DoesNotExist:
        selected_payment_method = lfs.payment.utils.get_selected_payment_method(request)

    valid_payment_methods = lfs.payment.utils.get_valid_payment_methods(request)
    display_bank_account = any([pm.type == lfs.payment.settings.PM_BANK for pm in valid_payment_methods])
    display_credit_card = any([pm.type == lfs.payment.settings.PM_CREDIT_CARD for pm in valid_payment_methods])

    return render(request, template_name, {
        "checkout_form": checkout_form,
        "bank_account_form": bank_account_form,
        "credit_card_form": credit_card_form,
        "invoice_address_inline": iam.render(request),
        "shipping_address_inline": sam.render(request),
        "shipping_inline": shipping_inline(request),
        "payment_inline": payment_inline(request, bank_account_form),
        "selected_payment_method": selected_payment_method,
        "display_bank_account": display_bank_account,
        "display_credit_card": display_credit_card,
        "voucher_number": lfs.voucher.utils.get_current_voucher_number(request),
        "cart_inline": cart_inline(request),
        "settings": settings,
    })
示例#3
0
def one_page_checkout(request,
                      template_name="lfs/checkout/one_page_checkout.html"):
    """
    One page checkout form.
    """
    OnePageCheckoutForm = lfs.core.utils.import_symbol(ONE_PAGE_CHECKOUT_FORM)

    cart = lfs.cart.utils.get_cart(request)
    if cart is None:
        return HttpResponseRedirect(reverse('lfs_cart'))

    initial_address = {}
    shop = lfs.core.utils.get_default_shop(request)
    if request.user.is_anonymous():
        if shop.checkout_type == CHECKOUT_TYPE_AUTH:
            return HttpResponseRedirect(reverse("lfs_checkout_login"))
    else:
        initial_address['email'] = request.user.email

    customer = lfs.customer.utils.get_or_create_customer(request)

    invoice_address = customer.selected_invoice_address
    shipping_address = customer.selected_shipping_address
    bank_account = customer.selected_bank_account
    credit_card = customer.selected_credit_card
    dinheiro_troco = customer.selected_dinheiro_troco

    if request.method == "POST":
        checkout_form = OnePageCheckoutForm(data=request.POST)
        iam = AddressManagement(customer,
                                invoice_address,
                                "invoice",
                                request.POST,
                                initial=initial_address)
        sam = AddressManagement(customer,
                                shipping_address,
                                "shipping",
                                request.POST,
                                initial=initial_address)
        bank_account_form = BankAccountForm(instance=bank_account,
                                            data=request.POST)
        credit_card_form = CreditCardForm(instance=credit_card,
                                          data=request.POST)
        dinheiro_troco_form = DinheiroTrocoForm(instance=dinheiro_troco,
                                                data=request.POST)

        if shop.confirm_toc and ("confirm_toc" not in request.POST):
            toc = False
            if checkout_form.errors is None:
                checkout_form._errors = {}
            checkout_form.errors["confirm_toc"] = _(
                u"Please confirm our terms and conditions")
        else:
            toc = True

        if checkout_form.is_valid() and bank_account_form.is_valid(
        ) and dinheiro_troco_form.is_valid() and iam.is_valid(
        ) and sam.is_valid() and toc:
            if CHECKOUT_NOT_REQUIRED_ADDRESS == 'shipping':
                iam.save()
                if request.POST.get("no_shipping", "") == "":
                    # If the shipping address is given then save it.
                    sam.save()
                else:
                    # If the shipping address is not given, the invoice address is copied.
                    if customer.selected_invoice_address:
                        if customer.selected_shipping_address:
                            # it might be possible that shipping and invoice addresses are same object
                            if customer.selected_shipping_address.pk != customer.selected_invoice_address.pk:
                                customer.selected_shipping_address.delete()
                        shipping_address = deepcopy(
                            customer.selected_invoice_address)
                        shipping_address.id = None
                        shipping_address.pk = None
                        shipping_address.save()
                        customer.selected_shipping_address = shipping_address
            else:
                sam.save()
                if request.POST.get("no_invoice", "") == "":
                    iam.save()
                else:
                    if customer.selected_shipping_address:
                        if customer.selected_invoice_address:
                            # it might be possible that shipping and invoice addresses are same object
                            if customer.selected_invoice_address.pk != customer.selected_shipping_address.pk:
                                customer.selected_invoice_address.delete()
                        invoice_address = deepcopy(
                            customer.selected_shipping_address)
                        invoice_address.id = None
                        invoice_address.pk = None
                        invoice_address.save()
                        customer.selected_invoice_address = invoice_address
            customer.sync_selected_to_default_addresses()

            # Save payment method
            customer.selected_payment_method_id = request.POST.get(
                "payment_method")

            # Save bank account
            forma_pagamento = ""
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_BANK:
                customer.selected_bank_account = bank_account_form.save()
                forma_pagamento = "Deposito em\n\nSUPERMERCADO SANTA RITA LTDA ME\nBANCO - CAIXA ECONOMICA\nAGENCIA: 0739\nCONTA CORRENTE: 1278-8\nOPERACAO: 003\n\nOU\n\nSUPERMERCADO SANTA RITA LTDA ME\nBANCO - BANCO DO BRASIL\nAGENCIA: 07757\nCONTA CORRENTE: 13589-5\n\n"

            # Save credit card
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_CREDIT_CARD:
                customer.selected_credit_card = credit_card_form.save()
                forma_pagamento = credit_card_form.cleaned_data
                forma_pagamento = "cartao {}".format(forma_pagamento["type"])

            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_DINHEIRO_TROCO:
                customer.selected_dinheiro_troco = dinheiro_troco_form.save()
                forma_pagamento = dinheiro_troco_form.cleaned_data
                forma_pagamento = "dinheiro e troco para {}".format(
                    forma_pagamento["Troco"].encode('utf-8'))

            # msg whatsapp
            selected_payment_method = lfs.payment.utils.get_selected_payment_method(
                request)
            selected_shipping_method = lfs.shipping.utils.get_selected_shipping_method(
                request)
            payment_costs = lfs.payment.utils.get_payment_costs(
                request, selected_payment_method)
            shipping_costs = lfs.shipping.utils.get_shipping_costs(
                request, selected_shipping_method)
            cart_price = cart.get_price_gross(request) + shipping_costs[
                "price_gross"] + payment_costs["price"]
            cart_items = []
            if cart:
                for cart_item in cart.get_items():
                    product = cart_item.product
                    quantity = product.get_clean_quantity(cart_item.amount)
                    cart_items.append({
                        "obj":
                        cart_item,
                        "quantity":
                        quantity,
                        "product":
                        product,
                        "product_price_net":
                        cart_item.get_price_net(request),
                        "product_price_gross":
                        cart_item.get_price_gross(request),
                        "product_tax":
                        cart_item.get_tax(request),
                    })

                cliente = customer.get_selected_shipping_address()

                termos_replace = [" ", "-", "_", "\\", "/", ")", "(", ",", "."]
                telefone = cliente.phone
                for termo in termos_replace:
                    telefone = telefone.replace(termo, "")
                telefone = telefone[-8:]
                telefone = "5579" + telefone.encode('utf-8')
                nome = cliente.firstname.encode('utf-8')
                total = cart_price
                msgw = 'Oi {}! Aqui é do Compre Sem Fila, venho lhe informar que o pedido no valor de {} com pagamento atraves de {} foi recebido com sucesso.\nObrigado!'.format(
                    nome, total,
                    forma_pagamento).decode("utf-8").encode("utf-8")
                comando = '{}/bin/python {}/yowsup/yowsup-cli demos -c {}/yowsup/config -s "{}" "{}"'.format(
                    sys.exec_prefix, sys.exec_prefix, sys.exec_prefix,
                    telefone, msgw)
                comando1 = '{}/bin/python {}/yowsup/yowsup-cli demos -c {}/yowsup/config -s "{}" "{}"'.format(
                    sys.exec_prefix, sys.exec_prefix, sys.exec_prefix,
                    "557999438361", msgw)
                comando2 = '{}/bin/python {}/yowsup/yowsup-cli demos -c {}/yowsup/config -s "{}" "{}"'.format(
                    sys.exec_prefix, sys.exec_prefix, sys.exec_prefix,
                    "557999654384", msgw)
                os.system(comando)
                os.system(comando1)
                os.system(comando2)

                # process the payment method
                result = lfs.payment.utils.process_payment(request)

                if result["accepted"]:
                    return HttpResponseRedirect(
                        result.get("next_url", reverse("lfs_thank_you")))
                else:
                    if "message" in result:
                        checkout_form._errors[result.get(
                            "message_location")] = result.get("message")

    else:
        checkout_form = OnePageCheckoutForm()
        iam = AddressManagement(customer,
                                invoice_address,
                                "invoice",
                                initial=initial_address)
        sam = AddressManagement(customer,
                                shipping_address,
                                "shipping",
                                initial=initial_address)
        bank_account_form = BankAccountForm(instance=bank_account)
        credit_card_form = CreditCardForm(instance=credit_card)
        dinheiro_troco_form = DinheiroTrocoForm(instance=dinheiro_troco)

    # Payment
    try:
        selected_payment_method_id = request.POST.get("payment_method")
        selected_payment_method = PaymentMethod.objects.get(
            pk=selected_payment_method_id)
    except PaymentMethod.DoesNotExist:
        selected_payment_method = lfs.payment.utils.get_selected_payment_method(
            request)

    valid_payment_methods = lfs.payment.utils.get_valid_payment_methods(
        request)
    display_bank_account = any([
        pm.type == lfs.payment.settings.PM_BANK for pm in valid_payment_methods
    ])
    display_credit_card = any([
        pm.type == lfs.payment.settings.PM_CREDIT_CARD
        for pm in valid_payment_methods
    ])
    display_dinheiro_troco = any([
        pm.type == lfs.payment.settings.PM_DINHEIRO_TROCO
        for pm in valid_payment_methods
    ])

    return render_to_response(
        template_name,
        RequestContext(
            request, {
                "checkout_form":
                checkout_form,
                "bank_account_form":
                bank_account_form,
                "credit_card_form":
                credit_card_form,
                "dinheiro_troco_form":
                dinheiro_troco_form,
                "invoice_address_inline":
                iam.render(request),
                "shipping_address_inline":
                sam.render(request),
                "shipping_inline":
                shipping_inline(request),
                "payment_inline":
                payment_inline(request, bank_account_form),
                "selected_payment_method":
                selected_payment_method,
                "display_bank_account":
                display_bank_account,
                "display_credit_card":
                display_credit_card,
                "display_dinheiro_troco":
                display_dinheiro_troco,
                "voucher_number":
                lfs.voucher.utils.get_current_voucher_number(request),
                "cart_inline":
                cart_inline(request),
                "settings":
                settings,
            }))
示例#4
0
def one_page_checkout(request,
                      template_name="lfs/checkout/one_page_checkout.html"):
    """
    One page checkout form.
    """
    cart = lfs.cart.utils.get_cart(request)
    if cart is None:
        return HttpResponseRedirect(reverse('lfs_cart'))

    shop = lfs.core.utils.get_default_shop(request)
    if request.user.is_anonymous(
    ) and shop.checkout_type == CHECKOUT_TYPE_AUTH:
        return HttpResponseRedirect(reverse("lfs_checkout_login"))

    customer = lfs.customer.utils.get_or_create_customer(request)
    invoice_address = customer.selected_invoice_address
    shipping_address = customer.selected_shipping_address
    bank_account = customer.selected_bank_account
    credit_card = customer.selected_credit_card

    if request.method == "POST":
        checkout_form = OnePageCheckoutForm(data=request.POST)
        iam = AddressManagement(invoice_address, "invoice", request.POST)
        sam = AddressManagement(shipping_address, "shipping", request.POST)
        bank_account_form = BankAccountForm(instance=bank_account,
                                            data=request.POST)
        credit_card_form = CreditCardForm(instance=credit_card,
                                          data=request.POST)

        if shop.confirm_toc and ("confirm_toc" not in request.POST):
            toc = False
            if checkout_form.errors is None:
                checkout_form.errors = {}
            checkout_form.errors["confirm_toc"] = _(
                u"Please confirm our terms and conditions")
        else:
            toc = True

        if checkout_form.is_valid() and bank_account_form.is_valid(
        ) and iam.is_valid() and sam.is_valid() and toc:
            # Save addresses
            iam.save()

            # If there the shipping address is not given, the invoice address
            # is copied.
            if request.POST.get("no_shipping", "") == "":
                sam.save()
            else:
                shipping_address = deepcopy(customer.selected_invoice_address)
                shipping_address.id = None
                shipping_address.save()
                customer.selected_shipping_address = shipping_address

            # Save payment method
            customer.selected_payment_method_id = request.POST.get(
                "payment_method")

            # Save bank account
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_BANK:
                customer.selected_bank_account = bank_account_form.save()

            # Save credit card
            if customer.selected_payment_method_id and \
               int(customer.selected_payment_method_id) == lfs.payment.settings.PM_CREDIT_CARD:
                customer.selected_credit_card = credit_card_form.save()

            customer.save()

            # process the payment method
            result = lfs.payment.utils.process_payment(request)

            if result["accepted"]:
                return HttpResponseRedirect(
                    result.get("next_url", reverse("lfs_thank_you")))
            else:
                if "message" in result:
                    form._errors[result.get("message_location")] = result.get(
                        "message")

    else:
        checkout_form = OnePageCheckoutForm()
        iam = AddressManagement(invoice_address, "invoice")
        sam = AddressManagement(shipping_address, "shipping")
        bank_account_form = BankAccountForm(instance=bank_account)
        credit_card_form = CreditCardForm(instance=credit_card)

    # Payment
    try:
        selected_payment_method_id = request.POST.get("payment_method")
        selected_payment_method = PaymentMethod.objects.get(
            pk=selected_payment_method_id)
    except PaymentMethod.DoesNotExist:
        selected_payment_method = lfs.payment.utils.get_selected_payment_method(
            request)

    valid_payment_methods = lfs.payment.utils.get_valid_payment_methods(
        request)
    display_bank_account = any([
        pm.type == lfs.payment.settings.PM_BANK for pm in valid_payment_methods
    ])
    display_credit_card = any([
        pm.type == lfs.payment.settings.PM_CREDIT_CARD
        for pm in valid_payment_methods
    ])

    return render_to_response(
        template_name,
        RequestContext(
            request, {
                "checkout_form":
                checkout_form,
                "bank_account_form":
                bank_account_form,
                "credit_card_form":
                credit_card_form,
                "invoice_address_inline":
                iam.render(request),
                "shipping_address_inline":
                sam.render(request),
                "shipping_inline":
                shipping_inline(request),
                "payment_inline":
                payment_inline(request, bank_account_form),
                "selected_payment_method":
                selected_payment_method,
                "display_bank_account":
                display_bank_account,
                "display_credit_card":
                display_credit_card,
                "voucher_number":
                lfs.voucher.utils.get_current_voucher_number(request),
                "cart_inline":
                cart_inline(request),
                "settings":
                settings,
            }))