Пример #1
0
 def handle(self, *args, **kwargs):
     for event_id in kwargs['event_ids']:
         event = Event.objects.get(pk=event_id)
         print(f'Process event {event.name}')
         qtickets = QTicketsInfo.get_order_list(event.external_id)
         for item in qtickets:
             Order.add_or_update(item)
def insert_cart(request, product_id):
    context = {}
    nItems = 0
    if 'order_id' in request.session:
        order = Order.objects.get(id=request.session['order_id'])
        orderItem = OrderItem()
        product = Product.objects.get(id=product_id)
        orderItem.order = order
        orderItem.product = product
        orderItem.value = product.value
        orderItem.save()
        # context['order'] = order
        # context['orderItems'] = OrderItem.objects.filter(order__id=order.id)
        request.session['howItems'] = \
        int(request.session['howItems']) + 1

    else:
        order = Order()
        order.user = User.objects.get(id=request.user.id)
        order.save()

        orderItem = OrderItem()
        product = Product.objects.get(id=product_id)
        orderItem.order = order
        orderItem.product = product
        orderItem.value = product.value
        orderItem.save()
        # context['order'] = order
        # context['orderItems'] = OrderItem.objects.filter(order__id=order.id)
        request.session['order_id'] = order.id
        request.session['howItems'] = 1

    return HttpResponseRedirect(resolve_url("/"))
def payment_completed(request):

    payload = request.body

    signature_header = request.META['HTTP_STRIPE_SIGNATURE']

    # To store the data that stripe is sending back to server
    event = None

    endpoint_secret = settings.STRIPE_ENDPOINT_SECRET

    try:
        event = stripe.Webhook.construct_event(payload, signature_header,
                                               endpoint_secret)

    except ValueError as e:
        return HttpResponse(status=400)
    except stripe.error.SignatureVerificationError as e:
        # means the data is not from Stripe
        return HttpResponse(status=400)

    if event['type'] == 'checkout.session.completed':

        plants = Plant.objects.all()

        hours = 8

        # to convert the date session in local SGT
        hours_added = datetime.timedelta(hours=hours)

        session = event['data']['object']
        session_created = datetime.datetime.fromtimestamp(
            event['created']) + hours_added

        all_plant_ids_jsonstr = session['metadata']['all_plant_ids']

        all_plant_ids = json.loads(all_plant_ids_jsonstr)

        # to retrieve the order item and save them in the database
        for item in all_plant_ids:

            plant_model = get_object_or_404(Plant, pk=item['plant_id'])
            user_model = get_object_or_404(User, pk=item['user'])

            plant_model.qty = plant_model.qty - item['qty']

            plant_model.save(update_fields=["qty"])

            order = Order(title=plant_model.name,
                          price=float(item['price']),
                          datetime_ordered=session_created,
                          plant=plant_model,
                          order_by=user_model,
                          qty=item['qty'])

            order.save()

    return HttpResponse(status=200)
Пример #4
0
def webhook(request):
    signature = hmac.new(settings.QTICKETS_SECRET.encode(), request.body,
                         hashlib.sha1).hexdigest()
    if signature != request.headers.get('X-Signature'):
        return HttpResponseBadRequest()

    payload = json.loads(request.body)
    Order.add_or_update(payload)
    return HttpResponse()
Пример #5
0
def create_order(request):
	order = Order()
	checkout_form = CheckoutForm(request.POST, instance=order)
	order = checkout_form.save(commit=False)
	order.user = None
	if request.user.is_authenticated():
		order.user = request.user
	order.status = Order.SUBMITTED
	print (order.number)
	order.save()
	print (order.number)
	order.number = int(str(order.id) + datetime.today().strftime('%m%d%Y'))
	order.save()
	print (order.number)
	# create order item for each cart item
	if order.pk:
		cart_items = carts.get_cart_items(request)
		for ci in cart_items: 
			oi = OrderItem()
			oi.order = order
			oi.quantity = ci.quantity
			oi.price = ci.product.price
			oi.product = ci.product
			oi.save()
			carts.empty_cart(request)
	return order
Пример #6
0
def create_order(request, transaction_id):
    order = Order()
    checkout_form = CheckoutForm(request.POST, instance=order)
    order = checkout_form.save(commit=False)
    order.transaction_id = transaction_id
    order.ip_address = request.META.get('REMOTE_ADDR')
    order.user = None
    if request.user.is_authenticated:
        order.user = request.user
    order.status = Order.SUBMITTED
    order.save()
    # if the order save succeeded
    if order.pk:
        cart_items = cart.get_cart_items(request)
        for ci in cart_items:
            # create order item for each cart item
            oi = OrderItem()
            oi.order = order
            oi.quantity = ci.quantity
            oi.price = ci.price  # now using @property
            oi.product = ci.product
            oi.save()
        # all set, empty cart
        cart.empty_cart(request)
        # save profile info for future orders
        if request.user.is_authenticated:
            profile.set(request)
    # return the new order object
    return order
Пример #7
0
    def test_Checkout_details(self):
        order = Order.objects.get(id=1)
        Order.update_total(order)
        Order.save(order)

        self.assertEqual(order.full_name, 'TestOrder')
        self.assertEqual(order.email, '*****@*****.**')
        self.assertEqual(order.town_or_city, 'Town')
        self.assertEqual(order.order_total, 10)
        # Delivery costs added
        self.assertEqual(order.delivery_cost, round(Decimal(5.99), 2))
        self.assertEqual(order.grand_total, round(Decimal(15.99), 2))
