def complete(request):
if request.method == 'POST':
order_json = json.loads(request.POST['product_form'])
order = Order()
for key, value in order_json.items():
if key == 'total_price':
order.total_price = value
print("total price")
order.order_status = OrderStatus(id=1)
order.order_date = date.today()
order.delivery = DeliveryType(id=2)
print("rétt fyrir Order save")
order.save()
print("Order saved")
order_id = order.id
print("producr form byrjun")
for key, value in order_json.items():
if key != 'NaN' and value != 'NaN' and key != 'total_price':
ordered_products = OrderedProducts()
ordered_products.product_id = key
ordered_products.quantity = value
ordered_products.order_id = order_id
ordered_products.save()
id_for_order = [{'order_id': order_id}]
return JsonResponse({'data': id_for_order})
else:
print('Else í complete')
return render(request, 'order/order_complete.html')
def new_order(request: WSGIRequest):
"""
request_body:
{
"creator": "Sam",
"title": "青子菁吃起來",
"content": "雞排/炸物",
"menu_url": "google.com",
"max_followers": 0,
"deadline_in_min": 20
}
response_body:
{
"status": "success",
"order_id": 1
}
"""
if request.method == 'POST':
try:
data_in = json.loads(request.body)
order = Order()
order.creator = User.objects.get(name=data_in['creator'])
order.title = data_in['title']
order.content = data_in['content']
order.menu_url = data_in['menu_url']
order.max_followers = data_in['max_followers']
order.deadline = datetime.datetime.now() + \
datetime.timedelta(minutes=data_in['deadline_in_min'])
order.save()
except Exception as e:
return _json(status='Failed to create order', exception=str(e))
return _json(status='Create order', post_id=order.id, data_in=data_in)
return _json(status='No such method')
def post(self, request, *args, **kwargs):
context = dict()
user = self.request.user
product_ids = self.request.POST.getlist('product_id')
product_prices = self.request.POST.getlist('product_price')
product_quantity = self.request.POST.getlist('product_quantity')
order_set_num = -1
# print("order check")
# print("user",user)
# print("id",product_ids)
# print("price",product_prices)
# print("qu",product_quantity)
# print("order check end")
for id, price, quantity in zip(product_ids, product_prices,
product_quantity):
# 새로운 주문 생성
product = get_object_or_404(Product, pk=id)
new_order = Order(owner = user, product=product, quantity=quantity,\
price = price, order_status = "Ordered")
new_order.save() # db 에 저장 해야만 pk를 알수있음
# 주문세트의 번호 설정(첫번째 주문의 pk로 전부 설정)
if order_set_num == -1:
order_set_num = new_order.pk
new_order.order_set = order_set_num
new_order.save()
return redirect(reverse('order:result'))
def orderCreate(request):
if request.method == 'POST':
orderProductList = request.POST.get('orderProductList', None)
if orderProductList:
result = orderProductList.split('%&key%&')[:-1]
check = True
for v in result:
prod = Product.objects.get(name=v)
quantity = request.POST.get(v, 0)
if (prod.stock <= int(quantity)):
check = False
res_data = {}
if check:
order = Order(fcuser=Fcuser.objects.get(
email=request.session.get('user')))
order.save()
for v in result:
prod = Product.objects.get(name=v)
quantity = request.POST.get(v, 0)
orderitem = OrderItem(order=order,
product=prod,
quantity=quantity)
orderitem.save()
prod.stock -= int(quantity)
prod.save()
else:
res_data['error'] = '주문 수량이 재고 수량을 초과합니다.'
return render(request, 'redirect.html', res_data)
def add_order():
# 定时( 00:00:00 )将 抢购的商品存入到订单
# [{'user_id': 8, 'goods_id': 2}]
qbuy_goods = get_all_qbuy()
if not qbuy_goods:
return '无数据，无法生成订单'
for goods in qbuy_goods:
user_id = goods.get('user_id')
book_id = goods.get('goods_id')
order = Order()
order.title = '抢读%s' % Book.objects.get(pk=book_id).title
order.price = 0
order.user_id = user_id
order.pay_status = 1 # 1 已支付
order.save()
order_detail = OrderDetail()
order_detail.order = order
order_detail.price = 0
order_detail.cnt = 1
order_detail.book_id = book_id
order_detail.save()
# 清空qbuy缓存
clear_qbuy()
return '定时生成订单成功'
def order(request):
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
_customerid = form.cleaned_data['customerid']
_voltage = form.cleaned_data['voltage']
_current = form.cleaned_data['current']
_width = form.cleaned_data['width']
_height = form.cleaned_data['height']
_status = form.cleaned_data['status']
job = Order(customerid=_customerid,
voltage=_voltage,
current=_current,
width=_width,
height=_height,
status=_status,
order_ts=timezone.now())
job.save()
return HttpResponse("thank you!")
else:
form = OrderForm()
render(request, 'order.html', {
'form': form,
})
else:
form = OrderForm()
return render(request, 'order.html', {
'form': form,
})
def create_order_from_express_paypal(nvp_dict):
"""
Create order in DB with ordered items
"""
#create order
#create items
#return order object
order = Order()
order.email = nvp_dict.get('email')
order.b_first_name = nvp_dict.get('firstname')
order.b_last_name = nvp_dict.get('lastname')
order.b_address_countryname = nvp_dict.get('shiptocountryname')
order.b_address_countrycode = nvp_dict.get('shiptocountrycode')
order.b_address_zip = nvp_dict.get('shiptozip')
order.b_address_state = nvp_dict.get('shiptostate')
order.b_address_city = nvp_dict.get('shiptocity')
order.b_address_street = nvp_dict.get('shiptostreet') \
+ nvp_dict.get('shiptostreet2', "")
order.status = order.NEW_ORDER
order.paypal_transaction_id = nvp_dict.get('transactionid')
order.save()
save_order_items(nvp_dict, order)
return order
def new(request):
"""创建订单，以购物车中选中的商品"""
order = Order(
# order_id =
user_id=request.session['user']['user_id'],
sum_price=0,
# 订单状态：已取消 0， 待付款 1， 待发货 2， 已发货 3， 已完成 4
status=1,
time_submit=datetime.datetime.now(),
# time_pay=None,
# time_finish=None,
)
order.save()
sum_price = 0.0
for book in Cart.objects.filter(
user_id=request.session['user']['user_id'],
select=True,
).all():
OrderContent.objects.create(order_id=order.order_id,
book_id=book.book_id,
number=book.number,
price=book.price)
sum_price += book.number * book.price
Order.objects.filter(order_id=order.order_id).update(sum_price=sum_price)
Cart.objects.filter(
user_id=request.session['user']['user_id'],
select=True,
).delete()
# 重定向展示实际的网址
return redirect("/order/detail/%d" % order.order_id)
def DoWriteOrderInfo(request):
userPkId = request.POST['userPkId']
orderDateTime = datetime.now()
formatted_datetime = formats.date_format(orderDateTime,
"SHORT_DATETIME_FORMAT")
mixedOrderNumber = formatted_datetime + userPkId
user = Customer.objects.get(email=request.POST['email'])
state = DeliveringState.SHIPPED
br = Order(
customer=user,
deliveringState=state,
orderNumber=mixedOrderNumber,
destination=request.POST['destination'],
baggageKind=request.POST['baggageKind'],
customerName=request.POST['customerName'],
quantity=request.POST['quantity'],
)
br.save()
url = '/showOrderList'
return HttpResponseRedirect(url)
def orderbook(request):
settings = Setting.objects.get(pk=1)
current_user = request.user
data = Order()
data.user_id = current_user.id
data.ip = request.META.get('REMOTE_ADDR')
ordercode = get_random_string(5).upper()
data.code = ordercode
data.save()
schopcard = ShopCard.objects.filter(user_id=current_user.id)
for rs in schopcard:
detail = OrderBook()
detail.order_id = data.id
detail.book_id = rs.book_id
detail.user_id = current_user.id
detail.start_date = rs.start_date
detail.end_date = rs.end_date
detail.end_date = rs.end_date
detail.save()
book = Book.objects.get(id=rs.book_id)
book.amount -= 1
book.save()
ShopCard.objects.filter(user_id=current_user.id).delete()
request.session['card_items'] = 0
messages.success(request, "Rezervasyon tamamlandi.")
return render(request, 'order_completed.html', {'ordercode': ordercode, 'settings': settings, 'user': current_user})
def post(self, request):
order = Order()
order.cart_id = request.session.get(CART_ID)
order.address = request.POST.get('address')
order.phone = request.POST.get('phone')
order.name = request.POST.get('name')
order.processed = False
order.comment = request.POST.get('comment')
if request.user.is_authenticated():
order.customer = request.user
order.save()
cart = CartService(request)
cart.checkout()
params = {
"phone": unicode(request.POST.get('phone')),
"name": None,
"customer": request.user,
"comment": order.comment,
"orderno": order.id,
"orderdt": order.checkout_date,
"orderaddr": order.address,
"ordercart": cart,
}
send_notification("order_notice", params)
return render(request, 'cart/after_order.html')
def make_order(request, chip_id):
chip = Chip.objects.all().filter(tag=chip_id)
if chip.exists():
old_order = Order.objects.all().filter(
chip__tag=chip_id,
status=OrderStatusOptions.PENDING).order_by('-created')
new_order = Order(chip=chip[0])
save_new = True
if len(old_order) >= 0:
order = old_order[0]
order_id = order.id
now_ts = datetime.datetime.now().timestamp()
create_ts = order.created.timestamp()
t = now_ts - create_ts
if t < 5 * 60:
save_new = False
order.created = datetime.datetime.now()
order.save()
if save_new:
new_order.save()
order_id = new_order.id
return HttpResponse('{ "order" : ' + str(order_id) + '}')
else:
return HttpResponse('{ "order" : -1 }')
def order_create(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderCreateForm(request.POST)
if form.is_valid():
if len(cart) > 0:
with transaction.atomic():
email = form.cleaned_data.get('email')
user = Member.objects.get(email=email)
order = Order(user=user)
order.save()
total_price = 0
total_count = 0
variety = 0
for item in cart:
product = item['product']
variety += 1
quantity = item['quantity']
total_count += quantity
price = item['price']
total_price += price * quantity
OrderItem.objects.create(order=order,
product=product,
price=price,
quantity=quantity)
product.stock -= quantity
product.save()
order.total_price = total_price
order.variety = variety
order.total_count = total_count
order.save()
cart.clear()
return render(request, 'order_created.html', {'order': order})
return redirect('/cart/')
def orderproduct(request):
category = Category.objects.all()
current_user = request.user
schopcart = ShopCart.objects.filter(user_id=current_user.id)
total = 0
for rs in schopcart:
total += rs.product.price * rs.quantity
if request.method == 'POST': # if there is a post
form = OrderForm(request.POST)
# return HttpResponse(request.POST.items())
if form.is_valid():
# Send Credit card to bank, If the bank responds ok, continue, if not, show the error
# ..............
data = Order()
data.first_name = form.cleaned_data['first_name'] # get product quantity from form
data.last_name = form.cleaned_data['last_name']
data.address = form.cleaned_data['address']
data.city = form.cleaned_data['city']
data.phone = form.cleaned_data['phone']
data.user_id = current_user.id
data.total = total
data.ip = request.META.get('REMOTE_ADDR')
ordercode = get_random_string(5).upper() # random cod
data.code = ordercode
data.save() #
schopcart = ShopCart.objects.filter(user_id=current_user.id)
for rs in schopcart:
detail = OrderProduct()
detail.order_id = data.id # Order Id
detail.product_id = rs.product_id
detail.user_id = current_user.id
detail.quantity = rs.quantity
detail.price = rs.product.price
detail.amount = rs.amount
detail.save()
# ***Reduce quantity of sold product from Amount of Product
product = Product.objects.get(id=rs.product_id)
product.amount -= rs.quantity
product.save()
ShopCart.objects.filter(user_id=current_user.id).delete() # Clear & Delete shopcart
request.session['cart_items'] = 0
messages.success(request, "Your Order has been completed. Thank you ")
return render(request, 'Order_Completed.html', {'ordercode': ordercode, 'category': category})
else:
messages.warning(request, form.errors)
return HttpResponseRedirect("/order/orderproduct")
form = OrderForm()
profile = UserProfile.objects.get(user_id=current_user.id)
context = {'schopcart': schopcart,
'category': category,
'total': total,
'form': form,
'profile': profile,
}
return render(request, 'Order_Form.html', context)
def buyProduct(request, product_id):
amount = request.POST.get('amount', 1)
try:
product = Product.objects.get(id=product_id)
order = Order()
order.client = request.META["REMOTE_ADDR"]
order.details = "is buying the product " + product.name + " in MINITRADE"
order.total = product.price * int(amount)
order.status = "created"
order.save()
orderProduct = OrderProduct()
orderProduct.product = product
orderProduct.order = order
orderProduct.amount = amount
orderProduct.total = product.price * int(amount)
orderProduct.save()
callback_url = "https://{0}/finish_buy/{1}/".format(request.get_host(), order.id)
response = createPayRequest(order, callback_url)
order.token = response['token']
order.status = response['status']
order.save()
return HttpResponse(json.dumps({
"url": response['url']
}), status=200)
except Exception as e:
# import traceback
# traceback.print_exc()
return HttpResponse(json.dumps({
"error": str(e),
"message": "The transaction could not be created!"
}), status=500)
def productOrder(request):
category = Category.objects.all()
current_user = request.user
basket = CustomerBasket.objects.filter(user_id = current_user.id)
total = 0
for rs in basket:
total += rs.product.price * rs.quantity
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
data = Order()
data.first_name = form.cleaned_data['first_name']
data.last_name = form.cleaned_data['last_name']
data.address = form.cleaned_data['address']
data.city = form.cleaned_data['city']
data.phone = form.cleaned_data['phone']
data.user_id = current_user.id
data.total = total
data.ip = request.META.get('REMOTE_ADDR')
ordercode = get_random_string(5).upper()
data.code = ordercode
data.save()
basket = CustomerBasket.objects.filter(user_id=current_user.id)
for rs in basket:
detail = OrderProduct()
detail.order_id = data.id
detail.product_id = rs.product_id
detail.user_id = current_user.id
detail.quantity = rs.quantity
product = Product.objects.get(id=rs.product_id)
product.amount -= rs.quantity
product.save()
detail.price = rs.product.price
detail.amount = rs.amount
detail.save()
CustomerBasket.objects.filter(user_id = current_user.id).delete()
request.session['cart_items']=0
messages.success(request, "Sipariş tamamlandı!")
return render(request, 'shop-basket.html',{'ordercode':ordercode,'category':category})
else:
messages.warning(request, form.errors)
return HttpResponseRedirect("/order/orderproduct")
form = OrderForm()
profile = UserProfile.objects.get(user_id = current_user.id)
context = {
'basket':basket,
'total':total,
'form':form,
'profile':profile
}
return render(request, 'shop-checkout1.html', context)
def checkout_transaction(request):
cart = request.user.cart
items = cart.cartitem_set.all()
with transaction.atomic():
try:
# Check if sufficient inventory for whole order, else raise error before creating order
for item in items:
p = Product.objects.get(name=item.product.name)
if item.quantity > p.inventory:
raise IntegrityError
new_order = Order(user=request.user)
new_order.save()
for item in items:
p = Product.objects.get(name=item.product.name)
order_product = OrderProduct(product=item.product,
order=new_order,
quantity=item.quantity,
cost=item.product.price)
order_product.save()
p.inventory = p.inventory - item.quantity
p.save()
cart.delete()
except IntegrityError:
messages.warning(request,
"Transaction failed, not enough in inventory!")
return HttpResponseRedirect(reverse('profile_cart'))
return HttpResponseRedirect(
reverse('profile_orderdetail', args=(new_order.pk, )))
def post(self, request):
info = json.loads(request.body)
ordered_food = info.get("ordered_food")
user_id = request.user.id
now = datetime.datetime.now().strftime("%Y%m%d%H%M%S")
order_number = "-".join((now, str(user_id).zfill(10)))
user = User.objects.get(id=user_id)
if user:
ordered_user = user
else:
return JsonResponse({
"error_code": 10002,
"error_msg": "invalid user"
})
for item in ordered_food:
food_id = int(item.get("food_id"))
amount = int(item.get("amount", 1))
food = Food.objects.get(id=food_id)
if food:
ordered_food = food
else:
return JsonResponse({
"error_code": 10001,
"error_msg": "parameter error"
})
order = Order()
order.order_number = order_number
order.amount = amount
order.ordered_user = ordered_user
order.ordered_food = ordered_food
order.save()
return JsonResponse({"order_number": order_number})
def create(request):
id = request.GET.get('id', '')
n = int(request.GET.get('n', '1'))
address = request.GET.get('address', '1 Memorial Drive Cambridge MA 02142')
debug = request.GET.get('debug', '')
account = get_object_or_404(Account, pk=id)
order = Order()
try:
response = order.get_order(account, n, debug, address)
except:
try:
response = order.get_order(account, n, debug, address)
except:
try:
response = order.get_order(account, n, debug, address)
except:
raise Http404
order.save()
response['order']['id'] = order.id
if debug == '':
return HttpResponse(unescape(json.dumps(response)),
content_type='application/json')
else:
return HttpResponse(json.JSONEncoder(indent=10).encode(response),
content_type='text/plain')
def handle(self, *args, **kwargs):
"""Create 'total' dummy orders in database."""
no_of_orders = kwargs['total']
clients = Client.objects.filter(email__endswith=DUMMY_EMAIL_MARKER)
if (no_of_orders < 1) or (clients.count() == 0):
self.stdout.write(
"Can not create -ive or zero number of orders against zero clients."
)
else:
no_of_chosen_clients = self.get_random_number(
lower_limit=1, upper_limit=clients.count())
orders = []
for client in clients:
for i in range(0, no_of_orders):
order = Order(
**{
'client': client,
'status': Order.RECIEVED,
'payment_status': False,
'payment_amount': 10000,
'advance_payment_amount': 2000,
'order': DUMMY_ORDER_MARKER,
'instructions': DUMMY_ORDER_MARKER,
'delivery_date': get_future_date(5)
})
orders.append(order)
Order.objects.bulk_create(orders)
self.stdout.write("Dummy orders created successfully.")
def post(self, request):
try:
data = json.loads(request.body)
customer_id = request.customer.id
cart = Cart.objects.get(customer_id=customer_id, cart_status_id=OrderStatusId.ActiveCart.value)
delivery_address = DeliveryAddress.objects.get(customer_id=customer_id)
expected_amount = Decimal(data['expected_amount'])
# Order 객체 생성
Order(
customer_id = customer_id,
cart_id = cart.id,
payment_amount = expected_amount,
payment_method_id = 2, # 프론트엔드에서 무통장입금만 구현하여 무통장인 2번으로 부여
order_status_id = OrderStatusId.Payment.value, # 오더완료 시, status를 결제완료로 세팅
delivery_address_id = delivery_address.id
).save()
# Cart Status를 주문완료로 변경한 후 Cart 객체 삭제 -> 장바구니에 가면 비게 됨
cart.cart_status_id = OrderStatusId.Order.value
cart.save()
return HttpResponse(status=200)
except KeyError:
return HttpResponse(status=400)
def create(self, request, *args, **kwargs):
u_id = request.data.get("u_id")
if u_id:
goodscar = Goodcar.objects.filter(u_id=u_id).filter(is_select=1)
order = Order()
order.u_id = u_id
order.save()
total_price = 0
for goodcar in goodscar:
goodOrder = Goodorder()
goodOrder.good_id = goodcar.good_id
goodOrder.order_id = order.id
goodOrder.buy_good_num = goodcar.buy_good_num
goodOrder.save()
good = Goods.objects.get(id=goodcar.good_id)
total_price += goodcar.buy_good_num * good.price
order.total_price = total_price
order.save()
# 购物车中的数据添加到ordergood中后，就删除购物车数据
goodscar.delete()
requestOrderAddress = request.data.get("order_address")
orderAddress = Orderaddress()
orderAddress.order_address = requestOrderAddress
orderAddress.order_id = order.id
# 保存一份地址数据，以免用户地址修改影响订单地址
orderAddress.save()
serializer = OrderSerializers(order)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
return Response({}, status=status.HTTP_400_BAD_REQUEST)
def orderproductviews(request):
category = Category.objects.all()
current_user = request.user
shopcart = ShopCart.objects.filter(user_id=current_user.id)
total = 0
for rs in shopcart:
total += rs.product.discount_price * rs.quantity
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
data = Order()
data.first_name = form.cleaned_data['first_name']
data.last_name = form.cleaned_data['last_name']
data.phone = form.cleaned_data['phone']
data.region = form.cleaned_data['region']
data.district = form.cleaned_data['district']
data.street_address = form.cleaned_data['street_address']
data.apartment_address = form.cleaned_data['apartment_address']
data.user_id = current_user.id
data.total = total
data.ip = request.META.get('REMOTE_ADDR')
ordercode = get_random_string(5).upper()
data.code = ordercode
data.save()
shopcart = ShopCart.objects.filter(user_id=current_user.id)
for rs in shopcart:
detail = OrderProduct()
detail.order_id = data.id
detail.product_id = rs.product_id
detail.user_id = current_user.id
detail.quantity = rs.quantity
detail.color = rs.color
detail.size = rs.size
detail.price = rs.product.price
detail.save()
ShopCart.objects.filter(user_id=current_user.id).delete()
request.session['cart_items'] = 0
messages.success(request, "Your Oder has been completed. Thank you")
context = {'category': category,
'ordercode': ordercode
}
return render(request, 'order_completed.html', context)
#return redirect('/order/payment/')
else:
messages.warning(request, form.errors)
return HttpResponseRedirect("/order/orderproduct/")
form = OrderForm()
profile = UserProfile.objects.get(user_id=current_user.id)
context = {'shopcart': shopcart,
'category': category,
'total': total,
'form': form,
'profile': profile
}
return render(request, 'check-out.html', context)
def post(self, request, order_id, product_id):
"""
주문을 생성합니다.
order_id : 입력받은 order_id를 이용하여 검증된 유저의 장바구니 여부를 확인합니다.
product_id : 개별적으로 주문을하고 장바구니에 담길 상품의 id입니다.
"""
data = json.loads(request.body)
user_id = request.userid
try:
if Order.objects.filter(username_id=user_id).exists():
user_address = User.objects.get(id=user_id).address
if user_address:
if Order.objects.filter(id=order_id).exists():
if Product.objects.filter(id=product_id).exists():
order_id = Order.objects.get(id=order_id)
product_id = Product.objects.get(id=product_id)
new_order = OrderProduct(order=order_id,
product=product_id,
quantity=data['quantity'])
new_order.save()
return JsonResponse({'message': "장바구니에 담겼습니다"},
status=200)
return JsonResponse({'message': '해당 상품은 존재하지 않습니다'},
status=400)
return JsonResponse({'message': '주소를 등록해주세요'}, status=400)
else:
new_order = Order(username_id=user_id)
new_order.save()
return JsonResponse({'message': '장바구니가 생성됬습니다'}, status=200)
except KeyError:
return JsonResponse({'error': '올바르지 않은 키 값'}, status=400)
def create_order_cod(request):
mnumber = request.user.mobile_number
total = 0.0
delivery_charge = 0
cart = Cart.objects.filter(mobile_number=mnumber).order_by('-add_time')
address = Address.objects.filter(mobile_number=mnumber).first()
al_number = ","
if address.alternate_number:
al_number = address.alternate_number
full_name = address.full_name
total_address = full_name + " , " + address.at + " , " + address.landmark + " , " + address.panchayat + " , " + address.dist + " , " + address.pin + " , " + al_number
total_product = len(cart)
for data in cart:
total += float(data.product.discount_price) * float(
data.customer_quantity)
#id = Orderid.generate_id()
if total <= 100:
delivery_charge = 10
elif total > 100 and total <= 200:
delivery_charge = 15
elif total > 200 and total <= 350:
delivery_charge = 20
elif total > 350 and total <= 500:
delivery_charge = 25
else:
delivery_charge = 0
final_price = delivery_charge + total
ordid = generate_id()
id = ordid
payment_mode = 'COD'
status = 'Shipping'
for item in cart:
brand = ''
if item.product.brand:
brand = item.product.brand
else:
brand = 'favshops'
order = Order(image=item.product.image,
order_id=id,
payment_mode=payment_mode,
mobile_number=mnumber,
name=item.product.product_name,
brand=brand,
quantity=item.product.quantity,
price=item.product.discount_price,
address=total_address,
status=status,
margin_price=item.product.margin_price,
customer_quantity=item.customer_quantity)
order.save()
for item in cart:
item.delete()
return id, final_price, total_address
def post(self, request, *args, **kwargs):
ctx = {}
basket = request.basket
if basket.is_empty:
raise ValueError("Корзина не должна быть пустой")
shipping_address_form = self.shipping_address_form(request.POST)
user_form = self.user_form(request.POST)
if shipping_address_form.is_valid() and user_form.is_valid():
order_number = 100000 + basket.id
basket.freeze()
total_price = 1000
shipping_address = shipping_address_form.save()
new_user = user_form.save(commit=False)
new_user.set_password("123456m")
new_user.save()
order_data = {
'basket': basket,
'number': order_number,
'total_excl_tax': total_price,
'shipping_address': shipping_address,
'user': new_user,
'date_placed': timezone.now()
}
# if request.user and request.user.is_authenticated():
# order_data['user_id'] = 1
order = Order(**order_data)
order.save()
for line in basket.lines.all():
product = line.product
line_data = {
'order': order,
# Product details
'product': product,
'quantity': line.quantity,
# Price details
'line_price_excl_tax': line.price_excl_tax,
'unit_retail_price': product.price,
}
current_line = Line.objects.filter(order=order,
product=product)
if current_line:
current_line.update(**line_data)
order_line = current_line
else:
order_line = Line._default_manager.create(**line_data)
basket.submit()
return redirect("checkout:thank-you")
else:
ctx['user_form'] = user_form
ctx['shipping_address_form'] = shipping_address_form
return render(request, self.template_name, ctx)
def orderproduct(request):
current_user = request.user
shopcart = ShopCart.objects.filter(user_id=current_user.id)
total = 0
count = 0
for rs in shopcart:
total += rs.product.price * rs.quantity
count += rs.quantity
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
data = Order()
data.first_name = form.cleaned_data['first_name']
data.last_name = form.cleaned_data['last_name']
data.address = form.cleaned_data['address']
data.city = form.cleaned_data['city']
data.phone = form.cleaned_data['phone']
data.user_id = current_user.id
data.total = total
data.ip = request.META.get('REMOTE_ADDR')
ordercode = get_random_string(5).upper()
data.code = ordercode
data.save()
for rs in shopcart:
detail = OrderProduct()
detail.order_id = data.id
detail.product_id = rs.product_id
detail.user_id = current_user.id
detail.quantity = rs.quantity
detail.price = rs.product.price
detail.amount = rs.amount
detail.save()
product = Product.objects.get(id=rs.product_id)
product.amount -= rs.quantity
product.count_sold += 1
product.save()
ShopCart.objects.filter(user_id=current_user.id).delete()
request.session['cart_item'] = 0
messages.success(request, 'Your order has been completed.')
return render(request, 'Order_Completed.html',
{'ordercode': ordercode})
else:
messages.warning(request, form.errors)
return HttpResponseRedirect('/order/orderproduct')
form = OrderForm()
profile = UserProfile.objects.get(user_id=current_user.id)
context = {
'shopcart': shopcart,
'total': total,
'form': form,
'profile': profile,
}
return render(request, 'order_form.html', context)
def test_place_order(self):
'''
Tests that the user can place an order
'''
order = Order(total=20.00, emailAddress="*****@*****.**")
order.save()
self.assertEqual(order.total, 20.00)
self.assertEqual(order.emailAddress, "*****@*****.**")
def payment(request):
profile = Profile.objects.filter(user=request.user).first()
address = Address.objects.filter(id=profile.address_id).first()
if address is None:
address = Address()
address.save()
has_address = False
else:
has_address = True
clear_incomplete_order(request.user)
new_order = Order(
order_completed=False,
address=address,
user=request.user
)
new_order.save()
copy_cart_to_order(new_order)
order_items = OrderItems.objects.filter(order=new_order)
total_price_payment = total_price(order_items)
if request.method == 'POST':
address_form = AddressForm(instance=address, data=request.POST)
payment_form = PaymentForm(data=request.POST)
if address_form.is_valid() and payment_form.is_valid():
address = address_form.save()
new_order.save()
# Checks if save address to profile was selected and adds the address to user profile
if request.POST.get('save_address', default=None) == 'on':
profile.address = address
profile.save()
return redirect('review-step')
else:
return render(request, 'order/payment.html', {
'order_items': order_items,
'address_form': address_form,
'payment_form': payment_form,
'total_price': total_price_payment,
'has_address': has_address
})
else:
address_form = AddressForm(instance=address) # Attempts to fetch the user profile's address
payment_form = PaymentForm()
return render(request, 'order/payment.html', {
'order_items': order_items,
'address_form': address_form,
'payment_form': payment_form,
'total_price': total_price_payment,
'has_address': has_address
})
def buyProduct(req,id):
from .userLang import lang2
check(req)
global context
product = Product.objects.get(id = id)
if(req.user.is_authenticated):
profile = UserProfile.objects.get(user = req.user)
form = buyProductForm(initial={'firstName': profile.firstName,'lastName':profile.lastName,'phone':profile.phone,"address":profile.address,"productAmount":1})
else:form = buyProductForm()
context['form'] = form
context['product'] = product
if(req.method == "POST"):
form = buyProductForm(req.POST)
if(form.is_valid()):
if(req.user.is_authenticated):
profile.firstName = req.POST.get("firstName")
profile.lastName = req.POST.get("lastName")
profile.phone = req.POST.get("phone")
profile.address = req.POST.get("address")
req.user.first_name = req.POST.get("firstName")
req.user.last_name = req.POST.get("lastName")
req.user.save()
order = Order(user = req.user,product = product,title = product.title,productImage = product.productImage,productAmount = req.POST.get("productAmount"),totalPrice = float(req.POST.get("productAmount")) * product.productPrice,orderedDate=datetime.datetime.now())
order.save()
profile.currentOrders.add(order)
profile.save()
else:
guest = GuestProfile(firstName = req.POST.get("firstName"),lastName = req.POST.get("lastName"),phone = req.POST.get("phone"),address = req.POST.get("address"))
guest.save()
order = Order(guestProfile = guest,product = product,title = product.title,productImage = product.productImage,productAmount = req.POST.get("productAmount"),totalPrice = float(req.POST.get("productAmount")) * product.productPrice,orderedDate=datetime.datetime.now(),isGuest = True)
order.save()
product.sold += int(req.POST.get("productAmount"))
product.save()
messages.warning(req,lang2['orderReceived'])
return HttpResponseRedirect('/')
else:
messages.warning(req,lang2['formInvalid'])
return HttpResponseRedirect('/users/buyproduct/'+str(id)+"/")
else:
return render(req,"buyproduct.html",context)
