Esempio n. 1
0
def process_payment(stripe_email, stripe_token, form):
    order = Order(
        state='S',
        from_first_name=form.cleaned_data['from_first_name'],
        from_last_name=form.cleaned_data['from_last_name'],
        from_email=stripe_email,
        stripe_tx=stripe_token,
        to_first_name=form.cleaned_data['to_first_name'],
        to_last_name=form.cleaned_data['to_last_name'],
        delivery_company_name=form.cleaned_data['delivery_company_name'],
        delivery_first=form.cleaned_data['delivery_first'],
        delivery_second=form.cleaned_data['delivery_second'],
        delivery_third=form.cleaned_data['delivery_third'],
        delivery_postcode=form.cleaned_data['delivery_postcode'],
        delivery_note=form.cleaned_data['delivery_note'],
    )

    try:
        # Create a charge: this will charge the user's card
        charge = stripe.Charge.create(amount=1600,
                                      currency='gbp',
                                      source=stripe_token,
                                      description='One succulent surprise')

        order.state = 'P'
    except stripe.error.CardError as e:
        # The card has been declined
        order.state = 'E'
    finally:
        order.save()

    return order
Esempio n. 2
0
def cart(request):
    cart = request.session.get('cart', {})
    entries = [Entry(product=Product.objects.get(pk=pk),
                     quantity=cart[pk]) for pk in cart]
    if request.method == 'POST':
        form = OrderForm(request.POST)
        if form.is_valid():
            order = Order(customer=request.user)
            order.address = form.cleaned_data['address']
            order.save()
            for entry in entries:
                entry.order = order
            Entry.objects.bulk_create(entries)
            messages.add_message(request, 777, f'Thanks for shopping! Your order was created with ID: {order.pk}.')
            request.session['cart'] = {}
            return redirect('profile:profile')
    else:
        data = {'name': request.user.name,
                'phone': request.user.phone}
        form = OrderForm(initial=data)

    total_price = sum(entry.price for entry in entries)
    context = {
        'entries': entries,
        'total_price': total_price,
        'form': form,
        'cart': sum(request.session.get('cart', {}).values()),
    }
    return render(request, 'cart.html', context)
Esempio n. 3
0
def custom_confirmation(request):
    if request.method == "POST":
        form = CustomOrderForm(request.POST)
        # Check if the form is valid:
        if form.is_valid():
            material_id = form.cleaned_data['custom_material']

            order_obj = Order(
                first_name=form.cleaned_data['first_name'],
                last_name=form.cleaned_data['last_name'],
                student_id=form.cleaned_data['student_id'],
                email=form.cleaned_data['email'],
                phone=form.cleaned_data['phone'],
                is_custom=True,
                custom_links=form.cleaned_data['custom_links'],
                custom_quantity=form.cleaned_data['custom_quantity'],
                custom_material=Material.objects.get(
                    id=material_id) if material_id != -1 else None,
                special_instructions=form.cleaned_data['special_instructions'],
                grand_total=0.0)
            order_obj.save()

            context = {"order": order_obj}

            send_confirmation_email(context, form.cleaned_data['email'])

            return render(request, 'confirmation.html', context=context)
    else:
        return custom_ordering(request)
Esempio n. 4
0
    def save(self, cart):
        first_name = self.cleaned_data.get('first_name')
        last_name = self.cleaned_data.get('last_name')
        street = self.cleaned_data.get('street')
        house_number = self.cleaned_data.get('house_number')
        flat_number = self.cleaned_data.get('flat_number')
        zip_code = self.cleaned_data.get('zip_code')
        phone_number = self.cleaned_data.get('phone_number')
        city = self.cleaned_data.get('city')

        order = Order()
        order.first_name = first_name
        order.last_name = last_name
        order.street = street
        order.house_number = house_number
        order.flat_number = flat_number
        order.zip_code = zip_code
        order.phone_number = phone_number
        order.city = city
        order.user = self.user
        order.save()

        for item in cart:
            order_item = OrderItem()
            order_item.order = order
            order_item.product = item['product']
            order_item.price = item['price']
            order_item.quantity = item['quantity']
            order_item.save()
Esempio n. 5
0
 def post(self, request):
     is_valid = True
     # Validation on the submitted request
     if len(request.DATA['order_items']) == 0:
         # Failed due to empty order
         is_valid = False
         response_data = {
             'status': 'failed',
             'reason': 'order_items cannot be empty'
         }
     if is_valid:
         order = Order(**request.DATA['order_data'])
         order.save()
         # Create OrderItem instances from the submitted order
         order_items = request.DATA['order_items']
         for item in order_items:
             new_item = OrderItem()
             new_item.beer = Beer.objects.get(pk=item['beer']['id'])
             new_item.quantity = item['quantity']
             new_item.order = order
             new_item.save()
         # Send relevant emails
         order.notify_ert()
         order.send_confirmation()
         # Send API response
         response_data = {'status': 'success', 'order_id': order.id}
         response = Response(response_data)
     else:
         response = Response(response_data,
                             status=status.HTTP_400_BAD_REQUEST)
     return response
