def post(self, request):
# 接收数据
data = json.loads(request.body)
token = data['token']
# 参数校验
if not all([token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
# 查询未支付状态的订单
order_info = OrderInfo.objects.filter(wx_user=wx_user,
state=0,
is_delete=False)
if order_info:
for order in order_info:
# 判断是否超时
if PublicFunction.timeout(order.create_time):
order.state = 6
order.cancel_time = time.time
order.save()
except:
return Response({'msg': '无订单信息'})
def post(self, request):
# 接收数据
data = json.loads(request.body)
order_id = data['order_id']
token = data['token']
# 参数校验
if not all([order_id, token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
data = {}
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
order_info = OrderInfo.objects.get(order_id=order_id)
except:
return Response({'msg': '订单不存在'})
try:
order_list = OrderList.objects.filter(
wx_user=wx_user, order_info=order_info,
is_delete=False).values()
data['order_list'] = order_list
except:
return Response({'msg': '获取订单清单失败'})
return Response(data)
def post(self, request):
# 接收数据
data = json.loads(request.body)
order_info_id = data['order_info_id']
token = data['token']
# 参数校验
if not all([order_info_id, token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
order_info = OrderInfo.objects.get(id=order_info_id)
order_info.is_delete = True
order_info.save()
except:
return Response({'msg': '订单不存在'})
return Response({'msg': '删除订单成功'})
def post(self, request):
data = json.loads(request.body)
token = data['token']
order_info_id = data['order_info_id']
returns_num = data['returns_num']
# 参数校验
if not all([token, order_info_id, returns_num]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
order_info = OrderInfo.objects.get(id=order_info_id)
order_info.returns_number = returns_num
order_info.state = 5
order_info.save()
except:
return Response({'msg': '订单不存在'})
return Response({'msg': '申请退款成功'})
def post(self, request):
data = json.loads(request.body)
token = data['token']
order_info_id = data['order_info_id']
# 参数校验
if not all([token, order_info_id]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
order_info = OrderInfo.objects.get(id=order_info_id)
order_info.state = 4
order_info.complete_time = time.strftime('%Y-%m-%d- %H:%M:%S')
order_info.save()
except:
return Response({'msg': '订单不存在'})
return Response({'msg': '订单已确认'})
def post(self, request):
'''购物车记录添加'''
# 接收数据
data = json.loads(request.body)
# 获取要删除的商品id列表
commodityId_list = data['commodityId_list']
token = data['token']
# 数据校验
if not all([commodityId_list, token]):
return Response({'msg': '数据不完整'})
# 校验商品是否存在
try:
for commodity_id in commodityId_list:
commodity = Commodity.objects.get(id=commodity_id)
except commodity.DoesNotExist:
return Response({'msg': '商品不存在'})
# 业务处理：删除购物车记录
open_id = PublicFunction().getOpenIdByToken(token)
conn = get_redis_connection('Cart')
cart_key = 'cart_%s' % open_id
# 删除商品
conn.hdel(cart_key, *commodityId_list)
# 计算用户购物车商品的条目数
total_count = conn.hlen(cart_key)
return Response({'msg': '删除成功', 'total_count': total_count})
def get(self, request, token):
# 参数校验
if not all([token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
data_list = []
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
user_card_list = UserCard.objects.filter(wx_user=wx_user)
for user_card in user_card_list:
card = Card.objects.filter(id=user_card.card.id).values()
data_list.append({
'card_token': user_card.card_token,
'card': card,
'is_use': user_card.is_use
})
except Exception as e:
print(e)
return Response({'msg': '暂无优惠券'})
return Response({'card_list': data_list})
def get(self, request,token):
'''显示'''
# 获取登录的用户
open_id = PublicFunction().getOpenIdByToken(token)
# 获取用户购物车的商品信息
conn = get_redis_connection('Cart')
cart_key = 'cart_%s' % open_id
# {'商品id':商品数量}
cart_dict = conn.hgetall(cart_key)
if cart_dict:
# 遍历获取商品的信息
commodity_list = []
for commodity_id, count in cart_dict.items():
# 根据商品的id获取商品的信息
commodity = Commodity.objects.get(id=commodity_id)
title = Goods.objects.get(id=commodity.goods_id).title
commodity_list.append({
'id':commodity.id,
'title':title,
'num':int(count),
'price':commodity.price,
'selected':False,
'image':commodity.image.url,
'color':commodity.color,
'code':commodity.code,
'stock':commodity.stock
})
data = {'commodity_list': commodity_list}
return Response(data)
return Response({'msg':'购物车无商品'})
def post(self, request):
# 获取请求数据
data = request.body
data = json.loads(data)
code = data['code']
# 获取open_id、session_key
data = PublicFunction().getOpenIdAndSessionKey(code)
open_id = data[0]
session_key = data[1]
# 如果获取的open_id不为空
if open_id:
# 查找是否存在该wx用户
try:
# 存在用户，直接返回token
wx_user = WxUser.objects.get(open_id=open_id)
data = PublicFunction().createRedisToken(open_id, session_key)
except:
# 创建用户，返回token
WxUser.objects.create(open_id=open_id).save()
data = PublicFunction().createRedisToken(open_id, session_key)
return Response(data)
def get(self, request, token):
# 获取open_id
open_id = PublicFunction().getOpenIdByToken(token)
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
address_list = Address.objects.filter(
wx_user=wx_user,
is_delete=False).order_by('-is_default').values()
return Response({'address_list': address_list})
return Response({'err': 'no_user'})
def get(self, request, token):
# 参数校验
if not all([token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
data_list = []
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
'''
{
order_list{
...
order_info:{
...
}
商品清单列表{
[商品，商品]
}
}
}
'''
order_info = OrderInfo.objects.filter(
wx_user=wx_user, is_delete=False).order_by('-create_time')
for order in order_info:
orders = OrderList.objects.filter(
order_info=order).values()
data = {
'order_info_id': order.id,
'order_id': order.order_id,
'create_time': str(order.create_time)[0:19],
'state': order.state,
'total_count': order.total_count,
'total_price': order.total_price,
'order_list': orders,
}
data_list.append(data)
except:
return Response({'msg': '无订单信息'})
return Response(data_list)
def post(self, request):
# 接收数据
data = json.loads(request.body)
card_id = data['card_id']
token = data['token']
# 参数校验
if not all([card_id, token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
str32 = PublicFunction().randomStr()
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
card = Card.objects.get(id=card_id)
user_card = UserCard.objects.filter(wx_user=wx_user, card=card)
if (len(user_card) == 0):
UserCard.objects.create(card_id=card_id,
wx_user=wx_user,
card_token=str32).save()
else:
if (len(user_card) >= card.get_count):
return Response({'msg': '您已领取过了!'})
else:
UserCard.objects.create(card_id=card_id,
wx_user=wx_user,
card_token=str32).save()
except:
return Response({'msg': '优惠券不存在'})
return Response({'msg': '领取成功'})
def post(self, request):
'''购物车记录添加'''
# 接收数据
data = json.loads(request.body)
commodity_id = data['commodity_id']
count = data['commodity_count']
token = data['token']
# 数据校验
if not all([commodity_id, count,token]):
return Response({'msg': '数据不完整'})
# 校验添加的商品数量
try:
count = int(count)
except Exception as e:
return Response({'msg': '商品数目出错'})
# 校验商品是否存在
try:
commodity = Commodity.objects.get(id=commodity_id)
except commodity.DoesNotExist:
return Response({'msg': '商品不存在'})
# 业务处理：添加购物车记录
open_id = PublicFunction().getOpenIdByToken(token)
conn = get_redis_connection('Cart')
cart_key = 'cart_%s' % open_id
# 先尝试获取commodity_id的值 hget cart_key 属性
# 如果commodity_id在hash中不存在，hget返回None
cart_count = conn.hget(cart_key, commodity_id)
if cart_count:
# 累加购物车中的商品数目
count += int(cart_count)
# 校验商品库存
if count > commodity.stock:
return Response({'msg': '商品库存不足'})
# 设置hash中sku_id对应的值
conn.hset(cart_key, commodity_id, count)
# 计算用户购物车商品的条目数
total_count = conn.hlen(cart_key)
# 返回应答
return Response({'msg': '添加成功', 'total_count': total_count})
def get(self, request, token):
# 参数校验
if not all([token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
user_card = UserCard.objects.filter(wx_user=wx_user,
is_use=False).values()
except:
return Response({'msg': '用户不存在'})
return Response({'data': user_card})
def post(self, request):
# 接收数据
data = json.loads(request.body)
commodity_id = data['commodity_id']
count = data['commodity_count']
token = data['token']
# 数据校验
if not all([commodity_id, count, token]):
return Response({'msg': '数据不完整'})
# 校验添加的商品数量
try:
count = int(count)
except Exception as e:
return Response({'msg': '商品数目出错'})
# 校验商品是否存在
try:
commodity = Commodity.objects.get(id=commodity_id)
except commodity.DoesNotExist:
return Response({'msg': '商品不存在'})
# 业务处理：更新购物车记录
open_id = PublicFunction().getOpenIdByToken(token)
conn = get_redis_connection('Cart')
cart_key = 'cart_%s' % open_id
# 校验商品库存
if count > commodity.stock:
return Response({'msg': '商品库存不足'})
# 更新
conn.hset(cart_key, commodity_id, count)
# 计算用户购物车商品的条目数
total_count = conn.hlen(cart_key)
# 返回应答
return Response({'msg': '更新成功', 'total_count': total_count})
def post(self, request):
# 获取请求数据
data = request.body
data = json.loads(data)
token = data['token']
address_id = data['address_id']
# 获取open_id
open_id = PublicFunction().getOpenIdByToken(token)
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
Address.objects.filter(
Q(wx_user=wx_user) & Q(is_default=True)
& Q(is_delete=False)).update(is_default=False)
Address.objects.filter(id=address_id).update(is_default=True)
return Response({'msg': 'success'})
return Response({'err': 'no_user'})
def get(self, request, token):
# 参数校验
if not all([token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
card = Card.objects.filter(is_delete=0).values()
except:
return Response({'msg': '暂无优惠券活动'})
return Response({'card_list': card})
def post(self, request):
# 接收数据
data = json.loads(request.body)
phone = data['phone']
token = data['token']
# 参数校验
if not all([phone, token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
wx_user.phone = phone
wx_user.save()
except:
return Response({'msg': '用户不存在'})
return Response({'msg': '修改成功'})
def post(self, request):
# 获取请求数据
data = request.body
data = json.loads(data)
token = data['token']
address_id = data['address_id']
# 数据校验
if not all([token, address_id]):
return Response({'errmsg': '数据不完整'})
# 获取open_id
open_id = PublicFunction().getOpenIdByToken(token)
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
# 伪删除
Address.objects.filter(wx_user=wx_user,
id=address_id).update(is_delete=True)
return Response({'msg': 'success'})
return Response({'err': 'no_user'})
def get(self, request, token):
# 参数校验
if not all([token]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
data = {}
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
data = {
'nick_name': wx_user.nick_name,
'birthday': wx_user.birthday,
'phone': wx_user.phone,
'weight': wx_user.weight,
'height': wx_user.height
}
except:
return Response({'msg': '用户不存在'})
return Response(data)
def post(self, request):
# 获取请求数据
data = request.body
data = json.loads(data)
token = data['token']
name = data['name']
phone = data['phone']
address = data['address']
address_code = data['address_code']
is_default = data['is_default']
# 数据校验
if not all([token, name, phone, address]):
return Response({'msg': '数据不完整'})
# 获取open_id
open_id = PublicFunction().getOpenIdByToken(token)
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
if (is_default):
Address.objects.filter(
Q(wx_user=wx_user) & Q(is_default=True)
& Q(is_delete=False)).update(is_default=False)
Address.objects.create(wx_user=wx_user,
name=name,
phone=phone,
address=address,
address_code=address_code,
is_default=is_default).save()
return Response({'msg': 'success'})
except:
return Response({'msg': '新增地址失败'})
return Response({'msg': '没有该用户，添加地址失败'})
def post(self, request):
# 接收数据
data = json.loads(request.body)
commodityId_list = data['commodityId_list']
address_id = data['address_id']
note = data['note']
token = data['token']
commodity_num = data['num']
discount_price = data['card_price']
card_token = data['card_token']
open_id = PublicFunction().getOpenIdByToken(token)
# 参数校验
if not all([commodityId_list, address_id, token]):
return Response({'msg': '数据不完整'})
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
# 校验地址信息
try:
address = Address.objects.get(id=address_id)
except Address.DoesNotExist:
# 地址不存在
return Response({'msg': '地址信息错误'})
# 业务逻辑
# 生成订单号
order_id = PublicFunction().orderNum()
# 运费
transit_price = 0
# 总数目和总价格
total_count = 0
total_price = 0
# 设置事务保存点
sid = transaction.savepoint()
try:
# 向gd_order_info表中添加一条记录
order = OrderInfo.objects.create(wx_user=wx_user,
address=address.address,
name=address.name,
phone=address.phone,
order_id=order_id,
commodity_total_price=total_price,
total_price=total_price,
total_count=total_count,
transit_price=transit_price,
discount_price=discount_price,
note=note)
# 遍历向gd_order_list中添加记录
for commodity_id in commodityId_list:
# 获取商品的信息(行锁查询)
try:
commodity = Commodity.objects.select_for_update().get(
id=commodity_id)
except Commodity.DoesNotExist:
# 商品不存在，回滚到sid事务保存点
transaction.savepoint_rollback(sid)
return Response({'msg': '商品不存在'})
# 获取用户要购买商品的数量
conn = get_redis_connection('Cart')
cart_key = 'cart_' + open_id
if commodity_num == '':
count = conn.hget(cart_key, commodity_id)
else:
count = commodity_num
# print(count)
# print(commodity.stock)
# 判断商品的库存
if int(count) > commodity.stock:
# 商品库存不足，回滚到sid事务保存点
transaction.savepoint_rollback(sid)
return Response({'msg': '商品库存不足'})
# 向gd_order_list中添加一条记录
OrderList.objects.create(
order_info=order,
wx_user=wx_user,
commodity=commodity,
commodity_name=commodity.name,
commodity_specifications=commodity.code + ' ' +
commodity.color,
commodity_price=commodity.price,
commodity_count=int(count),
commodity_image=commodity.image)
# 减少商品的库存，增加销量
commodity.stock -= int(count)
commodity.sales += int(count)
commodity.save()
# 加计算用户要购买的商品的总数目和总价格
total_count += int(count)
total_price += commodity.price * int(count)
# 更新order对应记录中的total_count和total_price
order.total_count = total_count
order.total_price = round(
float(total_price) + float(transit_price) -
float(discount_price), 2)
# print('-------------------------')
# print(order.total_price)
# print('-------------------------')
order.commodity_total_price = total_price
order.save()
except Exception as e:
# 数据库操作出错，回滚到sid事务保存点
print(e)
transaction.savepoint_rollback(sid)
return Response({'msg': '下单失败'})
# 删除购物车中对应的记录 sku_ids=[1,2]
conn.hdel(cart_key, *commodityId_list)
if (card_token != 'no'):
user_card = UserCard.objects.get(card_token=card_token)
user_card.is_use = True
user_card.save()
# 返回应答
return Response({'msg': '订单创建成功', 'order_id': order_id})
def post(self, request):
# 接收数据
data = json.loads(request.body)
order_info_id = data['order_info_id']
token = data['token']
# 参数校验
if not all([token, order_info_id]):
return Response({'msg': '数据不完整'})
# 获取用户open_id
open_id = PublicFunction().getOpenIdByToken(token)
data = {}
# 校验用户
if open_id:
try:
wx_user = WxUser.objects.get(open_id=open_id)
except:
return Response({'msg': '用户不存在'})
try:
'''
{
order_list{
...
order_info:{
...
}
商品清单列表{
[商品，商品]
}
}
}
'''
order_info = OrderInfo.objects.get(wx_user=wx_user,
is_delete=False,
id=order_info_id)
orders = OrderList.objects.filter(
order_info=order_info).values()
data = {
'order_id': order_info.order_id,
'name': order_info.name,
'phone': order_info.phone,
'address': order_info.address,
'note': order_info.note,
'create_time': str(order_info.create_time)[0:19],
'cancel_time': order_info.cancel_time,
'state': order_info.status_choices[order_info.state],
'total_count': order_info.total_count,
'commodity_total_price': order_info.commodity_total_price,
'total_price': order_info.total_price,
'transit_price': order_info.transit_price,
'courier_number': order_info.courier_number,
'returns_number': order_info.returns_number,
'discount_pric': order_info.discount_price,
'order_list': orders
}
except:
return Response({'msg': '无订单信息'})
return Response(data)