Пример #8
0
def create_order(request, transaction_id):

    order = Order()
    checkout_form = CheckoutForm(request.POST, instance = order)
    order = checkout_form.save(commit = False)
    order.transaction_id = transaction_id
    order.ip_address = request.META.get('REMOTE_ADDR')
    order.user = None
    if request.user.is_authenticated():
        order.user = request.user
    order.status = Order.SUBMITTED
    order.save()

    if order.pk:
        cart_items = cart.get_cart_items(request)
        for ci in cart_items:
            oi = OrderItem()
            oi.order = order
            oi.quantity = ci.quantity
            oi.price = ci.price
            oi.product = ci.product
            oi.save()
        cart.empty_cart(request)

        if request.user.is_authenticated():
            from accounts import profile
            profile.set(request)

    return order
Пример #9
0
    def create_order(request, transaction_id):
        order = Order()
        checkout_form = CheckoutForm(request.POST, instance=order)
        order = checkout_form.save(commit=False)
        order.transaction_id = transaction_id
        order.ip_address = reqest.META.get('REMOTE_ADDR')
        order.user = None
        if request.user.is_authenticated():
            order.user = request.user
        order.status = Order.SUBMITTED
        order.save()

        # If order save succeeded
        if order.pk:
            cart_items = cart_utils.get_cart_items(request)
            for ci in cart_items:
                # Create order item for each cart item
                oi = OrderItem()
                oi.order = order
                oi.quantity = ci.quantity
                oi.price = ci.price
                oi.product = ci.product
                oi.save()
            # Now we can emty the cart
            cart_utils.empty_cart(request)
        # save profile info for future orders
        if request.user.is_authenticated():
            from accounts import profile
            profile.set(request)
        # Return  the new order object
        return order
Пример #10
0
    def setUp(self):
        self.discount_1 = Discount(name="2-for-1")
        self.discount_1.save()
        self.discount_2 = Discount(name="3 or more")
        self.discount_2.save()

        self.product_1 = Product(code="TEST1", name="Test 1", price=10, discount=self.discount_1)
        self.product_1.save()
        self.product_2 = Product(code="TEST2", name="Test 2", price=10, discount=self.discount_2)
        self.product_2.save()

        self.order_1 = Order(quantity=5, product=self.product_1)
        self.order_2 = Order(quantity=5, product=self.product_2)

        self.total_1 = 30
        self.total_2 = 45
Пример #11
0
def confirm_pre_order(request, order_number):
    """ view upgrading preorder and creating a corresponding order """
    if not request.user.is_superuser:
        messages.error(request, 'Sorry, only store owners can see that.')
        return redirect(reverse('home'))
    pre_order = get_object_or_404(PreOrder, order_number=order_number)
    pp_transaction_id = request.POST['pp_transaction_id']
    order = Order(user_profile=pre_order.user_profile,
                  full_name=pre_order.full_name,
                  email=pre_order.email,
                  phone_number=pre_order.phone_number,
                  country=pre_order.country,
                  postcode=pre_order.postcode,
                  town_or_city=pre_order.town_or_city,
                  street_address1=pre_order.street_address1,
                  street_address2=pre_order.street_address2,
                  county=pre_order.county,
                  delivery_cost=pre_order.delivery_cost,
                  order_total=pre_order.order_total,
                  grand_total=pre_order.grand_total,
                  pp_transaction_id=pp_transaction_id)
    # save order
    order.save()
    # copy line items from preorder to order
    for li in pre_order.lineitems.all():
        order_line_item = OrderLineItem(
            order=order,
            product=li.product,
            quantity=li.quantity,
        )
        order_line_item.save()
        # update product reserved, sold
        product = li.product
        quantity = li.quantity
        product.sold = product.sold + quantity
        product.reserved = product.reserved - quantity
        product.save()
    # update preorder
    pre_order.upgraded_order = order
    pre_order.status = "UPG"
    pre_order.save()
    # success message
    messages.success(request, (f'Preorder {pre_order.order_number} upgraded.'
                               f'New order {order.order_number} confirmed.'))
    return redirect(reverse('products_management'))
    def test_order_shipped(self):
        """testing if order is marked as shipped correctly"""
        order = Order(full_name="test",
                      email="test",
                      phone_number="12",
                      country="test",
                      postcode="test",
                      town_or_city="test",
                      street_address1="test",
                      street_address2="test",
                      county="test",
                      delivery_cost=10,
                      order_total=10,
                      grand_total=10,
                      original_bag="test")
        order.save()
        user = User.objects.create_superuser('testuser', '*****@*****.**',
                                             '12345')
        user.save()
        self.client.login(username=user.username, password='******')
        delivery_info = {
            'tracking_number': '12345',
            'provider': 'test provider',
            'expected_wait': 22,
            'order': order,
        }

        response = self.client.post(f'/products/toggle_shipped/{order.id}',
                                    delivery_info)
        order = Order.objects.get(pk=order.id)
        self.assertTrue(order.shipped)
        # check if associated delivery was generated
        delivery_generated = False
        delivery = order.delivery.all()[0]
        if (delivery_info['tracking_number'] == delivery.tracking_number
                and delivery_info['provider'] == delivery.provider
                and delivery_info['expected_wait'] == delivery.expected_wait):
            delivery_generated = True
        self.assertTrue(delivery_generated)
        # request to unship the order
        response = self.client.post(f'/products/toggle_shipped/{order.id}')
        order = Order.objects.get(pk=order.id)
        self.assertFalse(order.shipped)
