class OrderView(TemplateView):
model = Order
template_name = "order.html"
form = None
def get(self, request, *args, **kwargs):
self.form = OrderForm()
return super(OrderView, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super(OrderView, self).get_context_data(**kwargs)
context["form"] = self.form
return context
def post(self, request, *args, **kwargs):
self.form = OrderForm(request.POST)
if self.form.is_valid():
if self.form.cleaned_data["honeypot"] == "":
if self.form['qty'] > 0:
self.form.save()
messages.add_message(request, messages.SUCCESS,
"Заказ успешно отправлен.")
return redirect("main")
else:
return super(OrderView, self).get(request, *args, **kwargs)
def put(request, order_id):
if order_id is not None:
try:
order = Order.objects.get(pk=order_id)
except Order.DoesNotExist:
return JsonResponse("Order doesn't exist", safe=False)
# If any of these parameters exist in the request, the corresponding attributes values
# of the found object will be replaced with them.
if 'price' in request.PUT:
order.price = request.PUT["price"]
if 'object' in request.PUT:
order.object = request.PUT["object"]
if 'user' in request.PUT:
# Check if user exists and affect it the found Order instance.
try:
user_id = request.PUT["user"]
user = User.objects.get(id=user_id)
order.user = user
except User.DoesNotExist:
return JsonResponse("User doesn't exist", safe=False)
order_form = OrderForm(
{
'object': order.object,
'price': order.price,
'user': order.user.id
},
instance=order)
# Check if the data in the updated instance is valid,
# if it's valid, update the object in the database.
if order_form.is_valid():
if 'image' in request.FILES:
image_file = request.FILES['image']
encoded_img = encode_to_base64(image_file)
order.image = encoded_img
order.save()
# Return the updated object in JSON format.
order_user_data = {
'id': order.user.id,
'username': order.user.username
}
data = {
'id': order.id,
'object': order.object,
'price': order.price,
'user': order_user_data
}
return JsonResponse(data)
else:
return JsonResponse(order_form.errors)
else:
return JsonResponse("Order id not provided", safe=False)
def post(self, request, *args, **kwargs):
self.form = OrderForm(request.POST)
if self.form.is_valid():
if self.form.cleaned_data["honeypot"] == "":
if self.form['qty'] > 0:
self.form.save()
messages.add_message(request, messages.SUCCESS,
"Заказ успешно отправлен.")
return redirect("main")
else:
return super(OrderView, self).get(request, *args, **kwargs)
def searchCustomer(request):
if request.method == "POST":
form = CustomerForm2(request.POST)
if form.is_valid():
customer_list = Customer.objects.filter(
phone_num=form.cleaned_data['phone_num'],
name=form.cleaned_data['name'])
print(customer_list)
if len(customer_list) != 0:
order = OrderForm()
return render(request, 'main/wash2.html', {
'customer': customer_list,
'order': order
})
else:
context = 'g'
form = CustomerForm2()
return render(
request, 'main/wash.html', {
'customer': customer_list,
'customer': form,
'context': context
})
else:
return render(request, 'main/wash.html', {
'customer': customer_list,
'context': '회원 정보를 찾을 수 없습니다.'
})
def url_addorder(request):
'''add a order '''
info = act_getinfo(request)
buyer = info['current_user'].buyer
uf = OrderForm(request.POST)
uf.fields['skus'].queryset = Sku.objects.filter(buyer=buyer)
if request.method == 'POST':
if uf.is_valid():
skus = uf.cleaned_data['skus']
# msg = str(isinstance(skus,Sku))
msg = act_addorder(skus, buyer)
# result = act_addorder(skus, buyer)
# uf = OrderForm(request.POST)
# uf.fields['skus'].queryset = Sku.objects.filter(buyer=info['current_user'].buyer)
return render(request, "main/addorder.html", locals())
def make_order_view (request):
cart = try_session(request)
form = OrderForm(request.POST or None)
if form.is_valid():
name = form.cleaned_data['name']
last_name =form.cleaned_data['last_name']
phone = form.cleaned_data['phone']
address = form.cleaned_data['address']
comments = form.cleaned_data['comments']
sticker_c = form.cleaned_data['sticker']
payment_c = form.cleaned_data['payment']
datep_c = form.cleaned_data['datep']
if request.user.is_authenticated :
user_name = request.user.username
else:
user_name = ''
new_order = Order.objects.create(
user=user_name,
items=cart,
total=cart.cart_total,
firstname=name,
lastname=last_name,
phone=phone,
address=address,
date= timezone.now() ,
comments=comments,
sticker=sticker_c ,
payment=payment_c ,
datep=datep_c
)
new_order.save()
send_order(request, new_order)
del request.session['cart_id']
del request.session['total']
c = count(cart)
context = {
'c': c,
'new_order' : new_order,
'categories':get_categories(),
'products' : Product.objects.all()
}
return render(request, 'thank_you.html', context)
def getOrder(request):
if request.method == 'POST':
order_form = OrderForm(request.POST, request.FILES)
if order_form.is_valid():
order_info = Post(**form.cleaned_data)
order_info.save()
return HttpResponse("finish")
elif request.method == 'GET':
customer = CustomerForm2()
order = OrderForm()
return render(request, 'main/wash.html', {
'customer': customer,
'order': order
})
else:
pass
def order_item(request, pk):
product_instance = get_object_or_404(ProductInstance, pk=pk)
# current_user = get_object_or_404(User, pk=pk)
# If this is a POST request then process the Form data
if request.method == 'POST':
# Create a form instance and populate it with data from the request (binding):
form = OrderForm(request.POST)
# Check if the form is valid:
if form.is_valid():
# process the data in form.cleaned_data as required (here we just write it to the model due_back field)
# product_instance.due_back = form.cleaned_data['renewal_date']
# product_instance.save()
order_details = OrderDetail()
user = User.objects.get(id=request.user.id)
# current_user = request.user
order_details.user = user
order_details.uuid = product_instance.id
order_details.brand = product_instance.title.brand
order_details.title = product_instance.title
order_details.price = product_instance.title.price
order_details.size = product_instance.size
order_details.address = form.cleaned_data['address']
order_details.pincode = form.cleaned_data['pincode']
order_details.panchayath = form.cleaned_data['panchayath']
order_details.phone_number = form.cleaned_data['phone_number']
order_details.save()
product_instance.delete()
# redirect to a new URL:
return HttpResponseRedirect(reverse('order-placed'))
# If this is a GET (or any other method) create the default form.
else:
# proposed_pincode = "enter pincode"
form = OrderForm()
context = {
'form': form,
'order_field': product_instance,
}
return render(request, 'main/order_detail.html', context)
def order(request,pk):
if request.user.is_authenticated:
if request.method == 'POST':
product = Product.objects.get(id=pk)
form = OrderForm(request.POST, instance=product)
if form.is_valid():
quantity = form.cleaned_data['quantity']
status = form.cleaned_data['status']
post = CompanyOrder(quantity=quantity, status=status, company_manager_id=request.user.id, product_id=product.id)
post.save()
return redirect ('/orderlist/')
else:
form = OrderForm()
return render(request, 'main/order.html', {'form': form})
else:
return redirect('/login/')
def get(self, request, *args, **kwargs):
categories = Category.objects.get_categories_for_left_sidebar()
form = OrderForm(request.POST or None)
context = {
'categories': categories,
'cart': self.cart,
'form': form
}
return render(request, 'checkout.html', context)
def order_product(request, pk):
'''
Shows order product page
'''
product = Product.objects.get(pk=pk)
form = OrderForm(initial={'product': product})
form_errors = None
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.product = product
order.client = request.user
order.save()
return redirect('order')
return render(request, "product_order.html", {
'form': form,
'form_errors': form_errors,
'product': product,
})
def getOrder(request):
if request.method == 'POST':
pass
elif request.method == 'GET':
customer = CustomerForm2()
order = OrderForm()
return render(request, 'main/wash.html', {
'customer': customer,
'order': order
})
else:
pass
def order_view(request):
# Рендерит главную страницу, с формой для заказа, и входа в аккаунт диспетчера
order_form = OrderForm(request.POST or None)
login_form = LoginForm(request.GET or None)
context = {
'order_form': order_form,
'login_form': login_form
}
if order_form.is_valid():
client_name = order_form.cleaned_data['client_name']
client_phone = order_form.cleaned_data['client_phone']
address = order_form.cleaned_data['address']
destination = order_form.cleaned_data['destination']
desired_time = order_form.cleaned_data['desired_time']
new_order = Order(client_name=client_name,
client_phone=client_phone,
address=address,
destination=destination,
desired_time=desired_time)
try:
car = Car.objects.filter(ordered=False)[0]
new_order.car = car
new_order.save()
car.ordered = True
car.save()
order_inf = {"order_id": new_order.id, "car_brand": car.brand}
except:
order_inf = False
context.update({'order_inf': order_inf})
if login_form.is_valid():
username = login_form.cleaned_data['username']
password = login_form.cleaned_data['password']
login_user = authenticate(username=username, password=password)
if login_user:
login(request, login_user)
return HttpResponseRedirect(reverse('all_orders'))
return render(request, 'order.html', context)
def post(request, *args, **kwargs): # pylint: disable=unused-argument
# Check whether the data is valid or not.
form = OrderForm(request.POST)
if form.is_valid():
# Get order object attributes.
order_object = request.POST.get('object', '')
price = request.POST.get('price', '')
user_id = request.POST.get('user', '')
user = User.objects.get(id=user_id)
# Get the uploaded image and encode it to base64.
encoded_img = ''
if 'image' in request.FILES:
image_file = request.FILES['image']
encoded_img = encode_to_base64(image_file)
# Persist the object.
order = Order.objects.create(object=order_object,
price=price,
image=encoded_img,
user=user)
# Return order data as a Json response.
order_user_data = {
'id': order.user.id,
'username': order.user.username
}
data = {
'id': order.id,
'object': order.object,
'price': order.price,
'user': order_user_data
}
return JsonResponse(data)
else:
# Returns the cause of the invalid found data.
return JsonResponse(form.errors)
def post(self, request, *args, **kwargs):
form = OrderForm(request.POST or None)
if form.is_valid():
new_order = form.save(commit=False)
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['first_name']
new_order.buying_type = form.cleaned_data['buying_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
new_order.cart = self.cart
new_order.save()
self.cart.delete()
messages.add_message(request, messages.INFO, 'Thank you for your order, but its not actually a shop :(')
return HttpResponseRedirect('/')
return HttpResponseRedirect('/checkout/')
def order(request):
basket = Basket.objects.get(user=request.user)
products_in_basket = ProductsInBasket.objects.filter(basket_id=basket)
products = products_in_basket.values_list('product_id', 'product_quantity')
products_list = []
total = 0
for product in products:
p, q = product
total_for_one = Product.objects.get(pk=p).product_price * q
total = total + total_for_one
products_list.append((Product.objects.get(pk=p), q, total_for_one))
form = OrderForm()
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
order = Order(user=request.user,
total_price=total,
payment_method=form.cleaned_data['payment_method'],
address=form.cleaned_data['address'],
postal_code=form.cleaned_data['postal_code'],
city=form.cleaned_data['city'],
country=form.cleaned_data['country'])
order.save()
for product_tuple in products:
product, quantity = product_tuple
order.products.add(Product.objects.get(pk=product))
order.save()
clean_basket(products_in_basket)
return redirect('thanks')
context = {'products': products_list, 'total': total, 'form': form}
return render(request, 'main/order.html', context)
def checkout_view(request):
cart = try_session(request)
if count(cart) == 0:
return HttpResponseRedirect(reverse('cart'))
else:
form = OrderForm(request.POST or None)
try:
phone = Phone.objects.get(user = request.user)
except:
phone = ''
c = count(cart)
context = {
'c': c,
'phone' : phone,
'form': form,
'cart' :cart,
'categories' :get_categories(),
'user' : request.user
}
return render(request, 'checkout.html', context)
def show_orderform(context):
request = context['request']
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
phone = form.cleaned_data['phone']
email = form.cleaned_data['email']
name = form.cleaned_data['name']
date_execution = form.cleaned_data['date_execution']
address = form.cleaned_data['address']
message = form.cleaned_data['message']
form.save()
recipients = ['*****@*****.**']
text_content = 'Имя: {}\n{}\nУдобное время: {}\nТелефон: {}\nПочта: {}\nАдрес: {}'.format(
message, date_execution.strftime("%d.%m.%Y %H:%M"), name, phone, email, address)
html_content = '<p>Имя: {}</p><p>{}</p><p>Удобное время: {}</p><p>Телефон: {}</p><p>Почта: {}</p><p>Адрес: {}</p>'.format(
message, date_execution.strftime("%d.%m.%Y %H:%M"), name, phone, email, address)
send_mail(u'Тест', text_content, '*****@*****.**', recipients, fail_silently=True, auth_user=None,
auth_password=None, connection=None, html_message=html_content)
messages.success(request, 'Поступила новая заявка, номер для связи: ' + phone + ' E-mail: ' + email)
form = OrderForm()
else:
form = OrderForm()
return {"form": form}
def get(self, request, *args, **kwargs):
self.form = OrderForm()
return super(OrderView, self).get(request, *args, **kwargs)
def register(request):
products = Product.objects.filter(active=True)
cheapest_product_price = list(products.aggregate(Min('sale_price_int')).values())[0] or 0
half_a_year_ago = datetime.now() - timedelta(days=180)
users = User.objects.filter(profile__balance__gte=cheapest_product_price)
# sort users after user's last purchase time
users = sorted(users, key=lambda u: u.profile.last_purchase_date(), reverse=True)
users_js = users_format_js(users)
# multiple orderlines (one per product)
OrderLineFormSet = formset_factory(OrderLineForm)
if request.method == "POST":
orderform = OrderForm(request.POST)
formset = OrderLineFormSet(request.POST)
if formset.is_valid() and orderform.is_valid():
order = orderform.save(commit=False)
if order.is_external():
order_sum = sum([ol['amount'] * ol['unit_price_ext'] for ol in formset.cleaned_data])
else:
order_sum = sum([ol['amount'] * ol['unit_price_int'] for ol in formset.cleaned_data])
# empty order?
if order_sum == 0:
messages.error(request, 'Du har ikke valgt hva du skal kjøpe...')
return HttpResponseRedirect(reverse('register'))
if not order.is_external():
profile = order.customer.profile
# can she afford it?
if profile.balance < order_sum:
messages.error(request, '{0} {1} har ikke råd, mangler {2} kr.'.format(
order.customer.first_name,
order.customer.last_name,
int(order_sum - profile.balance)))
return HttpResponseRedirect(reverse('register'))
# substract order from balance
profile.balance -= order_sum
profile.save()
order.order_sum = order_sum
order.save()
orderlines = []
for ol in formset.cleaned_data:
if ol['amount'] > 0:
product = Product.objects.get(pk=ol['product'])
if order.is_external():
unit_price = ol['unit_price_ext']
else:
unit_price = ol['unit_price_int']
OrderLine.objects.create(
order=order,
product=product,
amount=ol['amount'],
unit_price=unit_price)
product.inventory_amount -= ol['amount']
product.save()
orderlines.append("{0} {1}".format(ol['amount'], product))
if order.is_external():
messages.success(request, 'Ekstern kjøpte {0}.'.format(", ".join(orderlines)))
else:
messages.success(request, '{0} {1} kjøpte {2}.'.format(
order.customer.first_name,
order.customer.last_name,
", ".join(orderlines)
))
return redirect('register')
else:
# TODO specify error(s)
messages.error(request, 'Skjemaet er ikke gyldig.')
orderform = OrderForm(request.POST)
formset = OrderLineFormSet(request.POST)
else:
orderform = OrderForm()
formset = OrderLineFormSet()
return render(request, 'register.html', locals())
def order(request):
context = {}
context.update(csrf(request))
template = "main/order_dialog_step1.html"
if request.method == 'POST':
step = request.POST.get('step', '1')
form = OrderForm(request.POST)
if form and form.is_valid():
if step == '1': # form -> preview
try:
book = Book.objects.get(alias=form.cleaned_data['book'])
except ObjectDoesNotExist:
response = simplejson.dumps({"success": False})
return HttpResponse(response,
content_type="application/javascript; charset=utf-8")
context['book'] = book
context['check_form'] = form
context['total'] = Order.calc_total2(
quantity=form.cleaned_data['quantity'],
price=Book.objects.filter(alias="red")[0].price,
delivery_price=Decimal(settings.DELIVERY_PRICE)
if form.cleaned_data['delivery_method'] == 'courier' else 0)
template = "main/order_dialog_step2.html"
success = True
elif step == '2': # preview -> submit
success = True
customer = Customer()
order = Order()
# customer.lastname = form.cleaned_data['lastname']
# customer.firstname = form.cleaned_data['firstname']
customer.name = form.cleaned_data['name']
customer.email = form.cleaned_data['email']
customer.tel = form.cleaned_data['tel']
customer.save()
order.book = Book.objects.get(alias=form.cleaned_data['book'])
order.quantity = form.cleaned_data['quantity']
order.payment_method = form.cleaned_data['payment_method']
order.delivery_method = form.cleaned_data['delivery_method']
if order.delivery_method == 'courier':
order.delivery_price = Decimal(settings.DELIVERY_PRICE)
order.order_date = datetime.datetime.now()
order.order_number = order.calc_order_number()
order.customer = customer
order.save()
context['order'] = order
context['total'] = order.calc_total()
template = "main/order_dialog_finish.html"
send_mail(u'Заказ на mislistudenta.ru', render_to_string('main/confirmation.txt', context), settings.EMAIL_HOST_USER, [order.customer.email])
else:
form._errors = {}
context["order_form"] = form
success = False
else:
form = request.GET.get('form')
if form:
form = unquote(request.GET.get('form').encode('utf8')).decode('utf8')
context["order_form"] = OrderForm(initial=dict(parse_qsl(form)))
else:
context["order_form"] = OrderForm()
success = True
html = render_to_string(template, RequestContext(request, context))
response = simplejson.dumps({"success": success, "html": html})
return HttpResponse(response,
content_type="application/javascript; charset=utf-8")