Esempio n. 6
0
def checkout(request):
    if request.method == "POST":
        item_json = request.POST.get('item_json', '')
        name = request.POST.get('name', '')
        email = request.POST.get('email', '')
        address = request.POST.get('add1', '') + request.POST.get('add2', '')
        city = request.POST.get('city', '')
        zip_code = request.POST.get('name', '')
        state = request.POST.get('name', '')

        order = Order(item_json=item_json,
                      name=name,
                      email=email,
                      address=address,
                      city=city,
                      zip_code=zip_code,
                      state=state)
        order.save()
        thank = True
        id = order.order_id
        return render(request, 'store/checkout.html', {
            'thank': thank,
            "id": id
        })

    return render(request, 'store/checkout.html')
Esempio n. 7
0
    def create(self, request):
        session_key = request.META['HTTP_SESSION_KEY']
        cart = get_object_or_404(Cart, session_key=session_key)
        data = request.data
        buyer = Buyer(name=data['name'],
                      surname=data['surname'],
                      email=data['email'],
                      phone=data['phone'],
                      address=data['address'])
        buyer.save()

        order = Order(cart=cart, buyer=buyer)
        order.save()

        # get all staff that have email
        staff = User.objects.filter(is_staff=True).exclude(email__exact='')

        emails = [user.email for user in staff]

        send_mail(
            "Новый заказ",
            "Новый заказ от {} {}. Посетите админку https://apimystore.artsmn.ml/admin/ .\n Order id: {}"
            .format(buyer.name, buyer.surname,
                    order.id), settings.EMAIL_HOST_USER, emails)

        serializer = OrderSerializer(order)
        return Response(serializer.data, 201)
Esempio n. 8
0
def checkout(request):
    if request.method == 'POST':
        items_json = request.POST.get('itemsjson', "")
        amount = request.POST.get('amount', "")
        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 = request.POST.get('zip', "")
        phone = request.POST.get('phone', "")
        order = Order(items_json=items_json,
                      name=name,
                      email=email,
                      address=address,
                      city=city,
                      state=state,
                      zip=zip,
                      phone=phone,
                      amount=amount)
        order.save()
        thank = True
        id = order.order_id
        return render(request, 'store/checkout.html', {
            'thank': thank,
            'id': id
        })
    return render(request, 'store/checkout.html')
Esempio n. 9
0
def orderInfo(request):
    print(request.POST)
    if not request.session['loggedIn']:
        return redirect('store_front')
    else:
        with connection.cursor() as cursor:
            cursor.execute(
                "SELECT p.Name, p.Price, p.ID FROM store_product p, store_cart c, store_cart_Product_ID cp WHERE c.Customer_Email_id=%s AND c.id = cp.cart_id AND cp.product_id = p.id",
                [request.session['userName']])
            cartItems = cursor.fetchall()
            cursor.execute(
                "SELECT SUM(p.Price) FROM store_product p, store_cart c, store_cart_Product_ID cp WHERE c.Customer_Email_id=%s AND c.id = cp.cart_id AND cp.product_id = p.id",
                [request.session['userName']])
            totalPrice = cursor.fetchone()[0]
            cursor.execute("SELECT Address FROM store_customer WHERE Email = %s", [request.session['userName']])
            address = cursor.fetchone()[0]
        if request.method == 'POST' and 'placeOrder' in request.POST:
            print('working')
            newOrder = Order()
            newOrder.Total_Price = totalPrice
            newOrder.Shipping_Info = request.POST['shippingAddress']
            newOrder.Billing_Info = request.session['ccNum']
            request.session['ccNum'] = None
            newOrder.Placed_By = Customer.objects.get(pk=request.session['userName'])
            newOrder.save()
            for item in cartItems:
                newOrder.Product_ID.add(item[2])
            myCart = Cart.objects.get(Customer_Email=request.session['userName'])
            myCart.Product_ID.clear()
            return order(request, newOrder.Order_Number)
        return render(request, 'store/orderInfo.html', {'cartItems': cartItems,
                                                        'total': totalPrice,
                                                        'shippingAddress': address,
                                                        'creditCard': request.session['ccNum']})