Пример #13
0
class OrderTests(TestCase):
    """
    Testing order line item total calculation
    """
    def test_subtotal_calculation(self):
        self.product = Product(name='test_name',
                               price=11,
                               description='test_description',
                               )
        self.product.save()
        self.order = Order(
            full_name="Test User",
            email="*****@*****.**",
            phone_number="12345",
            country="gb",
            postcode="e114dr",
            town_or_city="london",
            street_address1="40 test road",
            original_bag="",
            stripe_pid="",
        )
        self.order.save()
        self.order_line_item = OrderLineItem(
            order=self.order,
            product=self.product,
            quantity=2,

        )
        self.order_line_item.save()
        '''
        Testing product and order is created
        '''
        self.assertEqual(str(self.product.name), 'test_name')
        self.assertEqual(str(self.order.full_name), 'Test User')
        '''
        Testing order line item
        '''
        self.assertEqual(str(self.order_line_item.lineitem_total), '22')
        '''
        Testing order total
        '''
        self.assertEqual(str(self.order.order_total), '22')
Пример #14
0
 def post(self, req):
     shipping_destination, fitting = req.POST['shipping'], req.POST['fitting'] if 'fitting' in req.POST else None
     order = Order()
     try:
         shipping_destination = ShippingDestination.objects.get(pk=shipping_destination)
         if not shipping_destination.active:
             messages.error(req, 'Something happen while creating your order, please try again.')
             return render_to_response(self.template_name, context_instance=RequestContext(req))
     except ShippingDestination.DoesNotExist:
         messages.error(req, 'Something happen while creating your order, please try again.')
         return render_to_response(self.template_name, context_instance=RequestContext(req))
     try:
         order.new_order(req.cart, shipping_destination, fitting, req.user)
     except Exception:
         messages.error(req, 'Something happen while creating your order, please try again.')
         return render_to_response(self.template_name, context_instance=RequestContext(req))
     else:
         # TODO: clear the cart
         messages.success(req, 'Your order has been successfully created, please proceed with the payment.')
         return redirect('/checkout/pay/' + order.id)
 def test_country_str_test(self):
     test_order = Order(full_name="test",
                        phone_number="test",
                        country="france",
                        postcode="test",
                        town_or_city="test",
                        street_address1="test",
                        street_address2="test",
                        county="test",
                        date="2020-01-01")
     self.assertEqual(str(test_order.country), "france")
Пример #16
0
def ordered(request):
    '''this saves your order to the data base'''
    if request.user.is_authenticated:
        payment_info = payment.objects.filter(user=request.user).first()
        pers_info = personal_info.objects.filter(user=request.user).first()
        create_order = Order(user=request.user,
                             info=pers_info,
                             confirmed=True,
                             payment=payment_info)
        create_order.save()
        cart = Cart.objects.filter(user=request.user)
        for item in cart:
            product = products.objects.get(pk=item.products.id)
            order_product = Order_item(order_id=create_order.id,
                                       products_id=product.id,
                                       quantity=item.quantity)
            order_product.save()

    Cart.objects.filter(user_id=request.user.id).delete()

    context = {}
    return render(request, 'checkout/order_success.html', context)
Пример #17
0
def saveOrder(request, method):
    try:
        sessionCopy = {k: v for k, v in request.session.items()}
        currentUser = request.user.id
        order = Order(accountId_id=currentUser, shippingMethod=method)
        order.save()

        for item, val in sessionCopy.items():
            if val == 'item':
                for product in Product.objects.all():
                    if int(product.id) == int(item):
                        image = _removePhotos(request, product.id)
                        sold = Sold(orderId_id=order.id, name=product.name, price=product.price, image=image)
                        sold.save()
                        del request.session[item]
                        removeItem = Product.objects.get(pk=product.id)
                        removeItem.delete()
        time.sleep(1)
        return redirect('homepage-index')

    except:
        return render(request, '404.html', manufacturerContext(request))
Пример #18
0
def create_order(request):
    order = Order()
    checkout_form = CheckoutForm(request.POST, instance=order)
    order = checkout_form.save(commit=False)
    order.ip_address = request.META.get('REMOTE_ADDR')
    order.user = None
    if request.user.is_authenticated():
        order.user = request.user
    order.status = Order.SUBMITTED
    order.save()
    # if the order save succeeded
    if order.pk:
        cart_items = cart.get_cart_items(request)
        for ci in cart_items:
            # create order item for each cart item
            oi = OrderItem()
            oi.order = order
            oi.quantity = ci.quantity
            oi.product = ci.product
            oi.save()
        # all set, empty cart
        cart.empty_cart(request)
    # save profile info for future orders
    if request.user.is_authenticated():
        from accounts import profile
        profile.fill(request)
    # mail the managers
    mail_manager_subject = '{0} has been placed!'.format(order)
    mail_manager_message = '{0} has been placed by {1}.\n\nClick here: {2}'.format(
        order, order.user if order.user else 'anonymous',
        request.build_absolute_uri(
            reverse('admin:checkout_order_change', args=(order.pk, ))))
    mail_managers(mail_manager_subject, mail_manager_message)
    # mail the customer
    if order.email:
        # FIXME: someday make templates for these emails
        mail_customer_subject = 'Thank you for placing {0}!'.format(order.name)
        mail_customer_message = '{0} was placed by you.  Click here for more details: {1}\n\nThank you for your order!\n\n{2}'.format(
            order.name, request.build_absolute_uri(order.get_absolute_url()),
            settings.SITE_NAME)
        send_mail(mail_customer_subject, mail_customer_message,
                  settings.DEFAULT_FROM_EMAIL, [order.email])
    # return the new order object
    return order
