def checkout(request): context = {} print('url = ',request.build_absolute_uri) cart_obj, cart_created = Cart.objects.new_or_get(request) billing_address_id = request.session.get('billing_address_id', None) shipping_address_id = request.session.get('shipping_address_id', None) billing_profile, billing_profile_created = BillingProfile.objects.new_or_get(request) order_obj = None if cart_created or cart_obj.cart_items.count() == 0: return redirect('/') login_form = LoginForm() guest_form = GuestForm() if billing_profile : if not shipping_address_id : return redirect('addresses:shipping_address') if not billing_address_id: return redirect('addresses:billing_address') context['shipping_address'] = Address.objects.get(id=shipping_address_id, billing_profile=billing_profile) context['billing_address'] = Address.objects.get(id=billing_address_id, billing_profile=billing_profile) if request.method == "POST": if billing_profile is not None: print('billing exist') order_obj, new_obj = Order.objects.new_or_get(billing_profile, cart_obj) if shipping_address_id: print(shipping_address_id) order_obj.shipping_address = Address.objects.get(id=shipping_address_id) if billing_address_id: print(billing_address_id) order_obj.billing_address = Address.objects.get(id=billing_address_id) if billing_address_id or shipping_address_id: order_obj.save() order_item = OrderItem() for item in cart_obj.cart_items.all(): order_item = OrderItem() order_item.order = order_obj order_item.item = item.item order_item.quantity = item.quantity order_item.total = item.total order_item.save() cart_obj.cart_items.all().delete() del request.session['item_count'] return redirect("success") context['order'] = order_obj context['form'] = login_form context['guest_form'] = guest_form context['cart'] = cart_obj context['billing_profile'] = billing_profile return render(request, 'carts/checkout.html', context)
def test_merge_same_products( buyer, traidoo_region, products, delivery_address, delivery_options, seller, logistics_user, ): order = Order(buyer=buyer, region=traidoo_region) order.save() order.recalculate_items_delivery_fee() order_items = [ OrderItem( product=products[0], quantity=5, order=order, delivery_address=delivery_address, delivery_option=delivery_options[0], latest_delivery_date=(timezone.now().date() + datetime.timedelta(days=3)), ), OrderItem( product=products[0], quantity=5, order=order, delivery_address=delivery_address, delivery_option=delivery_options[0], latest_delivery_date=(timezone.now().date() + datetime.timedelta(days=2)), ), OrderItem( product=products[0], quantity=5, order=order, delivery_address=delivery_address, delivery_option=delivery_options[0], latest_delivery_date=(timezone.now().date() + datetime.timedelta(days=1)), ), ] [items.save() for items in order_items] order.recalculate_items_delivery_fee() factory = factories.ProducerInvoiceFactory( order=order, seller=seller, region=traidoo_region ) assert len(factory._items) == 1 assert factory._items[0].product == products[0] assert factory._items[0].quantity == 15 assert factory._items[0].product_snapshot == order_items[0].product_snapshot assert factory._items[0].order == order assert factory._items[0].delivery_address == order_items[0].delivery_address assert factory._items[0].delivery_option == order_items[0].delivery_option assert factory._items[0].latest_delivery_date == order_items[0].latest_delivery_date
def modal(request): t = loader.get_template("orders/modalmenu.html") if request.method == "POST": i = int(request.POST["itemid"]) item = Menu.objects.get(id=i) cart = Cart.objects.get(user_id=request.user.id) r = { "item": item.item, "itemid": i, "category": item.category.item, "size": request.POST["size"], "price": float(request.POST["price"]), "quantity": int(request.POST["quantity"]), "cart": cart, "toppings": request.POST.getlist("toppings[]"), } form = CreateOrderItem(r, x=i) if form.is_valid(): r.pop("itemid") toppingspop = r.pop("toppings") orditem = OrderItem(**r) orditem.save() if len(toppingspop) > 0: orditem.toppings.set(toppingspop) orditem.save() return HttpResponse("it was a success!", status=200) else: return HttpResponse(t.render({"form": form}, request), status=422) elif request.method == "GET": i = int(request.GET["item"]) item = Menu.objects.get(id=i) form = CreateOrderItem(x=i, initial={"size": "Large"}) return HttpResponse(t.render({"item": item, "form": form}, request))
def save(self, user, commit=True): from django.contrib.contenttypes.models import ContentType # booking = super(BookingForm, self).save(commit=False) booking.booked_by = user open_order_list = Order.objects.open_order(user=user) if open_order_list: order = open_order_list[0] if commit: booking.save() # Add to open order if not open_order_list: order = Order(ordered_by=user) order.save() order_item = OrderItem( order=order, description=booking.price.__unicode__(), value=(booking.price.value * booking.quantity), vat=booking.price.vat, content_type=ContentType.objects.get_for_model(booking), object_id=booking.id) order_item.save() return booking
def handle(self, *args, **options): reference = datetime(2018, 1, 1, 9, 0, 0, 0, datetime_tz.utc) new_order_number = Order.objects.order_by().aggregate(max_number=Coalesce(Max('number'), 0))['max_number'] + 1 new_orders_amount = options['amount'] orders_to_create = [] for i in range(new_orders_amount): num = new_order_number + i orders_to_create.append(Order( number=num, created_date=reference + timedelta(hours=num - 1) )) orders = Order.objects.bulk_create(orders_to_create) # to get id (non-PostgreSQL db) orders = (Order.objects.filter(number__gte=new_order_number) # .annotate(cnt_items=Count('items')).filter(cnt_items=0) .order_by('id')) order_items_to_create = [] for order_id, order_number in orders.values_list('id', 'number'): for i in range(randint(1, 5)): order_items_to_create.append(OrderItem( order_id=order_id, product_name='Товар{}-{}'.format(order_number, i + 1), product_price=uniform(100, 9999), amount=randint(1, 10) )) items = OrderItem.objects.bulk_create(order_items_to_create) print('Created {} orders and {} order items'.format(len(orders_to_create), len(order_items_to_create)))
def order_custom(request): config = OrderConfig.objects.get(id=1) options = CustomCakeOrderConfigOption.objects.filter( available=True).order_by('sort') if request.method == 'POST': custom_cake_order_form = CustomCakeOrderForm(data=request.POST, options=options) order_form = OrderForm(request.POST) if custom_cake_order_form.is_valid() and order_form.is_valid(): product = Product.objects.get(slug='custom-cake') new_order = order_form.save() OrderItem(price=product.price, quantity=1, product=product, order_id=new_order.id).save() new_order.send_admin_custom_cake_confirm_emails( custom_cake_order_form.cleaned_data) new_order.send_client_custom_cake_confirm_emails( custom_cake_order_form.cleaned_data) return render(request, template_name='orders/order/custom-done.html', context={'config': config}) else: custom_cake_order_form = CustomCakeOrderForm(options) # cake_form = CustomCakeForm() order_form = OrderForm() return render( request, 'orders/order/custom.html', { 'config': config, # 'cake_form': cake_form, 'order_form': order_form, 'ok': custom_cake_order_form })
def create_order(request): cart = request.data.get("cart") orderData = request.data.get("order") orderData['user'] = request.user serializers = OrderSerializer(orderData) print(orderData) order = Order.objects.create( firstname = orderData['firstname'], lastname = orderData['lastname'], email = orderData['email'], address = orderData['address'], city = orderData['city'], postal_code = orderData['postal_code'], user = request.user ) if cart: for item in cart: product = get_object_or_404(Product, id=item['id']) order_item = OrderItem( order=order, product = product, price = item['price'], quantity = item['quantity'] ) order_item.save() else: order.delete() return Response(status=HTTP_400_BAD_REQUEST,data='Cart is Empty') return Response({'order_no': order.id}, status=HTTP_201_CREATED)
def update(self, instance, validated_data): if validated_data.get('status') is not None: if self.context['request'].user.is_superuser: instance.status = validated_data.get('status', instance.status) instance.save() return instance else: raise serializers.ValidationError( 'Only the admin can change status') item_data = validated_data.pop('item') raw_item = [] for item_data in item_data: items = OrderItem( order=instance, product=item_data['product'], quantity=item_data['quantity'], ) raw_item.append(items) OrderItem.objects.filter(order=instance).delete() OrderItem.objects.bulk_create(raw_item) instance.sum_order = instance.total_price instance.save() return instance
def test_get_total_cost(self): for item in range(10): order_item = OrderItem(order=self.order, product=self.product, price=1, count=1) order_item.save() self.assertEqual(self.order.get_total_cost(), 10)
def create_order(): user = current_user # You can not check is user is not None because user is LocalProxy even when no authenticated # to check if the user is authenticated we may do hasattr user_id = user.id if hasattr(user, 'id') else None address_id = request.json.get('address_id', None) if address_id is not None: # reusing address, the user has to be authenticated and owning that address address = Address.query.filter_by(id=address_id, user_id=user_id).first() if address is None: return get_error_response('Permission Denied, you can not use this address', 401) else: first_name = request.json.get('first_name', None) last_name = request.json.get('last_name', None) zip_code = request.json.get('zip_code', None) street_address = request.json.get('address', None) country = request.json.get('address', None) city = request.json.get('address', None) if user_id is not None: if first_name is None: first_name = user.first_name if last_name is None: last_name = user.last_name address = Address(first_name=first_name, last_name=last_name, city=city, country=country, street_address=street_address, zip_code=zip_code, ) if hasattr(user, 'id'): address.user_id = user.id db.session.add(address) db.session.flush() # we would need the address.id so let's save the address to the db to have the id import faker fake = faker.Faker() order = Order(order_status=0, tracking_number=fake.uuid4(), address_id=address.id) cart_items = request.json.get('cart_items') product_ids = [ci['id'] for ci in cart_items] products = db.session.query(Product).filter(Product.id.in_(product_ids)).all() if len(products) != len(cart_items): return get_error_response('Error, make sure all products you want to order are still available') for index, product in enumerate(products): order.order_items.append(OrderItem(price=product.price, quantity=cart_items[index]['quantity'], product=product, name=product.name, slug=product.slug, user_id=user_id)) db.session.add(order) db.session.commit() return get_success_response('Order created successfully', data=order.get_summary(include_order_items=True), status_code=200)
def change_cart_item(cls, cart_obj, product_item, is_added_to_cart): """ Change the cart item - Add more existed product to cart. - Add new product to cart. - Update product item quantity in cart. @param is_added_to_cart: A flag to determine add to cart or not @param cart_obj: Shopping cart object @param product_item: Product item data @return: Return `True` if the process completed successfully. """ try: cart_item_objs = OrderItem.objects.non_archived_only() \ .filter(order=cart_obj, product=product_item['product']) except EmptyCartException as e: raise e is_duplicated_item = len(cart_item_objs) > 1 is_one_item = len(cart_item_objs) == 1 # Do not allow duplicate cart item. if is_duplicated_item: raise DuplicateCartItemException( 'There are duplicate product item ' 'in the cart') if is_added_to_cart: if is_one_item: cart_item_objs.update(quantity=F('quantity') + 1) else: # There is no item in the cart. Create a new one. new_item_values = { 'order': cart_obj, 'product': Product.objects.get(pk=product_item['product']), 'quantity': 1 } cart_item_obj = OrderItem(**new_item_values) cart_item_obj.save() return True else: # Update cart item quantity if is_one_item: updated_data = {'quantity': product_item.get('quantity', None)} UpdatingCartItemSerializer(data=updated_data).is_valid( raise_exception=True) cart_item_objs.update(**updated_data) return True else: raise CartItemDoesNotExistException('Cart item not found')
def order_add_var_item(request, pk, var_pk, restaurant_pk, menu_pk, **kwargs): product = Product.objects.get(pk=pk) variation = ProductVariation.objects.get(pk=var_pk) menu = Menu.objects.get(pk=menu_pk) restaurant = Restaurant.objects.get(pk=restaurant_pk) if request.user.is_authenticated: pass # TODO: Lógica para usuários autenticados try: order_slug = request.session["order_slug"] except KeyError: order = Order(restaurant=restaurant) order.save() request.session["order_slug"] = order_slug = order.slug order = Order.objects.get(slug=order_slug) if order.orderitem_set.all().filter(item=product, variation=variation).exists(): item = OrderItem.objects.get(order=order, item=product, variation=variation) item.quantity = item.quantity + 1 item.save() messages.info( request, f'{product.name} Já está no pedido. ' f'<a href="/orders/cart/{order_slug}/" ' f'class="alert-link">Ver pedido</a>.') return redirect( reverse('restaurant_menu', kwargs={ 'restaurant_slug': restaurant.slug, 'menu_slug': menu.slug })) else: item = OrderItem(order=order, item=product, unity_price=variation.price, variation=variation) item.save() messages.success( request, f'{item.item.name} adicionado ao pedido. ' f'<a href="/orders/cart/{order_slug}/" ' f'class="alert-link">Ver pedido</a>.') return redirect( reverse('restaurant_menu', kwargs={ 'restaurant_slug': restaurant.slug, 'menu_slug': menu.slug }))
def create(self, validated_data): print('>>>', validated_data) chef = validated_data.get('chef') consumer = validated_data.get('consumer') meal = validated_data.get('meal') quantity = validated_data.get('quantity') item = OrderItem(consumer=consumer, chef=chef, meal=meal, quantity=quantity) item.save() return item
def setUp(self): self.product = Product(product_name="Arduino", product_image="", product_prices=750, product_overview="aeqweq") self.order = Order(first_name='N', last_name='Zh', email='*****@*****.**', address='S', city='Bishkek') self.order_item = OrderItem(order=self.order, product=self.product, price=100, count=10)
def test_get_total_cost_product_different_count(self): for item in range(10): product = Product(product_name=str(item), product_image="", product_prices=5 * item, product_overview=str(item)) product.save() order_item = OrderItem(order=self.order, product=product, price=product.product_prices, count=item) order_item.save() # self.assertEqual(self.order.get_total_cost(), 1425)
def save(self, event, price, user, commit=True): from django.contrib.contenttypes.models import ContentType # booking = super(BookingForm, self).save(commit=False) booking.booked_by = user booking.event = event booking.price = price total_booked = 0 open_order_list = Order.objects.open_order(user=user) if open_order_list: order = open_order_list[0] for item in order.orderitem_set.all(): total_booked += item.content_object.quantity if not (event.pricing_set.all().filter(online_book=True) and not event.fully_booked): raise ValidationError(_('This event is fully booked'), code='Fully Booked') commit = False elif event.num_spaces < (booking.quantity + total_booked): places = booking.quantity + total_booked raise ValidationError( _('Not enough spaces for %(places)s people.'), code='No Space', params={'places': places}, ) commit = False if commit: booking.save() # Add to open order if not open_order_list: order = Order(ordered_by=user) order.save() order_item = OrderItem( order=order, description=event.__unicode__(), value=(price.value * booking.quantity), vat=price.vat, content_type=ContentType.objects.get_for_model(booking), object_id=booking.id) order_item.save() return booking
def handle(self, *args, **kwargs): file_name = kwargs['file_name'] with open(f'{file_name}.csv') as csv_file: reader = csv.DictReader(csv_file) for row in reader: try: order_item = OrderItem(order_id=row['order_id'], product_name=row['product_name'], qty=row['qty']) order_item.save() except Exception as e: raise CommandError('OrderItem save fail') self.stdout.write( self.style.SUCCESS('%s.csv Data Feed Success!' % file_name))
def save_order(stripe_response): # print("Fulfilling order") transaction_id = stripe_response.id user_id = stripe_response.metadata.user_id cart_id = stripe_response.metadata.cart_id # Fetch all record of cart try: cart_data = Cart.objects.get(id=cart_id) except Cart.DoesNotExist: cart_data = None if cart_data is not None: # Insert into orders table order = Order(user_id=user_id, total=cart_data.total, transaction_id=transaction_id) order.save() latest_order_id = Order.objects.latest('id') # Fetch all record of cart items try: cart_items = CartItem.objects.filter(cart_id=cart_data.id) except CartItem.DoesNotExist: cart_items = None if cart_items is not None: # Insert into order detail table for data in cart_items: product_info = Product.objects.get(id=data.product_id) order_item = OrderItem(order_id=latest_order_id.pk, product_id=data.product_id, quantity=data.quantity, product_price=product_info.price, product_total=data.product_total) order_item.save() # Removing the current cart and its item data cart_data.delete() cart_items.delete() return True
def post(self,request,pk=None,format=None): # print('Request data is ' + str(request.data)) # o_parameters = {"table_no":request.data['tableno']} # r = requests.post('http://127.0.0.1:8000/orders/o/',data=o_parameters) print('aa') check_ob = Order.objects.filter(table_no=request.data['tableno']).count() if(check_ob <=0 ): new_order = Order(table_no=request.data['tableno']) new_order.save() order = Order.objects.get(table_no=request.data['tableno']) print('bb') print(order) check_oi = OrderItem.objects.filter(order=order).count() orderi = OrderItem(order=order,quantity=request.data['quantity']) orderi.save() food = FoodItem.objects.get(name=request.data['name']) print(orderi.fooditem) orderi.fooditem.add(food) return Response('Success')
def create_order_from_cart(**kwargs): logger.debug("creating order from Cart") user = kwargs['user'] ship_mode = kwargs['ship_mode'] cart = get_user_cart(user) total = 0 if cart.coupon: total = cart.solded_price else: total = cart.amount total += ship_mode.price logger.info(f"create_order_from_cart : Total : {total}") #order = Order.objects.create(user=user, address=address, coupon=cart.coupon, amount=cart.amount, solded_price=cart.solded_price, quantity=cart.quantity, shipping_price=SHIPPING_PRICE, total=total) order_kwargs = {'coupon' : cart.coupon, 'amount' : cart.amount, 'solded_price' : cart.solded_price, 'quantity' : cart.quantity, 'shipping_price' : ship_mode.price, 'total' : total} order_kwargs.update(kwargs) order = Order.objects.create(**order_kwargs) OrderStatusHistory.objects.create(order=order, order_status=order.status, order_ref_id=order.id, changed_by=user) logger.debug("order instance created") items_queryset = get_user_cartitems(user) logger.debug("got cartitems queryset") batch_size = 10 logger.debug("preparing orderitems from CartItems") orderitems = None product_update_list = items_queryset.values_list('product', 'product__quantity', 'quantity') try: orderitems = (OrderItem(order=order, product=item.product, quantity=item.quantity,promotion_price=item.promotion_price, unit_price=item.original_price,total_price=item.item_total_price) for item in items_queryset) except Exception as e: logger.error("error on preparing orderitems from CartItems") logger.exception(e) logger.debug("orderitems prepared from CartItems") if orderitems: while True: batch = list(islice(orderitems, batch_size)) if not batch: break OrderItem.objects.bulk_create(batch, batch_size) for pk, available_quantity, quantity in product_update_list: ProductVariant.objects.filter(pk=pk).update(quantity=F('quantity') - quantity, is_active=(available_quantity > quantity)) Product.objects.filter(variants__in=[pk]).update(quantity=F('quantity') - quantity) logger.debug("Order created from Cart") return order
def create(self, validated_data): validated_data['creator'] = self.context['request'].user item_data = validated_data.pop('item') order = super().create(validated_data) raw_item = [] for item_data in item_data: items = OrderItem( order=order, product=item_data['product'], quantity=item_data['quantity'], ) raw_item.append(items) OrderItem.objects.bulk_create(raw_item) order.sum_order = order.total_price order.save() return order
def get_order_items(cartProducts): orderItems = [] if cartProducts: for productID, quantity in cartProducts.items(): product = Product.objects.filter(id=productID).first() if product: if product.discount_price != product.price: discountedPrice = product.discount_price else: discountedPrice = None orderItem = OrderItem(product=product, quantity=quantity, price=product.price, discountedPrice=discountedPrice) orderItems.append(orderItem) return orderItems
def post(self,request,pk=None,format=None): table_qs = Table.objects.filter(table_no = request.data['tableno']) table = list(table_qs)[0] # print(table) check_ob = Order.objects.filter(table_no=table).count() if(check_ob <=0 ): new_order = Order(table_no=table) new_order.save() order_qs = Order.objects.filter(table_no = table) order = list(order_qs)[0] print(order) food = FoodItem.objects.get(name=request.data['name']) print(food) orderi = OrderItem(order=order,fooditem=food,quantity=request.data['quantity']) orderi.save() return Response('Success')
def seed_orders(): orders_count = db.session.query(func.count(Order.id)).scalar() orders_to_seed = 31 addresses = db.session.query(Address).options(load_only('id', 'user_id')).all() products = db.session.query(Product).options( load_only('id', 'name', 'slug', 'price')).all() for i in range(orders_count, orders_to_seed): address = random.choice(addresses) tracking_number = fake.uuid4() order_status = fake.random_int(min=0, max=2) user_id = address.user_id order = Order(tracking_number=tracking_number, order_status=order_status, address_id=address.id, user_id=user_id) db.session.add(order) ''' this is to save the order now, so I can have the id to be used in order items or the other way is to comment flush(), order_id=order.id, and session.add(oi). Instead use order.order_items.append(oi); See below. Both ways lead to the same result ''' db.session.flush() for i in range(fake.random_int(min=1, max=6)): product = random.choice(products) oi = OrderItem(name=product.name, slug=product.slug, price=product.price, order_id=order.id, product_id=product.id, user_id=user_id, quantity=fake.random_int(min=1, max=5)) db.session.add(oi) # order.order_items.append(oi) db.session.commit()
def form_valid(self, form): cart = Cart(self.request) if len(cart) == 0: return redirect('cart:cart_details') order = form.save(commit=False) order.user = self.request.user order.total_price = cart.get_total_price() order.save() products = Product.objects.filter(id__in=cart.cart.keys()) orderitems = [] for i in products: q = cart.cart[str(i.id)]['quantity'] orderitems.append( OrderItem(order=order, product=i, quantity=q, total=q * i.price)) OrderItem.objects.bulk_create(orderitems) cart.clear() messages.success(self.request, 'Your order is successfully placed.') return redirect('store:product_list')
def save_cart_as_order(cart): address = None if cart.get('details').get('delivery_address'): address = Address( street_one = cart.get('details').get('delivery_address').get('street_one'), street_two = cart.get('details').get('delivery_address').get('street_two'), city = cart.get('details').get('delivery_address').get('city'), state = cart.get('details').get('delivery_address').get('state'), zipcode = cart.get('details').get('delivery_address').get('zipcode'), ) address.save() customer = Customer( first_name = cart.get('details').get('contact_info').get('first_name'), last_name = cart.get('details').get('contact_info').get('last_name'), email = cart.get('details').get('contact_info').get('email'), phone_number = cart.get('details').get('contact_info').get('phone'), address = address, ) customer.save() order = Order( ref_code = create_ref_code(), customer = customer, ordered_date = timezone.now(), pickup = cart.get('details').get('pickup'), note = cart.get('details').get('note'), ) order.save() id_list = cart.get('details').get('item_id_list') for id in id_list: item = Item.objects.get(id=id) order_item = OrderItem( item = item, quantity = cart.get(str(id)).get('quantity'), note = cart.get(str(id)).get('note'), order = order, ) order_item.save() return order
def save(self, user, value, commit=True): from django.contrib.contenttypes.models import ContentType pricing = Pricing() pricing.value = value pricing.save() donation = super(PaymentForm, self).save(commit=False) donation.price = pricing donation.booked_by = user open_order_list = Order.objects.open_order(user=user) if open_order_list: order = open_order_list[0] if commit: donation.save() # Add to open order if not open_order_list: order = Order(ordered_by=user) order.save() order_item = OrderItem( order=order, description=donation.__unicode__(), value=(pricing.value * donation.quantity), vat=donation.price.vat, content_type=ContentType.objects.get_for_model(donation), object_id=donation.id) order_item.save() return pricing
def post(self, request, *args, **kwargs): cart = Cart(request.session) serializer = OrderSerializer(data=request.data) if serializer.is_valid(): order = serializer.save() for item in cart.items: instance = OrderItem( order=order, product=item.product, price=item.price, quantity=item.quantity ) instance.save() cart.clear() UserOrderNotification.apply_async((order.pk,), countdown=10) AdminOrderNotification.apply_async((order.pk,), countdown=10) return Response( status=status.HTTP_201_CREATED ) else: return Response( status=status.HTTP_422_UNPROCESSABLE_ENTITY )
def checkout(request): #assume credit card not recorded for customer until proven otherwise cc_reg = "btn btn-sm btn-success disabled" #get user object user = get_object_or_404(User, username=request.user) #set cost and amount variables global total_cost total_cost = 0 total_amount = 0 delivery_cost = 0 #if basket present if 'cart' in request.session: #Select all records from Cart_Item for current id items_in_cart = CartItem.objects.filter( cart_id=request.session['cart']) #for each cart item, use the stored product_id to retrive product details from product table products = Product.objects.filter( id__in=[item.product_id for item in items_in_cart]) #getting amount ordered of each product so can auto-fill checkout list for item in products: cartItem_amount = get_object_or_404( CartItem, product_id=item.id, cart_id=request.session['cart']) item.amount = cartItem_amount.amount item.cost = item.amount * item.price total_cost = total_cost + item.cost total_amount = total_amount + item.amount #add £2 deliver charge per item delivery_cost = total_amount * 2 total_cost = total_cost + delivery_cost pence_cost = int(total_cost * 100) if items_in_cart.exists(): #Check that credit card and address have been logged before allowing checkout (and enabling purchase button) if user.stripe_custID == "None": messages.error( request, "Please register a valid credit card in your profile") elif user.address_line1 == "None" or user.address_line2 == "None" or user.county == "None" or user.postcode == "None": messages.error( request, "Please register a delivery address in your profile") else: #enable purchase button cc_reg = "btn btn-sm btn-success" #if request method is POST some is trying to buy product if 'purchase' in request.POST: #set cost and amount variables to check if checkout amounts needs to be refreshed at checkout. # #On a multi-user system for a company with relatively small stock levels, between the customer #putting item(s) in cart and getting to checkout, their is the real risk that another customer purchase #could pull stock levels down to a level where the current customers order can't be met with existing #stock. This would then require extra time to restock, so the company would prefer the customer call them #so they can speak through the options. total_cost_refresh = 0 total_amount_refresh = 0 delivery_cost_refresh = 0 #Go through and check stock levels are still OK pre purchase #i.e has another customer made a purchase and reduced available stock levels below what can be fulfilled? refresh_checkout = False #This is a cart_items_to_refresh = [] for item in products: #Need to get current stock level current_product = get_object_or_404(Product, id=item.id) if item.amount > current_product.stock_level: refresh_checkout = True #Get the object that hold this amount value cartItem = get_object_or_404( CartItem, product_id=item.id, cart_id=request.session['cart']) #set it to the stock leve value (so that 'refresh_checkout' won't be true 2nd time around) cartItem.amount = current_product.stock_level #save it to database cartItem.save() #Also change value of item being iterated over item.amount = current_product.stock_level #tracking the items in order that need to be refreshed cart_items_to_refresh.append(current_product) item.cost = item.amount * item.price total_cost_refresh = total_cost_refresh + ( item.amount * item.price) total_amount_refresh = total_amount_refresh + item.amount #£2 deliver charge per item delivery_cost_refresh = total_amount_refresh * 2 total_cost_refresh = total_cost_refresh + delivery_cost_refresh if refresh_checkout == True: messages.error( request, "Other recent customer purchases mean we can no longer currently meet you order with our existing stock, your order has been updated to reflect current stock levels. Please contact us to discuss acquiring the additional items." ) #Need to amend cartItem to store new amount value, so that if purchase not made #but cart stored, the item is not deleted (on signing back in) unless #stock levels has actually gone below the amended amount for item in cart_items_to_refresh: current_product = get_object_or_404(Product, id=item.id) cart_item = get_object_or_404( CartItem, product_id=item.id, cart_id=request.session['cart']) #if the stock level is 0, remove from cart, no point in having it (would only confuse customer) if current_product.stock_level == 0: cart_item.delete() else: cart_item.amount = current_product.stock_level cart_item.save() #disable the purchase button if refrsh has meant the order is now for nothing (to prevent processing errors) if total_amount_refresh == 0: cc_reg = "btn btn-sm btn-success disabled" return render( request, "checkout/checkout.html", { "user": user, "products": products, "cc_reg": cc_reg, "total_cost": total_cost_refresh, "total_amount": total_amount_refresh, "delivery_cost": delivery_cost_refresh }) try: #Try to make payment! charge = stripe.Charge.create( amount=pence_cost, currency="gbp", customer=user.stripe_custID, ) messages.success(request, "Payment Successful") #Create order entries in database customer = get_object_or_404(User, username=request.user) new_order = Order(address_line1=user.address_line1, address_line2=user.address_line2, county=user.county, postcode=user.postcode, total=(pence_cost / 100), customer_id=customer.id) new_order.save() for item in products: new_orderItem = OrderItem(order_id=new_order.id, product=item, quantity=item.amount, price=item.price) new_orderItem.save() #Reduce the stock level #The amount won't be bigger than current stock levels due to pre-purchase stock #level checks (so no need to check here) current_product = get_object_or_404(Product, id=item.id) current_product.stock_level = current_product.stock_level - item.amount current_product.save() #"When Django deletes an object, by default it emulates the behavior of the SQL constraint ON DELETE #CASCADE – in other words, any objects which had foreign keys pointing at the object to be deleted #will be deleted along with it". So this command should remove the cart and associated cart items #from the database. Cart.objects.filter( id=request.session['cart']).delete() del request.session['cart'] #If the cart was from a stored version, remove it if user.saved_cart_id != 0: user.saved_cart_id = 0 user.save() #Send user to orders page after successful purchase return redirect("orders") #Gracefully catch error, inform customer of issue except stripe.error.CardError as e: body = e.json_body err = body.get('error', {}) messages.error(request, err.get('message')) else: #this is enabling purchase button on initial page load (rather than when purchase has been pressed) #when credit card and address have been stored in database. cc_reg = "btn btn-sm btn-success" return render( request, "checkout/checkout.html", { "user": user, "products": products, "cc_reg": cc_reg, "total_cost": total_cost, "total_amount": total_amount, "delivery_cost": delivery_cost }) #empty cart, let use rknow else: messages.error( request, "Nothing in your cart, please add an item before attempting purchase" ) return render( request, "checkout/checkout.html", { "cc_reg": cc_reg, "total_cost": total_cost, "total_amount": total_amount, "delivery_cost": delivery_cost }) else: messages.error( request, "You don't have a cart yet, please create one by adding an item before attempting purchase" ) return render( request, "checkout/checkout.html", { "cc_reg": cc_reg, "total_cost": total_cost, "total_amount": total_amount, "delivery_cost": delivery_cost })
def populate(): """Populate the database with activity simulating last 365 days.""" # Start by dropping all the previous data main_tables = (Expense, Customer, Order, Item, StatusShift, Timetable, User) for table in main_tables: table.objects.all().delete() # Create a default user name user = User.objects.create_user(username='******', password='******') # random numbers upper bound u = len(WORDS) - 1 # Create some customers for name in NAMES: Customer.objects.create( name=name, address=multiword(), city=multiword(), phone=randint(20000, 2000000), email='{}@{}.com'.format(multiword(1), multiword(1)), cp=randint(1000, 99000), CIF=str(randint(10000, 99000)), notes=multiword(5), provider=randint(0, 1), ) # Create some items for _ in range(10): Item.objects.create( name=WORDS[randint(0, u)], item_type=randint(0, 18), foreing=randint(0, 1), price=randint(10, 150), fabrics=randint(1, 3), stocked=300, ) # Create daily activity for the last n days days = (date.today() - date(date.today().year, 1, 1)).days for n in range(days): print('.', end='') curr_datetime = timezone.now() - timedelta(days=days - n) order = Order.objects.create( inbox_date=curr_datetime, user=user, customer=choice(Customer.objects.filter(provider=False)), ref_name=multiword(), delivery=curr_datetime + timedelta(days=randint(7, 30)), status=randint(1, 6), waist=randint(60, 70), chest=randint(90, 120), hip=randint(90, 120), others=multiword(5), ) for i in range(randint(2, 4)): item = OrderItem( element=choice(Item.objects.all()), reference=order, qty=randint(1, 3), price=randint(10, 100), stock=randint(0, 1), ) item.clean() if randint(1, 15) > 1: item.crop = timedelta(seconds=1000 * randint(1, 3)) item.sewing = timedelta(seconds=1000 * randint(1, 3)) item.iron = timedelta(seconds=1000 * randint(1, 3)) item.save() # Add a comment if randint(1, 15) > 1: Comment.objects.create(creation=curr_datetime, user=user, reference=order, comment=multiword(10)) # Sell something active_orders = Order.live.all() sell_it = randint(1, 20) > 1 # p = 19/20 if sell_it and active_orders.exists(): order = active_orders.first() pay_method = choice(['C', 'T', 'V']) CashFlowIO.objects.create( creation=curr_datetime, order=order, amount=order.pending, pay_method=pay_method, ) if order.status != '7': order.deliver() # Creates status shift # Set status to 9 (invoiced) order.status = '9' order.save() i = Invoice(reference=order, issued_on=curr_datetime, amount=order.total, pay_method=pay_method) i.save(kill=True) # Update Item health [i.save() for i in Item.objects.all()] # Expend some money somewhere providers = Customer.objects.filter(provider=True) expense = Expense.objects.create( creation=curr_datetime, issuer=choice(providers), invoice_no=choice(WORDS), issued_on=curr_datetime, concept=multiword(2), amount=randint(180, 250), pay_method=choice(['C', 'T', 'V']), notes=multiword(5), ) if randint(1, 15) > 1: expense.kill() # Deliver a couple of orders without selling [order.deliver() for order in Order.live.all()[:3]]