Esempio n. 10
0
def create(request):
    #set_day = request.POST['set_day'] 셋데이 여기서 빼고, 밑에 order=Order(set_day 여기서도 뺐다)
    pickuptime = request.POST['pickuptime']
    today_lineup = request.POST['today_lineup']
    order_quota = request.POST['order_quota']
    ordered_date = request.POST['orderd_date']
    order = Order(pickuptime=pickuptime, orderedate=timezone.now())
    orderlist = Orderlist(today_lineup=today_lineup, order_quota=order_quota)
    order.save()
    orderlist.save()
    #누구누구님안녕하세요 기능넣고, first_name order db로 넘기기
    return redirect('store:order_detail', order_id=order.id)
Esempio n. 11
0
def cart_form(request):
    if request.method == 'POST' and request.is_ajax():
        print(request)
        name = request.POST.get('field1')
        address = request.POST.get('location')
        email = request.POST.get('field2')
        message = request.POST.get('field3')
        phone = request.POST.get('field4')

        client = Client(name=name,
                        address=address,
                        email=email,
                        phone=phone,
                        message=message)
        client.save()

        products = {}
        items = []
        i = 0
        while request.POST.get('products[' + str(i) + '][id]') is not None:
            id = request.POST.get('products[' + str(i) + '][id]')
            amount = request.POST.get('products[' + str(i) + '][amount]')
            products[id] = amount
            i += 1
            item = OrderItems(product=Product.objects.get(pk=id),
                              amount=amount)
            item.save()
            items.append(item)

        order = Order(client=client)
        order.save()
        order.orderItems.set(items)

        subject = 'טופס הזמנה חדש של חקלתות'
        recipient_list = [
            '*****@*****.**',
        ]
        my_body = 'שם: {}\n כתובת: {}\n מייל: {}\n פאלפון: {}\n הערות: {}\n'.format(
            name, address, email, phone, message)
        my_body += '\nמוצרים:\n'
        for item in items:
            my_body += 'פריט: \t{} כמות: \t{}\n'.format(
                item.product.title, item.amount)
        email = EmailMessage(subject,
                             body=my_body,
                             from_email='MS-GLOBAL <*****@*****.**>',
                             to=recipient_list,
                             reply_to=['*****@*****.**'])
        mail_res = email.send(True)

    print(request)
    return home_view(request)
Esempio n. 12
0
def completeOrder(request):
    request.session.set_expiry(0)
    cart = request.session['cart']
    order = Order()
    order.first_name = request.POST['first_name']
    order.last_name = request.POST['last_name']
    order.address = request.POST['address']
    order.city = request.POST['city']
    order.payment_method = request.POST['payment']
    order.payment_data = request.POST['payment_data']
    order.save()
    order.items = genItemsList(cart)
    request.session['cart'] = []
    return render(request, "complete_order.html", None)
Esempio n. 13
0
def confirmation(request):
    if request.method == "POST":
        #protection against refreshing or posts with empty cart
        if len(request.session['cart']) == 0:
            context = generate_cart_context(request)
            context[
                'alert_message'] = "You have to order something first before you can get a confirmation. 🤔"
            return render(request, 'cart.html', context=context)

        form = CheckoutForm(request.POST)
        # Check if the form is valid:
        if form.is_valid():
            order_obj = Order(
                first_name=form.cleaned_data['first_name'],
                last_name=form.cleaned_data['last_name'],
                student_id=form.cleaned_data['student_id'],
                email=form.cleaned_data['email'],
                phone=form.cleaned_data['phone'],
                special_instructions=form.cleaned_data['special_instructions'],
                grand_total=0.0)
            order_obj.save()

            grand_total = 0
            for cart_id, cart_item in request.session['cart'].items():
                product_obj = Product.objects.get(id=cart_item['product_id'])
                material_obj = Material.objects.get(id=cart_item['material'])
                price = int(cart_item['quantity']) * product_obj.price
                grand_total += price

                product_instance = ProductInstance(product=product_obj,
                                                   material=material_obj,
                                                   quantity=int(
                                                       cart_item['quantity']),
                                                   total_price=price,
                                                   order=order_obj)
                product_instance.save()
            order_obj.grand_total = grand_total

            context = generate_cart_context(request)
            context["order"] = order_obj

            send_confirmation_email(context, form.cleaned_data['email'])

            request.session['cart'] = {}
            return render(request, 'confirmation.html', context=context)
    else:
        context = generate_cart_context(request)
        context[
            'alert_message'] = "You have to order something first before you can get a confirmation. 🤔"
        return render(request, 'cart.html', context=context)
