Ejemplo n.º 1
0
def edit_address_view(request, pk):
    address = get_object_or_404(Address, pk=pk, user=request.user)
    if request.method == 'POST':
        form = AddressForm(request.POST, instance=address)
        if form.is_valid():
            contact_name = form.cleaned_data['contact_name']
            country_name = form.cleaned_data['country_name']
            city_name = form.cleaned_data['city_name']
            state_name = form.cleaned_data['state_name']
            street_address_line_1 = form.cleaned_data['street_address_line_1']
            street_address_line_2 = form.cleaned_data['street_address_line_2']
            zipcode = form.cleaned_data['zipcode']
            phone_number = form.cleaned_data['phone_number']
            country_code_phone_number = form.cleaned_data['country_code_phone_number']

            address.contact_name = contact_name
            address.country_name = country_name
            address.city_name = city_name
            address.state_name = state_name
            address.street_address_line_1 = street_address_line_1
            address.street_address_line_2 = street_address_line_2
            address.zipcode = zipcode
            address.phone_number = phone_number
            address.country_code_phone_number = country_code_phone_number
            address.last_updated_datetime = datetime.datetime.now()

            address.save()
            return HttpResponseRedirect(reverse('accounts:address'))
    else:
        form = AddressForm(instance=address)

    return render(request, "accounts/edit_address.html", {'form': form})
Ejemplo n.º 2
0
Archivo: views.py Proyecto: scotfu/M
def save(request, address_id=None):
    user=request.user
    if request.method =='POST':
        form=AddressForm(request.POST)
        if form.is_valid():
            if form.cleaned_data['address_id']:
                address=Address.objects.get(pk=form.cleaned_data['address_id'])
            else:
                address=Address()
            address.name=form.cleaned_data['name']
            address.address=form.cleaned_data['address']
            address.postal_code=form.cleaned_data['postal_code']
            address.user=user
            address.save()
            return HttpResponseRedirect('/address/')
    else:
        if address_id:
            address=Address.objects.get(pk=address_id)
            if address.user==request.user:
                form=AddressForm(initial={'address_id': address.id,
                    'name': address.name, 'address': address.address,
                    'postal_code': address.postal_code})
        else:
            form=AddressForm()
    return render_to_response('address_form.html', {
            'form': form},
             context_instance=RequestContext(request))
Ejemplo n.º 3
0
 def test_address_form_fails_without_some_field(self):
     form = AddressForm({
         'house_number_name': '8 house',
         'street': '11 test street',
         'town': 'test town',
     })
     self.assertFalse(form.is_valid())
Ejemplo n.º 4
0
def add_address_company(request):
    if request.method == 'POST':
        form = AddressForm(request.POST)
        if form.is_valid():
            endereco = form.save()
            return redirect(request.user.get_absolute_url() )
    else:
        form = AddressForm(initial={'empregador': request.user.empregador})
    
    return render_to_response('accounts/add_address_company.html', {'form': form}, RequestContext(request))
Ejemplo n.º 5
0
 def test_address_form(self):
     form = AddressForm({
         'house_number_name': '8 house',
         'street': '11 test street',
         'town': 'test town',
         'postcode': 'sss',
     })
     self.assertTrue(form.is_valid())
     # get user
     user = User.objects.get(pk=16)
     # assign user to address
     address = form.save(commit=False)
     address.user = user
     # save address
     address.save()
     # check if saved address is user's address now
     self.assertTrue(address, user.address_set.all())
Ejemplo n.º 6
0
def address_create_view(request):
    form = AddressForm(request.POST or None)

    if form.is_valid():
        print(request.POST)
        instance = form.save(commit=False)
        billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(request=request)
        cart_obj = Cart.objects.new_or_get(request=request)

        if billing_profile is not None:
            order_obj, order_obj_created = Order.objects.new_or_get(cart_obj=cart_obj, billing_profile=billing_profile)
            payment_method = request.POST.get("payment_method", None)
            if payment_method:
                order_obj.payment_method = payment_method
                order_obj.save()
            instance.billing_profile = billing_profile
            instance.save()
            request.session['billing_address_id'] = instance.id
        else:
            messages.error(request, "Might have some problem....!")
            return redirect("cart:checkout")

    return redirect("cart:checkout")
