def order_product(request, user_id, cart_id):
if request.method == 'GET': # отображаем форму
c = {
'customer': user_id,
'cart': cart_id,
'order_form': OrderForm(),
}
return render(request, 'order/order_detail.html', c)
elif request.method == 'POST': # забираем данные из формы и сохраняем в модель
order_form = OrderForm(request.POST)
if order_form.is_valid():
with transaction.atomic():
order = ProductOrder(
customer_id=user_id,
cart_id=cart_id,
address=order_form.cleaned_data['address'],
delivery_time=order_form.cleaned_data['delivery_time'],
comment=order_form.cleaned_data['comment'])
order.save()
cart = CartModel.objects.get(pk=cart_id)
cart.set_check_out()
return HttpResponseRedirect('/')
else:
print('Not Valid')
return HttpResponse(status=405)
def get_common_context(request):
c = {}
form = OrderForm()
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
form.save(request.POST['action'])
if request.POST['action'] == 'request':
c['order_ok'] = True
else:
c['feedback_ok'] = True
form = OrderForm()
c['form'] = form
c['request_url'] = request.path
c['is_debug'] = settings.DEBUG
c['phone'] = config_value('MyApp', 'PHONE')
ORDERS_COUNT = int(config_value('MyApp', 'ORDERS_COUNT'))
c['oc_3'] = ORDERS_COUNT % 10
ORDERS_COUNT = ORDERS_COUNT / 10
c['oc_2'] = ORDERS_COUNT % 10
c['oc_1'] = ORDERS_COUNT / 10
c.update(csrf(request))
return c
def order(request):
if request.POST:
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
else:
return render_to_response("order.html",{"form":form},context_instance=RequestContext(request))
try:
cart = Cart.objects.get(id = request.session.get("cart"))
except:
return HttpResponse("Server Error")
cart.status = 'off'
cart.save()
order.cart = cart
order.delivery = cart.delivery
del request.session['cart']
order.serial = serial_generator()
order.save()
#mailing(order,request)
for i in cart.items.all():
i.size.stock-=i.quantity
i.size.save()
return render_to_response("thanks.html",{ "order":order }, context_instance=RequestContext(request))
else:
form = OrderForm()
return render_to_response("order.html",{"form":form},context_instance=RequestContext(request))
def order(request):
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
sid = str(form.cleaned_data.get('sid'))
with connection.cursor() as cursor:
username = str(request.user)
cursor.execute("SELECT uid FROM Users WHERE login = %s",
[username])
uid = cursor.fetchone()
uid = str(uid[0])
cursor.execute(
"INSERT INTO Purchases (sid,uid) " + "VALUES " +
"(%s,%s,%s)",
[sid, uid,
datetime.date.today().strftime("%Y-%m-%d")])
cursor.execute(
"UPDATE Songs SET numDownloads = numDownloads+1 WHERE sid = %s",
[sid])
return redirect('/myrecord/' + uid)
else:
form = OrderForm()
return render(request, 'order/order.html', {'form': form})
def create(request):
print(request.POST)
if request.method == "POST":
form = OrderForm(request.POST)
form.save()
return redirect("/order")
else:
form = OrderForm()
return render(request, "order/create.html", {'form': form})
def update(request, id):
order = Order.objects.get(order_id=id)
if request.method == "POST":
form = OrderForm(request.POST, instance=order)
form.save()
return redirect("/order")
else:
form = OrderForm(instance=order)
return render(request, "order/edit.html", {'form': form})
def Order(request):
'''
Render the order page
'''
template = 'order/order.html'
if request.method == 'GET':
return render(request, template, {'orderForm': OrderForm()})
orderForm = OrderForm(request.POST)
if not orderForm.is_valid():
return render(request, template, {'orderForm': OrderForm})
orderForm.save()
return render(request, 'main/main.html')
def order(request):
context = {}
basket = Basket.get_session_basket(request.session._session_key)
# if not basket['goods_count']:
# return HttpResponseRedirect('/')
if request.method.lower() == 'post':
order_form = OrderForm(request.POST, basket_summary=basket['summary'])
context['show_form'] = True
if order_form.is_valid():
order_instance = order_form.save(commit=False)
order_instance.delivery_price = order_form.cleaned_data['delivery_price']
order_instance.delivery_type = order_form.cleaned_data['delivery_type_label']
order_instance.delivery_time = order_form.cleaned_data['delivery_time']
order_instance.make_order(request.session.session_key)
send_order_email(order_instance, request.META.get('HTTP_HOST'))
if order_instance.pay_type not in ('nal', 'nalk'):
# оплата онлайн
payment_url = WalletonePaymentForm(initial={
'WMI_PAYMENT_AMOUNT': order_instance.total_price(),
'WMI_PAYMENT_NO': order_instance.id,
'WMI_DESCRIPTION': u'%s заказ №%s' % (request.get_host(), order_instance.id)
}, host=settings.HOST).get_redirect_url()
return HttpResponseRedirect(payment_url)
else:
# оплата наличными
return HttpResponseRedirect(reverse('ordered', args=(order_instance.id, )))
else:
order_form = OrderForm(basket_summary=basket['summary'])
context['for_order'] = True
context['order_form'] = order_form
context['delivery_types'] = DELIVERY_TYPES
context['pay_types'] = PAY_TYPES
context['free_delivery_price'] = FREE_DELIVERY_PRICE
context['add_toy_price'] = ADD_TOY_PRICE
add_goods_filter = Q(show_in_bouquets=True)
context['add_goods'] = list(Bouquet.active_objects().filter(add_goods_filter))
context['add_goods'].extend(list(Unusual.active_objects().filter(add_goods_filter)))
context['add_goods'].extend(list(Special.active_objects().filter(add_goods_filter)))
shuffle(context['add_goods'])
return render(request, 'order.html', context)
def place_order(request):
if request.method == "POST":
form = OrderForm(request.POST, request.FILES)
if form.is_valid():
data = form.save(commit=False)
custm_user = CustomUser.objects.filter(user=request.user).first()
data.user = custm_user
data.save()
return HttpResponseRedirect(reverse('home'))
else:
form = OrderForm()
return render(request, "order/index.html", {'form': form})
def checkout(request):
if request.method == 'POST':
order_form = OrderForm(request.POST)
if order_form.is_valid():
user = request.user
user = User.objects.get(username=user)
initial = order_form.cleaned_data
initial.update({
'key':
settings.PAYU_INFO['merchant_key'],
'surl':
request.build_absolute_uri(reverse('order:success')),
'furl':
request.build_absolute_uri(reverse('order:success')),
'service_provider':
'payu_paisa',
'firstname':
user.first_name,
'email':
user.email,
'curl':
request.build_absolute_uri(reverse('order:cancel'))
})
# Once you have all the information that you need to submit to payu
# create a payu_form, validate it and render response using
# template provided by PayU.
initial.update({'hash': generate_hash(initial)})
payu_form = PayUForm(initial)
if payu_form.is_valid():
context = {
'form': payu_form,
'action': "%s" % settings.PAYU_INFO['payment_url']
}
return render(request, 'payu_form.html', context)
else:
logger.error('Something went wrong! Looks like initial data\
used for payu_form is failing validation')
return HttpResponse(status=500)
else:
initial = {
'txnid': uuid4().hex,
'productinfo': 'package',
'amount': randint(100, 1000) / 100.0
}
order_form = OrderForm(initial=initial)
context = {'form': order_form}
return render(request, 'checkout.html', context)
def new_ordermeat(request):
meat_order_list = {}
for meatInfo in MeatPrice.objects.all():
meat_order_list[meatInfo.name] = request.POST[meatInfo.name]
orderer_form = OrdererForm()
order_form = OrderForm()
return render(request, 'new_orderer.html', {'orderer_form': orderer_form, 'order_form': order_form, 'meat_order_list': meat_order_list})
def post(self, request, *args, **kwargs):
form = OrderForm(request.POST or None)
customer = Customer.objects.get(user=request.user)
if form.is_valid():
new_order = form.save(commit=False)
new_order.customer = customer
new_order.first_name = form.cleaned_data['first_name']
new_order.last_name = form.cleaned_data['last_name']
new_order.phone = form.cleaned_data['phone']
new_order.address = form.cleaned_data['address']
new_order.delivery_type = form.cleaned_data['delivery_type']
new_order.order_date = form.cleaned_data['order_date']
new_order.comment = form.cleaned_data['comment']
new_order.save()
self.cart.in_order = True
self.cart.save()
new_order.cart = self.cart
new_order.save()
customer.orders.add(new_order)
messages.add_message(
request, messages.INFO,
f'Благодарим за заказ, {new_order.first_name}! Заказ будет обработан в течение 30 минут'
)
return HttpResponseRedirect('/')
return HttpResponseRedirect('/checkout/')
def create(request):
print(request.POST)
if request.method == "POST":
form = OrderForm(request.POST)
form.save()
request.session.clear()
return redirect("/")
def get_context_data(self, **kwargs):
# 기본 구현을 호출해 context를 가져온다
# context = super(ProductDetail, self).get_context_data(**kwargs)
context = super().get_context_data(**kwargs)
context['form'] = OrderForm(self.request)
return context
def get_context_data(self, **kwargs):
context = super().get_context_data(
**kwargs) # 먼저 디테일뷰가 전달해주는 데이터를 이용해서 만들고
context['form'] = OrderForm(
self.request) # 기존에 생성된 데이터에 주문하기라는 새로운 폼을 추가함
return context
def post(self, request, *args, **kwargs):
form = OrderForm(request.POST, prefix='order')
user = UserOrderForm(request.POST, prefix='user')
if user.is_valid():
user = user.save()
elif not request.POST.get('phone') or not request.POST.get('name'):
user = User.objects.get(name='Администратор')
if form.is_valid():
cart = Cart()
cart.session_id = request.session.session_key
cart.save()
order = form.save(commit=False)
order.user = user
order.cart = cart
order.save()
return JsonResponse({
'result': True,
'href': '/order/edit/%s' % order.id,
'item_id': order.id
})
else:
return JsonResponse({
'errors': form.errors,
'user-errors': user.errors
})
def post(self, request, pk, context={}):
form = OrderForm(request.POST)
if form.is_valid():
delivery_address = form.cleaned_data.get("delivery_address")
payment_method = form.cleaned_data.get("payment_method")
status = form.cleaned_data.get("status")
notes = form.cleaned_data.get("notes")
ordered_date = form.cleaned_data.get("ordered_date")
delivery_date = form.cleaned_data.get("delivery_date")
order_obj = Order.objects.get(id=pk)
order_obj.delivery_address = delivery_address
order_obj.ordered = True
order_obj.status = status
order_obj.payment_method = payment_method
#order_obj.delivery_charge=delivery_charge
#order_obj.discount=discount
order_obj.total = order_obj.get_total()
order_obj.notes = notes
order_obj.ordered_date = ordered_date
order_obj.delivery_date = delivery_date
order_obj.save()
order_item = OrderItem.objects.filter(ordered=False).update(
ordered=True)
else:
print(form.errors)
print(form.error_messages)
return redirect("product:details")
def get_context_data(self, **kwargs):
# 기본적으로 super를 호출해서 기본을 작업 후 작업을 진행한다.
context = super().get_context_data(**kwargs)
# form변수에 OrderForm 추가
# View class 이기때문에 session가 존재한다.
print("===== get_context_data ======")
context['form'] = OrderForm(self.request)
return context
def veg_food_view(request):
veg_types = FoodItem.objects.filter(
food_super_class__class_name__contains="veg")
veg_dict = {'veg_records': veg_types}
form = OrderForm()
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
form.save(commit=True)
return redirect('type/')
else:
print("Error")
return render(request, 'order/veg_food.html', {
'form': form,
'veg_records': veg_dict
})
def orderCreate(request):
'''
Create a new order instance
1. If method is GET, render an empty form
2. If method is POST, perform form validation and display error messages if the form is invalid
3. Save the form to the model and redirect the user to the article page
'''
template = 'order/orderCreate.html'
if request.method == 'GET':
return render(request, template, {'orderForm':OrderForm()})
# POST
orderForm = OrderForm(request.POST)
if not orderForm.is_valid():
return render(request, template, {'orderForm':orderForm})
orderForm.save()
return render(request, 'main/main.html')
def get(self, request, id):
"""Return add new order form."""
order = get_object_or_404(Order, id=id)
form = OrderForm(instance=order)
return render(request, 'order/add-order.html', {
'form': form,
'func': 'Update',
'order': order
})
def orderCreate(request):
'''
Create a new article instance
1. If method is GET, render an empty form
2 . If method is POST, perform form validation. Display error messages if the form is invalid
3. Save the form to the model and redirect to the article page
'''
template = 'order/orderCreate.html'
if request.method == 'GET':
print(OrderForm())
return render(request, template, {'orderForm': OrderForm()})
# POST
orderForm = OrderForm(request.POST)
if not orderForm.is_valid():
return render(request, template, {'orderForm': orderForm})
orderForm.save()
messages.success(request, '訂單已傳送')
return redirect('order:order')
def get(self, request, client_id):
"""Return add new order form."""
client = get_object_or_404(Client, id=client_id)
form = OrderForm()
return render(request, 'order/add-order.html', {
'form': form,
'func': 'Add',
'client': client
})
def get(self, request, *args, **kwargs):
context = {}
context['form'] = OrderForm()
context['view'] = 'order'
context['user'] = UserOrderForm()
context['js'] = 'order'
context['model'] = 'order'
return render(request, 'order.html', context)
def user_dash_view(request):
orders = Order.objects.filter(
user_details=request.user).order_by('-date_of_order')
if (request.user.user_type == 'U'):
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.user_details = request.user
order.status = 'P'
order.save()
# return redirect()
else:
form = OrderForm()
return render(request, 'user/userhome2.html', {
'orders': orders,
'form': form
})
def form_valid(self, request):
if self.request.method == 'POST':
form = OrderForm(self.request.POST, self.request.FILES)
if form.is_valid():
form.save()
return HttpResponse("order created!!!")
return render(request, self.template_name, {'form': form})
else:
return render(request, self.template_name)
def plantBuy(request, plantId):
template = 'shop/buyInfo.html'
plant = get_object_or_404(Plant, id=plantId)
context = {}
if request.method == 'GET':
context.update({
'plant':
plant,
'orderForm':
OrderForm(
initial={
'name': request.user.fullName,
'email': request.user.email,
'address': request.user.address,
'plantName': plant.plantName
})
})
return render(request, template, context)
# POST
orderForm = OrderForm(request.POST)
print(orderForm)
if not orderForm.is_valid():
return render(request, template, {
'plant': plant,
'orderForm': orderForm
})
if plant.newPrice:
realPrice = plant.newPrice
else:
realPrice = plant.price
order = orderForm.save(commit=False)
order.plant = plant
order.customer = request.user
order.totalPrice = realPrice
order.save()
messages.success(request, '購買成功')
if request.user not in plant.buyes.all():
plant.buyes.add(request.user)
plant.inventory = plant.inventory - 1
plant.save()
return redirect('shop/shop.html')
def get_context_data(self, **kwargs):
for key in kwargs:
print(key,'->', kwargs[key])
context = super().get_context_data(**kwargs)
print(context)
context['form'] = OrderForm(self.request)
print(context)
return context
def order(request):
c = get_common_context(request)
if request.method == 'POST':
if 'step' in request.POST:
step = int(request.POST['step'])
res = []
sum_price = 0
for k, v in request.POST.iteritems():
if k.startswith('field_') and int(v) > 0:
item = Item.get(int(k[6:]))
count = int(v)
res.append((item, count))
sum_price += item.price * count
c['sum_price'] = sum_price
c['order_content'] = res
if step == 1:
c['form'] = OrderForm()
return render_to_response(
'order.html', c, context_instance=RequestContext(request))
elif step == 2:
form = OrderForm(request.POST)
if form.is_valid():
ord = form.save()
print ord
for item, count in res:
OrderContent(order=ord, item=item, count=count).save()
ord.send_email()
return render_to_response(
'order_ok.html',
c,
context_instance=RequestContext(request))
else:
c['form'] = form
return render_to_response(
'order.html',
c,
context_instance=RequestContext(request))
else:
raise Http404()
else:
raise Http404()
def confirm_order(request, unit_id):
has_profile = __user_has_profile(request.user)
if has_profile != None: return has_profile
oc = OrderCarts(request.session,unit_id)
unit = oc.get_unit()
total_sum = oc.get_total_sum()
oc.update_prices()
oc.check_and_show_odd_promotion_message(request)
if not unit.is_open():
messages.warning(request, _('This restaurant is now closed! Please check the open hours and set desired delivery time accordingly.'))
if unit.minimum_ord_val > total_sum:
messages.error(request, _('This restaurant has a minimum order value of %(min)d') % {'min': unit.minimum_ord_val})
return redirect('restaurant:detail', unit_id=unit.id)
"""if current_order.address and not current_order.address.geolocation_error:
src = (unit.latitude, unit.longitude)
dest = (current_order.address.latitude, current_order.address.longitude)
dist = distance.distance(src, dest)
if dist.km > unit.delivery_range:
messages.warning(request, _('We are sorry, you are not in the delivery range of this restaurant.'))
return redirect('restaurant:detail', unit_id=unit.id)"""
if request.method == 'POST':
form = OrderForm(request.POST)
form.unit = unit
if form.is_valid():
order = form.save(commit=False)
paid_with_bonus = 'paid_with_bonus' in form.data
construct_order(request, oc, unit, order, paid_with_bonus)
if not unit.is_open():
return redirect('restaurant:detail', unit_id=unit.id)
return redirect('order:timer', order_id=order.id)
else:
form = OrderForm()
form.fields['delivery_type'] = forms.ModelChoiceField(unit.delivery_type.all(), required=True, initial={'primary': True})
form.fields['address'] = forms.ModelChoiceField(queryset=DeliveryAddress.objects.filter(user=request.user), required=True, initial={'primary': True})
profile = request.user.get_profile()
show_pay_with_bonus = profile and profile.get_current_bonus() > total_sum
if show_pay_with_bonus:
messages.info(request, _('Congratulations! You have enough bonus to pay for your order. Please check "Pay using bonus" to use it.'))
form.fields['paid_with_bonus'] = forms.BooleanField(label=_('Pay using bonus'), help_text=_('We shall use the minimum number of received bonuses enough to cover the order total amount'), required=False)
return locals()