Esempio n. 14
0
    def handle(self, *args, **options):
        Product.objects.all().delete()

        now = timezone.now()

        Product(
            pk=1,
            name='Mineral Water Strawberry',
            description=
            'Natural-flavored strawberry with an anti-oxidant kick.',
            price=1.00,
            photo='products/mineralwater-strawberry.jpg',
        ).save()
        Product(
            pk=2,
            name='Mineral Water Raspberry',
            description='Flavoured with raspberry, loaded with anti-oxidants.',
            price=2.00,
            photo='products/mineralwater-raspberry.jpg',
            sale_start=now + timedelta(days=20),
            sale_end=None,
        ).save()
        Product(
            pk=3,
            name='Vitamin A 10,000 IU (125 caplets)',
            price=3.00,
            description=
            'Vitamin A is essential for normal and night vision, and helps maintain healthy skin and mucous membranes.',
            sale_start=now - timedelta(days=10),
            sale_end=None,
            photo='products/vitamin-a.jpg',
        ).save()
        Product(
            pk=4,
            name='Vitamin B-Complex (100 caplets)',
            price=3.00,
            description=
            'Contains a combination of essential B vitamins that help convert food to energy.',
            sale_start=now,
            sale_end=now + timedelta(days=10),
            photo='products/vitamin-bcomplex.jpg',
        ).save()

        Order.objects.all().delete()

        for i in range(1, 11):
            Order(pk=i, product_id=i % 4 + 1,
                  quantity=random.randint(1, 20)).save()
Esempio n. 15
0
def order(request, pk):
    related_item = Item.objects.get(pk=pk)
    if request.FILES:
        image = request.FILES['image']
    else:
        image = None

    new_order = Order(item=related_item,
                      description=request.POST['placename'],
                      email=request.POST['email'],
                      phone=request.POST['phone'],
                      name=request.POST['name'],
                      image=image)
    new_order.save()
    request.session['from_order'] = True
    return redirect(reverse('landing:index'))
Esempio n. 16
0
def completeOrder(request):
    request.session.set_expiry(0)
    cart = request.session['cart']
    ctx = {'cart': cart}
    order = Order()
    order.first_name = request.POST['first_name']
    order.last_name = request.POST['last_name']
    order.address = request.POST['address']
    order.city = request.POST['city']
    order.payment_method = request.POST['payment']
    order.payment_data = request.POST['payment_data']
    order.items = genItemsList(cart)
    order.fulfilled = False
    order.save()
    request.session['cart'] = []
    return render(request, 'store/complete_order.html', ctx)
Esempio n. 17
0
    def post(self, request):
        address = request.POST.get('address')
        mobile = request.POST.get('mobile')
        customer = request.session.get('customer')
        cart = request.session.get('cart')
        products = Product.get_product_by_id(list(cart.keys()))
        print(address, mobile, customer, cart, products)

        for product in products:
            order = Order(customer=Costomer(id=customer),
                          product=product,
                          price=product.price,
                          address=address,
                          mobile=mobile,
                          qauntity=cart.get(str(product.id)))
            order.placeOrder()
        return redirect('cart')
Esempio n. 18
0
def place_order(request, product_id):  ## VTR1 Done.
    """
	Place order and update customer details.
	"""
    try:
        if user is None:
            return HttpResponseRedirect('/shop/login/')
    except:
        return HttpResponseRedirect('/shop/login/')

    customer = Customer.objects.get(customer_name=user.customer_name)
    product = Product.objects.get(pk=product_id)
    time_of_order = timezone.now()
    ## Decide mode of payment and take appropriate action
    if customer.store_credit >= product.price:
        customer.store_credit -= product.price
        payment_type = 1
    else:
        payment_type = 2
    ## Update purchase history and save instance
    customer.purchase_history += product.price
    customer.save()
    ## Create a new Order object
    order = Order(customer=customer,
                  product=product,
                  status=1,
                  status_change_time=time_of_order,
                  payment_type=payment_type)
    order.save()

    if payment_type == 1:
        payment_type = 'Paid from store credit'
    else:
        payment_type = 'Cash on delivery'
    context = {
        'product': product,
        'customer': customer,
        'time_of_order': time_of_order,
        'payment_type': payment_type,
        'user': user
    }
    return render(request, 'store/order_success.html', context)
Esempio n. 19
0
    def post(self, request):
        address = request.POST.get('address')
        phone = request.POST.get('phone')
        customer = request.session.get('customer')
        cart = request.session.get('cart')
        products = Product.get_products_by_id(list(cart.keys()))
        print(address, phone, customer, cart, products)

        for product in products:
            print(cart.get(str(product.id)))
            order = Order(customer=Customer(id=customer),
                          product=product,
                          price=product.price,
                          address=address,
                          phone=phone,
                          quantity=cart.get(str(product.id)))
            order.save()
        request.session['cart'] = {}

        return redirect('cart')