Ejemplo n.º 7
0
def edit_customer(request, profile_id):
    if profile_id is not None:
        user_profile = get_object_or_404(UserProfile, pk=profile_id)
        user = user_profile.user
        try:
            address = Address.objects.get(user=user)
        except Address.DoesNotExist:
            address = None
        if request.POST:
            userprofile_form = UserProfileForm(request.POST, )
            if userprofile_form.is_valid():
                user_profile.title = userprofile_form.cleaned_data['title']
                user_profile.date_of_birth = userprofile_form.cleaned_data[
                    'date_of_birth']
                user_profile.phone = userprofile_form.cleaned_data['phone']

                user_profile.save()

            address_form = AddressForm(request.POST)
            if address_form.is_valid():
                if not address:
                    address = Address()
                    address.user = user
                address.line_1 = address_form.cleaned_data['line_1']
                address.line_2 = address_form.cleaned_data['line_2']
                address.city = address_form.cleaned_data['city']
                address.county = address_form.cleaned_data['county']
                address.postcode = address_form.cleaned_data['postcode']
                address.save()

        return render_to_response(
            'admin/accounts/edit_customer.html', {
                'userprofile_form': UserProfileForm(instance=user_profile),
                'address_form': AddressForm(instance=address),
                'user_profile': user_profile,
            }, RequestContext(request))
Ejemplo n.º 8
0
def edit_customer(request, profile_id):
    if profile_id is not None:
        user_profile = get_object_or_404(UserProfile, pk=profile_id)
        user = user_profile.user
        try:
            address = Address.objects.get(user=user)
        except Address.DoesNotExist:
            address = None
        if request.POST:
            userprofile_form = UserProfileForm(request.POST,)
            if userprofile_form.is_valid():
                user_profile.title = userprofile_form.cleaned_data['title']
                user_profile.date_of_birth = userprofile_form.cleaned_data['date_of_birth']
                user_profile.phone = userprofile_form.cleaned_data['phone']

                user_profile.save()

            address_form = AddressForm(request.POST)
            if address_form.is_valid():
                if not address:
                    address = Address()
                    address.user = user
                address.line_1 = address_form.cleaned_data['line_1']
                address.line_2 = address_form.cleaned_data['line_2']
                address.city = address_form.cleaned_data['city']
                address.county = address_form.cleaned_data['county']
                address.postcode = address_form.cleaned_data['postcode']
                address.save()

        return render_to_response('admin/accounts/edit_customer.html',
                {
                    'userprofile_form': UserProfileForm(instance=user_profile),
                    'address_form': AddressForm(instance=address),
                    'user_profile' : user_profile,
                },   RequestContext(request)
                )
Ejemplo n.º 9
0
def new_address(request):
    # if this is a POST request we need to process the form data
    if request.method == 'POST':
        # create a form instance and populate it with data from the request:
        form = AddressForm(request.POST)
        # check whether it's valid:
        if form.is_valid():
            # process the data in form.cleaned_data as required
            # ...
            # redirect to a new URL:

            contact_name = form.cleaned_data['contact_name']
            country_name = form.cleaned_data['country_name']
            city_name = form.cleaned_data['city_name']
            state_name = form.cleaned_data['state_name']
            street_address_line_1 = form.cleaned_data['street_address_line_1']
            street_address_line_2 = form.cleaned_data['street_address_line_2']
            zipcode = form.cleaned_data['zipcode']
            phone_number = form.cleaned_data['phone_number']
            country_code_phone_number = form.cleaned_data['country_code_phone_number']

            Address.objects.create(user=request.user, contact_name=contact_name,
                                   country_name=country_name, city_name=city_name,state_name=state_name,
                                   street_address_line_1=street_address_line_1,
                                   street_address_line_2=street_address_line_2, zipcode=zipcode,
                                   phone_number=phone_number,
                                   country_code_phone_number=country_code_phone_number,
                                   )

            return HttpResponseRedirect(reverse("accounts:address"))

    # if a GET (or any other method) we'll create a blank form
    else:
        form = AddressForm()

    return render(request, "accounts/new_address.html", {'form': form})
Ejemplo n.º 10
0
def delete_address(request, pk):
    address = Address.objects.get(pk=pk)
    form = AddressForm(instance=address)

    for _, field in form.fields.items():
        field.widget.attrs['disabled'] = True

    if request.method == 'GET':
        context = {
            'form': form,
            'address': address,
        }
        return render(request, 'accounts/delete_address.html', context)
    else:
        address.delete()
        return redirect('user addresses')
