def delete(self, request, order_id):
response = CommonResponse()
# try:
order_obj = Order.objects.get(pk=order_id)
print(order_obj)
if request.user_id == order_obj.buyer.id:
order_obj.buyer_is_show = 0
response.msg = '买家已将订单删除'
elif request.user_id == order_obj.seller.id:
order_obj.seller_is_show = 0
response.msg = '卖家已将订单删除'
else:
response.msg = '用户身份校验失败'
response.status = 101
order_obj.save()
# except Exception as e:
# response.msg = str(e)
return Response(response.get_dic())
def post(self, request, order_id):
response = CommonResponse()
try:
order_obj = Order.objects.get(pk=order_id)
# 有订单且当前登录用户是买家才可以修改状态
# print(str(order_obj.buyer_id) == str(request.user_id),'++++++++++++++++')
if order_obj and (str(order_obj.buyer_id) == str(request.user_id)):
# 判断订单状态,是买家已付款,卖家已发货的订单,才可以继续做收货操作
buy_status = OrderStatusAndBillStatus.objects.get(
status_content='买家已付款')
can_receive_status = OrderStatusAndBillStatus.objects.get(
status_content='卖家已发货')
if order_obj.bill_status == buy_status and order_obj.order_status == can_receive_status:
# 订单状态是可以收货的状态,修改订单为买家已收货,卖家已收款,并且修改卖家账户余额,将订单金额加进用户账户
bill_complete_status = OrderStatusAndBillStatus.objects.get(
status_content='卖家已收款')
receive_complete_status = OrderStatusAndBillStatus.objects.get(
status_content='买家已收货')
seller_obj = User.objects.get(pk=order_obj.seller_id)
with transaction.atomic():
order_obj.bill_status = bill_complete_status
order_obj.order_status = receive_complete_status
seller_obj.balance += float(order_obj.order_price)
order_obj.save()
seller_obj.save()
response.msg = '买家收货成功,钱款已打入卖家余额中'
else:
response.msg = '订单当前状态不能做收货操作'
else:
response.msg = '没有该订单或您不是订单的买家'
response.status = 101
except Exception as e:
response.msg = str(e)
return Response(response.get_dic())
def post(self, request, good_id):
"""
order_id = models.CharField(max_length=128, unique=True, verbose_name='订单号')
order_title = models.TextField(verbose_name='商品标题')
buyer = models.ForeignKey(to='user.User', null=True, on_delete=models.SET_NULL, db_constraint=False, verbose_name='买家')
seller = models.ForeignKey(to='user.User', related_name='seller', null=True, on_delete=models.SET_NULL, db_constraint=False, verbose_name='卖家')
order_status = models.ForeignKey(to='OrderStatusAndBillStatus', null=True, related_name='order_status', default=0, on_delete=models.SET_NULL, verbose_name='订单状态')
bill_status = models.ForeignKey(to='OrderStatusAndBillStatus', related_name='bill_status', null=True, on_delete=models.SET_NULL, default=5, verbose_name='钱款状态')
delivery_price = models.FloatField(verbose_name='运费')
order_price = models.FloatField(verbose_name='订单金额')
delivery = models.ForeignKey(to='Delivery', null=True, on_delete=models.SET_NULL, db_constraint=False, verbose_name='快递')
created_time = models.DateField(auto_now_add=True, verbose_name='订单生成时间')
good = models.ForeignKey(to='good.Good', null=True, on_delete=models.SET_NULL, db_constraint=False, verbose_name='订单对应商品')
:param request:
:param good_id:
:return:
"""
response = CommonResponse()
try:
response = CommonResponse()
good_id = request.POST.get('good', None)
good_obj = Good.objects.get(pk=good_id)
# 当前买家不能是商品的拥有者,且不是卖家
# print(good_obj.owner_user_id)
# print(request.POST.get('seller', None))
# print(str(request.POST.get('buyer', None) != str(good_obj.owner_user_id)))
if str(request.POST.get('buyer', None)) != str(
good_obj.owner_user_id):
# good_obj = Good.objects.get(pk=good_id)
# print(good_obj.good_status.status_content)
if good_obj.good_status.status_content == '已发布':
# 将post数据转成通过序列化组件转成对象
order_ser = SaveOrderSerializer(data=request.POST)
if order_ser.is_valid():
# ORM的事务操作原子化,一个出错全部撤回
with transaction.atomic():
order_obj = order_ser.save()
if order_obj:
good_buy_status = GoodStatusAndSellMethod.objects.get(
status_content='交易中')
good_obj.good_status = good_buy_status
good_obj.save()
response.status = 200
response.msg = '订单生成成功'
else:
response.msg = '订单生成失败'
else:
response.msg = '订单数据有误'
else:
response.msg = '当前商品不能购买'
else:
response.msg = '你不能买自己发布的商品'
except Exception as e:
response.msg = str(e)
return Response(response.get_dic())
def post(self, request, order_id):
print('======================进入了post请求中========')
response = CommonResponse()
try:
order_obj = Order.objects.get(pk=order_id)
# 判断用户是卖家,才能发货
if request.user_id == order_obj.seller_id:
pay_status = OrderStatusAndBillStatus.objects.get(
status_content='买家已付款')
can_delivery_status = OrderStatusAndBillStatus.objects.get(
status_content='卖家未发货')
delivert_status = OrderStatusAndBillStatus.objects.get(
status_content='卖家已发货')
# 判断订单是否买家已付款,已付款才能发货
if order_obj.bill_status == pay_status and order_obj.order_status == can_delivery_status:
# 根据原订单买家的收货地址+卖家传来的收货地址id,生成快递单
buyer_address_obj = UserAddress.objects.get(
pk=order_obj.buyer_address_id)
seller_address_id = request.POST.get(
'seller_address_id', None)
seller_address_obj = UserAddress.objects.get(
pk=seller_address_id)
if seller_address_obj:
buyer_address_ser = UserAddressSerializer(
instance=buyer_address_obj)
seller_address_ser = UserAddressSerializer(
instance=seller_address_obj)
print(buyer_address_ser.data)
print(seller_address_ser.data)
with transaction.atomic():
delivery_obj = Delivery.objects.create(
delivery_company=request.POST.get(
'delivery_company'),
receiver_address=buyer_address_ser.
data['receiver_address'],
receiver_name=buyer_address_ser.
data['receiver_name'],
receiver_telephone=buyer_address_ser.
data['receiver_telephone'],
sender_address=seller_address_ser.
data['receiver_address'],
sender_telephone=seller_address_ser.
data['receiver_telephone'],
sender_name=seller_address_ser.
data['receiver_name'])
if delivery_obj:
# 将快递单信息保存到对应的订单中
order_obj.delivery = delivery_obj
order_obj.seller_address = seller_address_obj
order_obj.order_status = delivert_status
order_obj.save()
response.msg = '快递单生成成功'
else:
response.msg = '订单生成失败'
else:
response.msg = '卖家地址不存在'
else:
response.msg = '当前订单状态不能发货'
else:
response.msg = '您不是商品的卖家,不能发货'
response.status = 101
except Exception as e:
response.msg = str(e)
return Response(response.get_dic())
def post(self, request):
response = CommonResponse()
check_form = RegisterCheckForm(request.POST)
print(request.POST)
print(check_form.is_valid())
if check_form.is_valid():
username = request.POST.get('username', None)
passwd = request.POST.get('passwd', None)
telephone = request.POST.get('telephone', None)
code = request.POST.get('code', None)
print(username)
print(code)
# email = request.POST.get('email', None)
# email_reg = r'^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){0,4}@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){0,4}$'
# telephone_reg = r'^1[3|4|5|7|8][0-9]{9}$'
# 值不全的时候不注册,返回失败
# if not (username and passwd and telephone and email):
# if not (username and passwd and telephone):
# response.status = 102
# response_dic['msg'] = '注册失败'
# print('缺少信息')
# elif len(username) < 6 or len(username) > 20 or len(passwd) < 6 or len(passwd) > 20:
# response_dic['status'] = 102
# response_dic['msg'] = '注册失败'
# print('密码或账户长度错误')
# # elif not (re.match(email_reg, email) and re.match(telephone_reg, telephone)):
# elif not re.match(telephone_reg, telephone):
# response_dic['status'] = 102
# response_dic['msg'] = '注册失败'
# print('手机格式错误')
# else:
# 服务器端短信验证码的获取
conn = redis.Redis(connection_pool=POOL)
redis_code = conn.get(telephone)
if redis_code:
redis_code = str(int(redis_code))
print('code', code)
# 验证码匹配成功
if redis_code == code:
print('匹配成功')
try:
# models.User.objects.create(username=username, password=passwd, email=email, telephone=telephone)
models.User.objects.create(username=username, password=passwd, telephone=telephone, user_type=0)
response.status = 100
response.msg = '注册成功'
except Exception as e:
print(e)
response.status = 100
response.msg = '用户已存在'
# 验证码匹配失败
else:
response.status = 101
response.msg = '验证码错误'
# 没有获取过验证码
else:
response.status = 101
response.msg = '请重新获取验证码'
else:
response.status = 101
response.msg = '信息格式错误'
return Response(response.get_dic())
def post(self, request):
print('开始验证')
response = CommonResponse()
check_form = LoginCheckForm(request.POST)
if check_form.is_valid():
# 获取客户端传来的token
client_token = request.token
print(client_token)
# print('token', client_token)
# 建立redis连接
conn = redis.Redis(connection_pool=POOL)
# 获取服务器端token
try:
keys = conn.keys()
keys = [str(key, encoding='utf-8') for key in keys]
# print('client_token', client_token)
# print('keys', keys)
# print(keys[3])
# print('status', client_token in keys)
# print()
except Exception as e:
print(e)
keys = None
# 如果存在token,就不再验证用户密码,直接通过了
if client_token in keys:
response.status = 200
response.msg = '登录成功'
response.data = {'salt_cookie': client_token}
# 如果客户端或服务器端有一方没有token的时候,直接根据手机号和密码登录
elif (not client_token) or (client_token not in keys):
telephone = request.POST.get('telephone', None)
passwd = request.POST.get('passwd', None)
print(telephone)
print(passwd)
if not (telephone and passwd):
response.msg = '登录失败'
else:
user = models.User.objects.filter(telephone=telephone, password=passwd).first()
# 如果查询成功,表示信息正确,生成token值
# if isinstance(user, models.User):
if user:
# 设置返回json的状态
response.status = 200
response.msg = '登录成功'
# 生成token的函数做成类
token_api = CheckUserToken()
token_str = token_api.get_token_str(telephone)
# 并设置过期时间,放在redis中
conn = redis.Redis(connection_pool=POOL)
# 在redis保存什么数据?
conn.set(token_str, user.id, ex=86400)
response.data = {'salt_cookie': token_str}
else:
response.msg = '账户或密码错误,请重新登录'
# 客户端和服务器都带有token数据时,做校验,如果校验失败,不在验证用户,跳转登录信息
else:
response.msg = '登录失败'
else:
response.status = 101
response.msg = '注册失败,信息格式不正确'
return Response(response.get_dic())