Esempio n. 20
0
 def get(self, request):
     # if customer is already logged in
     if request.session.get('customer_id'):
         # getting current customer_id from session
         customer_id = request.session.get('customer_id')
         cart = request.session.get('cart')
         # getting the objects 
         customer = Customer.objects.get(id = customer_id)
         products = Product.get_products_byId(list(cart.keys()))
         # setting values
         for product in products:
             order = Order(customer_name=customer,
             product=product, quantity=cart.get(str(product.id)), price = product.price, 
             address=customer.address, phone=customer.phone )
             # placing order
             order.place_order()
         # clearing the cart
         request.session['cart'] = {}
         return redirect('orders')
     else:
         return redirect('login')
Esempio n. 21
0
def completeOrder(request):
    cart = request.session['cart']
    request.session.set_expiry(0)
    ctx = {
        'cart': cart,
        'cart_size': len(cart),
        'cart_items': cartItems(cart),
        'total_price': priceCart(cart)
    }
    order = Order()
    order.items = genItemsList(cart)
    order.first_name = request.POST['first_name']
    order.last_name = request.POST['last_name']
    order.address = request.POST['address']
    order.city = request.POST['city']
    order.payment_data = request.POST['payment_data']
    order.fulfill = False
    order.payment_method = request.POST['payment']
    order.save()
    request.session['cart'] = []
    return render(request, "complete_order.html", ctx)
Esempio n. 22
0
def create_order(request):
    try:
        address_id = request.data["address"]
        address = Address.objects.get(id=address_id)
    except Address.DoesNotExist:
        return Response({"error": "Address not found"},
                        status=status.HTTP_404_NOT_FOUND)

    if address.owner != request.user:
        return Response(status=status.HTTP_403_FORBIDDEN)

    # calculate the total price of all cart items
    cart_items = CartItem.objects.filter(owner=request.user)
    amount = 0.0
    for item in cart_items:
        price = item.product.price
        amount += price * item.count

    order = Order(owner=request.user,
                  shipping_address=address,
                  total_price=amount)

    order.save()

    # create individual order items
    for item in cart_items:
        order_item = OrderItem(item=item.product,
                               count=item.count,
                               order=order)
        order_item.save()

    # delete all cart items for the user
    for item in cart_items:
        item.delete()

    return Response(status=status.HTTP_201_CREATED)
Esempio n. 23
0
    def post(self, request):
        address = request.POST.get('address')
        phone = request.POST.get('phone')
        cart = request.session.get('cart')
        products = Product.getProductById(list(cart.keys()))
        customer = request.session.get('customer')

        for product in products:

            newOrder = Order(
                product=product,
                customer=Customer(id=customer),
                quantity=cart[str(product.id)],
                price=product.price,
                address=address,
                phone=phone,
            )
            newOrder.save()
            print(newOrder.id)

            OrderEmail.delay(order_id=newOrder.id)

        request.session['cart'] = {}
        return redirect('order')
Esempio n. 24
0
def checkOutView(request, coupon_id):
    total = 0
    counter = 0
    cart_items = None
    discount_price = None
    new_total = None
    add_coupon = False
    coupon = None

    try:
        cart = Cart.objects.get(cart_id=_cart_id(request))  #ดึงตะกร้า
        cart_items = CartItem.objects.filter(
            cart=cart, active=True)  #ดึงข้อมูลสินค้าในตะกร้า
        for item in cart_items:
            total += (item.product.price * item.quantity)
            counter += (item.quantity)
    except Exception as e:
        pass

    form = CheckOutForm(request.POST)

    if request.method == 'POST':

        if 'confirm' in request.POST:
            print('Uppppppppppppppppppppppppppppppppp')
            if coupon_id == 0:
                new_total = total

            else:
                coupon = Coupon.objects.get(id=coupon_id)
                new_total = total - coupon.discount
                add_coupon = True

        else:
            print('Downnnnnnnnnnnnnnnnnnnnnnnnnnnnnn')
            if coupon_id == 0:
                new_total = total

            else:
                coupon = Coupon.objects.get(id=coupon_id)
                new_total = total - coupon.discount
                add_coupon = True
            form = CheckOutForm(request.POST)
            if form.is_valid():
                now = timezone.now()
                data = Order()

                data.first_name = form.cleaned_data['first_name']
                data.last_name = form.cleaned_data['last_name']
                data.phone = form.cleaned_data['phone']
                data.user_id = request.user.username
                data.address = form.cleaned_data.get('address')
                data.city = form.cleaned_data.get('city')
                data.district = form.cleaned_data.get('district')
                data.subdistrict = form.cleaned_data.get('subdistrict')
                data.postcode = form.cleaned_data.get('postcode')
                data.total = new_total
                data.status = 'รอชำระเงิน'
                if coupon_id != 0:
                    data.code = coupon.code
                data.save()

                for item in cart_items:
                    order_item = OrderItem.objects.create(
                        product=item.product.name,
                        quantity=item.quantity,
                        price=item.product.price,
                        order=data)
                    order_item.save()
                    #ลดจำนวนstock
                    product = Product.objects.get(id=item.product.id)
                    product.stock = int(item.product.stock -
                                        order_item.quantity)
                    product.save()
                    item.delete()
                order = Order.objects.get(id=data.id)
                return redirect(order.get_url())

    else:
        form = CheckOutForm()
        new_total = total

    return render(
        request, "checkout.html",
        dict(cart_items=cart_items,
             total=total,
             counter=counter,
             form=form,
             new_total=new_total,
             coupon=coupon,
             add_coupon=add_coupon,
             coupon_id=coupon_id))
