def OrderCreate1(self, request):
"""
订单确认
:param request:
:return:
"""
data = request.data_format
try:
order = Order.objects.select_for_update().get(
orderid=data.get("orderid"))
except Order.DoesNotExist:
raise PubErrorCustom("订单异常!")
if not len(data.get("address")):
raise PubErrorCustom("收货地址不能为空!")
order.address = json.dumps(data.get("address", {}), ensure_ascii=False)
order.memo = data.get("desc", "")
OrderBase(order=order).checkvoidForcreateOrder(flag='city')
order.save()
return {"data": order.orderid}
def login(self, request, *args, **kwargs):
"""
登录
:param request:
:param args:
:param kwargs:
:return:
"""
try:
user = Users.objects.get(uuid=request.data_format.get("loginname"))
except Users.DoesNotExist:
raise PubErrorCustom("登录账户或密码错误！")
if user.passwd != request.data_format.get("password"):
raise PubErrorCustom("登录账户或密码错误！")
if user.status == 1:
raise PubErrorCustom("登陆账号已到期！")
elif user.status == 2:
raise PubErrorCustom("已冻结！")
token = get_token()
res = UserModelSerializerToRedis(user, many=False).data
RedisTokenHandler(key=token).set(res)
return {"data": token}
def PayHandlerVip(self, request):
payType = request.data_format.get("payType", None)
ruleid = request.data_format.get("ruleid", None)
try:
viprule = VipRule.objects.get(id=ruleid)
except VipRule.DoesNotExist:
raise PubErrorCustom("规则不存在!!")
if not payType:
raise PubErrorCustom("支付方式有误!")
order = OrderVip.objects.create(**{
"userid":request.user['userid'],
"amount":viprule.amount,
"term":viprule.term,
"unit":viprule.unit,
"paytype":payType
})
subject=""
if order.unit == '0':
subject = "{}周会员充值".format(order.term)
elif order.unit == '1':
subject = "{}月会员充值".format(order.term)
elif order.unit == '2':
subject = "{}年会员充值".format(order.term)
else:
subject = "会员充值"
if payType == 2:
return {"data": AlipayBase(isVip=True).create(order.orderid, order.amount,subject=subject)}
else:
raise PubErrorCustom("支付方式有误!")
def PayHandler(self, request):
payType = request.data_format.get("payType",None)
orderid = request.data_format.get("orderid",None)
if not payType:
raise PubErrorCustom("支付方式有误!")
try:
order = Order.objects.select_for_update().get(orderid=orderid)
except Order.DoesNotExist:
raise PubErrorCustom("订单异常!")
try:
user = Users.objects.select_for_update().get(userid=order.userid)
except Users.DoesNotExist:
raise PubErrorCustom("用户不存在!")
if order.use_jf > user.jf:
raise PubErrorCustom("积分不够!")
order.paytype = str(payType)
order.save()
if payType == 2:
return {"data":AlipayBase().create(order.orderid,order.amount)}
else:
raise PubErrorCustom("支付方式有误!")
def RefundConfirmHandler(self, request):
"""
退款确认
:param request:
:return:
"""
orderid = request.data_format.get("orderid", None)
try:
order = Order.objects.select_for_update().get(orderid=orderid)
if order.before_status != '1':
raise PubErrorCustom("只允许通过已申请退款的订单!")
order.before_status = '2'
order.status = '4'
order.save()
try:
user = Users.objects.select_for_update().get(
userid=order.userid)
except Users.DoesNotExist:
raise PubErrorCustom("用户{}有误!".format(user.mobile))
user.jf += order.use_jf
user.jf -= order.get_jf
user.save()
AlipayBase().refund(order=order,
orderid=order.orderid,
refund_amount=order.amount)
except Order.DoesNotExist:
raise PubErrorCustom("订单异常!")
return None
def RefundHandler(self, request):
"""
申请退款
:param request:
:return:
"""
orderid = request.data_format.get("orderid", None)
refundmsg = request.data_format.get("refundmsg", None)
# raise PubErrorCustom("目前不支持退款!")
if not refundmsg:
raise PubErrorCustom("理由不能为空!")
try:
order = Order.objects.select_for_update().get(orderid=orderid)
if order.status not in ['1', '2', '3']:
raise PubErrorCustom("只允许已付款的订单申请退款!")
if order.before_status == '1':
raise PubErrorCustom("请勿重复申请退款!")
if order.before_status == '2':
raise PubErrorCustom("已退款,请勿再申请退款!")
order.before_status = '1'
order.refundmsg = refundmsg
order.apply_refund_time = UtilTime().timestamp
order.save()
except Order.DoesNotExist:
raise PubErrorCustom("订单异常!")
def OrderUpdate(self, request):
"""
订单修改
:param request:
:return:
"""
data = request.data_format
try:
order = Order.objects.select_for_update().get(
orderid=data.get("orderid"))
except Order.DoesNotExist:
raise PubErrorCustom("订单异常!")
if len(data.get("address", {})):
if order.status in ['0', '1']:
order.address = json.dumps(data.get("address", {}),
ensure_ascii=False)
else:
raise PubErrorCustom("此状态不能修改订单地址!")
if data.get("desc", None):
order.memo = data.get("desc", "")
if data.get("kdno", None):
order.kdno = json.dumps(data.get("kdno", []))
if data.get("memo", None):
order.memo = data.get("memo")
order.save()
return {"data": order.orderid}
def checkvoidForcreateOrder(self, **kwargs):
"""
按区域限购
按周期时间限购
:param kwargs:
:return:
"""
ut = self.ut
end = ut.timestamp
cityHandler = self.cityHandler
order = self.order
goodsObj = kwargs.get("goodsObj")
gdnum = kwargs.get("gdnum")
flag = kwargs.get("flag", None)
if flag == 'city':
for item in OrderGoodsLink.objects.filter(
linkid__in=json.loads(order.linkid)['linkids']):
try:
goodsObj = Goods.objects.get(gdid=item.gdid)
if goodsObj.gdstatus != '0':
raise PubErrorCustom("商品{}已下架".format(goodsObj.gdname))
except Goods.DoesNotExist:
raise PubErrorCustom("商品{}不存在".format(goodsObj.gdname))
try:
city = json.loads(order.address).get("label",
"").split('-')[0]
except Exception as e:
logger.info(str(e))
city = None
if city:
for itemCity in json.loads(goodsObj.limit_citys):
if cityHandler.isExists(itemCity, city):
logger.info("收货地址{},限购城市{}".format(itemCity, city))
raise PubErrorCustom("{},库存不够!".format(
goodsObj.gdname))
else:
if goodsObj.limit_unit == 'A':
pass
else:
if goodsObj.limit_unit == 'M':
start = ut.today.shift(months=goodsObj.limit_count *
-1).timestamp
elif goodsObj.limit_unit == 'W':
start = ut.today.shift(weeks=goodsObj.limit_count *
-1).timestamp
okcount = queryBuyOkGoodsCount(order.userid, goodsObj.gdid,
start, end)
logger.info("目前购买->{},实际已购买->{},规则数量->{}".format(
gdnum, okcount, goodsObj.limit_number))
if gdnum + okcount > goodsObj.limit_number:
raise PubErrorCustom("{},库存不够!".format(goodsObj.gdname))
def OrderByOrderidQuery(self, request):
try:
orderQuery = Order.objects.get(
orderid=request.query_params_format.get("orderid"))
except Order.DoseNotExists:
raise PubErrorCustom("订单号不存在!")
try:
user = Users.objects.get(userid=request.user.get("userid"))
except Users.DoesNotExist:
raise PubErrorCustom("用户不存在!")
order = OrderModelSerializer(orderQuery, many=False).data
isVirtual = True
for item in order['linkid']:
if item['virtual'] == '1':
isVirtual = False
break
return {
"data": {
"order": order,
"bal": "%.2lf" % user.bal,
"isVirtual": isVirtual
}
}
def QzCanlceHandler(self, request):
"""
系统强制退款
:param request:
:return:
"""
orderid = request.data_format.get("orderid", None)
try:
order = Order.objects.select_for_update().get(orderid=orderid)
if order.status != '1':
raise PubErrorCustom("只允许强制取消已付款待发货状态的订单!")
order.before_status = '2'
order.refundmsg = "因为系统原因，订单提交失败，钱款将原路退回支付账户，请注意查收！"
order.status = '4'
order.save()
try:
user = Users.objects.select_for_update().get(
userid=order.userid)
except Users.DoesNotExist:
raise PubErrorCustom("用户{}有误!".format(user.mobile))
user.jf += order.use_jf
user.jf -= order.get_jf
user.save()
AlipayBase().refund(order=order,
orderid=order.orderid,
refund_amount=order.amount)
except Order.DoesNotExist:
raise PubErrorCustom("订单异常!")
return None
def BuyForOrderCreate(self, request):
orderObj = Order.objects.create(**dict(userid=request.user['userid']))
orderObj.linkid = {"linkids": []}
orderObj.amount = Decimal("0.0")
try:
goods = Goods.objects.get(gdid=request.data_format.get("gdid"),
gdstatus='0')
except Goods.DoesNotExist:
raise PubErrorCustom("该商品已下架!")
try:
glink = GoodsLinkSku.objects.select_for_update().get(
id=request.data_format.get("linkid"))
if glink.stock < 1:
raise PubErrorCustom("库存不够!")
except Goods.DoesNotExist:
raise PubErrorCustom("该规格已下架!")
link = OrderGoodsLink.objects.create(
**dict(userid=request.user['userid'],
orderid=orderObj.orderid,
gdid=goods.gdid,
gdimg=json.loads(goods.gdimg)[0],
gdname=goods.gdname,
gdprice=glink.price,
gdnum=1))
orderObj.linkid['linkids'].append(link.linkid)
orderObj.amount += link.gdprice * int(link.gdnum)
orderObj.linkid = json.dumps(orderObj.linkid)
orderObj.save()
return {"data": orderObj.orderid}
def login1(self, request):
"""
普通玩家
:param request:
:return:
"""
try:
user = Users.objects.get(loginname=request.data_format.get('loginname'), rolecode__in=['2001'])
except Users.DoesNotExist:
raise PubErrorCustom("登录账号或密码错误！")
if user.passwd != self.request.data_format.get('password'):
raise PubErrorCustom("登录账号或密码错误！")
if user.status == 1:
raise PubErrorCustom("登陆账号已到期！")
elif user.status == 2:
raise PubErrorCustom("已冻结！")
token = get_token()
res = UserModelSerializerToRedis(user, many=False).data
RedisTokenHandler(key=token).redis_dict_set(res)
return {"data": {
"token": token,
"userinfo":{
"rolecode":user.rolecode
}
}}
def winHandler(orderid):
try:
order = Order.objects.select_for_update().get(orderid=orderid)
games = RedisCaCheHandler(
method="get",
serialiers="CpGamesModelSerializerToRedis",
table="cpgames",
must_key_value=order.gamesid).run()
if not games:
raise PubErrorCustom("无此玩法!")
try:
cpno = CpTermListHistory.objects.get(cpid=order.cpid,term=order.term).cpno
except CpTermListHistory.DoesNotExist:
return False
if wincode_run(order,games,cpno):
Order.status = '1'
user = Users.objects.get(userid=order.userid)
user.bal += order.amount
user.save()
order.save()
return True
except Order.DoesNotExist:
raise PubErrorCustom("无此订单!")
return False
def delOrder(self, request):
orderid = request.data_format.get("orderid", None)
try:
order = Order.objects.select_for_update().get(orderid=orderid)
if order.status == '1':
raise PubErrorCustom("此订单已中奖!")
elif order.status == '2':
raise PubErrorCustom("此订单已撤单!")
elif order.status == '3':
raise PubErrorCustom("此订单未中奖!")
except Users.DoesNotExist:
raise PubErrorCustom("无此订单!")
try:
user = Users.objects.select_for_update().get(
userid=request.user['userid'], status='0')
except Users.DoesNotExist:
raise PubErrorCustom("非法用户!")
order.status = '2'
order.save()
user.bal += order.amount
user.save()
return None
def userHandler(self, request):
logger.info(request.user)
if request.user['rolecode'] != 1000:
raise PubErrorCustom("只有超级管理员能操作!")
if request.method == 'POST':
# userid = request.data_format.get('userid')
uuid = request.data_format.get("login_name")
name = request.data_format.get("name")
pic = request.data_format.get("pic")
passwd = request.data_format.get("passwd")
if not uuid:
raise PubErrorCustom('登录名称不能为空!')
if not name:
name = uuid
user = Users.objects.create(
**{
"uuid": uuid,
"mobile": uuid,
"rolecode": 1001,
"name": name,
"passwd": passwd,
"pic": pic
})
user.userid = user.id
user.save()
elif request.method == 'PUT':
userid = request.data_format.get('userid')
uuid = request.data_format.get("login_name")
name = request.data_format.get("name")
pic = request.data_format.get("pic")
passwd = request.data_format.get("passwd")
try:
user = Users.objects.get(userid=userid)
except Users.DoesNotExist:
raise PubErrorCustom('该用户不存在!')
user.uuid = uuid if uuid else user.uuid
user.mobile = uuid if uuid else user.uuid
user.name = name if name else user.name
user.pic = pic if pic else user.pic
user.passwd = passwd
user.save()
elif request.method == 'DELETE':
Users.objects.filter(
userid=request.data_format.get('userid')).delete()
elif request.method == 'GET':
return {
"data":
UsersSerializers(Users.objects.filter(rolecode=1001).order_by(
'-createtime')[request.page_start:request.page_end],
many=True).data
}
def orderWin(self, request):
cpid = request.data.get("cpid", None)
term = request.data.get("term", None)
if not cpid:
raise PubErrorCustom("cpid is void!")
if not term:
raise PubErrorCustom("term is void!")
pass
def getUser(self, request):
try:
user = Users.objects.get(userid=request.user['userid'])
if user.status !='0':
raise PubErrorCustom("用户状态异常!")
except Users.DoesNotExist:
raise PubErrorCustom("用户不存在!")
return {"data":UsersSerializers(user,many=False).data}
def upd_passwd(self, request):
try:
user = Users.objects.get(userid=request.user['userid'])
except Users.DoesNotExist:
raise PubErrorCustom("该用户不存在!")
user.passwd = request.data_format.get("passwd")
if not user.passwd:
raise PubErrorCustom("密码不能为空!")
user.save()
def request(self, request_data):
data = {}
data['appid'] = WECHAT_APPID
data['mch_id'] = WECHAT_PAY_MCHID
data['nonce_str'] = ''.join(
random.sample(string.ascii_letters + string.digits, 30))
data['body'] = "勇缘健康传承者-推广会员充值"
data['out_trade_no'] = request_data['out_trade_no']
data['total_fee'] = request_data['total_fee']
data['spbill_create_ip'] = request_data['spbill_create_ip']
data['notify_url'] = CALLBACKURL
data['trade_type'] = 'JSAPI'
data['openid'] = request_data['openid']
data['sign_type'] = 'MD5'
data['sign'] = self.hashdata(data, WECHAT_PAY_KEY)
print(data)
param = {'root': data}
xml = xmltodict.unparse(param)
res = requests.request(method="POST",
data=xml.encode('utf-8'),
url=self.createUrl,
headers={'Content-Type': 'text/xml'})
xmlmsg = xmltodict.parse(res.text)
if xmlmsg['xml']['return_code'] == 'SUCCESS':
sign = self.hashdata(xmlmsg['xml'], WECHAT_PAY_KEY)
if sign != xmlmsg['xml']['sign']:
raise PubErrorCustom("非法操作！")
prepay_id = xmlmsg['xml']['prepay_id']
timeStamp = str(int(time.time()))
data = {
"appId": WECHAT_APPID,
"nonceStr": data['nonce_str'],
"package": "prepay_id=" + prepay_id,
"signType": 'MD5',
"timeStamp": timeStamp
}
data['paySign'] = self.hashdata(data, WECHAT_PAY_KEY)
data["orderid"] = request_data['out_trade_no']
return data
else:
raise PubErrorCustom(xmlmsg['xml']['return_msg'])
def getCardForOrder(self, request):
if not request.query_params_format.get("id"):
raise PubErrorCustom("系统错误,请联系客服人员!")
try:
obj = OrderGoodsLink.objects.get(linkid=request.query_params_format.get("id"))
except OrderGoodsLink.DoesNotExist:
raise PubErrorCustom("系统错误,请联系客服人员!")
return {"data": json.loads(obj.virtualids).get('ids')}
def updPassword(self, request):
if not request.data_format.get("passwd",None):
raise PubErrorCustom("密码是空!")
try:
obj = Users.objects.get(userid=request.user['userid'])
obj.passwd = request.data_format['passwd']
obj.save()
except Users.DoesNotExist:
raise PubErrorCustom("用户不存在!")
return None
def updCpMiniGameTypeData(self, request):
if not request.data_format.get("id", None):
raise PubErrorCustom("请选择彩票玩法子类!")
if not request.data_format.get("form", None):
raise PubErrorCustom("提交数据为空!")
redis_cli_minigametype = RedisCaCheHandlerBase(db="default",key="minigametype_{}".format(request.data_format.get("id", None)[:8]))
redis_cli_minigametype.redis_dict_set(request.data_format.get("id", None),request.data_format.get("form", None))
return {"data":request.data_format.get("form", None)}
def orderFh(self,request):
orderid = request.data_format.get("orderid")
kdno = request.data_format.get("kdno")
if not kdno:
raise PubErrorCustom("快递单号不能为空!")
try:
obj = Order.objects.get(orderid=orderid)
obj.kdno = kdno
obj.status='2'
obj.save()
except Order.DoesNotExist:
raise PubErrorCustom("订单不存在!")
return None
def orderFh1(self, request):
orderid = request.data_format.get("orderid")
try:
obj = Order.objects.select_for_update().get(orderid=orderid)
if not len(obj.kdno):
raise PubErrorCustom("请先扫发货条形码!")
obj.status = '2'
obj.fhtime = UtilTime().timestamp
obj.save()
except Order.DoesNotExist:
raise PubErrorCustom("订单不存在!")
return None
def OrderDel(self, request):
try:
order = Order.objects.select_for_update().get(
orderid=request.data_format.get("orderid"))
except Order.DoesNotExist:
raise PubErrorCustom("订单号不存在!")
if order.status == '0':
OrderBase(order=order).callbackStock()
order.status = '8'
order.save()
else:
raise PubErrorCustom("错误!")
return None
def OrderCreate(self, request):
"""
生成订单
:param request:
:return:
"""
if not len(request.data_format['shopcart']):
raise PubErrorCustom("购买商品不能为空!")
orderObj = Order.objects.create(**dict(userid=request.user['userid']))
orderObj.linkid = {"linkids": []}
orderObj.amount = Decimal("0.0")
isvirtual = '0'
for item in request.data_format['shopcart']:
if not item['selected']:
continue
res = RedisCaCheHandler(
method="get",
table="goods",
must_key_value=item['gdid'],
).run()
if not res or res['gdstatus'] == '1':
raise PubErrorCustom("{}商品已下架,请在购物车删除此商品!".format(
item['gdname']))
link = OrderGoodsLink.objects.create(
**dict(userid=request.user['userid'],
orderid=orderObj.orderid,
gdid=res['gdid'],
gdimg=res['gdimg'],
gdname=res['gdname'],
gdprice=Decimal(str(res['gdprice'])),
gdnum=item['gdnum'],
virtual=res['virtual']))
if res['virtual'] != '0':
isvirtual = '1'
orderObj.linkid['linkids'].append(link.linkid)
orderObj.amount += link.gdprice * int(link.gdnum)
orderObj.isvirtual = isvirtual
orderObj.linkid = json.dumps(orderObj.linkid)
orderObj.save()
return {"data": orderObj.orderid}
def orderFh(self, request):
orderid = request.data_format.get("orderid")
kdno = request.data_format.get("kdno", [])
if not kdno or not len(kdno):
raise PubErrorCustom("快递单号不能为空!")
try:
obj = Order.objects.get(orderid=orderid)
obj.kdno = json.dumps(kdno)
obj.status = '2'
obj.fhtime = UtilTime().timestamp
obj.save()
except Order.DoesNotExist:
raise PubErrorCustom("订单不存在!")
return None
def OrderCanleSys(self, request):
print("30分钟取消订单[{}]".format(request.data_format.get("orderid")))
try:
order = Order.objects.select_for_update().get(
orderid=request.data_format.get("orderid"))
except Order.DoesNotExist:
raise PubErrorCustom("订单号不存在!")
if order.status == '0':
OrderBase(order=order).callbackStock()
order.status = '9'
order.save()
else:
raise PubErrorCustom("只能未付款订单才能取消！")
return None
def getActive(self, request, *args, **kwargs):
id = request.query_params_format.get('id', None)
status = request.query_params_format.get('status', None)
isapp = request.query_params_format.get('isapp', None)
if id:
try:
return {
"data":
ActiveModelSerializer(Active.objects.get(id=id),
many=False).data
}
except Active.DoesNotExist:
raise PubErrorCustom("此活动不存在!")
else:
query = Active.objects.filter()
if status:
query = query.filter(status=status)
if isapp:
query = query.filter(end_time__gt=UtilTime().timestamp * 1000)
return {
"data":
ActiveModelSerializer(query.order_by('-createtime'),
many=True).data
}
def delAttachMent(self, request):
print(request.data_format.get("id"))
aObj = AttachMent.objects.filter(id=request.data_format.get("id"))
if not aObj.exists():
raise PubErrorCustom("不存在此照片!")
else:
obj = aObj[0]
obj1 = AttachMentGroup.objects.select_for_update().get(
id=obj.grouid)
obj1.number -= 1
obj1.save()
aObj.delete()
RedisCaCheHandler(
method="save",
serialiers="AttachMentGroupModelSerializerToRedis",
table="AttachMentGroup",
filter_value=obj1,
must_key="id",
).run()
RedisCaCheHandler(
method="delete",
table="AttachMent",
must_key="id",
must_key_value=request.data_format.get("id")).run()
return None