def get_order():
choises = [(type.name, type.name) for type in Type.query.all()]
form = OrderForm(choises)
if form.validate_on_submit():
type = Type.query.filter(Type.name == form.product_type.data).one()
model = form.model.data
product = Product.query.filter(Product.model == model,
Product.type_id == type.id).first()
if product is None:
flash(
'Sorry, we don\'t have such product. Please check input fields'
)
return render_template('order.html', title='Order Page', form=form)
count = int(form.product_count.data)
if product.count < count:
flash(
'Currently we don\'t have so much products. Please choose smaller number'
)
return render_template('order.html', title='Order Page', form=form)
order = Order(customer=current_user,
product=product,
price=product.price * count)
db.session.add(order)
db.session.commit()
flash('You successfully bought {}'.format(order))
return redirect(url_for('get_order'))
# elif request.method == 'GET':
# choises = [(type.name, type.name) for type in Type.query.all()]
# form.product_type.choices = choises
return render_template('order.html', title='Order Page', form=form)
def order():
if request.method == 'GET':
session.clear()
data = db.session.query(Config).first()
if data.state != 'ordering':
return redirect("/")
form = OrderForm(request.form)
if request.method == 'POST' and form.validate():
db.session.rollback()
db.session.expunge_all()
if form.item.data == 'half':
order = Half()
order.email = form.email.data + EMAIL_DOMAIN
order.location = form.location.data
order.topping1 = form.topping1.data
order.topping2 = form.topping2.data
order.topping3 = form.topping3.data
elif form.item.data == 'whole':
order = Pizza()
person = Person()
order.topping1_left = form.topping1.data
order.topping2_left = form.topping2.data
order.topping3_left = form.topping3.data
order.topping1_right = form.topping4.data
order.topping2_right = form.topping5.data
order.topping3_right = form.topping6.data
order.sauce = form.sauce.data
order.size = 'Large'
person.email = form.email.data + EMAIL_DOMAIN
person.location = form.location.data
order.person1 = person
db.session.add(person)
elif form.item.data == 'medium':
order = Pizza()
person = Person()
order.topping1_left = form.topping1.data
order.topping2_left = form.topping2.data
order.topping1_right = form.topping4.data
order.topping2_right = form.topping5.data
order.sauce = form.sauce.data
order.size = 'Medium'
person.email = form.email.data + EMAIL_DOMAIN
person.location = form.location.data
order.person1 = person
db.session.add(person)
order.time_added = datetime.datetime.now()
db.session.add(order)
db.session.flush()
session['order_id'] = order.id
session['order_type'] = type(order).__name__
session['payment_amount'] = set_price(form)
url = 'https://api.venmo.com/v1/oauth/authorize?client_id={}&scope=make_payments&response_type=code'.format(
CONSUMER_ID)
return redirect(url)
return render_template('order.html',
data=data,
form=form,
domain=EMAIL_DOMAIN,
large_price=LARGE_PRICE,
medium_price=MEDIUM_PRICE)
def order():
form = OrderForm()
outputInfo = ''
if current_user.is_authenticated:
if int(current_user.get_id()) is 1:
return redirect(url_for('index'))
con = db.engine.connect()
if form.validate_on_submit():
userid = int(current_user.get_id())
stockNumber = form.stocknumber.data
part = con.execute('SELECT * FROM Part WHERE stocknumber = {0}'.format(stockNumber)).fetchone()
if not part:
outputInfo = 'No part matches the stock number you typed in.'
return render_template('Order.html',Info=outputInfo,title='Order Info',form=form)
else:
originQty = part[4]
if (originQty > 1):
con.execute('UPDATE Part SET quantity = {0} WHERE stocknumber = {1}'.format((originQty-1),stockNumber))
else:
con.execute('DELETE FROM Part WHERE stocknumber = {0}'.format(stockNumber))
sql_section = 'INSERT INTO [Order] (customer_id, part_id) VALUES ({0}, {1})'.format(userid,stockNumber)
con.execute(sql_section)
db.session.commit()
outputInfo = 'Successfully Ordered!'
return render_template('Order.html',Info=outputInfo,title='Order Info',form=form)
return render_template('Order.html',Info=outputInfo,title='Order Info',form=form)
def add_order():
form = OrderForm()
choice = []
# users = User.query.all()
# for u in users:
# label = u.name
# value = u.username
# choice.append((value,label))
# form.buyer.choices = choice
form.update_choices()
if form.validate_on_submit():
order_status = dict(form.order_status.choices).get(
form.order_status.data)
buyer = User.query.filter_by(username=form.buyer.data).first()
order = Orders(amount=form.amount.data,
order_status=order_status,
buyer=buyer)
db.session.add(order)
db.session.commit()
message = "*{}'s* Taobao order of SGD *{}* has been added.".format(
order.buyer.name, order.amount)
#message = '*' + buyer_name + '*' + ' has added a Taobao order of SGD ' + '*' + str(amount) + '*' + ' successfully. \n*Order Status:* ' + status
api_result = sendtelegram(message)
flash("Order added.", "success")
if api_result is True:
flash("Sent telegram message successfully", 'success')
else:
flash("Error sending telegram message", 'danger')
return redirect(url_for('add_order'))
return render_template('add_order.html', form=form)
def cart():
form = OrderForm()
my_cart = session.get('cart', [])
title = f"Блюд в корзине: {len(my_cart)}" if my_cart else "Ваша корзина пуста"
products = [Meal.query.get(product_id) for product_id in my_cart]
total_amount = sum(product.price for product in products)
total_amount_msg = f"Всего товаров на {total_amount} рублей"
if request.method == 'GET' and current_user.is_authenticated:
form.username.data = current_user.username
form.email.data = current_user.email
if current_user.address:
form.address.data = current_user.address
if form.validate_on_submit():
new_order = Order()
new_order.amount = total_amount
new_order.state = OrderState.query.filter(
OrderState.title == 'новый').first()
new_order.user = current_user
db.session.add(new_order)
for item in my_cart:
meal = Meal.query.get(item)
new_order.meals.append(meal)
db.session.commit()
session['cart'] = []
return redirect('/ordered/')
return render_template('cart.html',
form=form,
products=products,
title=title,
total_amount=total_amount_msg)
def order(current_order):
form = OrderForm()
current_order = Order.query.filter_by(id=current_order).first()
if form.validate_on_submit():
current_order.adress = form.adress.data
current_order.phone_number = form.phone.data
db.session.commit()
return redirect(url_for('order_submit'))
return render_template('order.html', form=form)
def add_order():
form = OrderForm()
clients = controllers.find_all_clients()
form.client.choices = [(client.id, client.name) for client in clients]
if form.validate_on_submit():
order = controllers.add_order(form)
return redirect(url_for('order', id=order.id))
else:
return render_template('new_order.html', form=form)
def order():
if request.method == 'GET':
session.clear()
data = db.session.query(Config).first()
if data.state != 'ordering':
return redirect("/")
form = OrderForm(request.form)
if request.method == 'POST' and form.validate():
db.session.rollback()
db.session.expunge_all()
if form.item.data == 'half':
order = Half()
order.email = form.email.data + EMAIL_DOMAIN
order.location = form.location.data
order.topping1 = form.topping1.data
order.topping2 = form.topping2.data
order.topping3 = form.topping3.data
elif form.item.data == 'whole':
order = Pizza()
person = Person()
order.topping1_left = form.topping1.data
order.topping2_left = form.topping2.data
order.topping3_left = form.topping3.data
order.topping1_right = form.topping4.data
order.topping2_right = form.topping5.data
order.topping3_right = form.topping6.data
order.sauce = form.sauce.data
order.size = 'Large'
person.email = form.email.data + EMAIL_DOMAIN
person.location = form.location.data
order.person1 = person
db.session.add(person)
elif form.item.data == 'medium':
order = Pizza()
person = Person()
order.topping1_left = form.topping1.data
order.topping2_left = form.topping2.data
order.topping1_right = form.topping4.data
order.topping2_right = form.topping5.data
order.sauce = form.sauce.data
order.size = 'Medium'
person.email = form.email.data + EMAIL_DOMAIN
person.location = form.location.data
order.person1 = person
db.session.add(person)
order.time_added = datetime.datetime.now()
db.session.add(order)
db.session.flush()
session['order_id'] = order.id
session['order_type'] = type(order).__name__
session['payment_amount'] = set_price(form)
url = 'https://api.venmo.com/v1/oauth/authorize?client_id={}&scope=make_payments&response_type=code'.format(CONSUMER_ID)
return redirect(url)
return render_template('order.html', data=data, form=form, domain=EMAIL_DOMAIN,
large_price=LARGE_PRICE, medium_price=MEDIUM_PRICE)
def edit_order(id):
form = OrderForm()
clients = controllers.find_all_clients()
form.client.choices = [(client.id, client.name) for client in clients]
if form.validate_on_submit():
order = controllers.edit_order(id, form)
return redirect(url_for('order', id=order.id))
elif request.method == 'GET':
order = controllers.find_order(id)
controllers.fill_order_form(order, form)
return render_template('edit_order.html', order=order, form=form)
def new_order():
job_numbers = job_nums()
if request.method == 'GET':
form = OrderForm()
return render_template(
"new_order.html",
form=form,
job_numbers=job_numbers,
)
elif request.method == 'POST':
form = OrderForm()
if form.lookup.data and (not form.submit.data):
if form.JobNumber.data:
job_number = form.JobNumber.data
# TODO: TAKE FIRST
# prepare = Tickets.query.filter(Tickets.JobNumber == job_number).all()
prepare = Tickets.query.filter(Tickets.JobNumber == job_number).first()
if prepare:
form = OrderForm()
form.CustomerName.data = Customer.query.get(prepare.CustomerID).CustomerName
form.JobName.data = Jobs.query.get(prepare.JobID).JobName
form.MapscoLocation.data = prepare.MapscoLocation
form.JobNumber.data = job_number
form.MaterialName.data = Materials.query.get(prepare.MaterialID).MaterialName
return render_template(
"new_order.html",
form=form,
job_numbers=job_numbers,
)
if form.submit.data:
form.lookup.data = True
if form.validate_on_submit:
new = Order(
CustomerName=form.CustomerName.data,
JobName=form.JobName.data,
destination=form.destination.data,
po=form.po.data,
city=form.city.data,
MapscoLocation=form.MapscoLocation.data,
Source=form.Source.data,
JobNumber=form.JobNumber.data,
MaterialName=form.MaterialName.data,
LoadTotal=form.LoadTotal.data,
Status=form.Status.data,
created=form.creation_date.data,
contact=form.contact.data
)
new.save()
return redirect(url_for("main.index"))
else:
flash("Wrong data", "danger")
def cart():
form = OrderForm()
if form.validate_on_submit():
order_service.create_order(form)
return redirect('/ordered')
else:
if request.method == 'GET' and session.get('user'):
form.name.default = session['user']['name']
form.email.default = session['user']['email']
form.address.default = session['user']['address']
form.process()
return render_template('cart.html', form=form, cart=cart_service.get_cart())
def table(id):
form = OrderForm()
if form.validate_on_submit():
french_fries = form.french_fries.data
dr_pepper = form.dr_pepper.data
jambalaya = form.jambalaya.data
order = Order.query.filter(Order.table_id == id).all()
if order:
pass
else:
order = Order()
return render_template("orders.html")
def change(id):
order = Order.query.get(id)
form = OrderForm(obj=order)
if form.validate_on_submit():
order.address = form.address.data
order.phone = form.phone.data
order.text = form.text.data
db.session.add(order)
db.session.commit()
flash('Заказ успешно изменен.')
bot.notify_change(order.client, order.volunteer, order)
return redirect(url_for('.given'))
return render_template('orders_change.html', form=form)
def create():
"""Создание заказа"""
form = OrderForm(obj=current_user)
if form.validate_on_submit():
order = Order(address=form.address.data,
phone=form.phone.data,
client_id=current_user.id,
text=form.text.data)
db.session.add(order)
db.session.commit()
flash('Успешно добавлен/изменён заказ.')
return redirect(url_for('.given'))
return render_template('orders_create.html', form=form)
def add_order():
order_form = OrderForm(request.form)
if order_form.validate_on_submit():
order = Order(title=order_form.title.data,
service=order_form.service.data,
price=order_form.price.data,
status=order_form.status.data,
customer=order_form.customer_id.data)
db_session.add(order)
db_session.commit()
flash('Thanks')
return redirect(url_for('settings'))
return redirect(url_for('settings'))
def new_order(supplierid):
supplier = Supplier.query.filter_by(id=supplierid).first_or_404()
form = OrderForm()
try:
if form.is_submitted():
# when a post is submitted, we first check if all fields are valid
if form.validate():
order = create_order(form, supplier)
if order:
db.session.add(order)
db.session.commit()
app.logger.info('Order "{}" criada com sucesso'.format(
order.id))
return redirect(
url_for('detail_supplier', supplierid=supplier.id))
else:
flash(('A compra não foi registrada porque o valor total '
'dos produtos foi R$0,00!'))
return redirect(
url_for('detail_supplier', supplierid=supplier.id))
else:
# when a field is not valid, we flash a message with the error.
app.logger.error(str(form.errors))
flash("Erro! Detalhes: {}".format(str(form.errors)))
# when the page is loaded, a GET is executed.
# In this case, we only fill table fields.
else:
if len(supplier.portfolio) == 0:
msg = ('O fornecedor "{}"" não tem nenhum produto em seu'
' portfolio. Antes de cadastrar uma compra, você'
' precisa adicionar produtos ao seu portfolio.').format(
supplier.name)
app.logger.info(msg)
flash(msg)
return redirect(
url_for('edit_supplier', supplierid=supplier.id))
for item in supplier.portfolio:
order_item_form = OrderItemForm()
order_item_form.item = item.name
order_item_form.quantity = 0
order_item_form.unit_price = 0
order_item_form.unity = ""
form.order_items.append_entry(order_item_form)
except Exception as err:
db.session.rollback()
app.logger.error(str(err))
flash('ERRO: {}'.format(str(err)))
return render_template('orderform.html',
title="Cadastrar compra",
form=form,
supplier=supplier)
def index():
print(current_user)
tracker = current_user.tracker[0]
form = OrderForm()
form.carrier.choices = [('Maersk Line', 'Maersk Line')]
orders_db = tracker.orders.all()
orders = []
for order in orders_db:
delete = DeleteButton()
delete.order_id.data = order.id
orders.append([order, delete])
if form.validate_on_submit():
tracker.create_order(form.orderName.data, form.po.data,
form.container.data, form.carrier.data,
form.dueDate.data)
return redirect(url_for('index'))
for order in orders:
a = request.form
b = dict(a)
print(b)
if "submit" in b and "order_id" in b:
print(order[0].id)
print(b["order_id"])
if order[1].is_submitted() and b["submit"] == ['Delete Order']:
qry = Order.query.get(int(b["order_id"][0]))
db.session.delete(qry)
db.session.commit()
orders_db = tracker.orders.all()
orders = []
for order in orders_db:
delete = DeleteButton()
delete.order_id.data = order.id
orders.append([order, delete])
return render_template('index.html',
title='Hello World',
orders=orders,
form=form)
return render_template('index.html',
title='Hello World',
orders=orders,
form=form)
def order():
form = OrderForm()
if form.validate_on_submit():
new_order = Order(address=form.address.data,
latlon=','.join([form.lat.data, form.lng.data]),
lat=float(form.lat.data),
lng=float(form.lng.data),
load=form.load.data)
db.session.add(new_order)
db.session.commit()
flash('Order added')
return redirect(url_for('index'))
return render_template('order.html', title='Orders', form=form)
def orders():
form = OrderForm()
shop_session = sfy.Session(session['shop_url'], '2019-04', session['token'])
# activate the shopify session to use resources.
sfy.ShopifyResource.activate_session(shop_session)
if request.method == 'POST':
if form.validate_on_submit():
generate_orders(form.number_of_orders_field.data,\
form.number_of_line_items_field.data,\
form.max_qty_sold_field.data,\
form.start_date.data,\
form.end_date.data,\
session['shop_url'],\
session['token'])
return render_template('orders.html', form=form)
def cart():
if "cart" not in session:
session["cart"] = []
items = session["cart"]
dict_of_products = {}
total_price = 0
for item in items:
product = Products.query.filter_by(id=item['id']).first_or_404()
price = product.price * int(item['quantity'])
total_price += price
if product.id in dict_of_products.keys():
dict_of_products[product.id]["quantity"] += int(item['quantity'])
else:
dict_of_products[product.id] = {"quantity":int(item['quantity']),
"name": product.product_name,
"price":int(product.price),
"image":product.profile_photo}
form = OrderForm()
if "order" not in session:
session["order"] = []
session.modified = True
session["order"] = dict_of_products
return render_template("cart.html", display_cart=dict_of_products, form=form, total=total_price, title='Shopping Cart')
def product(id):
login_form = is_auth()
post_product = Product.query.get(id)
item_packs = post_product.item_packs.order_by(ItemPack.status,
ItemPack.id).all()
items = []
if post_product.type_id == 1: # товар типа ростовка
order_form = None
for item_pack in item_packs: #Сортировка итемов по возрастанию id
i = item_pack.items.order_by(Items.id).all()
items.append(i)
else: #товар типа "минимальное количество"
item_packs = ItemPack.query.filter_by(id_product=id).order_by(
ItemPack.status).first()
item_packs.get_product_busy_items()
item_packs.get_percent_items_goal()
order_form = OrderForm()
if current_user.is_authenticated:
current_user.ordered_items(id, current_user.id)
categories = Category.query.all()
return render_template("post.html",
title=post_product.name,
product=post_product,
item_packs=item_packs,
items=items,
login_form=login_form,
order_form=order_form,
categories=categories)
def index():
tables = list(Table.query.options(joinedload(Table.orders)).all())
menu_items = list(MenuItem.query.options(joinedload(MenuItem.type)).all())
form = OrderForm()
return render_template("orders.html",
tables=tables,
menu=menu_items,
form=form)
def order_create(request):
try:
cart_id = request.session['cart_id']
cart = Cart.objects.get(id=cart_id)
request.session['total'] = cart.items.count()
except:
cart = Cart()
cart.save()
cart_id = cart.id
request.session['cart_id'] = cart_id
cart = Cart.objects.get(id=cart_id)
form = OrderForm(request.POST)
if form.is_valid():
new_order = Order()
new_order.user = request.user
new_order.save()
context = {'form': form}
return render(request, 'order.html', context)
def order():
form = OrderForm()
if form.validate_on_submit():
address = request.form.get('autocomplete')
geocode_result = gmaps.geocode(address)[0]['geometry']['location']
latlon = str(geocode_result['lat'])+','+str(geocode_result['lng'])
order = Order(address = address, latlon=latlon, load=form.load.data)
db.session.add(order)
db.session.commit()
flash('order added')
return redirect(url_for('index'))
return render_template('order.html', title='Orders', form=form)
def book(request):
token = request.session['user']['token']
user_response = api_get_user(request.session['user']['email'], token)
gas_choices_response = api_get_gas(request.session['user']['token'])
if user_response.ok and gas_choices_response.ok:
user = user_response.json()
if not user['address_set']:
messages.warning(request, 'Vous devez créer une adresse.')
return HttpResponseRedirect(reverse('create_address'))
if not user['vehicle_set']:
messages.warning(request, 'Vous devez ajouter un véhicule.')
return HttpResponseRedirect(reverse('create_vehicle'))
gas_choices = gas_choices_response.json()
if request.method == 'POST':
form = OrderForm(request.POST, user['address_set'], user['vehicle_set'], gas_choices)
if form.is_valid():
data = form.cleaned_data
if int(data['date_refill'].month) > int(date.today().month) + settings.CALENDAR['months_visibilty']:
return render(request, 'book.html', {
'form': form, 'errors': 'Date invalide'
})
data['user'] = request.session['user']['id']
data['date_refill'] = str(data['date_refill'])
for gas_choice in gas_choices:
if data['gas_name'] == gas_choice['name']:
data.update({'gas_price': gas_choice['price']})
break
order_response = api_order_validate(data, request.session['user']['token'])
if order_response.ok:
request.session['order'] = order_response.json()
request.session['payment'] = True
return HttpResponseRedirect(reverse('payment'))
return render(request, 'book.html', {
'form': form, 'errors': order_response.json()['errors']
})
form = OrderForm(None, user['address_set'], user['vehicle_set'], gas_choices)
return render(request, "book.html", {
'user': user,
'form': form,
})
return HttpResponseRedirect(reverse('logout'))
def submit():
form = OrderForm()
for error in form.errors.items():
print(error)
import sys
sys.stdout.flush()
if request.method == "POST" and form.validate():
email = form.email.data
if validate_email(email):
import sys
sys.stdout.flush()
user = User.get_or_create(email)
orders = request.get_json()["order"]
orders = [
Order(user, order["id"], order["in_half"], order["notes"])
for order in orders
]
place_order(email, orders)
return jsonify({"success": True})
return jsonify({"success": False})
def edit_order(orderid):
order = Order.query.filter_by(id=orderid).first_or_404()
supplier = Supplier.query.filter_by(id=order.supplier_id).first_or_404()
form = OrderForm(obj=order)
try:
if form.is_submitted():
# when a post is submitted, we first check if all fields are valid
if form.validate():
order = create_order(form, supplier, order)
if order:
db.session.commit()
app.logger.info('Order "{}" editada com sucesso'.format(
order.id))
return redirect(
url_for('detail_supplier', supplierid=supplier.id))
else:
flash(('A compra não foi alterada porque o valor total '
'dos produtos foi R$0,00!'))
return redirect(
url_for('detail_supplier', supplierid=supplier.id))
else:
# when a field is not valid, we flash a message with the error.
app.logger.error(str(form.errors))
flash('Erro! Detalhes: {}'.format(str(form.errors)))
else:
for item in supplier.portfolio:
if not order.has_item(item):
order_item_form = OrderItemForm()
order_item_form.item = item.name
order_item_form.quantity = 0
order_item_form.unit_price = 0
order_item_form.unity = ""
form.order_items.append_entry(order_item_form)
except Exception as err:
db.session.rollback()
app.logger.error(str(err))
flash('ERRO: {}'.format(str(err)))
return render_template('orderform.html',
title="Editar compra",
form=form,
supplier=supplier)
def make_order(dishname):
dish = Dish.query.filter_by(dish_name=dishname).first_or_404()
form = OrderForm()
if form.validate_on_submit():
order = Order(quantity=form.quantity.data,
status="ongoing",
dish=dish,
buyer=current_user)
dish.current_order_number += 1
db.session.add(order)
notice = "Dear chef %s, you have a new order made by user %s for your dish %s." % (
dish.seller.username, current_user.username, dish.dish_name)
msg = Message(author=None, recipient=dish.seller, body=notice)
db.session.add(msg)
dish.seller.add_notification('unread_message_count',
dish.seller.new_messages())
db.session.commit()
flash('Your order is successful!')
return redirect(url_for('index'))
return render_template('order.html', dish=dish, form=form)
def group_order(gid):
form = OrderForm()
if form.validate_on_submit():
order = Orders(username=form.username.data,
groupId=gid,
orderName=form.orderName.data,
quantity=form.quantity.data,
size=form.size.data)
db.session.add(order)
db.session.commit()
order_details = Grouporder.query.get(gid)
total_friends_expected = order_details.n_friends
order_till_now = Orders.query.filter_by(groupId=gid)
if total_friends_expected == order_till_now.count():
email_to_list = [order_details.username]
email_from = '*****@*****.**'
email.send_email(
email_from, email_to_list, "Order status ",
render_template('returnStatus.html', order=order_till_now))
flash('Your order placed Successfully {}'.format(form.username.data))
return redirect('/index')
return render_template('orderForm.html', form=form)
def create_order():
"""
Creates an order.
"""
form = OrderForm()
print(request.get_json())
# Get the csrf_token from the request cookie and put it into the
# form manually to validate_on_submit can be used
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
virtual_bool = form.data['virtual'] == "True"
order = Order(nonprofit_id=form.data['nonprofit_id'],
title=form.data['title'],
description=form.data['description'],
location=form.data['location'],
start_time=form.data['start_time'],
duration=form.data['duration'],
karma=form.data['karma'],
virtual=virtual_bool)
db.session.add(order)
db.session.commit()
return order.to_dict()
return 'invalid form'
def order(request):
form = OrderForm(request.POST or None)
cart = get_cart(request)
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']
new_order = Order(user=request.user,
first_name=name,
last_name=last_name,
phone=phone,
address=address,
comments=comments,
total_price=cart.cart_total)
new_order.user = request.user
new_order.save()
new_order.items.add(*cart.items.all())
Cart.objects.get(id=int(request.session['cart_id'])).delete()
del request.session['cart_id']
email_list = []
for user in User.objects.filter(is_superuser=True):
email_list.append(user.email)
send_mail(
'Нове замовлення',
'До вас прийшло нове замовлення. Його деталі зможете перглянути в адмінці',
'*****@*****.**',
[email_list],
)
return HttpResponseRedirect('/thank_you')
return render(request, 'order.html', {
'form': form,
})
def order():
"""
Create an ORDER form
After ORDER form is submitted, create it in the database
Next, loop over cart and make a CartItem for each item.
This will create an Order that contains many order items
You can then access an Order and query the CartItems directly.
On successful completion of an order, flash a success message
"""
form = OrderForm()
products = []
if session['cart']:
for key, value in session['cart'].items():
product = Product.query.filter_by(id=key).first()
products.append({
'id': key,
'item': product.name,
'quantity': value['quantity'],
'price': product.price,
'subtotal': (product.price * value['quantity']),
'image_url': product.image_url
})
if form.validate_on_submit():
order = Order(first_name=form.data['first_name'],
last_name=form.data['last_name'],
email=form.data['email'],
address=form.data['address'],
postal_code=form.data['postal_code'],
city=form.data['city'])
order.save()
return redirect(url_for('order_confirm', id=order.id))
return render_template('order.html', form=form, products=products)
def post(self, request):
order_form = OrderForm(request.POST)
order_form.save()
to = ['*****@*****.**']
subject = request.POST.get('subject', '')
details = request.POST.get('message', '')
email = request.POST.get('email', '')
phone = request.POST.get('phone')
name = request.POST.get('name')
ctx = {'name': name,
'phone': phone,
'email': email,
'details': details,
}
if subject and details and email:
try:
message = render_to_string('emails/webenquiry.txt', ctx)
EmailMessage(subject, message, to=to).send()
return HttpResponseRedirect('thankyou')
except BadHeaderError:
return HttpResponse('Invalid header found.')
