def init_order(order: Order):
order_products = order.products.select_related('product').all()
order.total_price = sum(p.price for p in order_products)
if order.deliver:
order.internal_delivery_price = order.delivery_price
order.total_price += order.delivery_price or Decimal(0)
order.internal_total_price = order.total_price
def test_q_method_use_prop(self):
order = Order(price=100)
order.delivered_time = timezone.now()
order.save()
pizza = Pizza(diameter=12, order=order, created=timezone.now())
pizza.save()
self.assertTrue(pizza.is_delivered)
def test_q_method_cant_use_self(self):
order = Order(price=100)
order.save()
pizza = Pizza(diameter=12, order=order, created=timezone.now())
pizza.save()
with self.assertRaisesRegexp(Exception, 'q_method'):
Pizza.objects.is_delivered_using_self()
def test_q_method_use_self(self):
order = Order(price=100)
order.delivered_time = timezone.now()
order.save()
pizza = Pizza(diameter=12, order=order, created=timezone.now())
pizza.save()
self.assertEqual(1, Pizza.objects.is_delivered_using_self().count())
def create_order_view(request, product, count):
try:
date = email.utils.formatdate(usegmt=True)
order = Order(product=product, count=count, date=date, qr="")
order.qr = hashlib.md5((email.utils.formatdate(usegmt=True) +
str(order.id)).encode('utf-8'))
order.save()
answer = "ok"
except Exception as e:
answer = str(e)
return JsonResponse({'answer': answer})
def success(request):
pay = Pay()
pay.user = request.user
pay.date = datetime.today().strftime("%Y-%m-%d %H:%M:%S")
pay.total = 0
pay.order_num = random.randrange(0, 500)
bt_list = list()
or_list = list()
for b in Basket.objects.all():
pay.total += int(b.ototal_price)
order = Order()
order.or_name = b.menu_id.m_name
order.or_num = pay.order_num
order.or_count = b.count
order.or_takeout = b.takeout
for bt in b.b_options.all():
bt_list.append(bt)
order.save()
order.or_options.add(*bt_list)
bt_list.clear()
or_list.append(order)
pay.save()
pay.orders.add(*or_list)
for b in Basket.objects.all():
b.delete()
return render(request, 'menuapp/success.html', {'pay': pay})
def test_IB_update_order(self):
order = self.test_IB_send_order()
orders = []
orders.append(order)
self.con.update_orders(orders)
self.assertFalse(
Order.FillInfo(order.fill_info) == Order.FillInfo.UNFILLED.value)
def orders_post():
order = request.form['order']
#インスタンス作成
new_order = Order(menu=order, user=session['user_name'])
db.session.add(new_order) #追加
db.session.commit() #コミット
return Response('OK')
def post(self):
if not self._check_order():
return make_response(
jsonify({
'type': 'error',
'text': 'This meal is already in your order'
}), 403)
_order_date = datetime.datetime.strptime(self.json.get('order_date'),
"%Y-%m-%d").date()
if not self._check_actual_date(_order_date.timetuple().tm_yday):
return make_response(
jsonify({
'type':
'error',
'text':
'You are trying to create an outdated order. That is not allowed'
}), 403)
new_order = Order(order_date=_order_date,
meal_id=self.json.get('meal_id'),
user_id=self.json.get('user_id'),
quantity=self.json.get('quantity'))
db_session.add(new_order)
db_session.commit()
return jsonify(_parse_order(new_order, detailed=False))
def step3(request):
des_seances = serializers.deserialize("json", request.session['seances'])
seances = [seance.object for seance in des_seances]
if request.method == 'POST':
form = ThirdStepOrder(request.POST, seances=seances)
if form.is_valid():
time = form.cleaned_data['time']
seances_ids = [seance.id for seance in seances]
seance = Seance.objects.get(time=time, id__in=seances_ids)
service = list(
serializers.deserialize("json",
request.session['service']))[0].object
order = Order(seance=seance, service=service, user=request.user)
order.save()
return redirect('main:home')
else:
form = ThirdStepOrder(seances=seances)
return render(request, 'main/order3.html', {'form': form})
def test_q_method_with_args(self):
"""Test whether q method can handle args and kwargs"""
amount = 100
order = Order(price=amount)
order.save()
# test various combinations of args and kwargs on the manager method
self.assertEqual(1, Order.objects.cost_between(amount - 1).count())
self.assertEqual(
1,
Order.objects.cost_between(amount - 1, amount + 1).count())
self.assertEqual(
1,
Order.objects.cost_between(amount - 1, upper=amount + 1).count())
self.assertEqual(
1,
Order.objects.cost_between(lower=amount - 1,
upper=amount + 1).count())
self.assertEqual(0, Order.objects.cost_between(amount + 1).count())
self.assertEqual(
0,
Order.objects.cost_between(lower=amount + 1,
upper=amount + 2).count())
# test various combinations of args and kwargs on the queryset method
self.assertEqual(1,
Order.objects.all().cost_between(amount - 1).count())
self.assertEqual(
1,
Order.objects.all().cost_between(amount - 1, amount + 1).count())
self.assertEqual(
1,
Order.objects.all().cost_between(amount - 1,
upper=amount + 1).count())
self.assertEqual(
1,
Order.objects.all().cost_between(lower=amount - 1,
upper=amount + 1).count())
self.assertEqual(0,
Order.objects.all().cost_between(amount + 1).count())
self.assertEqual(
0,
Order.objects.all().cost_between(lower=amount + 1,
upper=amount + 2).count())
def check_products_for_wish():
wishes = Wish.objects.all()
for wish in wishes:
products = Products.objects.all()
need = wish.needCount
good = []
for product in products:
if (wish.category.lower() in product.tags.lower()
or wish.category.lower()
in product.name.lower()) and need != 0:
good.append(product)
if need <= product.count:
need = 0
else:
need -= product.count
if need == 0:
order = Order(count=need,
date=email.utils.formatdate(usegmt=True),
qr="")
order.save()
for product in good:
order_product = Order_p(order=order,
product_id=product.id_code,
qty=need)
order_product.save()
device = FCMDevice.objects.all()[2]
orders_p = Order_p.objects.filter(order=order)
i = 1
answer = ""
for order_p in orders_p:
answer += "{0}. {1} | qty : {2}\n".format(
i,
Products.objects.filter(
id_code=order_p.product_id)[0].name, order_p.qty)
device.send_message(
title="Your order is ready!",
body=answer,
)
wish.save()
wish.delete()
def test_q_method_with_args(self):
"""Test whether q method can handle args and kwargs"""
amount = 100
order = Order(price=amount)
order.save()
# test various combinations of args and kwargs on the manager method
self.assertEqual(1, Order.objects.cost_between(amount - 1).count())
self.assertEqual(1, Order.objects.cost_between(amount - 1, amount + 1).count())
self.assertEqual(1, Order.objects.cost_between(amount - 1, upper=amount + 1).count())
self.assertEqual(1, Order.objects.cost_between(lower=amount - 1, upper=amount + 1).count())
self.assertEqual(0, Order.objects.cost_between(amount + 1).count())
self.assertEqual(0, Order.objects.cost_between(lower=amount + 1, upper=amount + 2).count())
# test various combinations of args and kwargs on the queryset method
self.assertEqual(1, Order.objects.all().cost_between(amount - 1).count())
self.assertEqual(1, Order.objects.all().cost_between(amount - 1, amount + 1).count())
self.assertEqual(1, Order.objects.all().cost_between(amount - 1, upper=amount + 1).count())
self.assertEqual(1, Order.objects.all().cost_between(lower=amount - 1, upper=amount + 1).count())
self.assertEqual(0, Order.objects.all().cost_between(amount + 1).count())
self.assertEqual(0, Order.objects.all().cost_between(lower=amount + 1, upper=amount + 2).count())
def order_view(request):
# Рендерит главную страницу, с формой для заказа, и входа в аккаунт диспетчера
order_form = OrderForm(request.POST or None)
login_form = LoginForm(request.GET or None)
context = {
'order_form': order_form,
'login_form': login_form
}
if order_form.is_valid():
client_name = order_form.cleaned_data['client_name']
client_phone = order_form.cleaned_data['client_phone']
address = order_form.cleaned_data['address']
destination = order_form.cleaned_data['destination']
desired_time = order_form.cleaned_data['desired_time']
new_order = Order(client_name=client_name,
client_phone=client_phone,
address=address,
destination=destination,
desired_time=desired_time)
try:
car = Car.objects.filter(ordered=False)[0]
new_order.car = car
new_order.save()
car.ordered = True
car.save()
order_inf = {"order_id": new_order.id, "car_brand": car.brand}
except:
order_inf = False
context.update({'order_inf': order_inf})
if login_form.is_valid():
username = login_form.cleaned_data['username']
password = login_form.cleaned_data['password']
login_user = authenticate(username=username, password=password)
if login_user:
login(request, login_user)
return HttpResponseRedirect(reverse('all_orders'))
return render(request, 'order.html', context)
def checkout():
if session['role'] == 'customer':
form = AddressForm()
cart = Cart.query.filter_by(user_id=current_user.id).all()
address = Address.query.filter_by(user_id=current_user.id).first()
total = 0
for item in cart:
total += item.product.price * item.quantity
if form.validate_on_submit():
if address is None:
address = Address(addressLine1=form.addressLine1.data,
addressLine2=form.addressLine2.data,
pincode=form.pincode.data,
city=form.city.data,
state=form.state.data,
mobile=form.mobile.data,
customer=current_user)
db.session.add(address)
db.session.commit()
for item in cart:
order = Order(product=item.product,
user_id=current_user.id,
seller_id=item.product.seller_id,
quantity=item.quantity,
total=total)
db.session.add(order)
db.session.commit()
for item in cart:
product = Product.query.filter_by(id=item.product.id).first()
product.quantity -= item.quantity
db.session.commit()
for item in cart:
Cart.query.filter_by(id=item.id).delete()
db.session.commit()
flash('Order Placed successfully', 'check')
return redirect(url_for('orders'))
if request.method == 'GET' and address is not None:
form.addressLine1.data = address.addressLine1
form.addressLine2.data = address.addressLine2
form.pincode.data = address.pincode
form.city.data = address.city
form.state.data = address.state
form.mobile.data = address.mobile
return render_template('checkout.html',
form=form,
total=total,
cart_items=cart)
else:
flash('Only customer can access this page', 'warning')
return redirect(url_for('seller_dashboard'))
def run(self, num):
for user in self.users:
for date in self._get_month_dates(num):
_meals = self._get_day_meals(date)
for _m in _meals:
new_order = Order(order_date=date,
meal_id=_m.id,
user_id=user.id,
quantity=random.randint(1, 10))
db_session.add(new_order)
print('Created orders for:', user)
db_session.commit()
print("Orders creation complete")
def create_order(request):
cart = ShoppingCart.objects.get(SessionID=request.session.session_key)
itemsincart = cart.ItemsInCart.all()
user = None
order_items = []
total_price = 0
for item in itemsincart:
product = Items.objects.get(ItemID=item.ItemID_id)
order_item = OrderContains(Quantity=item.Quantity, ItemID=product)
product.Quantity_available -= item.Quantity
total_price += item.Quantity * product.Price
product.save()
if cart.Promo is not None:
order_item.Price = round(
(product.Price * (1 - cart.Promo.Discount)), 2)
else:
order_item.Price = product.Price
order_item.save()
order_items.append(order_item)
if cart.Promo is not None:
total_price = int(round((total_price * (1 - cart.Promo.Discount))))
if request.user.is_authenticated:
user = User.objects.get(id=request.user.id)
try: # to get user info
shippinginfo = UserInfo.objects.get(AccountConnected=user)
except UserInfo.DoesNotExist:
shippinginfo = create_shipping_info(request.POST, user=user)
else:
shippinginfo = create_shipping_info(request.POST, user=None)
order = Order(ShippingInfoID=shippinginfo,
TotalPrice=total_price) # 'total' may be subject to change
order.save()
for item in order_items:
order.ItemsInOrder.add(item)
if user is not None:
order.AccountConnected = user
order.SessionConnected = Session.objects.get(
session_key=request.session.session_key)
order.save()
#delete from cart
for item in itemsincart:
cart.ItemsInCart.remove(item)
item.delete()
cart.delete()
return order.id
def act_addorder(skus, buyer):
'''it will add a Order'''
cny_price = ds_get_order_cny_price(skus)
order = Order(cny_price=cny_price, buyer=buyer, type=OrderType.objects.get(id=1))
order.save()
if isinstance(skus, Sku):
order.skus.add(skus)
else:
order.skus = skus
order.save()
result = _(u'Order added, need to pay: CNY¥'+ str(cny_price) +', this order includes: '+str(skus))
result = {'info':result, 'order':order}
return result
def test_example(self):
order = Order(price=100, name_on_order='Bob')
order.save()
pizza = Pizza(diameter=12, order=order, created=timezone.now())
pizza.save()
self.assertEqual(0, Pizza.objects.is_delivered().count())
self.assertEqual(0, Order.objects.is_delivered().count())
self.assertFalse(pizza.is_delivered)
order.delivered_time = timezone.now()
order.save()
self.assertEqual(1, Order.objects.is_delivered().count())
self.assertEqual(1, Pizza.objects.is_delivered().count())
self.assertTrue(pizza.is_delivered)
def test_valid_api_works(self):
Order(price=100).save()
# valid api
self.assertIsInstance(Order.objects.cost_between(lower=50),
models.QuerySet)
self.assertIsInstance(OrderQuerySet.cost_between.q(lower=50), models.Q)
q1 = OrderQuerySet.cost_between.q(lower=50)
q2 = OrderQuerySet.cost_between.q(upper=200000)
Pizza.objects.filter(nested_q('order', q1 & q2))
# invalid api
with self.assertRaisesRegexp(Exception, 'Not a Q object'):
Pizza.objects.filter(
nested_q('order', Order.objects.cost_between(0, 500)))
# invalid api
with self.assertRaisesRegexp(AttributeError, 'no attribute'):
q2 = Order.objects.cost_between.q(upper=200000)
def additional_stuff(obj):
obj.save()
for i in set((i.split("/")[1] for i in request.POST if "/" in i)):
count = request.POST["count/" + str(i)]
each_cents = request.POST["each_cents/" + str(i)]
product = request.POST["product/" + str(i)]
if each_cents and count and int(each_cents) > 0 and int(count) > 0:
if int(i) < 0:
order = Order(incoming_invoice=obj)
else:
order = obj.order_set.get(pk=int(i))
order.each_cents = each_cents
order.product_id = product
order.count = count
order.save()
elif int(i) >= 0:
obj.order_set.get(pk=int(i)).delete()
return True, ""
def test_q_method_used_from_other_model(self):
"""
Use a @q_method from a different model in a queryset
This test is a good example of a plausible use case for this.
"""
order = Order(price=100)
order.save()
pizza = Pizza(diameter=12, order=order, created=timezone.now())
pizza.save()
self.assertEqual(0, Pizza.objects.is_delivered().count())
order.delivered_time = timezone.now()
order.save()
self.assertEqual(1, Pizza.objects.is_delivered().count())
def test_example(self):
order = Order(price=100, name_on_order="Bob")
order.save()
pizza = Pizza(diameter=12, order=order, created=timezone.now())
pizza.save()
self.assertEqual(0, Pizza.objects.is_delivered().count())
self.assertEqual(0, Order.objects.is_delivered().count())
self.assertFalse(pizza.is_delivered)
order.delivered_time = timezone.now()
order.save()
self.assertEqual(1, Order.objects.is_delivered().count())
self.assertEqual(1, Pizza.objects.is_delivered().count())
self.assertTrue(pizza.is_delivered)
def test_q_method_used_from_other_model(self):
"""
Use a @q_method from a different model in a queryset
This test is a good example of a plausible use case for this.
"""
order = Order(price=100)
order.save()
pizza = Pizza(diameter=12, order=order, created=timezone.now())
pizza.save()
self.assertEqual(0, Pizza.objects.is_delivered().count())
order.delivered_time = timezone.now()
order.save()
self.assertEqual(1, Pizza.objects.is_delivered().count())
def supply_order(request):
order = urllib2.unquote(request.POST.get("order", ""))
phone = request.POST.get("phone", None)
email = request.POST.get("email", None)
name = request.POST.get("name", None)
address = request.POST.get("address", None)
deliveryCloseHour = IntModel.objects.filter(intType=IntModel.HOUR_DELIVERYCLOSE)[0].value
freeDeliveryMinPrice = IntModel.objects.filter(intType=IntModel.FREE_DELIVERY_MIN_PRICE)[0].value
deliveryPrice = IntModel.objects.filter(intType=IntModel.DELIVERY_PRICE)[0].value
deliveryInterval = IntModel.objects.filter(intType=IntModel.MAX_DELIVERY_INTERVAL)[0].value
if order == "":
return HttpResponseRedirect(reverse("url_main"))
order = json.loads(order)
supplyGroups = []
supplies = Supply.objects.all().order_by("supplyDate")
for orderItem in order:
found = False
for supply in supplies:
supplyDate = supply.supplyDate
if supplyDate < date.today():
if datetime.now().hour < deliveryCloseHour:
supplyDate = date.today()
else:
supplyDate = date.today() + timedelta(1)
availableGoods = supply.listAvailableGoods()
for availableGood in availableGoods:
if availableGood["good"].pk == int(orderItem["id"]) and float(availableGood["value"]) >= float(
orderItem["value"]
):
found = True
orderItem["name"] = availableGood["good"].name
if availableGood["supplyItem"].supply.status != Supply.NEW:
orderItem["price"] = availableGood["good"].price
else:
orderItem["price"] = availableGood["good"].priceFut
orderItem["total"] = orderItem["value"] * float(orderItem["price"])
createNewGroup = True
orderItem["supply"] = supply
orderItem["modelGood"] = availableGood["good"]
orderItem["supplyItem"] = availableGood["supplyItem"]
orderItem["isPartnerGood"] = availableGood["isPartnerGood"]
for supplyGroup in supplyGroups:
if (supplyDate - supplyGroup["minDate"]).days < deliveryInterval and (
supplyGroup["maxDate"] - supplyDate
).days < deliveryInterval:
createNewGroup = False
supplyGroup["goods"].append(orderItem)
if supplyDate < supplyGroup["minDate"]:
supplyGroup["minDate"] = supplyDate
elif supplyGroup["maxDate"] < supplyDate:
supplyGroup["maxDate"] = supplyDate
supplyGroup["totalPrice"] += orderItem["total"]
if orderItem["cut"]:
supplyGroup["totalPrice"] += 100
break
if createNewGroup:
supplyGroups.append(
{
"goods": [orderItem],
"minDate": supplyDate,
"maxDate": supplyDate,
"totalPrice": orderItem["total"] + 100 * orderItem["cut"],
"delivery": False,
}
)
break
if found:
break
if phone is None or email is None:
for supplyGroup in supplyGroups:
for good in supplyGroup["goods"]:
good["modelGood"] = None
good["supplyItem"] = None
good["supply"] = None
if supplyGroup["totalPrice"] < freeDeliveryMinPrice:
supplyGroup["totalPrice"] += deliveryPrice
supplyGroup["delivery"] = True
if "application/json" in map(lambda x: x.strip(), request.META.get("HTTP_ACCEPT").lower().split(",")):
return HttpResponse(
json.dumps({"supplyGroups": supplyGroups, "deliveryPrice": deliveryPrice}, cls=DjangoJSONEncoder),
content_type="application/json",
)
return render_to_response(
"card.html", {"supplyGroups": supplyGroups, "deliveryPrice": deliveryPrice}, RequestContext(request)
)
else:
order = Order(phone=phone, email=email, name=name, address=address)
order.save()
for supplyGroup in supplyGroups:
for good in supplyGroup["goods"]:
if good["isPartnerGood"]:
resides = good["supplyItem"].getResides(good["modelGood"])
if resides < good["value"]:
difference = good["value"] - resides
good["supplyItem"].value += difference
good["supplyItem"].save()
SupplyOrderItem(
good=good["modelGood"], order=order, supply=good["supply"], value=good["value"], cut=False
).save()
# logoName = ImageModel.objects.get(imgType=ImageModel.LOGO_BW)
# logo = ''
# with open(os.path.join(MEDIA_ROOT, logoName.image), 'rb') as image_file:
# logo = base64.b64encode(image_file.read())
messageVars = {"name": name, "orderNumber": order.pk, "sumPrice": supplyGroup["totalPrice"]}
message = TextModel.objects.get(name=TextModel.NEW_ORDER_MAIL).text.format(**messageVars)
# message = u'''Здравствуйте, %s!
# Ваш заказ №%d принят и ожидает обработки!
#
# Огромное спасибо!
# Искренне ваши, мясо-яйца-молоко!''' % (name, order.pk,)
# send_mail(u'Заказ #%d' % order.pk, message, u'[email protected]', (order.email,))
messageVars["logo"] = ""
messageVars["items"] = map(
lambda x: {"object": x[0], "id": x[1]},
[(supplyGroup["goods"][index], index + 1) for index in xrange(len(supplyGroup["goods"]))],
)
messageVars["deliveryPrice"] = deliveryPrice
messageVars["messageText"] = message.split("\n")
send(u"Заказ №%d" % order.pk, message, "order.html", messageVars, order.email)
resp = HttpResponseRedirect(reverse("url_main"))
resp.set_cookie("card", "", 3600)
resp.set_cookie("lastCard", request.COOKIES["card"], 31536000)
return resp
def post(self, request, format=None):
serializer = self.serializer_class(
data=request.data,
)
if serializer.is_valid():
user_phone_number = serializer.validated_data['user_phone_number']
restaurant_name=serializer.validated_data['restaurant']
phone_number=serializer.validated_data['phone_number']
item_jsons=serializer.validated_data['item_jsons']
name = serializer.validated_data['name']
email = serializer.validated_data['email']
shipping_address = serializer.validated_data['shipping_address']
billing_address = serializer.validated_data['billing_address']
state = serializer.validated_data['state']
country = serializer.validated_data['country']
zip_code = serializer.validated_data['zip_code']
total_price=serializer.validated_data['total_price']
paymentStatus=serializer.validated_data['paymentStatus']
how=serializer.validated_data['how']
special_instruction=serializer.validated_data['special_instruction']
schedule_time=serializer.validated_data['schedule_time']
schedule_date=serializer.validated_data['schedule_date']
try:
user=User.objects.filter(phone_number=user_phone_number)[0]
except:
user=None
response_data={}
if user:
try:
restaurant=Restaurant.objects.filter(name=restaurant_name)[0]
except:
restaurant=None
if restaurant:
if how=='d':
how='delivery'
elif how=='t':
how='takeaway'
elif how=='sd':
how='schedule-delivery'
elif how=='st':
how='schedule-takeaway'
if how=="delivery" or how=="takeaway":
today=date.today()
schedule_date=today.strftime("%Y-%m-%d")
now = datetime.now()
schedule_time=now.strftime("%H:%M:%S")
if how=='delivery' or how=='schedule-delivery':
order=Order(user=user,restaurant=restaurant,item_jsons=item_jsons,name=name,phone_number=phone_number,email=email,
shipping_address=shipping_address,billing_address=billing_address,state=state,country=country,zip_code=zip_code,
total_price=total_price,payment_mode=paymentStatus,how=how,special_instruction=special_instruction,schedule_time=schedule_time,
schedule_date=schedule_date)
else:
order=Order(user=user,restaurant=restaurant,item_jsons=item_jsons,name=name,phone_number=phone_number,email=email,
total_price=total_price,payment_mode=paymentStatus,how=how,special_instruction=special_instruction,schedule_time=schedule_time,
schedule_date=schedule_date)
order.save()
id=order.order_id
if paymentStatus=="COD":
order.order_status='pending'
order.payment_mode='COD'
order.payment_status=False
order.save()
if how=='delivery' or how=='schedule-delivery':
newadd=shipping_address+'\n'+state+'\n'+country+'\n'+zip_code
obj=Address.objects.filter(user=user,address=newadd)
if obj.count()<=0:
address=Address(user=user,address=newadd)
address.save()
response={'order_id':id,'status':'success','checkSum':""}
return Response(response)
else:
order.save()
if how=='delivery' or how=='schedule-delivery':
newadd=shipping_address+'\n'+state+'\n'+country+'\n'+zip_code
obj=Address.objects.filter(user=user,address=newadd)
if obj.count()<=0:
address=Address(user=user,address=newadd)
address.save()
id=order.order_id
data_dict = {
'MID':'aVrRqW70498541104158',
'ORDER_ID':str(order.order_id),
'TXN_AMOUNT':str(order.total_price),
'CUST_ID':str(email),
'INDUSTRY_TYPE_ID':'Retail',
'WEBSITE':'WEBSTAGING',
'CHANNEL_ID':'WAP',
'CALLBACK_URL':'https://securegw-stage.paytm.in/theia/paytmCallback?ORDER_ID='+str(order.order_id),
}
data_dict['CHECKSUMHASH']=Checksum.generate_checksum(data_dict,MERCHANT_KEY)
print(data_dict['CHECKSUMHASH'])
response={'order_id':id,'status':'success','checkSum':data_dict['CHECKSUMHASH']}
return Response(response)
else:
response_data={'status':'restaurant not found'}
return Response(response_data)
else:
response_data={'status':'user not found'}
return Response(response_data)
else:
return Response({'status':"Fail"})
def m_tif(self):
if Order.TimeInForceChoice(self.TimeInForce) not in self._tif_map:
raise NotImplementedError(
'Time in force of this type ' +
Order.TimeInForceChoice.to_str(self.TimeInForce))
return self._tif_map[Order.TimeInForceChoice(self.TimeInForce)]
def order(request):
context = {}
context.update(csrf(request))
template = "main/order_dialog_step1.html"
if request.method == 'POST':
step = request.POST.get('step', '1')
form = OrderForm(request.POST)
if form and form.is_valid():
if step == '1': # form -> preview
try:
book = Book.objects.get(alias=form.cleaned_data['book'])
except ObjectDoesNotExist:
response = simplejson.dumps({"success": False})
return HttpResponse(response,
content_type="application/javascript; charset=utf-8")
context['book'] = book
context['check_form'] = form
context['total'] = Order.calc_total2(
quantity=form.cleaned_data['quantity'],
price=Book.objects.filter(alias="red")[0].price,
delivery_price=Decimal(settings.DELIVERY_PRICE)
if form.cleaned_data['delivery_method'] == 'courier' else 0)
template = "main/order_dialog_step2.html"
success = True
elif step == '2': # preview -> submit
success = True
customer = Customer()
order = Order()
# customer.lastname = form.cleaned_data['lastname']
# customer.firstname = form.cleaned_data['firstname']
customer.name = form.cleaned_data['name']
customer.email = form.cleaned_data['email']
customer.tel = form.cleaned_data['tel']
customer.save()
order.book = Book.objects.get(alias=form.cleaned_data['book'])
order.quantity = form.cleaned_data['quantity']
order.payment_method = form.cleaned_data['payment_method']
order.delivery_method = form.cleaned_data['delivery_method']
if order.delivery_method == 'courier':
order.delivery_price = Decimal(settings.DELIVERY_PRICE)
order.order_date = datetime.datetime.now()
order.order_number = order.calc_order_number()
order.customer = customer
order.save()
context['order'] = order
context['total'] = order.calc_total()
template = "main/order_dialog_finish.html"
send_mail(u'Заказ на mislistudenta.ru', render_to_string('main/confirmation.txt', context), settings.EMAIL_HOST_USER, [order.customer.email])
else:
form._errors = {}
context["order_form"] = form
success = False
else:
form = request.GET.get('form')
if form:
form = unquote(request.GET.get('form').encode('utf8')).decode('utf8')
context["order_form"] = OrderForm(initial=dict(parse_qsl(form)))
else:
context["order_form"] = OrderForm()
success = True
html = render_to_string(template, RequestContext(request, context))
response = simplejson.dumps({"success": success, "html": html})
return HttpResponse(response,
content_type="application/javascript; charset=utf-8")
def add_order(request):
response = {'response': '2'}
r_platform = 'android'
error_message = ''
user = None
buyer = None
r_goods = ''
goods = []
price_total = 0
counts = []
wishes_json = None
print(request.method)
if request.method == 'GET':
token = request.session.get('token', '')
r_platform = 'web'
if token == '':
return HttpResponseRedirect('/login')
else:
buyer = Buyer.objects.filter(token_web=request.session.get('token', ''))
elif request.method == 'POST':
req = json.loads(request.body)
# req = json.loads(request.POST.get('test'))
print req
r_platform = req['platform']
r_goods = json.loads(req['goods'])
r_address_id = req['address_id']
address1 = Address.objects.get(id=r_address_id)
buyer = Buyer.objects.filter(token=req['token'])
try:
wishes_json = json.loads(req['wish_list'])
for foo in wishes_json:
wish = WishList.objects.get(id=foo['id'])
wish.dele = 0
wish.save()
except Exception:
print wishes_json is None
for foo in r_goods:
good = Goods.objects.get(id=foo['id'])
goods.append(good)
price_total += good.price * string.atoi(foo['count'])
counts.append(foo['count'])
print len(buyer)
if len(buyer) == 1 and len(goods) != 0:
user = buyer[0]
order = Order(goods=r_goods, buyer=user, date=datetime.datetime.now(), state=0,
price=price_total, address=address1)
order.save()
for index, foo in enumerate(goods):
history = BuyHistory(buyer=user, goods=foo, price=foo.price, amount=counts[index],
order=order, state=0, date=order.date)
history.save()
response['response'] = 1
response['order_id'] = order.id
elif len(goods) == 0:
error_message = 'No this goods'
response['error_msg'] = error_message
if r_platform == 'web':
return render_to_response('personal.html', locals())
elif r_platform == 'android':
json.dumps(response)
j = json.dumps(response)
return HttpResponse(j)
