def new_order(request):
order_id = OrderModel.objects.last()
print order_id.id
bot = ('https://api.telegram.org/bot120000427:AAGVzPumYWYHJAx_EtBS3KehPA2r-_5Fxwg/sendMessage')
data_chat = {'chat_id': -20063683, 'text': 'new order created. order id is --> %s' % order_id.id}
user_credentials = {}
info_basket = basket_info(request)
if request.method == 'POST': # якщо метод з форми є POST тоді наступне
name_form = OrderForm(request.POST) # свторюємо PostForm з даними з форми
if name_form.is_valid(): # валідація
data = name_form.cleaned_data
post = name_form.save(commit=False) # відтермінування збереження форми комміт=фолс
post.save() # saving and redirecting
# name_form.save_m2m()
info_basket[0].delete()
send_order_email(post.id, prefix='send_order_email')
requests.post(bot, data_chat)
return HttpResponseRedirect('/thanks')
else:
name_form = OrderForm()
return render(request, 'orders/orders.html',
{'full_price': info_basket[1], 'user_info': name_form, 'basket': info_basket,
'user_credentials': user_credentials})
def show_the_cart():
cart_info = get_right_cart_end()
cart = session.get("cart", [])
dishes_for_buy = []
for d in cart:
dishes_for_buy.append(db.session.query(Dish).get(d))
if request.method == "POST":
form = OrderForm()
if form.validate_on_submit():
dishes_ids = session['cart']
date = datetime.datetime.today()
user = db.session.query(User).get(session['user']['user_id'])
user.address = form.address.data
user.name = form.username.data
order = Order(final_price=form.price.data,
date=date,
buyer_id=user.u_id)
for ident in dishes_ids:
dish = db.session.query(Dish).get(ident)
order.dishes.append(dish)
db.session.add(order, user)
db.session.commit()
session.pop('cart')
return redirect('/ordered/')
return render_template('cart.html',
cart_info=cart_info,
form=form,
dishes=dishes_for_buy)
form = OrderForm(price=cart_info[1])
return render_template('cart.html',
cart_info=cart_info,
form=form,
dishes=dishes_for_buy)
def order(request): # создание заказа
if request.method == 'POST':
raw_data = OrderForm(request.POST)
if raw_data.is_valid():
data = raw_data.cleaned_data
order = Orders.objects.create(**data)
if check_time() == 'notify':
send_email('admin', order)
context = {'message': u'Заказ успешно добавлен'}
return render(request, 'order_success.html', context)
else:
context = {'message': u'Ощибка. Вы ввели неверные данные'}
return render(request, 'order_success.html', context)
else:
order_f = OrderForm()
message = ''
disable_submit = False
if check_time() == 'stop':
message = u'Время приема заказов истекло. Ваш заказ не будет принят.'
disable_submit = True # блокируем кнопку отправки заказа
for field in order_f.fields:
order_f.fields[field].widget.attrs['disabled'] = True
context = {'order_add_form': order_f, 'message': message, 'disable_submit': disable_submit}
return render(request, 'order_add_form.html', context)
def new_order():
received = request.get_json()
form = OrderForm(data=received)
if form.validate():
customer_id = int(received['customer_id'])
order = Order(customer_id=customer_id)
for product_id in received['products']:
product = Product.query.get(product_id)
order.products.append(product)
order.save()
success = {"message" : "success"}
return make_response(jsonify(success), 201)
if form.errors:
validation_err = []
for entry in form.errors:
validation_err.append({"message": "incorrect value: < {0} : {1} >".format(entry, received[entry])})
return make_response(jsonify(validation_err), 400)
# Something went really bad
err = {"message": "internal server error"}
return make_response(jsonify(err), 500)
def cart():
form = OrderForm()
cart_list_id = session.get('dish', [])
dish_list = []
for dish_id in cart_list_id:
dish_list.append(db.session.query(Dish).get(dish_id))
flag_del = session.get('flag_dish_del', False)
if flag_del:
session['flag_dish_del'] = False
flag_login = session.get('login', False)
if form.validate_on_submit():
return redirect('/ordered/')
client_data = [
session.get('client_name', ''),
session.get('client_address', ''),
session.get('client_email', ''),
session.get('client_phone', '')
]
return render_template('cart.html',
count_cart=count_dish_nav(),
form=form,
dish_list=dish_list,
flag_del=flag_del,
flag_login=flag_login,
client_data=client_data)
def cart():
user = User()
if session.get('user_id'):
user = User.query.filter_by(id=int(session.get('user_id'))).first()
else:
flash(
Markup(
"Чтобы сделать заказ – <a href='/login/'>войдите</a> или <a "
"href='/register/'>зарегистрируйтесь</a>"), 'warning')
form = OrderForm()
if form.validate_on_submit():
ids = list(map(int, session.get('cart', {}).keys()))
meals = db.session.query(Meal).filter(Meal.id.in_(ids)).all()
order = Order(date=date.today(), mail=form.email.data, user_id=user.id)
for meal in meals:
order.meals.append(meal)
db.session.add(order)
db.session.commit()
flash("Заказ был успешно сделан!", 'success')
session['cart'] = {}
return render_template("ordered.html")
if form.errors:
flash("{}".format(form.errors), 'danger')
return render_template("cart.html",
form=form,
cart=session.get("cart", {}),
user=user)
def prepare_payment(request):
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
product = Clothes.objects.get(id=request.POST['product_id'])
order = Order(
buyer_id = request.user.id,
address = form.cleaned_data['address'],
phone = form.cleaned_data['phone'],
email = request.user.email,
amount = product.price,
create_date = datetime.now(),
payment_system = '11'
)
order.save()
order.products.add(product)
order.save()
return HttpResponse(prepare_order('11', order.id, order.amount, order.phone, order.email))
else:
raise Http404
variables = RequestContext(request, {
'form': form,
'product': Clothes.objects.get(id=request.POST['product_id']),
})
return render_to_response(
'prepare_order.html',
variables
)
def order(request):
cookie_order = unquote(request.COOKIES.get("order", "{}"))
order_items = json.loads(cookie_order)
order_products = Product.objects.filter(id__in=order_items.keys())
if request.method == "POST":
form = OrderForm(request.POST)
response = HttpResponseRedirect("/order")
if form.is_valid():
try:
order=form.save(commit=False)
order.save()
ocs = []
total = 0;
for product in order_products:
oc = OrderCount(product=product, order=order, count=int(order_items[u"%d" % product.pk]['order_num'])*product.load)
oc.save()
oc.summ = order_items[u"%d" % product.pk]['order_summ']
total += oc.summ
ocs.append(oc)
message = render_to_string('order_email.txt', {"products": ocs, "order": order, "total": total})
send_to = [manager[1] for manager in settings.MANAGERS]
email = EmailMessage(u'Заказ на сайте', message, 'temp <*****@*****.**>', to=send_to)
email.send()
messages.success(request, u'Ваша заявка отправлена специалистам компании.')
response.delete_cookie("order")
except :
messages.error(request, u'При отправке заявки произошла ошибка. Пожалуйста, повторите попытку позднее.')
return response
else:
form = OrderForm()
return {'form':form, "products": order_products, "p": Page.objects.get(url="order")}
def order(request):
if request.method == "POST":
order_form = OrderForm(request.POST, request.FILES)
if order_form.is_valid():
body = "Details of the order:"
body = body + "\nName: " + order_form.cleaned_data['name']
body = body + "\nCollege: " + order_form.cleaned_data['college']
body = body + "\nContact No: " + str(order_form.cleaned_data['mobile_no'])
body = body + "\nE-Mail: " + order_form.cleaned_data['email']
#body = body + "\nArchive order present: " + order_form.cleaned_data['archive']
body = body + "\nProduct ID: " + order_form.cleaned_data['pid']
#body = body + "\nOwn choice present: " + order_form.cleaned_data['choice']
body = body + "\n End of Order details."
attachments = []
if order_form.cleaned_data['choice'] == True:
f = order_form.cleaned_data.get('f')
#image = ImageFile(f)
attachments.append((str(f.name),f.read()))
mail.send_mail(sender="Order Daemon <*****@*****.**>",
to="Imposter <*****@*****.**>",
subject="New Order placed",
body=body,attachments=attachments)
return render_to_response("success.html", locals(), context_instance=RequestContext(request))
else:
order_form = OrderForm()
return render_to_response("order.html", locals(), context_instance=RequestContext(request))
def new_order(request):
if request.method == "POST":
form = OrderForm(request.POST)
if form.is_valid():
data = form.cleaned_data
meal = data['meal']
person = data['person']
email = data['email']
byn = data['byn']
byr = data['byr']
comment = data['comment']
if byn is None and byr is None:
return HttpResponse("мы работаем только по предоплате")
d_now = datetime.datetime.now().time()
d1 = datetime.time(hour=13)
d2 = datetime.time(hour=15)
if d1 <= d_now <= d2:
mail_admins(u'заказ', u'получен новый заказ')
Order.objects.create(meal=meal, person=person, email=email, byn=byn, byr=byr, comment=comment)
return redirect(go_main)
data = form.errors
return HttpResponse("{0}".format(data))
else:
d_now = datetime.datetime.now().time()
d1 = datetime.time(hour=15)
if d1 < d_now:
context = {'my_form': OrderForm(), 'state':'off'}
else:
context = {'my_form':OrderForm()}
return render(request, 'new_order_page.html', context)
def New(request):
try:
if CheckAccess(request,'2') != 'OK':
return render_to_response("tmc/notaccess/tmc.html")
except:
return HttpResponseRedirect('/')
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
tmc = form.cleaned_data['tmc']
project = form.cleaned_data['project']
executor = form.cleaned_data['executor']
r = NewOrder(tmc,project,GetUserKod(request),executor)
if r == 'OK':
return HttpResponseRedirect('/tmcorderlist')
form = OrderForm(None)
c = RequestContext(request,{'form':form})
c.update(csrf(request))
return render_to_response("tmc/ordernew.html",c)
def new_order(request, pk):
template = 'pos/new_order.html'
form = OrderForm(request.POST or None)
if request.method == 'POST':
if form.is_valid():
table_order = Order.objects.filter(table=pk)
latest = table_order.latest('created')
if latest.paid == True:
order = Order()
else:
order = latest
order.number = Order.objects.count() + 1
order.table = Table.objects.get(number=pk)
order.paid = False
order.save()
orderitem = OrderItem()
product = form.cleaned_data.get('product')
orderitem.product = Product.objects.get(title=product)
orderitem.order = order
orderitem.table = Table.objects.get(number=pk)
orderitem.quantity = form.cleaned_data.get('quantity')
orderitem.total_price = orderitem.quantity * orderitem.product.unit_price
orderitem.discount = form.cleaned_data.get('discount')
orderitem.notes = form.cleaned_data.get('notes')
orderitem.save()
return redirect('/table/' + pk)
context = {'form': form}
return render(request, template, context)
def api_orders():
form = OrderForm()
if form.is_submitted():
result = request.form
orders_dict['id'] = result['id']
orders_dict['order_text'] = result['order_text']
return redirect(url_for('apiget', action="all"))
return render_template('orders.html', form=form)
def create_order(request):
if request.method == "POST":
from forms import OrderForm
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.creator = request.user
order.save()
def addorder(request, article_id):
if request.POST:
form = OrderForm(request.POST)
if form.is_valid():
order = form.save(commit=False)
order.order_title=str(datetime.now())
order.order_article=Article.objects.get(id=article_id)
form.save()
return redirect('articles/get/%s/' % article_id)
def detail(menu_item_name):
form = OrderForm()
form.side.choices= [(s.id, s.name) for s in\
MenuItems.query.filter_by(category='side').all()]
menu_item = MenuItems.query.filter_by(name=menu_item_name).first_or_404()
if form.validate_on_submit():
add_to_order(menu_item.id)
return render_template('customer/detail.html', title="Dave's Bread - " + menu_item.name,
menu_item=menu_item, form=form, user=current_user)
def orders(form: OrderForm = None) -> str:
"Generate general order view"
if form is None and not current_user.is_anonymous():
form = OrderForm()
location_id = request.args.get("location_id")
form.location_id.default = location_id
form.process()
form.populate()
return render_template("orders.html", orders=get_orders(), form=form)
def create_order(request):
form=OrderForm(request.POST or None)
if form.is_valid():
order=form.save()
for item in request.session['cart'].items:
item.order=order
item.save()
clean_cart(request)
# return store_view(request)
return render_to_response("create_order.html",locals(),context_instance=RequestContext(request))
def market(request):
if request.user.id:
if request.POST:
form = OrderForm(request.POST)
if form.is_valid():
form.save()
return redirect('market_success')
return map(request, template='b2c/market.html')
else:
return render(request, 'please_login.html')
def NewOrder(request):
try:
if CheckAccess(request,'26') != 'OK':
return render_to_response("costcontract/notaccess/list.html")
except:
return HttpResponseRedirect('/')
try:
contract_id = request.session['contract_id']
except:
return HttpResponseRedirect('/costcontract')
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
order = form.cleaned_data['order']
cost = form.cleaned_data['cost']
start_date = form.cleaned_data['start_date']
end_date = form.cleaned_data['end_date']
clientorder = form.cleaned_data['clientorder']
status = form.cleaned_data['status']
try:
file_size = request.FILES['file_load'].size
if file_size <= 104857600:
file_name = request.FILES['file_load'].name
file_data = request.FILES['file_load'].read()
file_name = file_name.split('\\')[-1]
(path,ext) = os.path.splitext(file_name)
file_name = file_name.replace(' ','_')
file_base64 = base64.b64encode(file_data)
else:
file_name = ''
except:
file_name = ''
file_base64 = ''
ext = ''
AddOrder(request,contract_id,order,cost,start_date,end_date,clientorder,status,file_name,file_base64,ext)
return HttpResponseRedirect('/costcontractorder')
con = GetContract(contract_id)
form = OrderForm(None)
file_link = pickle.loads(con['file_data'])
c = RequestContext(request,{'form':form,'con':con,'file_link':file_link,'legend':'Создание заказа'})
c.update(csrf(request))
return render_to_response("costcontract/editorder.html",c)
def create_order(request):
form = OrderForm(request.POST or None)
if form.is_valid():
order = form.save()
for item in request.session['cart'].items:
item.order = order
item.save()
clean_cart(request)
# return store_view(request)
return render_to_response("create_order.html",
locals(),
context_instance=RequestContext(request))
def show_cart():
form = OrderForm()
items = session.get("cart", [])
is_removed = session.get("is_removed", False)
is_auth = session.get("is_auth", False)
# show message if item is removed
session['is_removed'] = False
# Orders to show
order: List[dict] = []
order_sum = 0
# Getting the meals from db
meals = [db.session.query(Meal).get(int(item)) for item in items]
for meal in meals:
meals_ids = session.get("meals_ids", [])
d = {'title': meal.title, 'price': meal.price, 'meal_id': meal.id}
meals_ids.append(meal.id)
session["meals_ids"] = meals_ids
order.append(d)
order_sum += meal.price
if request.method == 'GET':
session['order_sum'] = order_sum
return render_template('cart.html',
meals_ids=items,
meals=order,
order_sum=order_sum,
form=form,
is_removed=is_removed,
is_auth=is_auth)
if request.method == 'POST':
if form.validate_on_submit():
session['email'] = form.email.data
session['name'] = form.name.data
session['address'] = form.address.data
session['phone'] = form.phone.data
session['order_sum'] = request.form['order_sum']
user = User.query.filter_by(email=session['email']).first()
if user:
return redirect('/login/')
else:
return redirect('/register/')
else:
return render_template('cart.html',
meals_ids=items,
meals=order,
order_sum=order_sum,
form=form,
is_removed=is_removed,
is_auth=is_auth)
def cart():
# Проверяем наличие товаров в корзине
if not session.get('cart_id'):
error = "Ваша корзина пуста. Для оформления заказа необхоимо выбрать блюда."
return render_template('error.html', error=error)
form = OrderForm()
# проверяем правильно заполнена ли форма (запрос POST)
if form.validate_on_submit():
order = OrderModel()
user = session.get('user_id')
# проверяем авторизирован ли пользователь, если нет - добавляем его в базу но без пароля и роль=guest
if not user:
user = UserModel(name=form.name.data,
email=form.email.data,
address=form.address.data,
phone=form.phone.data,
role='guest')
db.session.add(user)
db.session.commit()
# пользователь авторизирован, можно из базы подгрузить его данные сразу в форму заказа
else:
user = db.session.query(UserModel).get(session.get('user_id'))
# проверяем есть ли выбранные для заказа блюда, если да - делаем заказ
if session.get('cart_id'):
order.users = user
order.summa = sum(list(map(int, session.get('cart_price'))))
meals = list(map(int, session.get('cart_id')))
for meal in meals:
meal = db.session.query(MealModel).get(meal)
order.meals.append(meal)
db.session.add(order)
db.session.commit()
session['cart_id'] = []
session['cart_price'] = []
return redirect('/ordered/')
else:
flash('У вас нет блюд в корзине. Дбавьте блюдо и повторите оформление заказа.')
return redirect('/')
# Проверяем прошел ли пользователь аутентификацию
if session.get('user_id'):
user = db.session.query(UserModel).get(session['user_id'])
form.name.data = user.name
form.email.data = user.email
form.address.data = user.address
form.phone.data = user.phone
meals = []
for meal in session.get('cart_id'):
meal = db.session.query(MealModel).get(meal)
meals.append(meal)
return render_template('cart.html', meals=meals, form=form)
def order():
""" Sends user to contact page """
form = OrderForm()
session['img_url'] = request.args.get('url')
if request.method == 'POST':
if form.validate() == False:
flash('All fields are required.')
return render_template('order.html', form=form)
else:
return 'Form posted.'
elif request.method == 'GET':
return render_template('order.html', form=form, img_url=session['img_url'])
def add(id):
qry = db_session.query(Tablets).filter(Tablets.tabletId == id)
tablet = qry.first()
if tablet:
form = OrderForm(formdata=request.form, obj=tablet)
if request.method == 'POST' and form.validate():
orderid = save_order(tablet, form)
return order_details(id, orderid)
return render_template(
'add_items.html',
form=form) #to display the form to add user details
else:
return 'Error loading #{id}'.format(id=tabletId)
def render_cart():
is_auth = session.get('is_auth')
form = OrderForm()
cart = session.get('cart')
cart_list = [] # список для страницы корзины
dish_list = [] # список id для страницы аккаунта
for dish_id in cart:
cart_list.append(
db.session.query(Dish).filter(Dish.id == dish_id).first()) #
total_count = 0
total_price = 0
for i in cart_list:
total_price += i.price # считаем общую стоимость и количество товаров в заказе
total_count += 1
dish_list.append(i.id)
if form.validate_on_submit():
email = form.email.data
phone = form.phone.data
address = form.address.data
dish = Dish.query.all()
user = db.session.query(User).filter(
User.email == form.email.data).first()
if user and is_auth: # Если пользователь залогинен добавляем заказ в базу
order = Order(date=date.today(),
order_price=total_price,
status='ok',
email=email,
phone=phone,
address=address,
users_id=user.id)
db.session.add(order)
for d in dish:
if d.id in dish_list:
order.dishes.append(d)
db.session.commit()
flash('Заказ принят в работу', 'success')
else:
return render_template('cart.html',
is_auth=is_auth,
form=form,
count=total_count,
price=total_price,
cart_list=cart_list)
return redirect(url_for('render_ordered'))
return render_template('cart.html',
form=form,
count=total_count,
price=total_price,
cart_list=cart_list,
is_auth=is_auth)
def order_edit(request, order):
form = OrderForm(instance=order)
if request.method == 'POST':
form = OrderForm(instance=order, data=request.POST)
if form.is_valid():
form.save(request=request)
messages.success(request, "Successfully updated order in {env}".format(
env=utils.get_environment_data(request).get('label')
))
return http.HttpResponseRedirect(reverse('order_home'))
context = dict(
form=form,
)
return request_to_response(request, 'order/edit.html', context)
def mealremove(meal_id):
form = OrderForm()
cart = session.get('cart', [])
cart.remove(meal_id)
session['cart'] = cart
status = session.get('auth', [])
return render_template('cart.html', cart=cart_information(session.get('cart', [])), form=form, status=status)
def get_order():
'''
Sandwich order view. Fill out simple form with name,
pickup location, etc. and then add to DB.
'''
form = OrderForm()
order_id = None
if form.validate_on_submit():
order_id = DB.add_order(form.name.data, form.location.data,
form.pickup.data, form.bec.data, form.ec.data,
form.be.data, form.comments.data,
form.recurring.data)
flash("Thank you for your order! Your order number is {}".format(
order_id))
return redirect('/')
return render_template("order.html", form=form)
def post(self, request, *args, **kwargs):
self.order_form = OrderForm(request.POST)
basket = Basket(request)
if "next" in request.POST:
try:
basket.put(id=int(request.POST.get("id")), qty=int(request.POST.get("qty", 1)))
except ValueError:
pass
return redirect(request.POST.get("next"))
else:
changed = False
for k, v in DotExpandedDict(request.POST)["variant"].items():
changed = changed or basket.change(int(k), int(v))
basket.recalculate()
basket.save()
if not changed:
if self.order_form.is_valid():
# process order
instance = self.order_form.save()
for variant, qty, _ in basket.get_contents():
OrderedWare.objects.create(variant=variant, qty=qty, order=instance)
basket.reset()
instance.status = 1
instance.save()
return self.render_to_response({"complete": True})
else:
return self.render_to_response({"complete": False})
return redirect(request.path)
def pop_from_cart(item):
is_removed = True
form = OrderForm()
items = db.session.query(Dish)
cart = session.get("cart", [])
cart.remove(item)
session["cart"] = cart
for i in items:
if i.title == item:
session["price"] -= i.price
cart = session.get("cart", [])
uniq_dish_in_cart = set()
new_cart = {}
for item in cart:
if item not in uniq_dish_in_cart:
new_cart[item] = 1
uniq_dish_in_cart.add(item)
else:
new_cart[item] += 1
user = None
if session.get("user_id"):
user = User.query.filter(User.id == session.get("user_id")).first()
session["word"] = correct_word(len(session.get("cart", [])))
return render_template("cart.html",
form=form,
is_removed=is_removed,
new_cart=new_cart,
user=user)
def order(order_id):
form = OrderForm(request.form)
session = Session()
order = session.query(Order).get(order_id)
if not order:
order = Order()
session.add(order)
session.commit()
# Берём список всех продуктов
products = session.query(Product).all()
order_products = order.order_products
# Генерируем динамический селект для бутстреп
choices = []
for product in products:
choices.append((product.id, "{} - ${}".format(product.name,
product.price)))
form.products.choices = choices
if request.method == 'POST':
product = session.query(Product).get(form.products.data)
order_product = OrderProduct()
order_product.product = product
order_product.order = order
session.add(order_product)
session.commit()
return redirect(url_for('order', order_id=order.id))
return render_template('order_form.html',
form=form,
order_products=order_products)
def order_list(request):
orders = Order.objects.using(utils.get_environment_db(request)).all()
form = OrderForm()
if request.method == 'POST':
form = OrderForm(data=request.POST)
if form.is_valid():
form.save(request=request)
messages.success(request, "Successfully added order to {env}".format(
env=utils.get_environment_data(request).get('label')
))
return http.HttpResponseRedirect(reverse('order_home'))
context = dict(
form=form,
orders=orders
)
return request_to_response(request, 'order/index.html', context)
def render_order():
form = OrderForm()
if request.method == "POST":
id_o = len(db.session.query(User).get(session["user_id"])) + 1
date = datetime.now().date()
mail = form.mail.data
name = form.name.data
address = form.address.data
user_id = session["user_id"]
sum_price = session["price"]
dishes = session.get("cart", [])
order = Order(id=id_o,
date=date,
mail=mail,
name=name,
address=address,
user_id=user_id,
sum_price=sum_price,
dishes=dishes)
db.session.add(order)
db.session.commit()
return render_template("ordered.html")
else:
orders = db.session.query(Order).filter(
Order.user_id == session["user_id"])
return render_template("cart.html", orders=orders)
def order_submit():
paypal_form = PaypalForm()
order_form = OrderForm()
credit_card_form = CreditCardForm()
order = Order(customer_id=1,
total_amount=1.99,
discount=0.99,
order_created=strftime("%c"),
order_fulfilled=strftime("%c"))
order_items = OrderItems(
order_id=order.id,
description=
"{'enviroment': {'nodes': [{'apps': ['jenkins', 'bugzilla', 'fitnesse', 'selenium'], 'memory': '1GB', 'os': 'ubuntu 12.04 LTS', 'name': 'tools', 'description': 'host build automation and test management tools'}, {'memory': '2GB', 'os': 'ubuntu 12.04 LTS', 'name': 'web', 'dependencies': [{'python': '2.7'}, {'mysql': '5.5'}], 'description': 'deploy python webapp for testing'}]}}",
price=99.99,
discount=0.00,
quantity=1)
db.session.add(order)
db.session.add(order_items)
db.session.commit()
#TODO: save cc form
if purchase_form.submit.data == True:
return redirect('https://www.paypal.com/cgi-bin/webscr')
content = render_template('order.html',
paypal_form=paypal_form,
credit_card_form=credit_card_form,
order_form=order_form)
return content
def cart():
form = OrderForm()
data = []
sum = 0
selected_meals = {}
user = User.objects.filter(name='guest').first()
if 'data' in session:
data = session['data']
selected_meals = {int(key): int(value) for key, value in data.items() if value != 0 and key != ''}
meals = Meal.objects(__raw__={"meal_id": {"$in": list(selected_meals.keys())}})
data = []
for meal in meals:
sum += int(meal.price) * int(selected_meals[meal.meal_id])
data.append({'meal_id': meal.meal_id, 'title': meal.title,
'price': meal.price, 'qnt': selected_meals[meal.meal_id]})
if request.method == "POST":
if 'logged_in' in session and session['logged_in']:
form.name.data = session['name']
form.email.data = session["username"]
user = User.objects.filter(name=session['name']).first()
order = Order(date=datetime.now(), sum=sum, status='ordered', user=user,
phone=form.phone.data, address=form.address.data)
order.save()
user.orders.append(order)
user.save()
for key, value in selected_meals.items():
meal = MealWithCount(meal=Meal.objects.filter(meal_id=key).first(), count=value)
meal.save()
order.meals.append(meal)
order.save()
return redirect('/order_done/')
return render_template("cart.html", data=data, form=form)
def pop_from_cart(item):
flag = 1
form = OrderForm()
items = db.session.query(Dish)
cart = session.get("cart", [])
cart.remove(item)
session["cart"] = cart
for i in items:
if i.title == item:
session["price"] -= i.price
cart = session.get("cart", [])
use_it = set()
new_cart = []
for item in cart:
if item not in use_it:
new_cart.append(item)
use_it.add(item)
user = None
if session.get("user_id"):
user = User.query.filter(User.id == session.get("user_id")).first()
session["word"] = correct_word(len(session.get("cart", [])))
return render_template("cart.html",
form=form,
flag=flag,
new_cart=new_cart,
user=user)
def checkout():
try:
form = OrderForm()
if request.method == "POST":
if session['logged_in']:
orders = mongo.db.orders
card_number = form.card_number.data
card_holder = form.card_holder.data
expires = form.expires.data
cvc = form.cvc.data
hashed_card_number = bcrypt.hashpw(card_number.encode('utf-8'),
bcrypt.gensalt())
hashed_cvc = bcrypt.hashpw(cvc.encode('utf-8'),
bcrypt.gensalt())
now = datetime.now()
formatted_date = now.strftime('%Y-%m-%d %H:%M:%S')
customer = session['email']
name = form.name.data
address = form.address.data
city = form.city.data
post_code = form.post_code.data
phone_number = form.phone_number.data
recipient_email = form.recipient_email.data
ordered_products = []
for value in session['cart_item'].items():
product_in_cart = {
"barcode": value[1]["barcode"],
"price": value[1]["price"],
"quantity": value[1]["quantity"],
"product_name": value[1]["product_name"]
}
ordered_products.append(product_in_cart)
orders.insert_one({
'card_number': hashed_card_number,
'card_holder': card_holder,
'cvc': hashed_cvc,
'expires': expires,
'order_date': formatted_date,
'customer': customer,
'name': name,
'address': address,
'city': city,
'post_code': post_code,
'phone_number': phone_number,
'email': recipient_email,
'ordered_products': ordered_products
})
flash("Order Confirmed! Check your email for details")
return redirect(url_for('products'))
else:
flash("Please login to continue")
return redirect(url_for('login_customer'))
return render_template('checkout.html', title='Checkout', form=form)
except Exception as e:
return str(e)
def search_form(request):
"""
View to display "search.html" i.e. the search interface or form.
First it'll check which type of request is i.e; 'search' request or
'generate register' request. On the basis of that, it'll assign code
to search_type_code which will be used in template.
It'll raise an exception if anyone give invalid value in 'type'.
Argument:Http Request
Return:Render Search
"""
try:
if request.GET['type'] == 'search':
submit_url = reverse('search_result')
search_type_code = '1'
client_form = ClientForm()
order_form = OrderForm()
request_status = request_notify()
temp = {
'client_form': client_form,
'order_form': order_form,
'code': search_type_code,
'url': submit_url,
'request': request_status
}
elif request.GET['type'] == 'register':
submit_url = reverse('view_register')
search_type_code = '2'
client_form = ClientForm()
order_form = OrderForm()
add_constraints = AddConstraints()
request_status = request_notify()
temp = {
'client_form': client_form,
'order_form': order_form,
'add_constraints': add_constraints,
'code': search_type_code,
'url': submit_url,
'request': request_status
}
else:
return HttpResponse('<h1>Page not found</h1>')
except:
return HttpResponse('<h1>Invalid URL</h1>')
return render(request, 'reports/search.html', temp)
def render_cart():
error = ''
del_item_message = ''
if session.get('del_item_message'):
del_item_message = 'Блюдо удалено из корзины'
session.pop('del_item_message')
order_form = OrderForm()
cart = session.get('cart')
ordered_dishes = Dish.query.filter(Dish.id.in_(cart)).all() if cart else []
counter = Counter(cart) if cart else {}
ordered_dishes = [{
'dish': dish,
'amount': counter[dish.id]
} for dish in ordered_dishes]
if request.method == 'POST' and order_form.validate_on_submit():
if not cart:
error = 'Для того чтобы сделать заказ в корзине должен быть хотя бы один товар'
else:
dishes_in_order = [
DishesInOrder(amount=item['amount'], dish=item['dish'])
for item in ordered_dishes
]
order = Order(date=datetime.datetime.now(),
status='accepted',
order_sum=session.get('cart_sum'),
name=order_form.name.data,
email=order_form.email.data,
phone=order_form.phone.data,
address=order_form.address.data,
dishes=dishes_in_order,
user_id=session.get('user')['id']
if session.get('user') else None)
db.session.add_all(dishes_in_order)
db.session.add(order)
db.session.commit()
return redirect(url_for('render_ordered'))
cart_for_template = get_cart_for_template(session)
return render_template('cart.html',
error=error,
message=del_item_message,
ordered_dishes=ordered_dishes,
cart=cart_for_template,
form=order_form,
session=session)
def order():
paypal_form = PaypalForm()
credit_card_form = CreditCardForm()
order_form = OrderForm()
content = render_template('order.html',
paypal_form=paypal_form,
credit_card_form=credit_card_form,
order_form=order_form)
return content
def contacts_page():
data = request.args.get("type")
if data == "order":
form = OrderForm()
else:
form = ContactForm()
if request.method == 'POST' and form.validate():
mail(subject=form.subject.data,
main=form.main.data,
name=form.name.data,
mail=form.mail.data)
return redirect(url_for("contacts_page"))
return render_template("contacts.html", form=form)
def creating_order():
orders = Order.query.all()
form = OrderForm(request.form)
if request.method == "POST":
name = form.name.data
unit = form.unit.data
provider_id = form.provider.data.id
Order.save(Order(name=name, unit=unit, provider_id=provider_id))
return render_template('orders.html', orders=orders, form=form)
def BeginToTrade(request):
RequestUser = request.user
RequestGroup = RequestUser.group
context={
"form":SearchForm(),
"sear":True
}
if request.method=="POST":
Post = request.POST.dict()
if Post.has_key("StockName"):
StockName=str(Post["StockName"])
else:
StockName=""
if Post.has_key("Volume"):
Volume=Post["Volume"]
else:
Volume=0
if Post.has_key("TransactionType"):
TransactionType=Post["TransactionType"]
else:
TransactionType=None
print Post
context={
"form":OrderForm(),
"sear":False
}
stock = Stock.objects.filter(StockName=StockName)
if len(stock)==0:
print "123123"
stock = Stock(StockName=StockName)
stock.save()
context["StockData"] = jsonpickle.encode(stock.Get_data())
else:
context["StockData"] = jsonpickle.encode(stock[0].Get_data())
if Volume!="" and TransactionType != None:
RequestUser.group.UpdateAcount()
stockprice = stock[0].Get_Price()
if TransactionType=="buy":
if RequestUser.group.Cash >= stockprice*float(Volume):
RequestGroup.transaction_set.create(TransType = TransactionType,StockOfTrans = stock[0], Volume=Volume, PriceAtTrans=stock[0].Get_Price() )
context["mess"] = "Succesfully making transaction"
else:
context["mess"] = "You don't have enough money"
else:
asset = RequestUser.group.AllAsset
if asset[StockName] >= float(Volume):
RequestGroup.transaction_set.create(TransType = TransactionType,StockOfTrans = stock[0], Volume=Volume, PriceAtTrans=stock[0].Get_Price() )
context["mess"] = "Succesfully making transaction"
else:
context["mess"] = "You don't have enough this stock to sell"
return render(request, "BeginToTrade.html", context)
def show_form():
form = OrderForm()
if form.validate_on_submit():
bitcoin = bitcoinrpc.connect_to_local()
order = Order().populate_from_order_form(form)
order.address = bitcoin.getnewaddress()
db.session.add(order)
for gb_form in form.group_buys:
db.session.add(GroupBuy(order = order
).populate_from_groupbuy_form(gb_form))
db.session.commit()
return redirect(url_for(".order_completed", address = order.address))
return render_template("index.html",
form = form, prices = prices, site_name = app.config["SITE_NAME"])
def order_detail(request, secret):
order = get_object_or_404(Order, secret=secret)
form = OrderForm(instance=order)
products_in_cart = ProductInCart.objects.filter(cart=order.cart)
return render_to_response('order_item.html', {
'order': order,
'form': form,
'products_in_cart': products_in_cart
})
def cart():
form = OrderForm()
lst_meals = cart_meals(session.get('cart', []))
if session.get("user_id"):
if request.method == "POST":
if not form.validate_on_submit():
form.errors.append("Не все поля заполнены корректно!")
return render_template('cart.html',
form=form,
log=session.get('user_id'),
lst_meals=lst_meals)
# Добавляем заказ в базу данных на основании данных из формы
user = User.query.get(session.get("user_id"))
order = Order(
date=datetime.datetime.today().strftime('%H:%M %d-%m-%Y'),
sum=form.order_summ.data,
status='preparing',
mail=user.mail,
phone=form.clientPhone.data,
address=form.clientAddress.data)
db.session.add(order)
# Добавляем данные в ассоциативную таблицу orders_meals
meals = []
for meal_id in session.get('cart'):
if meal_id not in meals:
meals.append(meal_id)
db_meal = Meal.query.get(meal_id)
orders_meals = OrdersMeals(
meal_amount=session.get('cart').count(meal_id),
meal_sum=session.get('cart').count(meal_id) *
int(db_meal.price),
orders=order,
meals=db_meal)
db.session.add(orders_meals)
db.session.commit()
return redirect(url_for('ordered'))
return render_template('cart.html',
form=form,
log=session.get('user_id', []),
lst_meals=lst_meals)
def get(self, request, *args, **kwargs):
self.order_form = OrderForm()
if "id" in request.GET:
basket = Basket(request)
try:
basket.remove(int(request.GET.get("id", 0)))
except ValueError:
pass
return redirect(request.path)
return super(BasketView, self).get(request, *args, **kwargs)
def order(request):
"""
Handle order
:param request:
:return:
"""
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
if 'name' in form.cleaned_data:
name = form.cleaned_data['name']
else:
name = None
if 'email' in form.cleaned_data:
email = form.cleaned_data['email']
else:
email = None
if 'phone' in form.cleaned_data:
phone = form.cleaned_data['phone']
else:
phone = None
if email == "" and phone == "":
return JsonResponse({"result": "error"})
Order.objects.create(
name=name,
email=email,
phone=phone,
datetime=timezone.now(),
)
try:
send_mail(
"New order",
'Phone: ' + phone + '\n \nEmail: ' + email,
getattr(settings, "EMAIL_HOST_USER", None),
[settings.EMAIL_ADDRESS, ],
fail_silently=False,
)
except:
pass
return JsonResponse({"result": "ok"})
else:
return JsonResponse({"result": "error"})
def add_order(request):
form=OrderForm(request.POST)
if form.is_valid():
global add
o=Order(FIO=form.cleaned_data['FIO'], adres=form.cleaned_data['adres'], phone_number=form.cleaned_data['phone_number'],
email=form.cleaned_data['email'], status=False, time=datetime.datetime.now())
o.save()
redirect=HttpResponseRedirect('/order/')
redirect.set_cookie(key='order',value="ваш заказ учтен",max_age=5)
return redirect
else:
redirect=HttpResponseRedirect('/order/')
redirect.set_cookie(key='order',value=form.errors, max_age=5)
return redirect
def create_order(request):
"""
Processes an book order from customers
"""
print request.session.session_key
print dict(request.session)
if request.user.has_perm('user.send_tweet'):
print "Si puede twittear"
else:
print "No puede twittear"
form = OrderForm()
if request.method == 'POST':
form = OrderForm(request.POST)
if form.is_valid():
# This decrements the number of books in stock
# for the requested book
order = form.save()
return HttpResponseRedirect(reverse('latest_books'))
return render_to_response(
'books/create_order.html',
{'form': form}
)
def change(request):
if request.method == "POST":
#этот if проверяет выбор элемента для изменения
if request.POST.get('change'):
change_id = request.POST.get('change')
order = Order.objects.filter(id=change_id).get()
data = {'meal':order.meal, 'person':order.person, 'email':order.email, 'byn':order.byn,
'byr':order.byr, 'comment':order.comment}
context = {'my_form':OrderForm(data)}
request.session['change_id'] = change_id
return render(request, 'change_page.html', context)
#здесь уже происходит само изменение
if request.session.has_key('change_id'):
form = OrderForm(request.POST)
if form.is_valid():
data = form.cleaned_data
order = Order.objects.filter(id=request.session.get('change_id')).get()
order.meal = data['meal']
order.person = data['person']
order.email = data['email']
order.byn = data['byn']
order.byr = data['byr']
order.comment = data['comment']
order.save()
admin_mail = User.objects.filter(username='******', is_superuser=True).get().email
send_mail(u'изменения в заказе', u'{0} {1}'.format(order.meal, order.comment),
'{0}'.format(admin_mail), ['{0}'.format(order.email)])
del request.session['change_id']
return redirect(show)
else:
data = form.errors
return HttpResponse("{0}".format(data))
else:
return HttpResponse('либо вы не выбрали заказ из списка<br>'
'либо обратитесь к администратору')
else:
context = {'data':Order.objects.filter(), 'step':1}
return render(request, 'change_page.html', context)
def show_cart(request, template_name="cart/cart.html"):
if request.method == 'POST':
subtotal_class = cart.Subtotal(request)
cart_items = cart.get_cart_items(request)
# cart_subtotal = subtotal_class.subtotal()
discount = subtotal_class.discount
postdata = request.POST.copy()
form = OrderForm(request.POST)
if 'Remove' in postdata:
cart.remove_from_cart(request)
if 'Update' in postdata:
cart.update_cart(request)
if form.is_valid():
# Пишу клиента в базу
cart.save_client(request, form)
# Удаляю сессию у клиента
del request.session['cart_id']
is_order = 1
# Отправляем админу смс
if SEND_SMS:
cart.send_sms(cart_items, form)
# Отправляем админу email
if SEND_EMAIL:
cart.send_admin_email(request, cart_items, form)
if form.cleaned_data['email']:
# Отправляем email клиенту
cart.send_client_email(cart_items, form)
else:
form = OrderForm()
cart_items = cart.get_cart_items(request)
# if cart_items:
# subtotal_class = cart.Subtotal(request)
# cart_subtotal = subtotal_class.subtotal()
# discount = subtotal_class.discount
page_title = 'Корзина'
return render_to_response(template_name, locals(), context_instance=RequestContext(request))
def order_create():
orderForm = OrderForm()
orderForm.populate()
if orderForm.validate_on_submit():
order = Order()
orderForm.populate_obj(order)
db.session.add(order)
db.session.commit()
return redirect(url_for('.order', id=order.id))
return orders(form=orderForm)
def order(request, id=None):
try:
# просмотр ранее завершенного заказа
order = Order.objects.get(pk=id, user=request.user)
except Order.DoesNotExist:
# использовать в форме заказа данные из последнего заказа
try:
last_order = Order.objects.filter(user=request.user).order_by('-id')[0]
except IndexError:
last_order = None
form = OrderForm(auto_id='%s', initial={
'name' : request.user.first_name+' '+request.user.last_name,
'email' : request.user.email,
'phone' : request.user.get_profile().phone,
'city' : last_order and last_order.city,
'address': last_order and last_order.address,
'phone' : last_order and last_order.phone
})
if not request.session.get('cart'):
raise Http404
if request.POST:
form = OrderForm(request.POST, auto_id='%s')
# сохранение заказа
if form.is_valid():
order = Order.objects.create(
user = request.user,
name = form.cleaned_data['name'],
city = form.cleaned_data['city'],
address = form.cleaned_data['address'],
email = form.cleaned_data['email'],
phone = form.cleaned_data['phone'],
sum = cart_total(request.session['cart']),
is_confirmed = 1
)
for id, item in request.session['cart'].iteritems():
OrderItem.objects.create(
order = order,
product_id = item.id,
title = item.title,
quantity = item.quantity,
comment = item.comment,
price = item.price,
sum = item.price * float(item.quantity)
)
del(request.session['cart'])
mail_managers(u'Новый заказ номер '+str(order.id), unicode(
'Поступил новый заказ на сумму '+str(order.sum)+' руб. Контактные данные: '+
order.name+' ('+str(order.phone)+', '+order.email+'). Доставка по адрессу '+order.city+', '+
order.address
))
return render_to_response('candy/order-confirmed.html', {'order': order}, context_instance=RequestContext(request))
return render_to_response('candy/order.html', {
'order': locals().get('order'),
'form' : locals().get('form'),
'items': locals().has_key('order') and order.items.all() or [item for id, item in request.session['cart'].iteritems()],
'total': cart_total(request.session.get('cart') or {}),
}, context_instance=RequestContext(request))
def orders(form=None):
if form is None and not current_user.is_anonymous():
form = OrderForm()
form.populate()
return render_template('orders.html', orders=get_orders(), form=form)
def order(request):
product_ids = [int(x) for x in request.POST.getlist('products')]
quantities = [int(x) for x in request.POST.getlist('quantities')]
spare_list = Spare.objects.filter(id__in=product_ids)
is_order = request.POST.has_key('_order')
order_products = []
body = []
total_sum = 0
no_price = False
for i, spare in enumerate(spare_list):
body.append(u'* %s - %s шт.' % (spare.title, quantities[i]))
if spare.price:
total_sum += spare.price * quantities[i]
else:
no_price = True
order_products.append({
'spare': spare,
'quantity': quantities[i]
})
body = '\n'.join(body)
data = request.POST.copy() if is_order else None
if data is not None:
data['body'] = body
data['total_sum'] = total_sum
if not request.user.is_anonymous():
data['user_id'] = request.user.id
else:
if is_order:
pass
# raise Exception('DATA IS NONE')
if request.user.is_anonymous():
form = OrderForm(data)
else:
try:
profile = request.user.profile
form = OrderForm(data, instance=profile, initial={'email': request.user.email})
except:
form = OrderForm(data)
if is_order and form.is_valid():
form.body = body.replace('\n', '<br>')
order = form.save(commit=False)
order.total_sum = total_sum
order.status = 0
order.body = body
if not request.user.is_anonymous():
order.user = request.user
order.save()
response = render(request, 'spares/success.html', {})
response.set_cookie('cart_ids', json.dumps([]))
return response
else:
return render(request, 'spares/form.html', {
'order_products': order_products,
'form': form,
'is_order': is_order,
'total_sum': total_sum,
'no_price': no_price
})
def view_order(request, compete_id=1):
if compete_id is None:
compete_id = 1
school = get_object_or_404(School, user=request.user)
competition = get_object_or_404(Competition, pk=compete_id)
groups = set(request.user.groups.all())
available_competitions = [c for c in Competition.objects.all()
if any(g in groups for g in c.available_for.all())]
parallels_for_competition = CompetitionForParallel.objects.filter(competition=competition)
parallels_for_competition_dict = dict((pc.parallel, pc) for pc in parallels_for_competition)
if competition not in available_competitions:
raise Http404('this competition is unavalilable for you')
if competition.state == 4:
return render_to_response('cabinet_order.html', {
'school': school,
'competitions': available_competitions,
'selected_competition': competition,
'form': None,
'message': '',
'parallels': parallels_for_competition,
}, context_instance=RequestContext(request))
else:
message = ''
messagestatus = 1
is_new = True
order_status = 'не подана'
blank_status = ''
try:
current_order = Order.objects.get(school=school, competition=competition)
order_status = current_order.get_status_display()
if competition.state == 3:
blank_status = current_order.get_blank_status_display()
is_new = False
except Order.DoesNotExist:
current_order = Order()
current_order.create_time = datetime.now()
current_order.competition = competition
current_order.school = school
if request.method == 'POST':
form = OrderForm(dict(request.POST.items()), instance=current_order)
if form.is_valid():
message = ('Заявка поступила на рассмотрение'
if is_new else
'Заявка изменена')
form.save()
else:
message='Неправильно указаны поля'
messagestatus = 0
if is_new:
current_order = None
#form = OrderForm(instance=current_order)
#form.errors = src_form.errors
else:
form = OrderForm(instance=current_order)
if is_new:
current_order = None
total = 0
total_cost = 0
if current_order:
order_parallels = OrderParallel.objects.filter(order=current_order)
total = sum(op.count for op in order_parallels)
total_cost = sum(op.count * parallels_for_competition_dict[op.parallel].cost for op in order_parallels if op.parallel in parallels_for_competition_dict)
return render_to_response('cabinet_order.html', {
'total': total,
'parallels': parallels_for_competition,
'total_cost': total_cost,
'competitions': available_competitions,
'selected_competition': competition,
'form': form,
'message': message,
'messagestatus': messagestatus,
'order': current_order,
'school': school,
}, context_instance=RequestContext(request))
def checkout(request):
if not request.session.has_key("basket"):
return redirect("category_list")
elif request.GET.has_key("add_item"):
item = Item.objects.get(pk=request.GET["add_item"])
match = 0
for itm in request.session["basket"]:
if itm["item"] == item:
itm["amount"] += 1
match = 1
if match == 0:
request.session["basket"].append({'item': item, 'amount': 1})
request.session.modified = True
return redirect("checkout")
elif request.GET.has_key("remove_item"):
item = Item.objects.get(pk=request.GET["remove_item"])
for itm in request.session["basket"]:
if itm["item"] == item:
itm["amount"] -= 1
if itm["amount"] == 0:
request.session["basket"].remove(itm)
if request.session["basket"] == []:
del request.session["basket"]
request.session.modified = True
return redirect("checkout")
basket = request.session["basket"] or []
total = 0
itms = []
for itm in basket:
itm["price"] = (itm["item"].price * itm["amount"])
itm["fees"] = []
itms.append(itm["item"])
total = total + itm["price"]
for fee in itm["item"].extra_fees.all():
d = {
'fee': fee,
'price': (fee.price * itm["amount"])
}
itm["fees"].append(d)
total = total + d["price"]
# Add eventual fees to order
for orderfee in OrderFee.objects.filter(applies_below__gt=total).order_by('price'):
avoid = False
avoid_item = None
diff = (orderfee.applies_below - total)
total = total + orderfee.price
print diff
if diff < 150 and diff > 0:
try:
avoid_item = Item.objects.filter(price__gte=(diff), price__lte=(diff+30))
if avoid_item.filter(related_items__in=itms).count() > 0:
avoid_item = avoid_item.filter(related_items__in=itms)
avoid_item = avoid_item[random.randrange(0,avoid_item.count())]
avoid = True
except:
pass
if diff > 0:
basket.append({
'price': orderfee.price,
'amount': 1,
'name': orderfee.name,
'avoid': avoid,
'avoid_fee': diff,
'avoid_item': avoid_item,
'item': None,
})
if request.POST:
form = OrderForm(request.POST, instance=Order(site=Site.objects.get_current()))
if form.is_valid():
order = form.save()
for itm in basket:
if itm["item"]:
o = OrderLine(item_id=itm["item"].id, name=itm["item"].name, amount=itm["amount"], price=itm["item"].price, order=order)
o.save()
i = Item.objects.get(pk=itm["item"].id)
i.amount_on_stock -= itm["amount"]
i.amount_sold += itm["amount"]
i.save()
for fee in itm["item"].extra_fees.all():
o = OrderLine(fee_id=fee.id, name=fee.name, amount=itm["amount"], price=fee.price, order=order)
o.save()
else:
o = OrderLine(name=itm["name"], amount=itm["amount"], price=itm["price"], order=order)
o.save()
msg = render_to_string("catalog/order_confirmation.html", {
'order': order,
'site': Site.objects.get_current(),
})
OrderMessage(order=order, gateway=default_settings.MSG_GATEWAY_DEFAULT, message=msg).save()
request.session.flush()
if request.POST.has_key("remember_my_address"):
request.session["first_name"] = order.first_name
request.session["last_name"] = order.last_name
request.session["address"] = order.address
request.session["address_2"] = order.address_2
request.session["postal_code"] = order.postal_code
request.session["city"] = order.city
request.session["cellphone"] = order.cellphone
request.session["email"] = order.email
request.session["remember_my_address"] = request.POST["remember_my_address"]
if options.payment == True:
return redirect("pay", order_id=order.id)
return redirect(order)
else:
form = OrderForm(initial=request.session)
dictionary = {
'basket': basket,
'total': total,
'vat': total * Decimal("0.2"),
'form': form,
}
return render_to_response('catalog/checkout.html',
dictionary,
context_instance=RequestContext(request))
def order(request, id=None):
DELIVERIES = {"post": 230, "ems": 550, "pek": 350, "self": 0}
try:
# просмотр ранее завершенного заказа
order = Order.objects.get(pk=id, user=request.user.is_authenticated() and request.user or None)
except Order.DoesNotExist:
# если корзина пуста заказа не будет
if not request.session.get("cart"):
raise Http404
# использовать в форме заказа данные из последнего заказа
try:
last_order = Order.objects.filter(user=request.user.is_authenticated() and request.user or None).order_by(
"-id"
)[0]
except IndexError:
last_order = None
try:
form = OrderForm(
auto_id="%s",
initial={
"name": request.user.first_name + " " + request.user.last_name,
"email": request.user.email,
"phone": request.user.get_profile() and request.user.get_profile().phone or None,
"city": last_order and last_order.city,
"address": last_order and last_order.address,
"phone": last_order and last_order.phone,
},
)
except AttributeError:
form = OrderForm(auto_id="%s")
if request.POST:
form = OrderForm(request.POST, auto_id="%s")
try:
user = User.objects.get(email=request.POST["email"])
# если клиент не авторизован и использует мыльник действительного
# аккаунта из базы - поругаться и предложить авторизоваться
if not request.user.is_authenticated():
auth_error = True
except User.DoesNotExist:
if form.is_valid():
user = register_inactive(
form.cleaned_data["email"][0 : form.cleaned_data["email"].index("@")],
form.cleaned_data["email"],
)
# такое может быть с пользователя, с пустым email
except User.MultipleObjectsReturned:
pass
# сохранение заказа
if form.is_valid() and not locals().get("auth_error"):
for values in [form.cleaned_data]:
order = Order.objects.create(
user=user,
name=values["name"],
city=values["city"],
address=values["address"],
email=values["email"],
phone=values["phone"],
delivery_by=values["delivery_by"],
sum=cart_total(request.session["cart"]) + DELIVERIES[values["delivery_by"]],
is_confirmed=1,
)
for id, item in request.session["cart"].iteritems():
OrderItem.objects.create(
order=order,
product_id=item.id,
title=item.title,
quantity=item.quantity,
comment=item.comment,
price=item.price,
sum=item.price * float(item.quantity),
)
items_str = (", ").join(
[
u'"%s" x %s (%.2f р. всего)' % (item.title, item.quantity, float(item.quantity) * item.price)
for id, item in request.session["cart"].iteritems()
]
)
user.get_profile().send_email(
u"Заказ номер %i принят к обработке" % order.id,
(
u"""
Вы совершили заказ на сумму %(sum).2f рублей. Контактные данные: %(name)s,
email %(email)s, телефон %(phone)s. Доставка по адресу %(city)s, %(address)s.
Содержимое заказа: %(items)s.
Спасибо, мы свяжемся с вами в ближайшее время!
"""
% {
"address": order.address,
"phone": order.phone,
"email": order.email,
"city": order.city,
"name": order.name,
"sum": order.sum,
"items": items_str,
}
).encode("utf8"),
)
del (request.session["cart"])
mail_managers(
u"Новый заказ номер " + str(order.id),
u"Поступил новый заказ на сумму "
+ str(order.sum)
+ u" руб. Контактные данные: "
+ order.name
+ " ("
+ str(order.phone)
+ ", "
+ order.email
+ u"). Доставка по адрессу "
+ order.city
+ ", "
+ order.address
+ u". Способ доставки "
+ order.delivery_by
+ u". Содержимое заказа: "
+ items_str,
)
return render_to_response(
"candy/order-confirmed.html", {"order": order}, context_instance=RequestContext(request)
)
return render_to_response(
"candy/order.html",
{
"order": locals().get("order"),
"form": locals().get("form"),
"auth_error": locals().get("auth_error"),
"total": cart_total(request.session.get("cart") or {}),
"delivery": DELIVERIES[
locals().get("order") and order.delivery_by or request.POST.get("delivery_by", "post")
],
"deliveries": DELIVERIES,
"items": locals().has_key("order")
and order.items.all()
or [item for id, item in request.session["cart"].iteritems()],
},
context_instance=RequestContext(request),
)
