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 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 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 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 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(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 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 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 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 get(self, request, *args, **kwargs):
self.form = OrderForm()
return super(OrderView, self).get(request, *args, **kwargs)