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 place_order(request):
if request.method == 'POST':
search_form = OrderForm(request.POST)
if search_form.is_valid():
unique_flight_id = request.POST['unique_flight_id']
first_name = search_form.cleaned_data['first_name']
last_name = search_form.cleaned_data['last_name']
document_id = search_form.cleaned_data['document_id']
birth_day = search_form.cleaned_data['birth_day']
email = search_form.cleaned_data['email']
class_of_service = request.POST['class_of_service']
order = Order(unique_flight_id=unique_flight_id,
first_name=first_name,
last_name=last_name,
document_id=document_id,
birth_day=birth_day,
email=email,
order_hash=uuid.uuid1().hex,
booking_id=uuid.uuid1().hex[:7].upper(),
class_of_service=class_of_service)
if order.unique_flight.try_take_seat(class_of_service):
order.save()
send_order(order)
return render_to_response('status.html', {'status': 'Order created, link sent to you by email'},
context_instance=RequestContext(request))
else:
return render_to_response('status.html', {
'status': 'We are sorry, but there are no free places of class you have chosen'},
context_instance=RequestContext(request))
else:
return redirect('/search/')
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 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 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 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):
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 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 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 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 create_order(request):
if request.method == 'POST':
orderForm = OrderForm(request.POST)
if orderForm.is_valid():
order = orderForm.save()
return redirect(order)
else:
orderForm = OrderForm()
return {
'orderForm': orderForm,
}
def order(request):
c = get_common_context(request)
#c.update({'p': Page.get('order', c['lang'])})
if request.method == 'GET':
c.update({'form': OrderForm()})
elif request.method == 'POST':
form = OrderForm(request.POST, request.FILES)
if form.is_valid():
form.save()
form = OrderForm()
c['feedback_ok'] = True
c.update({'form': form})
return render_to_response('order.html', c, context_instance=RequestContext(request))
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):
c = get_common_context(request)
form = OrderForm()
# filter real countries
c["countries"] = Country.objects.filter(wt_4=False)
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
form.save()
c["order_ok"] = True
form = OrderForm()
c["form"] = form
return render_to_response("order.html", c, context_instance=RequestContext(request))
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 order(request):
form = OrderForm(request.POST or None)
context = {'form': form}
if form.is_valid():
transection = form.cleaned_data.get('transection')
contact = form.cleaned_data.get('contact')
cart_id = request.session.get("cart_id")
cart_instance = Cart.objects.get(id=cart_id)
Order.objects.create(user=request.user,
cart=cart_instance,
transection=transection,
contact=contact)
return redirect('order:confirm')
return render(request, 'order/order.html', context)
def post(self, request, client_id):
"""Save order and redirect to order list."""
form = OrderForm(request.POST)
client = get_object_or_404(Client, id=client_id)
if form.is_valid():
new_order = form.save(commit=False)
new_order.client = client
new_order.save()
return redirect('order:orders')
else:
return render(request, 'order/add-order.html', {
'form': form,
'func': 'Add',
'client': client
})
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 post(self, request, id):
"""Save order and redirect to order list."""
order = get_object_or_404(Order, id=id)
client = get_object_or_404(Client, id=order.client.id)
form = OrderForm(request.POST, instance=order)
if form.is_valid():
new_order = form.save(commit=False)
new_order.client = client
new_order.save()
return redirect('order:orders')
else:
return render(request, 'order/add-order.html', {
'form': form,
'func': 'Update',
'order': order
})
def new_order(request):
orderer_form = OrdererForm(request.POST)
order_form = OrderForm(request.POST)
if orderer_form.is_valid() and order_form.is_valid():
orderer = orderer_form.save()
order = order_form.save(commit=False)
order.orderer = orderer
order.save()
for meatInfo in MeatPrice.objects.all():
meatOrder = MeatOrder(order=order,
meat_price=meatInfo,
count=request.POST[meatInfo.name])
meatOrder.save()
return redirect(reverse('order:view_order', args=[orderer.id]))
def index(request):
cart = get_cart(request)
items = CartItem.objects.filter(cart=cart)
if request.method == 'POST':
voucher_code = request.POST.get('voucher_code', None)
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.discount_total = cart.discount_total
order.gross_total = cart.gross_total
order.net_total = cart.net_total
order.user = request.user
order.voucher_code = voucher_code
order.order_id = ''
order.billing_post_code = request.POST['billing_zip']
order.billing_county = request.POST['billing_county']
order.billing_district = request.POST['billing_district']
order.shipping_post_code = request.POST['shipping_zip']
order.shipping_county = request.POST['shipping_county']
order.shipping_district = request.POST['shipping_district']
order.save()
request.session.save()
request.session['order'] = order
if order.payment_method == 0:
return redirect('order-paypal')
else:
return redirect('order-success')
else:
profile = request.user.profile
form = OrderForm(initial={
'billing_recipient': request.user.get_name(),
'billing_phone' : profile.phone,
'billing_address': profile.address,
'billing_country': profile.country,
'payment_method': 0,
'reciept_type': 0,
'dispatch_time': 0,
}
)
try:
voucher = request.session['voucher']
except KeyError:
voucher = None
return render(request, 'order/index.html', {'cart': cart, 'form': form, 'items': items, 'voucher': voucher})
def add_order(request):
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
form.save()
return redirect(index)
else:
print(form.errors)
else:
context = {'form':OrderForm()}
return render(request, 'add_order.html',context)
def add_order(request):
order_form = OrderForm(request.POST or None)
gig_id = order_form.data.get('gig_id')
if check(request, gig_id):
return render(request, 'deny_buy_same_gig.html', {'categories': CATEGORY})
else:
print('Hello man')
if order_form.is_valid():
order = Order.objects.filter(owner=request.user, paid=False).first()
if not order:
order = Order.objects.create(owner=request.user, paid=False)
gig_id = order_form.cleaned_data['gig_id']
gig = Gig.objects.get(id=gig_id)
deadline = order_form.cleaned_data.get('deadline')
order.orderdetail_set.create(gig=gig, deadline=deadline)
return redirect('gig:gig_detail', gig_id)
return redirect('gig:gig_detail', gig_id)
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 order_page(request):
c = get_common_context(request)
c.update(pages.views.get_page('order'))
if request.POST:
form = OrderForm(request.POST)
if form.is_valid():
form.save()
form = OrderForm()
c['done'] = True
messages.success(request, u'Ваш заказ успешно отправлен.')
else:
form = OrderForm()
c['form'] = form
return render_to_response('vn.html', c, context_instance=RequestContext(request))
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 add_order(request):
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
form.save()
return redirect(order_index)
else:
print(form.errors)
else:
context = {"form": OrderForm()}
return render(request, "add_order.html", context)
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 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 update_order(request, order_id):
order = get_object_or_404(Cust_order, pk=order_id)
order_form = OrderForm(request.POST or None, instance=order)
if request.method == 'POST':
if order_form.is_valid():
order_form.save()
return HttpResponseRedirect(reverse('admin_app:order_report'))
else:
print(order_form.errors)
else:
context = {
'order_form': order_form,
'order_id': order_id,
}
return render(request, 'admin_app/order_form.html', context=context)
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 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()
def post(self, request, *args, **kwargs):
order = Order.objects.get(id=kwargs.get['id'])
user = UserOrderForm(request.POST, prefix="user", instance=order.user)
order = OrderForm(request.POST, prefix="order", instance=order)
if user.is_valid():
user.save()
else:
return JsonResponse({
'errors': user.errors,
'non-field': user.non_field_errors()
})
if order.is_valid():
order.save()
else:
return JsonResponse({
'errors': order.errors,
'non-field': order.non_field_errors()
})
return JsonResponse({'result': True})
def OrderView(request,order_id=None):
if order_id:
order = Order.objects.filter(pk=order_id)
else:
order = Order()
NestedFormset = inlineformset_factory(Order,DetailOrder,form=DetailForm,can_delete=True)
if request.method == 'POST':
main_form = OrderForm(request.POST, instance=order)
detail_form = NestedFormset(request.POST, request.FILES, instance=order)
if main_form.is_valid() and detail_form.is_valid():
main_form.save()
detail_form.save()
return HttpResponseRedirect('summary')
else:
main_form = OrderForm(instance=order)
detail_form = NestedFormset(instance=order)
return render_to_response('order.html', {'main_form':main_form,'detail_form':detail_form},context_instance=RequestContext(request))
def listing(request, listing_id):
"""Страница listing"""
listing = get_object_or_404(Listing, pk=listing_id)
form = OrderForm(request.POST or None, initial={'listing': listing} )
if request.method == "POST":
if form.is_valid():
form.save()
send_mail('Заявка от torrehome.ru', 'Зайдите в админку чтобы почетать заявку', 'torrehome.ru/admin/',
['*****@*****.**'], fail_silently=False)
return HttpResponseRedirect("{}?sended=True".format(reverse('listing', kwargs={'listing_id': listing_id})), )
context = {
'listing': listing,
'form' : form,
'sended': request.GET.get("sended", False)
}
return render(request, 'listings/listing.html', context)
def new_order(request):
orderer_form = OrdererForm(request.POST)
order_form = OrderForm(request.POST)
if orderer_form.is_valid():
orderer = orderer_form.save(commit=False)
if orderer.is_exist():
orderer = Orderer.objects.get(username=orderer.get_username())
else:
orderer.username = orderer.get_username()
orderer.save()
if order_form.is_valid():
order = order_form.save(commit=False)
order.orderer = orderer
order.save()
for meatInfo in MeatPrice.objects.all():
meat_order = MeatOrder(order=order, meat_price=meatInfo, count=request.POST[meatInfo.name])
meat_order.save()
order.send_order_email()
return redirect(reverse('order:view_order', args=[orderer.id]))
def create_order(request):
"""使用 cart 的数据创建 order"""
cart = Cart(request)
if request.method == 'POST':
order_form = OrderForm(request.POST)
if order_form.is_valid():
# create order
order = order_form.save(commit=False)
order.customer = request.user
order.email = request.user.email
if cart.coupon:
order.coupon = cart.coupon
order.discount = cart.coupon.discount
order.save()
# create order_item
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
cart.clear()
# store order id
request.session['order_id'] = order.id
# send notice mail by celery
order_created.delay(order.id)
# 推荐计分
recommender = Recommender()
recommender.cal_products_bought(
[item.product for item in order.items.all()])
# 重定向到支付页
return redirect('order:payment_process')
else:
order_form = OrderForm()
return render(request, 'order/create.html', {
'order_form': order_form,
'cart': cart
})
def order_edit(request, order_id):
context = {}
try:
order = get_object_or_404(Order, id=order_id)
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
order.order_customer_id = form.cleaned_data['order_customer_id']
order.order_product_id = form.cleaned_data['order_product_id']
order.order_amount = form.cleaned_data['order_amount']
order.save()
return HttpResponseRedirect('/order/detail/%s/' % order.id)
else:
order_data = {
'order_product_id': order.order_product_id,
'order_customer_id': order.order_customer_id,
'order_amount': order.order_amount
}
form = OrderForm(initial=order_data)
except Order.DoesNotExist:
context.update({'error': True})
context.update({'title': 'Editar Cliente', 'form': form, 'update': True, 'order': order})
return render(request, 'add_order.html', context)
def post(self, request):
generic_error_response = self.render_json_response({'status': 'error', 'errors': {'non_field_errors': 'Invalid submission.'}})
try:
data = json.loads(request.POST.get('data'))
tip = data.get('tip')
items = data.get('items')
first_name = data.get('first_name')
last_name = data.get('last_name')
phone_number = data.get('phone_number')
cc_number = data.get('crimsoncash')
except (IndexError, ValueError):
return generic_error_response
if any(i is None for i in [tip, items, first_name, last_name, phone_number, cc_number]):
return generic_error_response
order_form = OrderForm(data={'tip': tip})
if not order_form.is_valid():
return self.render_json_response({'status': 'error', 'errors': order_form.errors})
else:
tip = order_form.cleaned_data.get('tip')
order_items = []
for pk, quantity in items.iteritems():
order_item_form = OrderItemForm(data={'item': pk, 'quantity': quantity})
if not order_item_form.is_valid():
return self.render_json_response({'status': 'error', 'errors': order_item_form.errors})
else:
quantity = order_item_form.cleaned_data.get('quantity')
item = order_item_form.cleaned_data.get('item')
if quantity > 0:
order_items.append((item, quantity))
# add the phone number country code if necessary
if not phone_number[:1] == '+' and not phone_number[:1] == '1':
phone_number = u'+1{}'.format(phone_number)
elif not phone_number[:1] == '+':
phone_number = u'+{}'.format(phone_number)
customer_form = CustomerForm(data={'first_name': first_name, 'last_name': last_name, 'phone': phone_number, 'cc_number': cc_number})
if not customer_form.is_valid():
return self.render_json_response({'status': 'error', 'errors': customer_form.errors})
# if they submitted an order with all quantities = 0
if not order_items:
return generic_error_response
first_name = customer_form.cleaned_data.get('first_name')
last_name = customer_form.cleaned_data.get('last_name')
phone_number = customer_form.cleaned_data.get('phone')
cc_number = customer_form.cleaned_data.get('cc_number')
customer, created = Customer.objects.get_or_create(
first_name=first_name,
last_name=last_name,
phone=phone_number,
cc_number=cc_number,
)
order = Order.objects.create(
customer=customer,
tip=tip,
)
m = hashlib.md5()
m.update('{}{}'.format(order.customer.last_name, order.pk))
key = m.hexdigest()
order.key = key
order.save()
for item, quantity in order_items:
order.add_item(item, quantity)
return self.render_json_response({'status': 'success', 'key': order.key})
def orderproduct(request):
category = Category.objects.all()
current_user = request.user
shopcart = ShopCart.objects.filter(user_id=current_user.id)
total = 0
for rs in shopcart:
if rs.product.variant == 'None':
total += rs.product.price * rs.quantity
else:
total += rs.variant.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()
# get product quantity from form
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() # random cod
data.code = ordercode
data.save()
for rs in shopcart:
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
if rs.product.variant == 'None':
detail.price = rs.product.price
else:
detail.price = rs.variant.price
detail.variant_id = rs.variant_id
detail.amount = rs.amount
detail.save()
# ***Reduce quantity of sold product from Amount of Product
if rs.product.variant == 'None':
product = Product.objects.get(id=rs.product_id)
product.amount -= rs.quantity
product.save()
else:
variant = Variants.objects.get(id=rs.product_id)
variant.quantity -= rs.quantity
variant.save()
# ************ <> *****************
# Clear & Delete shopcart
ShopCart.objects.filter(user_id=current_user.id).delete()
request.session['cart_items'] = 0
messages.success(request,
"Your Order has been completed. Thank you ")
return render(request, 'order/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 = {
'shopcart': shopcart,
'category': category,
'total': total,
'form': form,
'profile': profile,
}
return render(request, 'order/order_form.html', context)
def get_common_context(request):
form = OrderForm()
hform = OrderHForm()
fform = OrderFForm()
c = {}
if request.method == 'POST':
if request.POST['action'] == 'subscribe':
em = request.POST.get('email', None)
if em:
Subscribe(email=em).save()
messages.success(request, u'Вы успешно подписались на рассылку.')
else:
messages.error(request, u'Необходимо ввести емейл.')
elif request.POST['action'] == 'homeform':
hform = OrderHForm(request.POST)
if hform.is_valid():
hform.save()
messages.success(request, u'Ваша заявка успешно отправлена.')
hform = OrderHForm()
else:
c['show_hform'] = True
messages.error(request, u'Необходимо ввести имя и телефон.')
elif request.POST['action'] == 'franchajzing':
fform = OrderFForm(request.POST)
if fform.is_valid():
fform.save()
messages.success(request, u'Ваша заявка успешно отправлена.')
fform = OrderFForm()
else:
print fform.errors
c['show_fform'] = True
messages.error(request, u'Необходимо ввести имя и телефон.')
else:
form = OrderForm(request.POST)
if form.is_valid():
form.save()
c['request-ok'] = True
else:
if request.POST['action'] == 'signup':
c['show_signup'] = True
if request.POST['action'] == 'get':
c['show_get'] = True
if request.POST['action'] == 'gift':
c['show_gift'] = True
messages.error(request, u'Необходимо ввести имя.')
c['request_url'] = request.path
c['is_debug'] = settings.DEBUG
c['reviews'] = Review.objects.all()[:3]
c['form'] = form
c['hform'] = hform
c['fform'] = fform
c['menu'] = Menu.objects.filter(parent=None)
c['partners'] = Partner.objects.all()
c['complex'] = Page.get_by_slug('complex').content
try:
c['menu_cat'] = Menu.get_by_href(request.path).parent
except:
c['menu_cat'] = None
c['siteurl'] = request.get_host().split('.')[0]
c['phone'] = config_value('MyApp', 'PHONE')
c.update(csrf(request))
return c