Пример #19
0
def create_order(request):
	order = Order()
	checkout_form = CheckoutForm(request.POST, instance=order)
	order = checkout_form.save(commit=False)
	order.user = None
	if request.user.is_authenticated():
		order.user = request.user
	order.status = Order.SUBMITTED
	order.save()
	order.number = int(str(order.id) + datetime.today().strftime('%m%d%Y'))
	order.save()
	# create order item for each cart item
	if order.pk:
		cart_items = carts.get_cart_items(request)
		for ci in cart_items: 
			oi = OrderItem()
			oi.order = order
			oi.quantity = ci.quantity

			if ci.product.quantity >= ci.quantity:
				ci.product.quantity = ci.product.quantity - ci.quantity
			else:
				ci.product.quantity = 0	
			ci.product.save()

			oi.price = ci.product.price
			oi.product = ci.product
			oi.save()
			carts.empty_cart(request)
	# send_mail('Subject here', 'Here is the message.', '*****@*****.**',
	# ['*****@*****.**'], fail_silently=False)
	items = OrderItem.objects.filter(order = order)
	plaintext = get_template('email.txt')
	htmly = get_template('email.html')
	d = Context({ 'order': order, 'items': items})
	subject, from_email, to = 'Ваш заказ', '*****@*****.**', [order.email]
	text_content = plaintext.render(d)
	html_content = htmly.render(d)
	msg = EmailMultiAlternatives(subject, text_content, from_email, to)
	msg.attach_alternative(html_content, "text/html")
	msg.send()
	print('sent!')
	return order
Пример #20
0
 def test_total_contributions(self):
     user = User.objects.create_user(username='******', password='******')
     feature = Feature(title="Test Post", author=user, content="Test Content")
     feature.save()
     order = Order(full_name = "Patrick Doherty",
                 phone_number = "02871774646",
                 country = "Ireland",
                 postcode = "BT829DE",
                 town_or_city = "Strabane",
                 street_address1 = "5 Lasts Lane",
                 street_address2 = "Urney Road",
                 county = "Tyrone",
                 date = timezone.now())
     order.save()
     contribution = OrderLineItem(order=order, feature=feature, user=user, contribution =50)
     contribution.save()
     page = self.client.get("/features/{0}/{1}/".format(feature.id, feature.slug))
     self.assertEqual(page.status_code, 200)
     self.assertTemplateUsed(page, "features/feature_detail.html")
     self.assertEqual(page.context["total_contributions"], 50)
     self.assertContains(page, 'Test Content')
     self.assertEqual(str(order), "{0}-{1}-{2}".format(order.id, order.date, order.full_name))
     self.assertEqual(str(contribution), "{0}-{1}-{2}".format(contribution.contribution, feature.title, user.username))
Пример #21
0
 def post(self, req):
     shipping_destination, fitting = req.POST[
         'shipping'], req.POST['fitting'] if 'fitting' in req.POST else None
     order = Order()
     try:
         shipping_destination = ShippingDestination.objects.get(
             pk=shipping_destination)
         if not shipping_destination.active:
             messages.error(
                 req,
                 'Something happen while creating your order, please try again.'
             )
             return render_to_response(self.template_name,
                                       context_instance=RequestContext(req))
     except ShippingDestination.DoesNotExist:
         messages.error(
             req,
             'Something happen while creating your order, please try again.'
         )
         return render_to_response(self.template_name,
                                   context_instance=RequestContext(req))
     try:
         order.new_order(req.cart, shipping_destination, fitting, req.user)
     except Exception:
         messages.error(
             req,
             'Something happen while creating your order, please try again.'
         )
         return render_to_response(self.template_name,
                                   context_instance=RequestContext(req))
     else:
         # TODO: clear the cart
         messages.success(
             req,
             'Your order has been successfully created, please proceed with the payment.'
         )
         return redirect('/checkout/pay/' + order.id)
Пример #22
0
def create_order(request, transaction_id):
    """
    if the POST to the payment gateway successfully billed the customer, create a new order
    containing each CartItem instance, save the order with the transaction ID from the gateway,
    and empty the shopping cart

    """
    order = Order()
    checkout_form = CheckoutForm(request.POST, instance=order)
    order = checkout_form.save(commit=False)

    order.transaction_id = transaction_id
    order.ip_address = request.META.get('REMOTE_ADDR')
    order.user = None
    if request.user.is_authenticated():
        order.user = request.user
    order.status = Order.SUBMITTED
    order.save()

    if order.pk:
        """ if the order save succeeded """
        cart_items = carts.get_cart_items(request)
        for ci in cart_items:
            """ create order item for each cart item """
            oi = OrderItem()
            oi.order = order
            oi.quantity = ci.quantity
            oi.price = ci.price  # now using @property
            oi.product = ci.product
            oi.save()
        # all set, clear the cart
        carts.empty_cart(request)

        # save profile info for future orders
        if request.user.is_authenticated():
            from accounts import profile
            profile.set(request)

    return order
