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 order_create(request):
cart = Cart(request)
user = request.user
if request.method == 'POST':
form= OrderForm(user,request.POST)
order = form.save(commit = False)
order.user = user
order.save()
for item in cart:
OrderItem.objects.create(order= order, book = item.book , quantity= item.quantity)
cart.clear()
return redirect('order:order_detail', order_id = order.order_id)
else:
form = OrderForm(user)
categories =[]
for item in cart:
category = item.book.category
if category not in categories:
categories.append(category)
if categories:
related_books = Book.objects.filter(category = categories[0])
if len(categories)>1:
for category in categories[1:]:
related_books= related_books|(Book.objects.filter(category = category))
related_books = related_books[:5]
return render(request,'order/order_form.html',{'cart':cart, 'form':form,'related_books':related_books})
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 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 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 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(order_index)
else:
print(form.errors)
else:
context = {"form": OrderForm()}
return render(request, "add_order.html", context)
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 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 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 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 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 order_detail(request):
cart = Cart(request)
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid:
order = form.save()
for item in cart:
print(item['product'])
print(item['price'])
OrderItem.objects.create(order=order,
product=item['product'],
quantity=item['quantity'],
price=item['price'])
cart.clear()
new_order = order
print('ZAKAZ', order.id)
return render(request, 'order/thanks_order.html',
{'order': new_order})
else:
form = OrderForm()
return render(request, 'order/order_detail.html', {
'form': 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 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',
'Зайдите в админку чтобы почетать заявку http://torrehome.ru/admin/ ',
'http://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 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):
'''
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 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 get(self, request, *args, **kwargs):
try:
order = Order.objects.get(id=kwargs.get['id'])
except Order.DoesNotExist:
return redirect('/order/list')
form = OrderForm(initial=order.__dict__, instance=order)
user = UserOrderForm(instance=order.user)
date = str(timezone.now().date())
context = {
'date': date,
'model': 'order',
'view': 'order',
'order': order,
'form': form,
'user': user
}
return render(request, 'order.html', context)
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 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 gig_detail(request, pk):
user = User.objects.filter(id=pk).first()
gig = Gig.objects.get_by_id(pk)
order_form = OrderForm(request.POST or None,
initial={
'count': 0,
'gig_id': pk
})
info = Comment.objects.filter(status=True, gig=gig, reply=None)
buyer = Transaction.objects.filter(gig=gig)
if request.method == "POST":
cmform = CommentForm(request.POST)
if cmform.is_valid():
content = request.POST.get('content')
reply_id = request.POST.get('comment_id')
comment_qs = None
if reply_id:
comment_qs = Comment.objects.get(id=reply_id)
comment = Comment.objects.create(gig=gig,
user=request.user,
content=content,
reply=comment_qs)
comment.save()
return HttpResponseRedirect(comment.gig.get_absolute_url())
else:
cmform = CommentForm()
if not gig:
raise Http404('یافت نشد')
context = {
'info': info,
'cmform': cmform,
'gig': gig,
'order_form': order_form,
'buyer': buyer,
'categories': CATEGORY,
}
# if request.is_ajax():
# html = render_to_string('gig/gig_detail.html', context, request=request)
# return JsonResponse({'form': html})
return render(request, 'gigs/gig_detail.html', context)
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 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 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 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 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 orderbook(request, base_code, quote_code):
try:
base_currency = Currency.objects.get(code=base_code)
quote_currency = Currency.objects.get(code=quote_code)
other_currencies = Currency.objects.exclude(
code__exact=base_code).exclude(code__exact=quote_code)
user = request.user
base_account = user.account_set.get(currency__code=base_code)
quote_account = user.account_set.get(currency__code=quote_code)
except (Currency.DoesNotExist, Account.DoesNotExist):
raise Http404('Non existent currencies')
other_accounts = user.account_set.exclude(currency__code=base_code)
other_accounts = other_accounts.exclude(currency__code=quote_code)
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
price = form.cleaned_data['price']
amount = form.cleaned_data['amount']
type_ = form.cleaned_data['order_type']
if type_ == OrderType.BUY:
account = quote_account
elif type_ == OrderType.SELL:
account = base_account
if amount > account.balance:
return HttpResponse('Not enough money')
account.balance -= amount
account.save()
assert account.balance >= 0
order = Order.objects.create(user=user,
base_currency=base_currency,
quote_currency=quote_currency,
price=price,
amount=amount,
status=StatusType.ACTIVE,
order_type=type_)
order.save()
else:
form = OrderForm()
account_orders = user.order_set.filter(base_currency__code=base_code,
quote_currency__code=quote_code)
all_orders = Order.objects.filter(base_currency__code=base_code,
quote_currency__code=quote_code,
status=StatusType.ACTIVE)
buy_orders = all_orders.filter(order_type=OrderType.BUY)
sell_orders = all_orders.filter(order_type=OrderType.SELL)
context = {
'base_currency': base_currency,
'quote_currency': quote_currency,
'other_currencies': other_currencies,
'base_account': base_account,
'quote_account': quote_account,
'other_accounts': other_accounts,
'account_orders': account_orders,
'form': form,
'buy_orders': buy_orders,
'sell_orders': sell_orders,
}
return render(request, 'orderbook.html', context=context)
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# order\forms.py 폼을 생성할때 리퀘스를 전달해줌
context['form'] = OrderForm(self.request)
return 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
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['form'] = OrderForm(
self.request) # orderform에서 받은 값을 'form'으로 템플릿에 전달한다.
return context # view 함수이기 때문에 request가 있으니 폼을 생성할 때 request를 전달한다.
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(self, request):
form = OrderForm()
return render(request, 'order/orderList.html', {'form': form})
def get(self, request, *args, **kwargs):
categories = Category.objects.all()
form = OrderForm(request.POST or None)
context = {'cart': self.cart, 'categories': categories, 'form': form}
return render(request, 'order_checkout.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 get_context_data(self, **kwargs): # 내가 원하는 데이터를 넣을 수 있는 함수
context = super().get_context_data(**kwargs) # super() DetailView먼저 실행
context['form'] = OrderForm(self.request) # form이라는 변수 추가
return context
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['form'] = OrderForm(
self.request) #order forms.py에서 def __init__에서 request받아온다.
return context
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
# 2. OrderForm 객체 생성시 request 전달, OrderForm 안에서 request에 접근하기 위해서
context["form"] = OrderForm(self.request)
return context
def test_order_form_for_empty_validation(self):
data = {}
form = OrderForm(data)
assert form.is_valid() is False, 'Should be False if Form is empty'
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
def create_order(request):
cart = Cart(request)
# 'if cart.products:' 를 별도로 구성하여 '장바구니가 비었습니다' 안내 페이지로 이동시킬 수 있음
# 현재 구성은 장바구니가 비어있을 경우, 빈 폼 로드
products = cart.products # cart에 담긴 아이템들
total_price = cart.get_total_price() # 총 가격
if products.exists() and request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
order_item_list = []
order = form.save(commit=False)
order.total_price = total_price
order.user = request.user
order.save()
# dict-type의 Product 객체 생성
product_bulk = products.in_bulk()
for item in cart:
order_item_obj = OrderWithItem(order=order,
item=item['product'],
price=int(item['price']) * int(item['quantity']),
quantity=item['quantity'])
# OrderWithItem 객체를 리스트에 추가
order_item_list.append(order_item_obj)
product_bulk[item['product'].id].quantity -= item['quantity']
# 사용자 동작
if request.user.is_authenticated:
pass
# user=Foreignkey(User) 이므로 request.user가 authenticated user가 아닐 경우 에러 발생
# track_action(user=request.user, verb='bought', content_object=item['product'])
# bulk_create를 이용한 OrderWithItem db 생성
order_items = OrderWithItem.objects.bulk_create(order_item_list)
# bulk_update를 이용한 Product.quantity 업데이트(release version2.2)
products.bulk_update(product_bulk.values(), ['quantity'])
# 함께 구매한 아이템 등록
r = Recommend()
try:
r.buy_item(products)
print('bought in redis')
except Exception as e:
print(f'not connect redis:{e}')
# for order_item in order_items:
# print(order_item.order.id) # 주문번호
# print(order_item.item) # 아이템
# print(order_item.price) # 가격
# print(order_item.quantity) # 수량
# 주문 완료 시, 장바구니(session) 비우기
cart.clear_session()
return render(request, 'order/created.html', {'order': order, 'order_items': order_items})
# order -> 주문번호, 사용자 성, 이름, 주소, 구매 총 가격
# order_item -> 구매 아이템 수량, 가격
else:
user = User.objects.get(id=request.user.id)
form = OrderForm(
initial={'first_name': user.first_name, 'last_name': user.last_name, 'address': user.profile.address,
'post_code': user.profile.postal_code})
print(form['address'])
return render(request, 'order/create.html', {'cart': cart, 'form': form})
def get_context_data(self, **kwargs): # 자세히보기 페이지에서 주문하기 기능을 위해선 해당 폼을 가져와야하는데 이 함수를 통해서 그 기능을 구현한다.
context = super().get_context_data(**kwargs) # 디테일 뷰에 있는 데이터를 먼저 만들고나서 내가 만들고자 하는 것을 추가하는 것
context['form'] = OrderForm(self.request) # orderform은 오더폴더에서 가져온 registerform을 앨리아스 한 것이고 뷰클래스에는 셀프안에 리퀘스트가 있다. 그래서 그냥 적어넣으면 됨
# 그러면 저 리퀘스트를 통해 order폴더 안에 있는 registerform의 리퀘스트와 연동됨.
return context
def get_context_data(self, **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
