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 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,
})
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 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 car_detail(request, car_id):
car = get_object_or_404(Car, id=car_id)
form = OrderForm(request.POST or None, initial={"car": car})
if request.method == "POST":
if form.is_valid():
form = OrderForm(request.POST)
name = request.POST.get('name', '')
carid = request.POST.get('car', '')
telephone = request.POST.get('phone', '')
autos = int(carid)
idauto = Car.objects.all()[autos].idauto
model = Car.objects.all()[autos].modelcar
complectation = Car.objects.all()[autos].complectation
engine = Car.objects.all()[autos].engine
power = Car.objects.all()[autos].power
kpp = Car.objects.all()[autos].kpp
color = Car.objects.all()[autos].color
oldprice = Car.objects.all()[autos].oldprice
newprice = Car.objects.all()[autos].newprice
subject = 'Заявка с сайта "Лайфхак SKODA"'
from_email = settings.EMAIL_HOST_USER
message = '''
На сайте "SKODA Лайфхак" появилась новая заявка на автомобиль!
_____________________________________________________________
АВТОМОБИЛЬ:
ID автомобиля: {0}
ŠKODA {1} {2} | {3}, {4} | {5} | {6}
Цена без скидки: {7} руб.
Цена со скидкой: {8} руб.
_____________________________________________________________
КЛИЕНТ:
Имя клиента: {9}
Телефон клиента: {10}'''.format(idauto, model, complectation, engine, power,
kpp, color, oldprice, newprice, name,
telephone)
recipient_list = Mail.objects.all()
messages = [(subject, message, from_email, [recipient])
for recipient in recipient_list]
send_mass_mail(messages)
return HttpResponseRedirect("{}?sended=True".format(
reverse("car", kwargs={"car_id": car.id})))
return render(request, "cars/car_detail.html", {
"car": car,
"form": form,
"sended": request.GET.get("sended", False)
})
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 order(req, article_id=0):
if req.user.has_perm('orders.can_order'):
choice_filter = {'day__gte': date.today() - timedelta(days=1)}
else:
choice_filter = {'day__gt': date.today()}
if req.method == 'POST':
form = OrderForm(req.POST)
form.fields['oday'].choices = h.get_oday_choices(choice_filter)
if form.is_valid():
cleaned = form.cleaned_data
company = Company.objects.get(id=cleaned['art_supplier_id'])
costs = h.get_costs(req.POST)
art, created = h.search_article(
cleaned['art_id'].strip(),
cleaned['art_name'], cleaned['art_q'], company
)
art.tax = int(req.POST.get('tax', '19'))
if created:
art.tox_control = cleaned['tox']
art.save()
_price = h.get_price(cleaned['art_price'])
if _price and art.price != _price:
art.price = _price
art.save()
order = Order.objects.create(
count=cleaned['count'], article=art,
order_day=OrderDay.objects.get(id=int(cleaned['oday']))
)
order.save()
for cost, percent in costs:
co = CostOrder.objects.create(percent=percent, order=order,
cost=cost)
co.save()
order.memo = cleaned['memo']
order.for_test = cleaned['exam']
order.for_repair = cleaned['repair']
order.users.add(req.user)
order.save()
# Add orderer to rating_users
if req.user.id not in [x.id for x in company.rating_users.all()]:
company.rating_users.add(req.user)
company.save()
messages.success(req, u'Sie wurden als Bewerter für %s '
u'hinzugefügt.' % company.name)
messages.success(req, u'Ihre Bestellung %s wurde gespeichert.'
% order)
return redirect('orders-detail', order_id=order.order_day.id)
messages.error(req, u'Bitte füllen Sie die benötigten Felder aus.')
else:
form = OrderForm()
form.fields['oday'].choices = h.get_oday_choices(choice_filter)
costs = Cost.objects.all().order_by('ident')
ctx = dict(
page_title=_(u'New Order'), form=form, menus=menus, costs=costs,
article_id=article_id, costs_msg=_(u'Sum of costs must be 100!'),
cur_msg=u'Preis in %s.' % settings.CURRENCY[0], extra=False,
need_ajax=True
)
return render(req, 'orders/order.html', ctx, app=u'orders')
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 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 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 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 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 test_require_amount(self):
# TODO: move to model test
form_data = {
"product": self.product.id,
"team": self.team.id,
"state": "REQ",
"unit_price": 10.00,
}
form = OrderForm(data=form_data, teams=Team.objects.all())
self.assertFalse(form.is_valid())
form_data["amount"] = 1
form = OrderForm(data=form_data, teams=Team.objects.all())
self.assertTrue(form.is_valid())
def process_form(request, order=None, creating_new=False):
"""
Called for generating the form initially, and processing it when submitted. Used by both the
main index page (for new orders), and the order details page (for changing an order).
"""
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
share_button = """<p>
<div class="fb-share-button" data-href="http://www.morningshade.farm/"
data-layout="button" data-size="large">
<a target="_blank" href="https://www.facebook.com/sharer/sharer.php?u=http%3A%2F%2Fwww.morningshade.farm%2F&src=sdkpreparse" class="fb-xfbml-parse-ignore">Share</a>
</div>
"""
msg = 'Your order for {} pounds of blueberries for ${} has been received. You can ' \
'pick them up from {} on {} at Morning Shade Farm.'.format(
order.quantity, order.total_cost, order.pretty_time, order.pretty_date
)
if order.quantity >= 200:
msg += " If you have additional requests, please add comments to your order or call us."
if creating_new:
msg += " You can <a href={}>see, update, and cancel your order here</a>.".format(
reverse('order_detail', args=[order.id]))
msg += share_button
messages.success(request, mark_safe(msg))
if creating_new:
email_new_order_info(request, order)
return HttpResponseRedirect(request.META['HTTP_REFERER'])
else:
# The bootstrap inline form displays global errors automatically, so we will remove
# them here. Other errors it does not display, so we need to add a message to the
# page with those.
non_global_errors = copy.copy(form.errors)
if "__all__" in non_global_errors:
del(non_global_errors["__all__"])
if non_global_errors:
msg = mark_safe("The form has errors: {}".format(non_global_errors))
messages.add_message(request, messages.constants.ERROR, msg, extra_tags='danger')
else:
form = OrderForm(instance=order)
return form
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 order(request):
if request.method == 'POST':
user = request.user
form = OrderForm(user, request.POST)
if form.is_valid():
user.profile.full_name = form.cleaned_data['full_name']
user.profile.phone = form.cleaned_data['phone']
user.profile.postcode = form.cleaned_data['postcode']
user.profile.region = form.cleaned_data['region']
user.profile.locality = form.cleaned_data['locality']
user.profile.street = form.cleaned_data['street']
user.profile.house_nmb = form.cleaned_data['house_nmb']
user.profile.apartment_nmb = form.cleaned_data['apartment_nmb']
user.save()
else:
return redirect('cart')
dandp = DandP(request)
delivery_id = int(dandp.dandp['delivery']) + 1
payment_id = int(dandp.dandp['payment']) + 1
delivery = Delivery.objects.get(id=delivery_id)
payment = Payment.objects.get(id=payment_id)
context = {
'delivery': delivery,
'payment': payment,
}
return render(request, 'orders/order.html', context)
def test_customer_excludes_providers(self):
"""Providers should be excluded from dropdown."""
form = OrderForm()
Customer.objects.create(name='Provider', phone=5, cp=1, provider=True)
self.assertEqual(len(form.fields['customer'].choices), 2)
for customer in form.fields['customer'].choices:
self.assertNotEqual(customer[1], 'express')
def test_avoid_duplicates(self):
"""Test to avoid duplicates."""
order = Order.objects.create(
user=User.objects.all()[0],
customer=Customer.objects.all()[0],
ref_name='Duplicate test',
delivery=date(2018, 1, 1),
priority='2',
waist=10,
chest=20,
hip=30,
lenght=40,
others='Duplicate order',
budget=100,
prepaid=100,
)
self.assertTrue(Order.objects.get(ref_name='Duplicate test'))
duplicated_order = OrderForm({
'customer': order.customer.pk,
'ref_name': order.ref_name,
'delivery': order.delivery,
'waist': order.waist,
'chest': order.chest,
'hip': order.hip,
'priority': order.priority,
'lenght': order.lenght,
'others': order.others,
'budget': order.budget,
'prepaid': order.prepaid,
})
self.assertFalse(duplicated_order.is_valid())
self.assertEqual(duplicated_order.errors['__all__'][0],
'The order already exists in the db')
def get(self, request):
cart = Cart(request)
# if not cart.delivery['price']:
# messages.error(request, 'Неверный почтовый индекс')
user = request.user
initial = cart.delivery
if user.is_authenticated:
initial = {
'method': cart.delivery['method'],
'price': cart.delivery['price'],
# 'postcode': cart.delivery['postcode'] or user.postcode,
'country': cart.delivery['country'] or user.country,
'region': cart.delivery['region'] or user.region,
'city': cart.delivery['city'] or user.city,
'micro_district': cart.delivery['micro_district']
or user.micro_district,
'street': cart.delivery['street'] or user.street,
'house_nmb': cart.delivery['house_nmb'] or user.house_nmb,
'building_nmb': cart.delivery['building_nmb']
or user.building_nmb,
'room_nmb': cart.delivery['room_nmb'] or user.room_nmb,
'phone': cart.delivery['phone'] or user.phone,
'full_name': cart.delivery['full_name'] or user.full_name,
'email': cart.delivery['email'] or user.email,
}
order_form = OrderForm(initial=initial)
context = {
'order_form': order_form,
}
return render(request, 'orders/cart.html', context)
def get(self, request):
index = Index.objects.first()
first_slide = index.slides.first()
products = Product.objects.filter(is_active=True)[:3]
order_form = OrderForm()
feedback_form = FeedBackForm()
news = News.objects.filter(is_active=True)[:4]
addresses = Address.objects.all()
phones = Phone.objects.all()
emails = Email.objects.all()
map_code = MapCode.objects.first()
context = {
'index': index,
'first_slide': first_slide,
'products': products,
'order_form': order_form,
'feedback_form': feedback_form,
'news': news,
'addresses': addresses,
'phones': phones,
'emails': emails,
'map_code': map_code,
}
return render(request, 'core/index.html', 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 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 contact_info(request):
cart = Cart(request)
if len(cart) != 0:
if request.method == 'POST':
dandp = DandP(request)
delivery = request.POST.get('delivery')
payment = request.POST.get('payment')
if delivery == 0:
dandp.dandp['delivery'] = 0
if delivery == 1:
dandp.dandp['delivery'] = 1
if payment == 0:
dandp.dandp['payment'] = 0
if payment == 1:
dandp.dandp['payment'] = 1
dandp.update(delivery, payment)
else:
return redirect('cart')
form = OrderForm(request.user)
context = {
'form': form,
}
return render(request, 'orders/contact_info.html', context)
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 meal_details(request, id, slug):
meal = get_object_or_404(Meal, id=id, slug=slug)
form = OrderForm()
context = {
'meal': meal,
'form': form,
}
return render(request, 'meals/details.html', context)
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,
})
def create_order(request):
cart = Cart(request)
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
order = form.save()
for item in cart:
OrderItem.objects.create(order=order,
book=item['book'],
price=item['price'],
quantity=item['quantity'])
cart.clear()
context = {'order': order}
return render(request, 'orders/order_created.html', context)
else:
form = OrderForm()
context = {'form': form, 'cart': cart}
return render(request, 'orders/create_order.html', context)
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')