def index(request):
    # search for order that had status active
    order = Order.objects.filter(user__id=request.user.id).\
    filter(status_order='A').first()
    context = {}

    if order:
        order.value = Order.get_total(order.id)
        order.save()

        context['order'] = order
        context['orderItems'] = OrderItem.objects.filter(order__id=order.id)
        context['total'] = order.value
    else:
        messages.warning(request, 'Você não tem nenhum pedido ativo')

    return render(request, 'dashboard_client/index.html', context)
 def test_show_correct_orders(self):
     """testing if orders shown are correctly associated to profile"""
     user = User.objects.create(username='******')
     user.set_password('12345')
     user.save()
     userprofile = user.userprofile
     logged_in = self.client.login(username='******', password='******')
     order = Order(
         user_profile=userprofile,
         full_name='test',
         email="test",
         phone_number="1",
         country="test",
         town_or_city="test",
         street_address1="test",
         delivery_cost=1,
         order_total=1,
         grand_total=1
         )
     order.save()
     order2 = Order(user_profile=userprofile,
                    full_name='test',
                    email="test",
                    phone_number="1",
                    country="test",
                    town_or_city="test",
                    street_address1="test",
                    delivery_cost=1,
                    order_total=1,
                    grand_total=1
                    )
     order2.save()
     user_orders = user.userprofile.orders.all()
     response = self.client.get('/profiles/')
     self.assertEqual(response.status_code, 200)
     context_orders = response.context['orders']
     set_context_orders = set(context_orders)
     set_user_orders = set(user_orders)
     self.assertEqual(set_context_orders, set_user_orders)
Пример #25
0
def create_order(request, transaction_id):
  """ if the POST to the payment gateway successfully billed the customer, create a new order
  containing each CartItem instance, save the order with the transaction ID from the gateway,
  and empty the shopping cart

  """
  order = Order()
  checkout_form = CheckoutForm(request.POST, instance=order)
  order = checkout_form.save(commit=False)

  order.transaction_id = transaction_id
  order.ip_address = request.META.get('REMOTE_ADDR')
  order.user = None
  if request.user.is_authenticated():
    order.user = request.user
  order.status = Order.SUBMITTED
  order.save()

  if order.pk:
    """ if the order save succeeded """
    cart_items = cart.get_cart_items(request)
    for ci in cart_items:
      """ create order item for each cart item """
      oi = OrderItem()
      oi.order = order
      oi.quantity = ci.quantity
      oi.price = ci.price  # now using @property
      oi.product = ci.product
      oi.save()
    # all set, clear the cart
    cart.empty_cart(request)

    # save profile info for future orders
    if request.user.is_authenticated():
      from ecomstore.accounts import profile
      profile.set(request)

  return order
Пример #26
0
    def test_place_order(self):
        Order.username = User(username='******')
        order = Order(full_name='Tom Riddle',
                      phone_number='07777888888',
                      country='Wizardland',
                      postcode='H0GWAR7',
                      town_or_city='Wizardtown',
                      street_address1='Hogwarts',
                      street_address2='Castle',
                      county='Wizardcounty',
                      username='******')

        self.assertEqual(order.full_name, 'Tom Riddle')
        self.assertEqual(order.phone_number, '07777888888')
        self.assertEqual(order.country, 'Wizardland')
        self.assertEqual(order.postcode, 'H0GWAR7')
        self.assertEqual(order.town_or_city, 'Wizardtown')
        self.assertEqual(order.street_address1, 'Hogwarts')
        self.assertEqual(order.street_address2, 'Castle')
        self.assertEqual(order.county, 'Wizardcounty')
        self.assertEqual(order.username, 'TomRiddle')
def send_order(request, order_id):

    order = Order.objects.get(id=order_id)
    items = OrderItem.objects.filter(order=order_id)
    order.value = Order.get_total(order.id)
    order.sended = True
    order.status_order = 'I'  # dont appears in dash board as not sended
    money = Utils.convertStringForNumber(request.GET['money'])

    if (money):
        order.money = money
    else:
        messages.warning(request,
                         'Por favor digite um calor válido para Dinheiro')
        return HttpResponseRedirect(reverse('dashboard_client:index'))

    order.save()

    del request.session['order_id']
    del request.session['howItems']

    return render(request, 'dashboard_client/sended.html')