Esempio n. 25
0
def checkout(request):
    if request.method == "GET":
        form = CheckoutForm()
        cart = request.session.get('cart')

        if cart is None:
            cart = []

        for c in cart:
            size_str = c.get('size')
            tshirt_id = c.get('tshirt')
            size_obj = SizeVarient.objects.get(size=size_str, tshirt=tshirt_id)
            c['size'] = size_obj
            c['tshirt'] = size_obj.tshirt
        context = {'form': form, 'cart': cart}

        return render(request,
                      template_name="store/checkout.html",
                      context=context)
    else:
        form = CheckoutForm(request.POST)
        user = None
        print("user 11", user)
        if request.user.is_authenticated:
            print("user 12", user)
            user = request.user
        if form.is_valid():
            print("user 13", user)
            # payment
            cart = request.session.get('cart')
            if cart is None:
                cart = []
            for c in cart:
                size_str = c.get('size')
                tshirt_id = c.get('tshirt')
                size_obj = SizeVarient.objects.get(size=size_str,
                                                   tshirt=tshirt_id)
                c['size'] = size_obj
                c['tshirt'] = size_obj.tshirt
            shipping_addres = form.cleaned_data.get('shipping_addres')
            contact = form.cleaned_data.get('contact')
            payment_method = form.cleaned_data.get('payment_method')
            total = cal_total_payable_amount(cart)

            print(shipping_addres, contact, payment_method, total)

            order = Order()
            order.shipping_addres = shipping_addres
            order.contact = contact
            order.payment_method = payment_method
            order.total = total
            order.order_status = "PENDING"
            order.user = user
            order.save()

            # saving order_items
            for c in cart:
                order_item = OrderItems()
                order_item.order = order
                size = c.get('size')
                tshirt = c.get('tshirt')
                order_item.price = floor(size.price -
                                         (size.price *
                                          (tshirt.discount) / 100))
                order_item.quantity = c.get('quantity')
                order_item.size = size
                order_item.tshirt = tshirt
                order_item.save()

            # payment gateway
            response = api.payment_request_create(
                amount=order.total,
                purpose='Payment for tshirt',
                send_email=True,
                buyer_name=f'{user.first_name} {user.last_name}',
                email=user.email,
                redirect_url="http://127.0.0.1:8000/validate_payment")
            # print('response', response)
            print('request_id', response['payment_request']['id'])
            print('request_longurl', response['payment_request']['longurl'])

            payment_id = (response['payment_request']['id'])
            url = response['payment_request']['longurl']

            payment = Payment()
            payment.order = order
            payment.payment_request_id = payment_id
            payment.save()
            return redirect(url)

        else:
            return redirect('/checkout/')
