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 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 new_order(request, pk): template = 'pos/new_order.html' form = OrderForm(request.POST or None) if request.method == 'POST': if form.is_valid(): table_order = Order.objects.filter(table=pk) latest = table_order.latest('created') if latest.paid == True: order = Order() else: order = latest order.number = Order.objects.count() + 1 order.table = Table.objects.get(number=pk) order.paid = False order.save() orderitem = OrderItem() product = form.cleaned_data.get('product') orderitem.product = Product.objects.get(title=product) orderitem.order = order orderitem.table = Table.objects.get(number=pk) orderitem.quantity = form.cleaned_data.get('quantity') orderitem.total_price = orderitem.quantity * orderitem.product.unit_price orderitem.discount = form.cleaned_data.get('discount') orderitem.notes = form.cleaned_data.get('notes') orderitem.save() return redirect('/table/' + pk) context = {'form': form} return render(request, template, context)
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 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 _change_order_item_packed_state(order_item: OrderItem, packed_state: bool) -> None: """Изменение состояния упаковки строки заявки :param order_item: Строка заявки :param packed_state: Состояние """ order_item.packed = packed_state order_item.save(update_fields=['packed'])
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 process_order(request): context = RequestContext(request) user = request.user increment_clicks(user) profile = get_associated_profile(user) cart = get_cart(profile) items_to_package = [] total_price = 0 for item in CartItem.objects.all(): if item.cart == cart: items_to_package.append(item.item) total_price = total_price + item.item.price entry_id = request.POST.get("entry_id") entry = Entry.objects.get(id=entry_id) new_order = Order( user_profile=profile, restaurant=profile.restaurant, total=total_price, entry=entry, status="PDG", order_success=False, order_rating=0, ) new_order.save() order_dict = {} for item in items_to_package: if item.id in order_dict.keys(): order_dict[item.id] = order_dict[item.id] + 1 else: order_dict[item.id] = 1 order_items = [] for key in order_dict.keys(): item = Item.objects.get(id=key) quantity = order_dict[key] new_order_item = OrderItem(item=item, order=new_order, quantity=quantity) new_order_item.save() order_items.append(new_order_item) # cart.delete() # print order_dict.keys() cart_id = cart.id print cart.id return render_to_response( "confirm.html", {"total_price": total_price, "user": user, "profile": profile, "order_items": order_items, "cart_id": cart_id}, context, )
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 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 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 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 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 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 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 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 create_order_item(order, supplier, unit_cost=1.0, quantity=1, supplier_order=None, name=None): if not name: name = "test_ingredient_%d" % random.randint(0, 9999) ingredient, _ = Ingredient.objects.get_or_create( unit_cost=unit_cost, name=name, supplier=supplier) order_item = OrderItem( ingredient=ingredient, user_order=order, quantity=quantity, supplier_order=supplier_order) order_item.save() return order_item
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 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 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 create_order(cart_id, user, context): cart = Cart.objects.get(id=cart_id) items = cart.get_items_and_quantities() profile = users.views.return_associated_profile_type(user) entry = cart.entry total = cart.get_total_price_of_cart() tax = cart.get_tax_for_cart() new_order = Order( profile=profile, total=total + tax, entry=entry, status='PDG', ) new_order.save() for item in items.keys(): new_order_item = OrderItem( item=item, order=new_order, quantity=items[item] ) item.number_ordered = item.number_ordered + 1 item.save() new_order_item.save() entry.available = entry.available - 1 entry.save() cart.cart_still_active = False cart.delete() profile = UserProfile.objects.get(user=user) send_receipt_text(profile, new_order) return render_to_response( 'successful_charge.html', { 'entry':entry, }, context)
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 process_order(request): context = RequestContext(request) user = request.user profile = get_associated_profile(user) cart = get_cart(profile) items_to_package = [] total_price = 0 for item in CartItem.objects.all(): if item.cart == cart: items_to_package.append(item.item) total_price = total_price + item.item.price entry_id = request.POST.get("entry_id") entry = Entry.objects.get(id=entry_id) new_order = Order( user_profile=profile, restaurant=profile.restaurant, total=total_price, entry=entry, status="PDG", order_success=False, order_rating=0, ) new_order.save() order_dict = {} for item in items_to_package: if item.id in order_dict.keys(): order_dict[item.id] = order_dict[item.id] + 1 else: order_dict[item.id] = 1 for key in order_dict.keys(): item = Item.objects.get(id=key) quantity = order_dict[key] new_order_item = OrderItem(item=item, order=new_order, quantity=quantity) new_order_item.save() cart.delete() return redirect("checkout.views.checkout")
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 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): 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 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, 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 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 )
class OrderItemTest(TestCase): 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_cost(self): self.assertEqual(self.order_item.get_cost(), 1000)
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 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 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 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 new_order(atg_order, tinla_profile, client): # Ensure that there is no profile with this atg login map_entry = None try: map_entry = AtgOrderMigrationMap.objects.select_related('order').get( atg_order = atg_order.order.order) log.info("Already migrated %s, skipping new_order" % atg_order.order.order) return map_entry.order except AtgOrderMigrationMap.DoesNotExist: pass # create new order order = Order() order.user = tinla_profile order.state = get_order_state(atg_order.order.order_state) order.timestamp = atg_order.order.atg_creation_date order.payment_realized_on = atg_order.order.atg_submitted_date order.modified_on = atg_order.order.last_modified_date order.reference_order_id = atg_order.order.order order.client = client order.save() # delivery info shipping = DcsppShipGroup.objects.filter(order_ref = atg_order.order.order) if shipping: shipping = shipping[0] dcspp_addr = DcsppShipAddr.objects.filter(shipping_group=shipping.shipping_group) if dcspp_addr: shipping = dcspp_addr[0] if shipping: addr = Address() addr.profile = tinla_profile addr.account = client.account_set.all()[0] addr.first_name = shipping.first_name addr.last_name = shipping.last_name addr.phone = shipping.phone_number addr.email = shipping.email addr.pincode = shipping.postal_code country, state, city = '', '', '' try: if shipping.county: country = get_country(shipping.county) if shipping.state and country: state = get_state(shipping.state.state_name, country) if shipping.city and state: city = get_city(shipping.city, state) if country: addr.country = country if state: addr.state = state if city: addr.city = city except: pass addr.save() del_info = DeliveryInfo() del_info.address = addr del_info.order = order del_info.save() order_items = atg_order.order.dcspporderitem_set.all() list_price_total, shipping_charges = Decimal(0), Decimal(0) for atg_oi in order_items: oi = OrderItem() ci = atg_oi.commerce_items oi.order = order oi.state = get_order_state(ci.state) try: src = SellerRateChart.objects.get(sku=ci.sku.sku.sku_id, seller__client = client) oi.seller_rate_chart = src except SellerRateChart.DoesNotExist: pass oi.list_price = ci.amount_info.list_price list_price_total += ci.amount_info.list_price oi.sale_price = ci.amount_info.sale_price del_item = FtbShipitemRel.objects.filter(relationship__commerce_item = atg_oi) if del_item: del_item = del_item[0] oi.shipping_charges = del_item.shipping_cost shipping_charges += del_item.shipping_cost "shipping found for ", atg_order.order oi.qty = ci.quantity oi.save() # amount info order_discount_total = Decimal(str(atg_order.ord_misc_field1)) sale_price_total = atg_order.order.price_info.raw_subtotal total_order_shipping = atg_order.order.price_info.shipping + shipping_charges order.shipping_charges = total_order_shipping order.list_price_total = list_price_total order.total = sale_price_total order.payable_amount = sale_price_total + total_order_shipping - order_discount_total order.save() print order.id print order.reference_order_id # map entry map_entry = AtgOrderMigrationMap(order = order, atg_order = atg_order.order.order) map_entry.save()
def process_order(request): context = RequestContext(request) user = request.user increment_clicks(user) profile = get_associated_profile(user) cart = get_cart(profile) items_to_package = [] total_price = 0 for item in CartItem.objects.all(): if item.cart == cart: items_to_package.append(item.item) total_price = total_price + item.item.price entry_id = request.POST.get('entry_id') entry = Entry.objects.get(id=entry_id) new_order = Order(user_profile=profile, restaurant=profile.restaurant, total = total_price, entry = entry, status = 'PDG', order_success = False, order_rating = 0 ) new_order.save() order_dict = {} for item in items_to_package: if item.id in order_dict.keys(): order_dict[item.id] = order_dict[item.id] + 1 else: order_dict[item.id] = 1 order_items = [] for key in order_dict.keys(): item = Item.objects.get(id=key) quantity = order_dict[key] new_order_item = OrderItem(item=item, order=new_order, quantity=quantity) new_order_item.save() order_items.append(new_order_item) #cart.delete() #print order_dict.keys() cart_id = cart.id #print cart.id total_price_display = new_order.view_order_total_in_usd() return render_to_response("confirm.html", {'total_price_display':total_price_display, 'total_price':total_price, 'user':user, 'profile':profile, 'order_items':order_items, 'cart_id':cart_id }, context)