Пример #28
0
def create_order(request):
    order = Order()
    checkout_form = CheckoutForm(request.POST, instance=order)
    order = checkout_form.save(commit=False)
    order.ip_address = request.META.get('REMOTE_ADDR')
    order.user = None
    if request.user.is_authenticated():
        order.user = request.user
    order.status = Order.SUBMITTED
    order.save()
    # if the order save succeeded
    if order.pk:
        cart_items = cart.get_cart_items(request)
        for ci in cart_items:
            # create order item for each cart item
            oi = OrderItem()
            oi.order = order
            oi.quantity = ci.quantity
            oi.product = ci.product
            oi.save()
        # all set, empty cart
        cart.empty_cart(request)
    # save profile info for future orders
    if request.user.is_authenticated():
        from accounts import profile
        profile.fill(request)
    # mail the managers
    mail_manager_subject = '{0} has been placed!'.format(order)
    mail_manager_message = '{0} has been placed by {1}.\n\nClick here: {2}'.format(order, order.user if order.user else 'anonymous', request.build_absolute_uri(reverse('admin:checkout_order_change', args=(order.pk,))))
    mail_managers(mail_manager_subject, mail_manager_message)
    # mail the customer
    if order.email:
        # FIXME: someday make templates for these emails
        mail_customer_subject = 'Thank you for placing {0}!'.format(order.name)
        mail_customer_message = '{0} was placed by you.  Click here for more details: {1}\n\nThank you for your order!\n\n{2}'.format(order.name, request.build_absolute_uri(order.get_absolute_url()), settings.SITE_NAME)
        send_mail(mail_customer_subject, mail_customer_message, settings.DEFAULT_FROM_EMAIL, [order.email])
    # return the new order object
    return order
Пример #29
0
def get_or_set_order_session(request):
    order_id = request.session.get('order_id', None)

    if order_id is None:
        order = Order()
        order.save()
        request.session['order_id'] = order.id

    else:
        try:
            order = Order.objects.get(id=order_id, ordered=False)
        except Order.DoesNotExist:
            order = Order()
            order.save()
            request.session['order_id'] = order.id

    if request.user.is_authenticated and order.user is None:
        order.user = request.user
        order.save()
    return order
Пример #30
0
def checkout(request):

    if request.method == 'GET':
        # request.session['braintree_client_token'] = braintree.ClientToken.generate()
        stripe_customer = stripe.Customer.retrieve(
            request.user.user.stripe_customer_id)
        payment_info = stripe_customer.sources.retrieve(
            stripe_customer.default_source)
        cart = request.session.get('cart', {})
        new_cart = cart.copy()
        item_list = []
        sold_item_list = []
        total_price = 0
        total_shipping = 0
        for id in cart:
            try:
                item = Item.objects.get(pk=id)
                if item.sold == True:
                    sold_item_list.append(item)
                    del new_cart[id]

                else:
                    item_list.append(item)
                    total_price = total_price + item.price
                    total_shipping = total_shipping + item.shipping_price
            except:
                pass

        final_total = total_shipping + total_price
        if sold_item_list:
            request.session['cart'] = new_cart
        return render(
            request, 'checkout/checkout.html', {
                'sold_item_list': sold_item_list,
                'items': item_list,
                'total': final_total,
                'sub_total': total_price,
                'total_shipping': total_shipping,
                'payment_information': payment_info
            })

    else:

        print request.POST
        cart = request.session.get('cart', {})
        new_cart = cart.copy()
        item_list = []
        sold_item_list = []

        total_price = 0
        total_shipping = 0
        final_total = 0
        print cart
        print new_cart

        for id in cart:
            try:
                item = Item.objects.get(pk=id)
                if item.sold == True:
                    sold_item_list.append(item)

                    base_sold_email_template = open(
                        os.path.join(PROJECT_ROOT,
                                     'emails/reminder_email.html')).read()
                    message = sendgrid.Mail(
                        to=item.seller.email,
                        subject='CampusThrift Buyer Reminder',
                        html=base_sold_email_template,
                        text='Body',
                        from_email='*****@*****.**')
                    sg.send(message)

                    del new_cart[id]

                else:
                    item_list.append(item)
                    total_price = total_price + item.price
                    total_shipping = total_shipping + item.shipping_price
            except:
                pass

        final_total = total_shipping + total_price

        if sold_item_list:
            request.session['cart'] = new_cart
            return render(
                request, 'checkout/checkout.html', {
                    'sold_item_list': sold_item_list,
                    'items': item_list,
                    'total': final_total,
                    'sub_total': total_price,
                    'total_shipping': total_shipping
                })
        else:

            new_order = Order()
            new_order.buyer = request.user

            sub_total = 0
            shipping_total = 0
            final_total = 0

            #
            for item in item_list:
                new_order_item = OrderItem()
                new_order_item.order = new_order
                new_order_item.item = item
                new_order_item.seller = item.user
                new_order_item.shipping_method = request.POST[str(item.pk) +
                                                              '_ship_method']
                new_order_item.price = item.price

                if int(request.POST[str(item.pk) + '_ship_method']) == 1:
                    new_order_item.shipping_price = 0.00
                    new_order_item.order_item_total_price = new_order_item.price
                else:

                    new_order_item.shipping_price = item.shipping_price
                    shipping_total = shipping_total + item.shipping_price
                    new_order_item.order_item_total_price = new_order_item.price + new_order_item.shipping_price

                sub_total = sub_total + item.price

                new_order_item.save()

            new_order.shipping_address = request.POST['address']
            new_order.city = request.POST['city']
            new_order.state = request.POST['state']
            new_order.zip = request.POST['zip']

            new_order.final_total = sub_total + shipping_total
            new_order.shipping_total = shipping_total
            new_order.sub_total = sub_total
            new_order.save()

            request.session['order'] = new_order.primary_key

            return redirect('confirm')