Ejemplo n.º 11
0
def checkout_home(request):
    order_obj = None
    if request.user.is_authenticated:
        cart_obj = Cart.objects.new_or_get(request)
        if cart_obj.products.count() == 0:
            messages.info(request, "Cart is empty now!")
            return redirect("cart:home")
        address_form = AddressForm()

        billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(
            request=request)

        if billing_profile is not None:
            order_obj, order_obj_created = Order.objects.new_or_get(
                cart_obj=cart_obj, billing_profile=billing_profile)

            billing_address_id = request.session.get('billing_address_id')
            if billing_address_id:
                order_obj.billing_address = Address.objects.get(
                    id=billing_address_id)
                del request.session['billing_address_id']
                order_obj.save()

        if request.method == 'POST':
            if order_obj.check_done():
                if order_obj.payment_method == 'Cash On Delivery':
                    request.session['cart_items_count'] = 0
                    del request.session["cart_id"]
                    return redirect("cart:success")
                else:
                    order_obj.mark_paid()
                    print(
                        "Credit or debit selected. go to the online payment page."
                    )
                    return redirect("cart:payment_page")

    else:
        messages.warning(request, "Please login, you cannot access this page.")
        return redirect("account:login")

    context = {
        'address_form': address_form,
        'cart_obj': cart_obj,
        'order_obj': order_obj,
        'billing_profile': billing_profile
    }
    return render(request, "carts/checkout.html", context=context)
Ejemplo n.º 12
0
def create_address(request):
    if request.method == 'GET':
        form = AddressForm()
        context = {
            'form': form,
        }
        return render(request, 'accounts/create_address.html', context)
    else:
        form = AddressForm(request.POST)
        if form.is_valid():
            address = form.save(commit=False)
            address.profile_id = request.user.profile.id
            address.is_default = False
            address.save()
            return redirect('user addresses')
        context = {
            'form': form,
        }
        return render(request, 'accounts/create_address.html', context)
Ejemplo n.º 13
0
def edit_address(request, pk):
    address = Address.objects.get(pk=pk)
    if request.method == 'GET':
        form = AddressForm(instance=address)
        context = {
            'form': form,
            'address': address,
        }
        return render(request, 'accounts/edit_address.html', context)
    else:
        form = AddressForm(request.POST, instance=address)
        if form.is_valid():
            address = form.save(commit=False)
            address.profile = request.user.profile
            address.is_default = False
            address.save()
            return redirect('user addresses')
        context = {
            'form': form,
            'address': address,
        }
        return render(request, 'accounts/edit_address.html', context)
Ejemplo n.º 14
0
def checkout_home(request):
    stripe_session_id = request.session.get('stripe_session_id')
    cart_obj, cart_created = Cart.objects.new_or_get(request)
    order_obj = None
    if cart_created or cart_obj.products.count() == 0:
        return redirect("cart:home")

    login_form = UserLoginForm()
    address_form = AddressForm()
    billing_address_id = request.session.get("billing_address_id", None)
    shipping_address_id = request.session.get("shipping_address_id", None)

    # billing address save with order
    billing_profile, billing_guest_profile_created = BillingProfile.objects.new_or_get(
        request)
    address_qs = None
    if billing_profile is not None:
        address_qs = Address.objects.filter(billing_profile=billing_profile)

        order_obj, order_obj_created = Order.objects.new_or_get(
            billing_profile, cart_obj)
        request.session["order_obj_id"] = order_obj.id
        if shipping_address_id:
            order_obj.shipping_address = Address.objects.get(
                id=shipping_address_id)
            del request.session["shipping_address_id"]
        if billing_address_id:
            order_obj.billing_address = Address.objects.get(
                id=billing_address_id)
            del request.session["billing_address_id"]
        if billing_address_id or shipping_address_id:
            order_obj.save()

    # stripe integration
    if not stripe_session_id:
        try:
            order_obj_forStripe = Order.objects.get(cart=cart_obj)
            product_data_forStripe = []
            host_uri = "{}://{}".format(request.scheme, request.get_host())

            # Add each item into stripe list
            for item in order_obj_forStripe.cart.products.all():
                product_data_forStripe.append({
                    'name':
                    item.title,
                    'description':
                    item.description,
                    'images': [urljoin(host_uri, "media/" + str(item.image))],
                    'amount':
                    int(item.price * 100),
                    'currency':
                    'usd',
                    'quantity':
                    1,
                })

            # stripe checkout
            stripe.api_key = settings.STRIPE_SECRET_KEY

            stripeSession = stripe.checkout.Session.create(
                payment_method_types=['card'],
                line_items=product_data_forStripe,
                success_url=urljoin(
                    host_uri,
                    reverse("cart:success") +
                    '?session_id={CHECKOUT_SESSION_ID}'),
                cancel_url=urljoin(host_uri, 'checkout/cancel'),
            )
            stripe_session_id = stripeSession.get('id')
            request.session['stripe_session_id'] = stripe_session_id
        except Order.DoesNotExist:
            # no need stripe if no order
            pass

    context = {
        "object": order_obj,
        "billing_profile": billing_profile,
        "login_form": login_form,
        "address_form": address_form,
        "address_qs": address_qs,
        "stripe_pub_key": settings.STRIPE_PUBLISHABLE_KEY,
        "stripe_session_id": stripe_session_id,
    }
    return render(request, "cart/checkout.html", context)