def update_order(request, pk_order):
"""
A order update page for the admin to change the status
and download/upload the artwork for the customer.
"""
order = Order.objects.get(id=pk_order)
form = OrderForm(instance=order)
tax = order.get_total() * Decimal(21 / 100)
total = order.get_total() + tax
if order.id_code:
if request.method == 'POST':
form = OrderForm(request.POST, request.FILES, instance=order)
if form.is_valid():
form.save()
messages.info(request, 'Order updated successfully')
return redirect('accounts:adminpage')
else:
context = {
'order': order,
'tax': tax,
'total': total,
'form': form
}
return render(request, 'accounts/update_order.html', context)
else:
messages.error(request, 'Order still in progress')
return redirect('accounts:adminpage')
def create_order(request):
billing_profile = BillingProfile.objects.filter(user=request.user).first()
cart = Cart.objects.filter(user=request.user, active=True).first()
if request.method == 'POST':
if not request.user.is_authenticated or Order.objects.filter(
billing_profile=billing_profile, active=True).first() is None or cart is None:
return HttpResponseBadRequest('Error occurred while placing the order!')
model_instance = Order.objects.get_active_order(
billing_profile=billing_profile, cart=cart)
form = OrderForm(request.POST, instance=model_instance)
if form.is_valid():
model_instance.shipping_address = form.cleaned_data.get('shipping_address')
model_instance.payment_method = form.cleaned_data.get('payment_method')
# change order status to placed
model_instance.status = 'placed'
# make order and cart inactive for placing next order
model_instance.active = False
model_instance.save()
form.save()
context = {
'order_id': model_instance.order_id,
}
return render(request, "carts/order_success.html", context)
return redirect('home')
def HomeView(request, pk, *args, **kwargs):
"""
Shows the user their order has been placed and gives them the option of
continuing with payment. Once payment is complete this same view will show
them all the details concerned with their order.
request -- holds the logged in user
pk -- the id number of the scheduled course being ordered
*args -- used for extensibility (if order should support GET args)
**kwargs -- used for extensibility (if order should support POST args)
"""
scheduled_course = CourseSchedule.objects.get(id=pk)
if request.method == 'POST': # If the form has been submitted...
form = OrderForm(request.POST, user=request.user, scheduled_course=scheduled_course) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
# Process the data in form.cleaned_data
# ...
form.save()
order = Order.objects.filter(user=request.user).order_by('-date')[0]
return HttpResponseRedirect(unicode(order.id)) # Redirect after POST
else:
form = OrderForm(request.POST, user=request.user, scheduled_course=scheduled_course) # An unbound form
return render(request, 'orders/home.html', {
'form': form,
'scheduled_course': scheduled_course,
})
def cvety_list(request):
cvetys = Cvety.objects.all()
form = OrderForm(request.POST or None)
if request.method == "POST":
if form.is_valid():
form.save()
return HttpResponseRedirect("?sended=True")
return render(request, "cvety/cvety_list.html", {'cvetys': cvetys, 'form': form, "sended": request.GET.get("sended", False)})
def update(request, id):
order = Order.objects.get(id=id)
form = OrderForm(request.POST, instance=order)
if form.is_valid():
form.save()
messages.success(request, "Order modified successfully")
return redirect("/list")
return render(request, 'edit.html', {'order': order})
def handle_order_form(request):
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
form.save()
return
else:
form = OrderForm()
return form
def post(self, request, *args, **kwargs):
form = OrderForm(request.POST)
if not form.is_valid():
errors = {key: invalid_msg.format(value[0]) for key, value in form.errors.items()}
return render(request, self.template_name, {'error': errors, 'form': form})
# 保存
form.save(request.user.id)
return redirect('order:index')
def add_order(request):
"""Allow to add a new order"""
form_filter = FilterForm()
form = OrderForm()
if request.method == 'POST':
form = OrderForm(request.POST)
form.save()
contains = {'orders': Order.objects.all(), 'form_filter': form_filter}
return render(request, 'orders/list_orders.html', contains)
return render(request, 'orders/add_order.html', {'form': form})
def post(self, request, *args, **kwargs):
order_id = request.POST.get('id')
order = get_object_or_404(Order, id=order_id)
form = OrderForm(request.POST, instance=order)
if not form.is_valid():
errors = {key: invalid_msg.format(value[0]) for key, value in form.errors.items()}
return render(request, self.template_name, {'error': errors, 'form': form})
# 保存
form.save(request.user.id)
return redirect('order:index')
def cvety_ditail(request, cvety_id):
cvety = get_object_or_404(Cvety, id=cvety_id)
form = OrderForm(request.POST or None, initial={"cvety": cvety })
if request.method == "POST":
if form.is_valid():
form.save()
return HttpResponseRedirect("{}?sended=True".format(reverse("cvety", kwargs={"cvety_id": cvety_id})))
return render(request, "cvety/cvety_ditail.html", {
"cvety": cvety,
"form": form,
"sended": request.GET.get("sended", False)
})
def create(request):
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
try:
form.save()
messages.success(request, "Order created successfully")
return redirect('/list')
except:
pass
else:
form = OrderForm()
return render(request, 'new.html', {'form': form})
def order_create(request, template_name='orders/create.html'):
form = OrderForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
form.save()
return HttpResponseRedirect(reverse('orders:create_success'))
context = {
'form': form,
}
return TemplateResponse(request, template_name, context)
def house_detail(request, house_id):
house = get_object_or_404(House, id=house_id)
form = OrderForm(request.POST or None, initial={'house': house})
if request.method == 'POST':
if form.is_valid():
form.save()
return HttpResponseRedirect('{}?sended=True'.format(reverse('house', kwargs={'house_id': house.id})))
return render(request, 'houses/house_detail.html', {
'house': house,
'form': form,
'sended': request.GET.get('sended', False)
})
def house_detail(request, house_id):
house = get_object_or_404(House, id=house_id)
form = OrderForm(request.POST or None, initial={"house": house})
if request.method == "POST":
if form.is_valid():
form.save()
return HttpResponseRedirect("{}?sended=True".format(
reverse("house", kwargs={"house_id": house.id})))
return render(request, "houses/house_detail.html", {
"house": house,
"form": form,
"sended": request.GET.get("sended", False)
})
def order_custom(request):
config = OrderConfig.objects.get(id=1)
options = CustomCakeOrderConfigOption.objects.filter(
available=True).order_by('sort')
if request.method == 'POST':
custom_cake_order_form = CustomCakeOrderForm(data=request.POST,
options=options)
order_form = OrderForm(request.POST)
if custom_cake_order_form.is_valid() and order_form.is_valid():
product = Product.objects.get(slug='custom-cake')
new_order = order_form.save()
OrderItem(price=product.price,
quantity=1,
product=product,
order_id=new_order.id).save()
new_order.send_admin_custom_cake_confirm_emails(
custom_cake_order_form.cleaned_data)
new_order.send_client_custom_cake_confirm_emails(
custom_cake_order_form.cleaned_data)
return render(request,
template_name='orders/order/custom-done.html',
context={'config': config})
else:
custom_cake_order_form = CustomCakeOrderForm(options)
# cake_form = CustomCakeForm()
order_form = OrderForm()
return render(
request,
'orders/order/custom.html',
{
'config': config,
# 'cake_form': cake_form,
'order_form': order_form,
'ok': custom_cake_order_form
})
def change(request, order_id=''):
"""
Display a single order
"""
if order_id is not '':
order = get_object_or_404(Order, pk=order_id)
else:
order = None
if request.method == 'POST':
if order is None:
order_form = OrderForm(request.POST)
else:
order_form = OrderForm(request.POST, instance=order)
if order_form.is_valid():
order = order_form.save()
print(order)
return HttpResponseRedirect('/orders/list/')
else:
if order is None:
order_form = OrderForm()
else:
order_form = OrderForm(instance=order)
context = {
'title': 'Change order',
'order_id': order_id,
'order_form': order_form,
}
return render(request, 'orders/change.html', context)
def order_detail(request, order_id):
order = Order.objects.get(id=order_id)
if request.method == "POST":
form = OrderForm(request.POST, instance=order)
if form.is_valid():
order = form.save()
order.save() # just to calculate & store the price
msg = 'Your order for {} pounds of blueberries for ${} has been received. You can ' \
'pick them up after 9am on {} at Morning Shade Farm.'.format(
order.quantity, order.total_cost, order.pickup_date,
)
if order.quantity >= 200:
msg += " If you have additional requests, please call the farm."
messages.success(request, msg)
return HttpResponseRedirect(request.META['HTTP_REFERER'])
else:
msg = mark_safe("The form has errors: {}".format(form.errors))
messages.add_message(request,
messages.constants.ERROR,
msg,
extra_tags='danger')
else:
form = OrderForm(instance=order, submit_button_name="Update Order")
return render(request, 'orders/order_detail.html', {
'pagetitle': "Order {}".format(order.id),
'form': form,
})
class PrepareOrder(TemplateView):
form = None
template_name = "checkout/prepare_order.html"
def get(self, request, *args, **kwargs):
self.form = OrderForm()
return super(PrepareOrder, self).get(self, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super(PrepareOrder, self).get_context_data(**kwargs)
context['form'] = self.form
context['brands'] = Brand.objects.order_by("name")
context['categorys'] = Category.objects.order_by("name")
return context
def post(self, request, *args, **kwargs):
self.form = OrderForm(request.POST)
if self.form.is_valid():
order = self.form.save()
for filter_in_cart in request.session['cart']:
filter = Filter.objects.get(pk=filter_in_cart['filter_id'])
total_price = "{0:.2f}".format(
float(filter_in_cart["filter_price"].replace(",", ".")) *
int(filter_in_cart["numb"])
).replace(".", ",")
product_in_order = ProductInOrder.objects.create(order=order, product=filter,
numb=filter_in_cart['numb'],
price_item=filter_in_cart["filter_price"],
total_price=total_price)
request.session['cart'].clear()
request.session.modified = True
return render(request, "checkout/thanks.html", locals())
else:
return super(PrepareOrder, self).get(request, *args, **kwargs)
def place_order(request):
if request.method == 'GET':
total_amount = round(
sum([
product.price
for product in Product.objects.filter(cart__user=request.user)
]), 2)
order = Order()
order.amount = total_amount
context = {
'form': OrderForm(instance=order),
}
return render(request, 'orders/order_details.html', context)
else:
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.buyer = request.user
order.order_date = datetime.datetime.now()
order.save()
set_sold_products_unavailable(request.user, order)
update_raised_money(order.amount)
empty_user_cart(request.user)
return redirect('successful donation', order.id)
context = {
'form': form,
}
return render(request, 'orders/order_details.html', context)
def charge(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderForm(request.POST)
order = form.save()
context = {
'key': settings.STRIPE_PUBLISHABLE_KEY,
'order': order,
}
for object in cart:
OrderItem.objects.create(
order=order,
item=object['item'],
price=object['price'],
quantity=object['quantity']
)
cart.clear()
#charge_amount = request.POST['amount']
charge = stripe.Charge.create(
amount=500, #OrderItem.objects.filter(price__icontains(object['price'])),
currency='usd', # will need to modify for different currency types (low priority)
description='A New Django Order',
source=request.POST['stripeToken']
)
return render(request, 'order_confirmation.html', context)
else:
response = HttpResponse("<center><h2>FATAL ERROR: Not a POST request.</h2></center>")
return response
def index(request):
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
order = form.save()
order.save() # just to calculate & store the price
msg = 'Your order for {} pounds of blueberries for ${} has been received. You can ' \
'pick them up after 9am on {} at Morning Shade Farm.'.format(
order.quantity, order.total_cost, order.pickup_date,
)
if order.quantity >= 200:
msg += " If you have additional requests, please add comments to your order or call us."
messages.success(request, msg)
return redirect('index')
else:
msg = mark_safe("The form has errors: {}".format(form.errors))
messages.add_message(request,
messages.constants.ERROR,
msg,
extra_tags='danger')
else:
form = OrderForm()
prices = Price.objects.all().order_by('min_quantity')
return render(request, 'orders/index.html', {
'form': form,
'prices': prices
})
def update_cart(request):
"""Updates the user's shopping cart."""
order = Order.get_or_create(request)
order_form = OrderForm(request.REQUEST, prefix='btb', instance=order)
if order_form.is_valid():
order = order_form.save()
return order.get_as_cart()
return False
def cart(request, slug):
order = Order.objects.get(slug=slug)
if order.status != "pending":
return redirect(reverse('order_detail', kwargs={'slug': slug}))
order_items = OrderItem.objects.filter(order=order)
order_total = 0
for item in order_items:
subtotal = item.quantity * item.unity_price
order_total = order_total + subtotal
order_items_formset = inlineformset_factory(Order,
OrderItem,
form=OrderItemsForm,
extra=0,
can_delete=True)
if request.method == "POST":
form = OrderForm(request.POST, instance=order, prefix='main')
formset = order_items_formset(request.POST,
instance=order,
prefix='product')
try:
if form.is_valid() and formset.is_valid():
form.save()
formset.save()
messages.success(request, "Pedido atualizado")
return redirect(reverse('cart', kwargs={'slug': slug}))
except Exception as e:
messages.warning(request,
'Ocorreu um erro ao atualizar: {}'.format(e))
else:
form = OrderForm(instance=order, prefix='main')
formset = order_items_formset(instance=order, prefix='product')
return render(
request, 'orders/cart.html', {
'order': order,
'order_items': order_items,
'order_total': order_total,
'form': form,
'formset': formset,
})
class OrderCreate(TemplateView):
model = Orders
template_name = "order_add.html"
form = None
formset2files = None
formset2desc = None
success_url = "/orders/index/"
def get(self, request, *args, **kwargs):
dataform = {'project_name': self.kwargs["contract"]}
self.form = OrderForm(initial=dataform)
self.formset2desc = OrderDescriptionFormset()
self.formset2files = OrderDocsFormset()
return super(OrderCreate, self).get(request, *args, **kwargs)
def get_context_data(self, **kwargs):
context = super(OrderCreate, self).get_context_data(**kwargs)
context['form'] = self.form
context['formset2desc'] = self.formset2desc
context['formset2files'] = self.formset2files
return context
def post(self, request, *args, **kwargs):
self.form = OrderForm(request.POST, request.FILES)
if request.method == "POST":
if self.form.is_valid():
new_order = self.form.save()
self.formset2desc = OrderDescriptionFormset(request.POST,
instance=new_order)
self.formset2files = OrderDocsFormset(request.POST,
request.FILES,
instance=new_order)
messages.add_message(request, messages.SUCCESS,
"Заказ успешно добавлен. ")
if self.formset2desc.is_valid():
self.formset2desc.save()
messages.add_message(request, messages.SUCCESS,
"Описание успешно добавлено. ")
if self.formset2files.is_valid():
self.formset2files.save()
messages.add_message(
request, messages.SUCCESS,
"Документ(ы) к заказу успешно добавлен(ы). ")
return redirect("/orders/index/", *args, **kwargs)
else:
messages.add_message(
request, messages.SUCCESS,
"Проверьте корректность добавление нового документа или подтвердите текущие изменения. "
)
self.formset2desc = OrderDescriptionFormset(request.POST)
self.formset2files = OrderDocsFormset(request.POST, request.FILES)
messages.add_message(
request, messages.SUCCESS,
"ВНИМАНИЕ: Необходимо заполнить все обязательные параметры! ")
return super(OrderCreate, self).get(request, *args, **kwargs)
def order_page(request):
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.save()
return redirect("http://localhost:8000/orders_list")
else:
form = OrderForm()
return render(request, "order.html", {'form': form})
def get_order(request, id):
"""get just one order for display details and modify order"""
form_filter = FilterForm()
order = Order.objects.get(id=id)
if request.method == 'POST':
form = OrderForm(request.POST, instance=order)
if form.is_valid():
form.save()
contains = {
'orders': Order.objects.all(),
'form_filter': form_filter
}
return render(request, 'orders/list_orders.html', contains)
else:
try:
form = OrderForm(instance=order)
except Order.DoesNotExist:
return HttpResponse(status=404)
return render(request, 'orders/order.html', {'formOrder': form})
def artifical_post(request):
""" функция ведет на обработку формы """
order_f = OrderForm(request.POST)
id_status = request.POST['payment_method']
id_status = int(id_status)
s = Status.objects.get(id=id_status)
new_status = order_f.save(commit=False)
new_status.current_status = s
new_status.save()
return redirect('orders_page')
def product_detail(request, product_id):
product = get_object_or_404(Product, pk=product_id)
form = OrderForm(request.POST)
bot = telebot.TeleBot('465058783:AAEJz6kcmZaVx0QPJrt7YGj-3wNXtBzOiXM')
chat_id = '-223188240'
if request.method == "POST":
if form.is_valid():
text = 'Заявка на товар' '\n' + 'имя: ' + request.POST.get('name') + '\n' + 'телфон: ' \
+ request.POST.get('phone') + '\n' + 'товар: ' + product.name
form.save()
return HttpResponseRedirect("?sended=true",
bot.send_message(chat_id, text))
return render(
request, "stock/product__detail.html", {
"product": product,
"form": form,
"sended": request.GET.get("sended", False)
})
def post(self, request):
form = OrderForm(request.POST)
if form.is_valid():
cust_id = request.POST.get("custID")
cust_name = request.POST.get("custName")
dvdid = request.POST.get("dvdID")
dvdtitle = request.POST.get("dvdTitle")
movie_price = request.POST.get("dvd_price")
quantity = request.POST.get("order_quantity")
tprice = request.POST.get("totalprice")
form = Order(customer_id=cust_id,
customer_name=cust_name,
dvd_id=dvdid,
dvd_title=dvdtitle,
items_ordered=quantity,
total_price=tprice)
form.save()
return HttpResponse('order Saved')
else:
print(form.errors)
return HttpResponse('not valid')
def book_order(request, category_slug, slug):
from orders.models import OrderItem
form = OrderForm(request.POST or None)
try:
category = Category.objects.get(slug=category_slug)
product = Product.objects.active().filter(slug=slug, category=category)[0]
except (Category.DoesNotExist, Product.DoesNotExist):
raise Http404
if request.method == "POST" and form.is_valid():
order = form.save()
order_item = OrderItem.objects.create(order=order, product=product)
subject = u"[%s] Новый заказ - %s" % (order.id, product.name)
message = u"""
Имя: %s
Телефон: %s
E-Mail: %s
Книга: %s, %s - %s грн
""" % (
order.full_name,
order.phone, order.email,
product.author,
product.name,
product.price
)
send_mail(subject, message, settings.DEFAULT_FROM,
settings.ORDER_MANAGERS, fail_silently=False)
# send email to customer
subject, _from, _to = CUSTOMER_SUBJECT, settings.DEFAULT_FROM, order.email
text_content = CUSTOMER_MESSAGE_PLAIN % (
product.author,
product.name,
product.price
)
html_content = CUSTOMER_MESSAGE_HTML % (
product.author,
product.name,
product.price
)
msg = EmailMultiAlternatives(subject, text_content, _from, [_to])
msg.attach_alternative(html_content, "text/html")
msg.send()
return HttpResponse(json.dumps({'message': ORDER_POPUP_MESSAGE}),
mimetype="application/json")
data = {
'form': form,
'product': product,
'category': category
}
return render(request, 'book-order.html', data)
def add_order(request):
form = OrderForm(request.POST or None)
orders = Order.objects.all()
if form.is_valid():
order = form.save(commit=False)
order.save()
messages.success(request, "Order placed")
return render(request, 'orders/index.html', {'orders': orders})
return render(request, 'orders/add_order.html', {'form': form})
def post(self, request):
if request.method == "POST":
form = OrderForm(request.POST)
publishable = settings.STRIPE_PUBLISHABLE_KEY
if form.is_valid():
fname = form.cleaned_data['fname']
lname = form.cleaned_data['lname']
email = form.cleaned_data['email']
address = form.cleaned_data['address']
address2 = form.cleaned_data['address2']
postal_code = form.cleaned_data['postal_code']
city = form.cleaned_data['city']
state = form.cleaned_data['state']
country = form.cleaned_data['country']
try:
customer = stripe.Charge.create(
amount=499,
currency="USD",
description=email,
card=form.cleaned_data['stripe_id'],
)
form.save()
redirect('confirmation/')
except:
print("Card Declined")
args = {
'form': form,
'fname': fname,
'lname': lname,
'email': email,
'address': address,
'postal_code': postal_code,
'city': city,
'state': state,
'country': country,
'publishable': publishable
}
return render(request, self.template_name, args)
def new_order(request):
if request.method == 'POST':
orderform = OrderForm(request.POST)
if orderform.is_valid():
order = orderform.save(commit=False)
order.created_by = request.user
order.save()
return HttpResponseRedirect(order.get_absolute_url())
else:
orderform = OrderForm()
return render_to_response('orders/new_order.html',
{'orderform': orderform,},
context_instance=RequestContext(request))
def orders(request):
# Register a new user.
if request.method != 'POST':
# Display blank registration form.
form = OrderForm()
else:
# Process completed form.
form = OrderForm(data=request.POST)
if form.is_valid():
new_user = form.save()
return redirect('/pizza')
context = {'form': form}
return render(request, 'orders/ordering.html', context)
def order_page(request):
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.id = request.id
order.author = request.author
order.number = request.number
order.order_price = request.order_price
order.order_comments = request.order_comments
order.date_and_time_of_order = timezone.now()
order.order_status = request.order_status
order.products_list = request.products_list
order.client = request.client
order.save()
return render(request, "order.html", {'form': form})
def Checkout(request):
try:
carts = myCart.objects.get(user=request.user)
order1 = Order.objects.get(user=request.user)
orders = Order.objects.filter(user=request.user).first()
form = OrderForm(request.POST, instance=order1)
if form.is_valid():
cart = myCart.objects.get(user=request.user)
form.instance.cart = cart
form.save()
context = {'form': form, 'cart': carts, 'orders': orders}
template = "order.html"
return render(request, template, context)
except Order.DoesNotExist:
order = Order.objects.create(user=request.user)
cart = get_object_or_404(myCart, user=request.user)
order1 = Order.objects.get(user=request.user)
form = OrderForm(request.POST, instance=order1)
if form.is_valid():
form.save()
context = {'cart': cart, 'form': form}
template = "order.html"
return render(request, template, context)
return render(request, template, context)
def new_order(request):
c = get_client_context(request)
c['map_center'] = '55.76, 37.64'
c['map_zoom'] = '11'
if request.method == 'GET':
order_form = OrderForm()
elif request.method == 'POST':
order_form = OrderForm(request.POST)
if order_form.is_valid():
o = order_form.save(commit=False)
o.set_created(c['client'])
messages.success(request, u'Ваш заказ успешно добавлен и ожидает оплаты.')
return HttpResponseRedirect('/cabinet/history')
c['order_form'] = order_form
return render_to_response('client/new.html', c, context_instance=RequestContext(request))
def index(req):
if req.method == 'POST':
orderform = OrderForm(req.POST)
if orderform.is_valid():
try:
o = orderform.save()
except IntegrityError as e:
messages.error(req, e)
return HttpResponseRedirect(reverse('orders:index'))
return HttpResponseRedirect(reverse('orders:detail', args=(o.id,)))
else:
orderform = OrderForm()
return render(req,
'orders/index.html', {
'title': 'Coffee Ordering',
'allorders': Order.objects.all(),
'orderform': orderform
}
)
def index(request):
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
order = form.save()
item_ids = request.POST.getlist('items[]')
for item_id in item_ids:
item = Item.objects.get(pk=item_id)
ItemOrder.objects.create(item=item, order=order)
messages.success(request, "Bestelling succesvol doorgegeven!")
return HttpResponseRedirect(reverse('index'))
else:
form = OrderForm()
categories = Category.objects.all().prefetch_related('items__discounts')
total = Item.objects.count()
n = 0
cols = [[], []]
for category in categories:
cols[0 if n < total/2 else 1].append(category)
n += category.items.count()
context = {'cols': cols, 'form': form}
return render(request, 'orders/index.html', context)