Пример #31
0
    def handle_payment_intent_succeeded(self, event):
        """
        Handle the payment_intent.succeeded webhook from Stripe
        """
        intent = event.data.object
        billing_details = intent.charges.data[0].billing_details
        shipping_details = intent.shipping

        """ create_webhook_order """

        """ create a unique order number """
        order_number = "wh" + uuid.uuid4().hex[:8]

        """ check for any unordered baskets """
        cookie = billing_details.phone
        pid = intent.id
        existing = Order.objects.filter(stripe_pid=pid)

        if not existing:
            order_total = round(intent.charges.data[0].amount / 100, 2)
            full_name = shipping_details.name
            customer_name = billing_details.name
            customer_email = billing_details.email

            webhook_order = Order(order_number=order_number,
                                  cookie=cookie,
                                  order_total=order_total,
                                  grand_total=order_total,
                                  full_name=full_name,
                                  customer_name=customer_name,
                                  stripe_pid=pid)
            webhook_order.save()

            """ fetch the basket items to save into order_items """
            baskets = Basket.objects.filter(cookie=cookie)

            for basket in baskets:
                cookie = basket.cookie
                item_number = basket.pk
                category = basket.category
                name = basket.name
                servings = basket.servings
                option = basket.option
                total_price = basket.total_price

                """ save the basket items into order_items """
                order_basket = Order_items(cookie=cookie,
                                           order_number=order_number,
                                           item_number=item_number,
                                           category=category,
                                           name=name,
                                           servings=servings,
                                           option=option,
                                           total_price=total_price)
                order_basket.save()
                basket.delete()
            baskets = Basket.objects.filter(cookie=cookie)

            """ compose and send confirmation email """
            order_date = webhook_order.date.strftime("%d/%m/%Y %H:%M:%S")
            parameters = {
                'order_number': order_number,
                'order_date': order_date,
                'order_total': webhook_order.grand_total,
            }
            # Credit: https://stackoverflow.com/questions/2809547/creating-email-templates-with-django
            msg_html = render_to_string('checkout/confirmation_email.html',
                                        parameters)
            send_mail(
                'Order Confirmation',
                msg_html,
                '*****@*****.**',
                [customer_email],
                html_message=msg_html,
            )

        """ webhook order created """

        return HttpResponse(
            content=f'Webhook received: {event["type"]}',
            status=200)
def noForwardedsInfo(request):
    """ This function update the information about orders no forwarded and 
	return the object orderSended. Some functions need no use this object """
    ordersSendeds = Order.objects.filter(sended=True)
    request.session['no_forwarded'] = Order.getNoForwardeds(ordersSendeds)
    return ordersSendeds
    def handle(self, *args, **options):
        path = args[0]

        if path.startswith('http'):
            content = requests.get(path).json()
        else:
            content = json.load(open(path))

        for item in content:
            id_ = int(item['id']) + 300  # 260 розничных заказов, плюс небольшой отступ
            try:
                order = Order.objects.get(id=id_)
            except Order.DoesNotExist:
                order = Order(id=id_)

            print 'Processing order %s' % item['id']

            order.code = item['code']
            order.net = float(item['amt'])
            order.comment = item.get('comment', '')
            order.created = TIMEZONE.localize(datetime.datetime.fromtimestamp(int(item['cdt'])))
            order.status = STATUSES_MAPPING[item['status']]
            order.payment_type = PAYMENT_MAPPING.get(item.get('payment'))
            order.delivery_cost = int(item.get('dcost', 0))

            try:
                order.delivery = Delivery.objects.get(id=DELIVERY_MAPPINGS.get(item.get('delivery')))
            except Delivery.DoesNotExist:
                pass

            try:
                order.user = User.objects.get(id=int(item['user_id']))
            except User.DoesNotExist:
                try:
                    if not 'email' in item:
                        raise User.DoesNotExist()
                    order.user = User.objects.get(email=item['email'])
                except User.DoesNotExist:
                    pass

            order.save()

            if order.user:
                try:
                    company = Company.objects.get(user=order.user)
                except Company.DoesNotExist:
                    company = Company(user=order.user)

                company.title = item.get('addr_name') or item.get('company_name', '')
                company.city = item.get('company_city', '')
                company.director = item.get('director', '')
                company.juridical_address = item.get('jaddress', '')
                company.post_address = item.get('address', '')
                company.industry = item.get('company_industry', '')
                company.phone = item.get('phone', '')
                company.inn = item.get('inn', '')
                company.ogrn = item.get('ogrn', '')
                company.save()
            else:
                print 'Order %d cant be linked to user' % order.id

            for pitem in item.get('lst', ()):
                product_id = int(pitem['item_id'])
                try:
                    product = Product.objects.get(wholesale_legacy_id=product_id, is_visible=True)
                    kwargs = {
                        'product': product,
                    }
                except Product.DoesNotExist:
                    print 'Unknown product with id %s' % pitem['item_id']
                    kwargs = {
                        'product_legacy_id': product_id,
                    }
                except Product.MultipleObjectsReturned:
                    print product_id
                    raise

                try:
                    order_item = OrderItem.objects.get(order=order, **kwargs)
                except OrderItem.DoesNotExist:
                    order_item = OrderItem(order=order, **kwargs)
                order_item.product_legacy_id = product_id
                order_item.amount = int(pitem['qty'])
                order_item.per_item = float(pitem['price'])
                order_item.save()