Esempio n. 26
0
    def post(self, request):
        user = None
        form = CheckoutForm(request.POST)
        if request.user.is_authenticated:
            user = request.user

        if form.is_valid():
            buy = request.session.get('buy')
            cart = request.session.get('cart')

            #creating order
            shipping_address = form.cleaned_data.get('shipping_address')
            phone = form.cleaned_data.get('phone')
            payment_method = form.cleaned_data.get('payment_method')
            order = Order()
            order.shipping_address = shipping_address
            order.phone = phone
            order.payment_method = payment_method

            #logic for buing item directly through pay button
            if buy:
                price = 0
                for b in buy:
                    size_str = b.get('size')
                    cloth_id = b.get('cloth')
                    cloth_obj = Size_Variant.objects.get(size=size_str,
                                                         cloth=cloth_id)
                    cloth = Cloth.objects.get(id=cloth_id)
                    b['size'] = cloth_obj
                    b['cloth'] = cloth_obj.cloth
                    price = cloth_obj.price
                    price = floor(price - (price *
                                           (cloth.cloth_discount / 100)))
                    b['total'] = price

                order.total = price

                order.order_status = "PENDING"
                order.user = user
                order.save()
                # preventing duplicated value in buy
                preventing_duplicate(buy)

                #creating order item
                for b in buy:
                    order_item = Order_Item()
                    order_item.order = order
                    size = b.get('size')
                    cloth = b.get('cloth')
                    order_item.price = floor(size.price -
                                             (size.price *
                                              (cloth.cloth_discount / 100)))
                    order_item.quantity = 1
                    order_item.size = size
                    order_item.cloth = cloth
                    order_item.save()

        #logic for buying item through cart
            else:
                if cart is None:
                    cart = []
                for c in cart:
                    size_str = c.get('size')
                    cloth_id = c.get('cloth')
                    cloth_obj = Size_Variant.objects.get(size=size_str,
                                                         cloth=cloth_id)
                    c['size'] = cloth_obj
                    c['cloth'] = cloth_obj.cloth
                total = total_payable_amount(cart)
                order.total = total
                order.order_status = "PENDING"
                order.user = user
                order.save()

                # saving order items
                for c in cart:
                    order_item = Order_Item()
                    order_item.order = order
                    size = c.get('size')
                    cloth = c.get('cloth')
                    order_item.price = floor(size.price -
                                             (size.price *
                                              (cloth.cloth_discount / 100)))
                    order_item.quantity = c.get('quantity')
                    order_item.size = size
                    order_item.cloth = cloth
                    order_item.save()

            if payment_method == "ONLINE":
                # creating payment
                try:
                    client = razorpay.Client(auth=(KEY_ID, KEY_SECRET))
                    payment_id = client.order.create({
                        "amount": order.total * 100,
                        'currency': 'INR',
                        'payment_capture': '1',
                    })
                except:
                    messages.error(
                        request,
                        'Payment gateway is not Responding , Check your connection !'
                    )
                    return redirect('Checkout')

                payment = Payment()
                payment.order = order
                payment.payment_request_id = payment_id['id']
                payment.save()
                form = CheckoutForm()
                context = {
                    'form': form,
                    'cart': cart,
                    'buy': buy,
                    'payment': payment_id
                }
                return render(request, 'store/checkout.html', context=context)
            else:
                order.order_status = "PLACED"
                order.save()
                try:
                    context = {
                        "username": user.first_name,
                        "order": order,
                    }

                    html_message = loader.render_to_string(
                        "store/product_email.html", context=context)

                    # mail to coustomer
                    send_mail(
                        'Product Purchased',
                        'Payment for ordered product has successfull worth of money !',
                        EMAIL_HOST_USER,
                        [user.email],
                        fail_silently=False,
                        html_message=html_message,
                    )
                    # mail to user
                    send_mail(
                        'Product Purchased',
                        f"You have recieved a COD delivery order of {order.total} Rupee for order id = {order.id}, check it out and procced for delivery",
                        EMAIL_HOST_USER,
                        [EMAIL_HOST_USER],
                        fail_silently=False,
                    )
                except:
                    return redirect('Orders')

                return redirect('Orders')
        else:
            return redirect('/checkout/')
Esempio n. 27
0
 def test_from_email(self):
     order = Order(f_name="Homer",
                   l_name="Simpson",
                   email="*****@*****.**")
     self.assertEqual(order.from_email(),
                      "Homer Simpson <*****@*****.**>")
