def create_order(request):
address = request.POST.get('address')
pay_code = request.POST.getlist('rd')
# 生成订单号
try:
with transaction.atomic():
uid = request.user.userprofile.uid
order_code = datetime.datetime.now().strftime('%Y%m%d%H%M%S') + str(random.randint(0, 10))
order = Order(order_code=order_code,
address='湖北武汉市高新区金融港', receiver='小玲',
user_message='请送货的时候给我带包辣条',
mobile='110',
user_id=uid)
order.save()
# 用户下面购物车的数据清空
# 1 表示正常 0表示删除
ShopCar.objects.filter(user_id=uid, status=1).update(status=-1, order=order)
if pay_code == 1:
pass
# 微信支付
else:
# 支付宝支付
pass
except:
pass
def post(self, request):
if request.user.role == 0:
# 获取空闲的回收人员
scrap_users = UserProfile.objects.filter(role=1,
deleted=0,
work_status=0)
if scrap_users:
scrap_user = scrap_users[0]
# 修改回收人员的状态
scrap_user.work_status = 1
scrap_user.save()
# 创建订单
order = Order(generate_order_number(), request.user.phone,
request.user.address, request.user.username,
scrap_user.phone)
order.save()
# 给废品回收人员发送订单通知
send_sms_notify(scrap_user.phone, order.order_number)
# 保存短信发送记录
SMSMsg(scrap_user.username, scrap_user.phone).save()
return JsonResponse({'status': 'success', 'msg': '下单成功'})
else:
return JsonResponse({
'status': 'failure',
'msg': '回收人员繁忙，请稍后再试'
})
else:
return JsonResponse({'status': 'failure', 'msg': '你没有该操作的权限'})
def checkout(request, first_name, last_name, email, address, zipcode, place,
country, phone):
order = Order(first_name=first_name,
last_name=last_name,
email=email,
address=address,
zipcode=zipcode,
place=place,
country=country,
phone=phone)
if request.user.is_authenticated:
order.user = request.user
order.save()
cart = Cart(request)
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
return order.id
def checkout(request, first_name, last_name, email, address, zipcode, place, phone):
"""
Params:
-first_name:[String] Customer's first name
-last_name:[String] Customer's last name
-email:[String] Customer's E-mail
-address:[String] Customer's Address
-zipcode:[String] Customer's zipcode
-phone:[String] Customer's phone
Return:
-order.id : [String] The generated id from the order that just saved into the Database
"""
order = Order(first_name=first_name, last_name=last_name, \
email=email, address=address, zipcode=zipcode, place=place, phone=phone)
# If the user is authenticated then save the already saved user's info in the order's info
if request.user.is_authenticated:
order.user = request.user
order.save()
cart = Cart(request)
# Create the order
for item in cart:
OrderItem.objects.create(order=order, product=item['product'], \
price=item['price'], quantity=item['quantity'])
return order.id
def placeorder(request):
cart=Cart(request)
if request.method == 'POST':
form = CheckoutForm(request.POST)
if form.is_valid():
try:
first_name = request.POST['first_name']
last_name = request.POST['last_name']
email = request.POST['email']
phone = request.POST['phone']
address = request.POST['address']
zipcode = request.POST['zipcode']
place = request.POST['place']
amount=12
order=Order(first_name=first_name,last_name=last_name, email=email, address=address, zipcode=zipcode, place=place, phone=phone, paid_amount=amount)
order.save()
for item in Cart(request):
ordr=OrderItem.objects.create( order=order,product=item['product'], vendor=item['product'].vendor, price=item['product'].price, quantity=item['quantity'])
order.vendors.add(item['product'].vendor)
notify_customer(order)
notify_vendor(order)
cart.clear()
return redirect('success')
except Exception:
messages.error(request, 'There was something wrong with the payment')
else:
form = CheckoutForm()
return render(request,'cart/placeorder.html',{'form': form})
def checkout(request, first_name, last_name, email, address, zipcode, place):
order = Order(first_name=first_name, last_name=last_name, email=email, address=address, zipcode=zipcode,
place=place)
order.save()
cart = Cart(request)
for item in cart:
OrderItem.objects.create(order=order, product=item['product'], price=item['price'], quantity=item['quantity'])
return order.id
def post(self):
args = self.parser.parse_args()
uid = args.get('uid')
movie_id = args.get('movie_id')
hs_id = args.get('hs_id')
seat_ids = args.get('seat_ids')
ss_id = args.get('ss_id')
try:
# db.session.begin()
# 查询座位是否可选
seats = Seats.query.filter(Seats.sid.in_(seat_ids)).all()
if is_choose(seats):
# 锁定座位
for seat in seats:
seat.is_choose = False
db.session.add_all(seats)
# 生成订单号
no = product_code()
# 查询票价
hs = HallScheduling.query.get(hs_id)
# 计算总金额
total = hs.current_price * 2
# 生成订单
order = Order(no=no,
number=2,
total=total,
status=1,
movie_id=movie_id,
hs_id=hs_id,
cinema_id=1,
ss_id=1,
seat_id=1)
# 提交订单
db.session.add(order)
db.session.commit()
return to_response_success(
data=no, fields=OrderSuccessFields.result_fields)
else:
return to_response_error(status='-1', msg='座位已经被选了')
except:
db.session.rollback()
return '失败'
def add(request, pk):
product = get_object_or_404(Product, pk=pk)
referer = request.META.get('HTTP_REFERER')
redirect = HttpResponseRedirect(reverse('product:view', args=[product.category.pk, pk]))
if referer and 'login' in referer:
return redirect
order = Order.objects.filter(user=request.user, status=Order.CART).first()
if not order:
order = Order(user=request.user)
order.save()
current = order.positions.filter(product=product)
if current:
current[0].quantity += 1
current[0].save()
else:
position = Position(product=product)
position.quantity = 1
position.save()
order.positions.add(position)
return HttpResponseRedirect(referer) if referer else redirect
def match_install(install,install1,amount,t):
install_res=Order()
install_res.trantype=install.trantype
install_res.subtrantype=install.subtrantype
install_res.amount=amount
install_res.userid=install.userid
install_res.username=install.username
install_res.userid_to=install1.userid
install_res.username_to=install1.username
install_res.ordercode_to=install1.ordercode
install_res.status=1
install_res.confirmtime=install.confirmtime
install_res.matchtime = t
install_res.createtime = install.createtime
install_res.img = install.img
install_res.umark = install.umark
install_res.save()
return install_res
def post(self, request, *args, **kwargs):
client_data = cookie_parser(request.COOKIES.get('client_data'))
order = Order()
order.shipping_address = client_data.get('shipping_address')
order.phone = client_data.get('phone')
order.client_name = client_data.get('client_name')
if request.user.is_authenticated:
order.customer = request.user
order.save()
cart_items = self.get_cart_items(self.request)
total_price = 0
json_data = []
for cart_item in cart_items:
cart_item.order = order
total_price += cart_item.total_price
cart_item.save()
title = "{} {}".format(cart_item.variation.product.name,
cart_item.variation.name)
if cart_item.variation.color:
title = "{} {}".format(title, cart_item.variation.color.name)
json_data.append({
'title': title,
'price': float(cart_item.variation.price),
'count': cart_item.count,
'total_price': float(cart_item.total_price)
})
order.products = json_data
order.total_price = Decimal(total_price)
order.order_unique_id = uuid.uuid4()
order.save()
order_detail_url = reverse_lazy(
'orders:order_detail', args=[order.phone, order.order_unique_id])
data = {
'message': _('Order successful placed'),
'status': 'success',
'redirect_url': order_detail_url
}
return JsonResponse(data=data, safe=False)
def checkout(request, first_name, last_name, email, phone, address, zipcode,
place):
order = Order(first_name=first_name,
last_name=last_name,
email=email,
phone=phone,
address=address,
zipcode=zipcode,
place=place)
# something happens if user is authenticated
if request.user.is_authenticated:
order.user = request.user
# ----
order.save()
cart = Cart(request)
# Add items to OrderItems
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
return order.id
def checkout(request, first_name, last_name, email, address, zipcode, city,
country):
order = Order(first_name=first_name,
last_name=last_name,
email=email,
address=address,
zipcode=zipcode,
city=city,
country=country)
order.save()
# Create a cart instance
cart = Cart(request)
# For each item in cart, create one of the order items for each product
for item in cart:
OrderItem.objects.create(order=order,
product=item['product'],
price=item['price'],
quantity=item['quantity'])
# Update order id
return order.id
def post(self, request, *args, **kwargs):
if request.POST.get('is_submitted'):
cart_items = get_cart_items(self.request)
total_weight = get_total_weight(cart_items=cart_items)
client_data_cookie = self.request.COOKIES.get('client_data')
client_data = cookie_parser(client_data_cookie)
address = client_data.get('address')
order = Order()
order.client_name = address.get('client_name')
order.payment = PaymentMethod.objects.get(
method__exact=client_data.get('payment_method'))
order.phone = address.get('phone')
order.shipping_address = address.get('shipping_address')
order.total_weight = total_weight
order.delivery_price = get_delivery_price(cart_items)
try:
order.need_porter = int(client_data.get('need_porter'))
except ValueError:
pass
if request.user.is_authenticated():
order.customer = request.user
if order.need_porter:
order.porter_work_price = get_delivery_price(cart_items)
order.shipping_time = datetime.fromtimestamp(
client_data.get('time'), tz=pytz.timezone(settings.TIME_ZONE))
order.save()
total_price = 0
json_data = []
for cart_item in cart_items:
cart_item.order = order
total_price += cart_item.total_price
cart_item.save()
title = "{} {}".format(cart_item.variation.product.name,
cart_item.variation.name)
if cart_item.variation.color:
title = "{} {}".format(title,
cart_item.variation.color.name)
json_data.append({
'title': title,
'price': float(cart_item.variation.price),
'count': cart_item.count,
'total_price': float(cart_item.total_price)
})
order.products = json_data
order.products_price = Decimal(total_price)
order.order_unique_id = uuid.uuid4()
order.total_price = order.products_price + get_delivery_price(
cart_items)
order.save()
if order.payment.method == PaymentMethod.CASH_ON_DELIVERY:
return redirect(
reverse_lazy('orders:order_detail',
args=[order.phone, order.order_unique_id]))
elif order.payment.method == PaymentMethod.PAYME:
# https://checkout.paycom.uz/base64(m=587f72c72cac0d162c722ae2;ac.order_id=197;a=500)
merchant_id = settings.PAYME_MERCHANT_ID
ac_order_id = order.id
ac_customer_id = order.phone
amount = int(order.total_price.real) * 100
redirect_url_after_operation = reverse_lazy(' basic:home')
ct = 15
cr = 860
data = "m={};ac.order_id={};ac.customer_id={};a={};c={}".format(
merchant_id, ac_order_id, ac_customer_id, amount,
redirect_url_after_operation)
base64_data = base64.b64encode(
data.encode('utf-8')).decode('utf-8')
base64_data_url = "https://checkout.paycom.uz/{}".format(
base64_data)
return redirect(to=base64_data_url)
elif order.payment.method == PaymentMethod.UZCARD:
return redirect(
reverse('orders:payment_uzcard',
args=[order.phone, order.order_unique_id]))
else:
return redirect(reverse(' basic:home'))
return redirect(reverse(' basic:home'))
def post(self,request):
data_dict = json.loads(request.body.decode())
house_id = data_dict.get('house_id')
start_date = data_dict.get('start_date')
end_date = data_dict.get('end_date')
user = request.user
#判断完整
if not all([house_id,start_date,end_date]):
return JsonResponse({'errno': 400, 'errmsg': '缺少必传参数'})
#是否存在
try:
house = House.objects.get(id=house_id)
except Exception as e:
return JsonResponse({"errno": 400, "errmsg": "房屋不存在"})
#是否房主
if user.id == house.user.id:
return JsonResponse({"errno": 400, "errmsg": "是房主无法预定"})
#跳转页面
#判断是否传入错误数据
try:
d1 = datetime.datetime.strptime(start_date, '%Y-%m-%d')
d2 = datetime.datetime.strptime(end_date, '%Y-%m-%d')
assert d1 < d2, Exception('开始日期大于结束日期')
days = (d2 - d1).days
if days < 0:
return JsonResponse({'errno': 400, 'errmsg': '日期有误'})
except Exception as e:
return JsonResponse({'errno': 400, 'errmsg': '参数有误'})
#开启事务
# with transaction.atomic():
#
# save_id = transaction.savepoint()
# try:
amount = days * house.price
if days < house.min_days:
return JsonResponse({'errno': 400, 'errmsg': '住的时间太短'})
if days > house.max_days:
return JsonResponse({'errno': 400, 'errmsg': '住的时间太长'})
order = Order()
order.user_id = user.id
order.house_id = house.id
order.begin_date = d1
order.end_date = d2
order.days = days
order.amount = amount
order.house_price = house.price
order.status = Order.ORDER_STATUS['WAIT_ACCEPT']
order.save()
# order = Order.objects.create(user_id=user.id,
# house_id=house_id,
# begin_date=d1,
# end_date=d2,
# days=days,
# amount=amount,
# # # status=Order.ORDER_STATUS['PAID'],
# price=house.price,
# )
# 判断用户下单的时间段是否有别的订单
count = Order.objects.filter(house_id=house_id,
begin_date__lte=end_date,
end_date__gte=start_date).count()
if count > 0:
# 说明房子被别人预定
# transaction.savepoint_rollback(save_id)
return JsonResponse({'errno': 400, 'errmsg': '房子已被预定'})
# except Exception as e:
# transaction.savepoint_rollback(save_id)
# return JsonResponse({'errno': 400, 'errmsg': '下单失败'})
#提交事务
# transaction.savepoint_commit(save_id)
return JsonResponse({'errno': 0, 'errmsg': '添加订单成功', "data": {"order_id": order.pk}})
def post_order(data):
user_id = data["user_id"]
notes = data['notes']
order_time = data['order_time']
items = data['items']
deliver_to = data['deliver_to']
order_loc = data['order_loc']
food_items = []
user = User.query.filter_by(id=user_id).first()
if not user:
return {"message": "user id is not found"}, 400
if not items:
return {"message": "items must be not null"}, 400
if list(order_loc.keys()) != ['latitude', 'longitude', 'accuracy']:
return {"message": "order_loc object is not valid key"}, 400
if type(order_loc['latitude']) != float and type(order_loc['latitude']) != int:
return {"message": "latitude of order_loc object is not valid type"}, 400
if type(order_loc['longitude']) != float and type(order_loc['longitude']) != int:
return {"message": "longitude of order_loc object is not valid type"}, 400
if type(order_loc['accuracy']) != float and type(order_loc['accuracy']) != int:
return {"message": "accuracy of order_loc object is not valid type"}, 400
if list(deliver_to.keys()) != ['latitude', 'longitude', 'accuracy', 'is_pinned']:
return {"message": "deliver_to object is not valid key"}, 400
if type(deliver_to['latitude']) != float and type(deliver_to['latitude']) != int:
return {"message": "latitude of deliver_to object is not valid type"}, 400
if type(deliver_to['longitude']) != float and type(deliver_to['longitude']) != int:
return {"message": "longitude of deliver_to object is not valid type"}, 400
if type(deliver_to['accuracy']) != float and type(deliver_to['accuracy']) != int:
return {"message": "accuracy of deliver_to object is not valid type"}, 400
if type(deliver_to['is_pinned']) != bool:
return {"message": "is_pinned of deliver_to object is not valid type"}, 400
for item in items:
if "id" and "qty" not in item.keys():
return {"message": "item must have id and qty"}, 400
if int != type(item["id"]):
return {"message": "id of item should be integer"}, 400
if int != type(item["qty"]):
return {"message": "qty of item should be integer"}, 400
food = Food.query.get(item["id"])
if not food:
return {"message": "food id={} is not found".format(item["id"])}, 400
if food.stock < item["qty"]:
return {"message": "stock not enough for {}, avalaible {} ".format(food.name, food.stock)}, 400
item = CartItem(
qty=item["qty"],
food_id=item["id"]
)
food_items.append(item)
order_loc = OrderLocationTracked(
latitude=order_loc['latitude'],
longitude=order_loc['longitude'],
accuracy=order_loc['accuracy']
)
deliver_to = OrderLocationTracked(
latitude=deliver_to['latitude'],
longitude=deliver_to['longitude'],
accuracy=deliver_to['accuracy'],
is_pinned=deliver_to['is_pinned']
)
order = Order(
order_time=order_time,
order_loc=order_loc,
deliver_to=deliver_to,
notes=notes,
cart=Cart()
)
order.cart.cart_items = food_items
user.user_detail.orders.append(order)
try:
user.commit()
except:
return {"message": "can't save, tell you engineer"}, 500
return {"message": "success", "data": order.get(detail=True)}
def get(self, *args, **kwargs):
if not self.request.session.get('cart'):
messages.error(self.request, 'Empty cart.')
return redirect('product:list')
if not self.request.user.is_authenticated:
messages.error(self.request, 'Please, login or create account.')
return redirect('costumer:create')
cart = self.request.session.get('cart')
cart_variation_ids = [v for v in cart]
variations_db = list(
Variation.objects.select_related('product').filter(
id__in=cart_variation_ids))
for variations in variations_db:
vid = variations.id
inventory = variations.inventory
cart_qt = cart[vid]['quantity']
price = cart[vid]['price']
promotional_price = cart[vid]['promotional_price']
error_msg_inventory = ''
if inventory < cart_qt:
cart[vid]['quantity'] = inventory
cart[vid]['price'] = inventory * price
cart[vid]['promotional_price'] = inventory * promotional_price
error_msg_inventory = 'Some products had inventory changes. ' \
'We reduced the quantities in your initial order.'
if error_msg_inventory:
messages.info(
self.request,
error_msg_inventory,
)
self.request.save()
return redirect('product:cart')
total_quantity_cart = utils.total_quantity_cart('cart')
total_value_cart = utils.cart_total('cart')
order = Order(
user=self.request.user,
total=total_value_cart,
total_quantity=total_quantity_cart,
status='C',
)
order.save()
ItemOrder.objects.bulk_create([
ItemOrder(
order=order,
product=v['product'],
product_id=v['product_id'],
variation=v['variation_name'],
variation_id=v['variation_id'],
price=v['quantitative_price'],
promotional_price=v['quantitative_promotional_price'],
image=v['image'],
) for v in cart.values()
])
context = {
'total_quantity_cart': total_quantity_cart,
'total_value_cart': total_value_cart,
}
del self.request.session['cart']
# return render(self.request, self.template_name, context)
return redirect(reverse('order:payment', kwargs={
'pk': order.pk,
}))
def post(self, request):
# 获取到当前用户的id
user = request.user
# 获取到传入的参数
dict_data = json.loads(request.body.decode())
house_id = dict_data.get('house_id')
start_date_str = dict_data.get('start_date')
end_date_str = dict_data.get('end_date')
# 校验参数
if not all([house_id, start_date_str, end_date_str]):
return http.JsonResponse({"errno": RET.PARAMERR, "errmsg": "参数错误"})
try:
start_date = datetime.datetime.strptime(start_date_str, "%Y-%m-%d")
end_date = datetime.datetime.strptime(end_date_str, "%Y-%m-%d")
assert start_date < end_date, Exception('开始日期大于结束日期')
# 计算出入住天数
days = (end_date - start_date).days
except Exception as e:
logger.error(e)
return http.JsonResponse({"errno": RET.PARAMERR, "errmsg": "参数错误"})
# 判断房屋是否存在
try:
house = House.objects.get(id=house_id)
except Exception as e:
logger.error(e)
return http.JsonResponse({"errno": RET.NODATA, "errmsg": "房屋不存在"})
# 判断房屋是否是当前登录用户的
if user.id == house.user.id:
return http.JsonResponse({
"errno": RET.ROLEERR,
"errmsg": "不能订购自己的房间"
})
# 查询是否存在冲突的订单
try:
filters = {
"house": house,
"begin_date__lt": end_date,
"end_date__gt": start_date
}
count = Order.objects.filter(**filters).count()
except Exception as e:
logger.error(e)
return http.JsonResponse({"errno": RET.DBERR, "errmsg": "数据库查询错误"})
if count > 0:
return http.JsonResponse({
"errno": RET.DATAERR,
"errmsg": "房间已经被预定"
})
amount = days * house.price
# 生成订单的模型
order = Order()
order.user = user
order.house = house
order.begin_date = start_date
order.end_date = end_date
order.days = days
order.house_price = house.price
order.amount = amount
try:
order.save()
except Exception as e:
logger.error(e)
return http.JsonResponse({"errno": RET.DBERR, "errmsg": "数据库保存失败"})
return http.JsonResponse({
"errno": RET.OK,
"errmsg": "发布成功",
"data": {
"order_id": order.pk
}
})