Пример #34
0
def create_order(request,transaction_id):
    order=Order()
    checkout_form=CheckoutForm(request.POST,instance=order)
    order=checkout_form.save(commit=False)
    order.transaction_id= transaction_id
    order.ip_address = request.META.get('REMOTE_ADDR')
    order.user = None
    order.user = None
    if request.user.is_authenticated():
        order.user=request.user
    order.status = Order.SUBMITTED
    order.save()
    order.status = Order.SUBMITTED
    order.save()
    # if the order save succeeded
    if order.pk:
        cart_items = cart.cart.get_cart_items(request)
        for ci in cart_items:
        # create order item for each cart item
            oi = OrderItem()
            oi.order = order
            oi.quantity = ci.quantity
            oi.price = ci.price # now using @property
            oi.product = ci.product
            oi.save()
    # all set, empty cart
    cart.cart.empty_cart(request)
    #associate orders placed with registered users if they are logged in during the checkout process.
    if request.user.is_authenticated():
        from account import profile
        profile.set(request)
            # return the new order object
    return order
Пример #35
0
    def save(self):
        self.checkout.storage['is_confirmed'] = True

        order = Order()
        order.user = self.request.user
        order.address = self._get_address()
        order.delivery_date = self._get_delivery_date()
        order.delivery_time = self._get_delivery_time()
        order.shop = self._get_shop()
        order.status = Order.STATUS_RECEIVED
        order.code = '!'

        form = PaymentForm(self.request.POST)
        form.is_valid()
        order.comment = form.cleaned_data.get('comment', self.checkout.storage.get('comment', ''))
        net = self.request.cart.get_total(request=self.request).net

        try:
            order.delivery = Delivery.objects.get(id=self.checkout.storage['delivery'])
        except Delivery.DoesNotExist:
            order.delivery = None
            order.delivery_cost = 0
        else:
            order.delivery_cost = order.delivery.cost(net)
            print 'DELIVERY', order.delivery_id
            if order.delivery_id == Delivery.TYPE_SELF:
                order.payment_type = Order.PAYMENT_CASHPICK

            elif order.delivery_id == Delivery.TYPE_COURIER:
                order.payment_type = Order.PAYMENT_COURIER
                if net > 1000 and (order.address.city == u'Иркутск' or order.address.courier_city_id == 1):  # Иркутск
                    order.delivery_cost = 0
                elif order.address.courier_city:
                    order.delivery_cost = order.address.courier_city.price

            elif order.delivery_id == Delivery.TYPE_RUSSIANPOST:
                order.payment_type = Order.PAYMENT_ROBOKASSA

            elif order.delivery_id == Delivery.TYPE_EXPRESSPOST:
                pass

        order.products_price = self.request.cart.get_total(request=self.request).net
        order.net = self.request.cart.get_total(request=self.request).net + order.delivery_cost
        order.status = Order.STATUS_PAYMENT_WAITING

        order.save()

        for line in self.request.cart:
            item = OrderItem(order=order, product=line.product, amount=line.quantity,
                per_item=line.product.price_for_user(self.request.user) or 0)

            if line.data:
                item.sign = line.data.get('sign')

            item.save()

        coupon = self._get_coupon()
        if coupon:
            diff = self._apply_coupon(order, coupon)
            order.coupon = coupon
            order.net -= diff
            order.save()
            try:
                del self.request.session[Cart.COUPON_KEY]
            except KeyError:
                pass

        self.checkout.storage['order_id'] = order.id
        self.checkout.save()
    def handle(self, *args, **options):
        path = args[0]

        if path.startswith('http'):
            content = requests.get(path).json()
        else:
            content = json.load(open(path))

        for item in content:
            try:
                order = Order.objects.get(id=int(item['id']))
            except Order.DoesNotExist:
                order = Order(id=int(item['id']))

            order.code = item['code']
            order.net = float(item['amt'])
            order.comment = item.get('comment', '')
            order.created = TIMEZONE.localize(datetime.datetime.fromtimestamp(int(item['cdt'])))
            order.status = STATUSES_MAPPING[item['status']]
            order.payment_type = PAYMENT_MAPPING.get(item.get('payment'))
            order.delivery_cost = int(item.get('dcost', 0))

            try:
                order.delivery = Delivery.objects.get(id=DELIVERY_MAPPINGS.get(item.get('delivery')))
            except Delivery.DoesNotExist:
                pass

            try:
                order.user = User.objects.get(id=int(item['user_id']))
            except User.DoesNotExist:
                try:
                    if not 'email' in item:
                        raise User.DoesNotExist()
                    order.user = User.objects.get(email=item['email'])
                except User.DoesNotExist:
                    pass

            order.save()

            for pitem in item.get('lst', ()):
                product = Product.objects.get(id=int(pitem['item_id']))

                try:
                    order_item = OrderItem.objects.get(order=order, product=product)
                except OrderItem.DoesNotExist:
                    order_item = OrderItem(order=order, product=product)
                order_item.amount = int(pitem['qty'])
                order_item.per_item = float(pitem['price'])
                order_item.save()