def checkout(request):
    # get Request
    if request.method == 'GET':
        form = CheckForm()
        cart = request.session.get('cart')
        if cart is None:
            cart = []

        for c in cart:
            size_str = c.get('size')
            tshirt_id = c.get('tshirt')
            size_obj = SizeVariant.objects.get(size=size_str, tshirt=tshirt_id)
            c['size'] = size_obj
            c['tshirt'] = size_obj.tshirt

        print(cart)

        return render(request, 'store/checkout.html', {
            "form": form,
            'cart': cart
        })
    else:
        # post request
        form = CheckForm(request.POST)
        user = None
        if request.user.is_authenticated:
            user = request.user
        if form.is_valid():
            # payment
            cart = request.session.get('cart')
            if cart is None:
                cart = []
            for c in cart:
                size_str = c.get('size')
                tshirt_id = c.get('tshirt')
                size_obj = SizeVariant.objects.get(size=size_str,
                                                   tshirt=tshirt_id)
                c['size'] = size_obj
                c['tshirt'] = size_obj.tshirt
            shipping_address = form.cleaned_data.get('shipping_address')
            phone = form.cleaned_data.get('phone')
            payment_method = form.cleaned_data.get('payment_method')
            total = cal_total_payable_amount(cart)
            print(shipping_address, phone, payment_method, total)

            order = Order()
            order.shipping_address = shipping_address
            order.phone = phone
            order.payment_method = payment_method
            order.total = total
            order.order_status = "PENDING"
            order.user = user
            order.save()

            # saving order items
            for c in cart:
                order_item = OrderItem()
                order_item.order = order
                size = c.get('size')
                tshirt = c.get('tshirt')
                order_item.price = floor(size.price -
                                         (size.price *
                                          (tshirt.discount / 100)))
                order_item.quantity = c.get('quantity')
                order_item.size = size
                order_item.tshirt = tshirt
                order_item.save()

            buyer_name = f'{user.first_name} {user.last_name}'
            print(buyer_name)
            # crating payment
            response = API.payment_request_create(
                amount=order.total,
                purpose="Payment For Tshirts",
                send_email=False,
                buyer_name=f'{user.first_name} {user.last_name}',
                email=user.email,
                redirect_url="http://localhost:8000/validate_payment")

            payment_request_id = response['payment_request']['id']
            url = response['payment_request']['longurl']

            payment = Payment()
            payment.order = order
            payment.payment_request_id = payment_request_id
            payment.save()
            return redirect(url)
        else:
            return redirect('/checkout/')
def checkout(request):
    if request.method == 'GET':     #for get Request
        form = CheckForm()
        cart=request.session.get('cart')
        if cart is None:
            cart=[]
        
        for c in cart:
            size_str = c.get('size')
            tshirt_id = c.get('tshirt')
            size_obj=SizeVariant.objects.get(size=size_str , tshirt=tshirt_id)   #now in cart list ,size is replaced by its object
            c['size']=size_obj
            c['tshirt']=size_obj.tshirt   #replacing in cart list , tshirt is id ,inplace of id tshirt object is stored

        return render(request,'store/checkout.html',{"form" : form, 'cart':cart})
    else:
        #this is for POST request
        form = CheckForm(request.POST)
        user = None
        if request.user.is_authenticated :
            user = request.user
        if form.is_valid():
            #payment should be done here
            cart=request.session.get('cart')
            if cart is None:
                cart = []
            for c in cart:
                size_str = c.get('size')
                tshirt_id = c.get('tshirt')
                size_obj=SizeVariant.objects.get(size=size_str , tshirt=tshirt_id)   #now in cart list ,size is replaced by its object
                c['size']=size_obj
                c['tshirt']=size_obj.tshirt
            shipping_address=form.cleaned_data.get('shipping_address')   #the shipping address entered will be stored in shipping_address variable
            phone=form.cleaned_data.get('phone')
            payment_method = form.cleaned_data.get('payment_method')
            total = cal_total_payable_amount(cart)
            print(shipping_address,phone,payment_method , total)
            order= Order()               #created Order Model object
            order.shipping_address = shipping_address   #entering data in ORDER table
            order.phone = phone
            order.payment_method= payment_method
            order.total = total
            order.order_status = "PENDING"
            order.user = user
            order.save()    
            #print(order.id)        # we will get order id 

            #saving to OrderItems Table
            for c in cart :
                order_item = OrderItem()   #creating new object for OrderItem Table
                order_item.order = order      #order id will be stored in order
                size=c.get('size')   #to access dictionary we use get('key')
                tshirt=c.get('tshirt')
                order_item.price = floor(size.price- (size.price*(tshirt.discount/100)))
                order_item.quantity = c.get('quantity')
                order_item.size = size
                order_item.tshirt = tshirt
                order_item.save()

            
            # CREATING PAYMENT
            # Create a new Payment Request
            response = API.payment_request_create(
                amount=order.total,
                purpose='Payment For Tshirts',
                buyer_name=f'{user.first_name} {user.last_name}',
                send_email=True,
                email=user.email,
                redirect_url="http://localhost:8000/validate_payment"
                )
            #print(response['payment_request'])
            payment_request_id = response['payment_request']['id']
            #the long URL of the payment request
            url =response['payment_request']['longurl']
            print(url)
            
            payment= Payment()
            payment.order= order
            payment.payment_request_id= payment_request_id
            payment.save()
            return redirect(url)
        else:
            return redirect('/checkout/')