def getGoodsForSearch(self, request):
rolecode = None
ticket = request.META.get('HTTP_TICKET')
if ticket:
result = RedisTokenHandler(key=ticket).redis_dict_get()
if result:
rolecode = str(result.get("rolecode"))
print("角色:[%s]" % rolecode)
print(request.query_params_format)
query = """
SELECT t1.* FROM goods as t1
INNER JOIN goodscategory as t2 ON t1.gdcgid = t2.gdcgid and t2.status = '0' and t1.gdstatus='0' and t2.rolecode like '%%{}%%'
WHERE 1=1 and t1.gdname like '%%{}%%' order by t1.sort
""".format(rolecode if rolecode else '4001',
request.query_params_format.get("name", ""))
print(query)
goodsObj = Goods.objects.raw(query)
data = GoodsForSearchSerializer(goodsObj, many=True).data
for item in data:
if request.addressBool:
item['gdnum'] = 0
return {"data": data}
def getGoodsForCategory(self, request):
userid = None
user = None
ticket = request.META.get('HTTP_TICKET')
if ticket:
result = RedisTokenHandler(key=ticket).redis_dict_get()
if result:
userid = result.get("userid")
print("用户代码:{}".format(userid))
if userid:
user = Users.objects.get(userid=userid)
obj = RedisCaCheHandler(
method="get",
serialiers="GoodsCateGoryModelSerializerToRedis",
table="goodscategory",
must_key_value=request.query_params_format.get('gdcgid')).run()
if obj['status'] == '0':
goods = []
res = RedisCaCheHandler(method="filter",
serialiers="GoodsModelSerializerToRedis",
table="goods",
filter_value={
"gdstatus": "0",
"gdcgid": obj['gdcgid']
}).run()
for item in res:
if userid and user.isvip == '1' and item['isvip'] == '0':
goods.append(
dict(
gdid=item['gdid'],
gdimg=item['gdimg'],
gdname=item['gdname'],
sort=item['sort'],
gdtext=item['gdtext'],
))
if item['isvip'] != '0':
goods.append(
dict(
gdid=item['gdid'],
gdimg=item['gdimg'],
gdname=item['gdname'],
sort=item['sort'],
gdtext=item['gdtext'],
))
goods.sort(key=lambda k: (k.get('sort', 0)), reverse=False)
return {"data": goods}
else:
return {"data": False}
def refeshToken(self, request, *args, **kwargs):
redis_cli = RedisTokenHandler(key=request.ticket)
res = redis_cli.redis_dict_get()
redis_cli.redis_dict_del()
token = get_token()
redis_cli = RedisTokenHandler(key=token)
redis_cli.redis_dict_set(res)
return {"data": token}
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 wechatlogin(self, request):
session_key = request.data_format.get("session_key")
appId = WECHAT_APPID
sessionKey = session_key
encryptedData = request.data_format.get("encryptedData")
iv = request.data_format.get("iv")
pc = WXBizDataCrypt(appId, sessionKey)
res = pc.decrypt(encryptedData, iv)
try:
user = UserModelSerializerToRedis(Users.objects.get(uuid=res.get('openId') if 'unionId' not in res else res['unionId']),many=False).data
except Users.DoesNotExist:
user = Users.objects.create(**{
"userid": idGenerator.userid('4001'),
"uuid": res.get('openId') if 'unionId' not in res else res['unionId'],
"mobile": res.get('openId') if 'unionId' not in res else res['unionId'],
"rolecode": '4001',
"name": res.get("nickName"),
"sex": res.get("sex"),
"addr": "{}-{}-{}".format(res.get("country"), res.get("city"), res.get("province")),
"pic": res.get("avatarUrl"),
"appid": res.get("watermark")['appid']
})
token = get_token()
res = UserModelSerializerToRedis(user, many=False).data
RedisTokenHandler(key=token).redis_dict_set(res)
print(token)
return {"data": {
"user": UsersSerializers(user, many=False).data,
"token": token
}}
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 register(self, request):
"""
普通玩家注册
:param request:
:return:
"""
if Users.objects.filter(loginname=request.data_format.get('loginname')).count():
raise PubErrorCustom("该账号已存在!")
user = Users.objects.create(**{
"userid":idGenerator.userid("2001"),
"name": request.data_format.get("loginname",""),
"loginname":request.data_format.get("loginname",""),
"passwd": request.data_format.get("password", ""),
"mobile": request.data_format.get("mobile", ""),
"code": request.data_format.get("code", ""),
"rolecode":"2001"
})
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 wechatauth(self, request):
params = dict(
js_code=request.data_format.get("js_code"),
appid=WECHAT_APPID,
secret=WECHAT_SECRET,
grant_type="authorization_code",
)
wechat_res = send_request_other(
url="https://api.weixin.qq.com/sns/jscode2session",
params=params)
if not wechat_res.get("openid"):
raise PubErrorCustom("获取用户错误,腾讯接口有误!")
print(wechat_res)
data={}
token=False
try:
user=Users.objects.get(uuid=wechat_res.get('openid'))
data = UsersSerializers(user,many=False).data
token = get_token()
res = UserModelSerializerToRedis(user, many=False).data
RedisTokenHandler(key=token).redis_dict_set(res)
except Users.DoesNotExist:
pass
return {"data":{
"user" : data,
"session_key":wechat_res.get("session_key"),
"token":token
}}
def login2(self, request):
"""
试玩玩家
:param request:
:return:
"""
user = Users.objects.create(**{
"userid": idGenerator.userid("2002"),
"rolecode": "2002",
"bal":1000.0
})
user.name = user.userid
user.loginname = user.userid
user.save()
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 cardCz(self, request):
rUser = None
account = request.data_format['account']
password = request.data_format['password']
try:
card = Card.objects.select_for_update().get(account=account,
password=password,
type='0')
if card.useuserid > 0:
return {"data": {"a": False}}
except Card.DoesNotExist:
return {"data": False}
try:
user = Users.objects.select_for_update().get(
userid=request.user['userid'])
except Users.DoesNotExist:
raise PubErrorCustom("用户非法!")
tmp = user.bal
user.bal += card.bal
if card.rolecode == user.rolecode:
flag = False
else:
request.user['rolecode'] = card.rolecode
RedisTokenHandler(key=request.ticket).redis_dict_set(request.user)
rUser = UsersSerializers(user, many=False).data
flag = True
updBalList(user=user,
order=None,
amount=card.bal,
bal=tmp,
confirm_bal=user.bal,
memo="充值卡充值",
cardno=card.account)
user.rolecode = card.rolecode
user.save()
card.useuserid = user.userid
card.save()
RedisCaCheHandler(
method="save",
serialiers="CardModelSerializerToRedis",
table="card",
filter_value=card,
must_key="id",
).run()
return {"data": {"a": True, "b": flag, "rUser": rUser}}
def thmCz(self, request):
rUser = None
account = request.data_format['account']
try:
user = Users.objects.select_for_update().get(
userid=request.user['userid'])
except Users.DoesNotExist:
raise PubErrorCustom("用户非法!")
try:
card = DeliveryCode.objects.select_for_update().get(
account=account)
if card.useuserid > 0:
return {"data": {"a": False}}
except DeliveryCode.DoesNotExist:
return {"data": False}
tmp = user.bal
user.bal += card.bal
if card.rolecode == user.rolecode:
flag = False
else:
request.user['rolecode'] = card.rolecode
RedisTokenHandler(key=request.ticket).redis_dict_set(request.user)
rUser = UsersSerializers(user, many=False).data
flag = True
updBalList(user=user,
order=None,
amount=card.bal,
bal=tmp,
confirm_bal=user.bal,
memo="提货码充值",
cardno=card.account)
user.rolecode = card.rolecode
user.save()
card.useuserid = user.userid
card.status = '0'
card.save()
return {"data": {"a": True, "b": flag, "rUser": rUser}}
def login(self, request):
try:
user = Users.objects.get(uuid=request.data_format.get('username'))
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}}
def login1(self, request):
try:
user = Users.objects.get(uuid=request.data_format.get("mobile",""))
except Users.DoesNotExist:
user = Users.objects.create(**{
"userid": idGenerator.userid('4001'),
"uuid": request.data_format.get("mobile",""),
"rolecode": '4001',
"mobile": request.data_format.get("mobile",""),
"name": request.data_format.get("mobile",""),
"sex": "",
"addr": "",
"pic": "",
"appid": ""
})
if not request.data_format.get('vercode',None):
raise PubErrorCustom("验证码不能为空!")
rRes = RedisVercodeHandler().get(user.uuid)
if rRes and not len(rRes) or not rRes:
raise PubErrorCustom("请先获取验证码!")
if request.data_format.get('vercode',None) != rRes:
raise PubErrorCustom("验证码错误!")
token = get_token()
res = UserModelSerializerToRedis(user, many=False).data
RedisTokenHandler(key=token).redis_dict_set(res)
res=Address.objects.filter(userid=user.userid,moren='0')
address = AddressModelSerializer(res, many=True).data[0] if res.count() else {}
return {"data": {
"token": token,
"userinfo":UsersSerializers(user, many=False).data,
"address":address
}}
def logout(self, request, *args, **kwargs):
RedisTokenHandler(key=request.ticket).redis_dict_del()
return None
def getHomeData(self, request):
userid = None
user = None
ticket = request.META.get('HTTP_TICKET')
if ticket:
result = RedisTokenHandler(key=ticket).redis_dict_get()
if result:
userid = result.get("userid")
print("用户代码:{}".format(userid))
rdata = {"banners": [], "newgoods": []}
#轮播图数据
rdata['banners'] = [
dict(id=item['id'], url=item['url']) for item in RedisCaCheHandler(
method="filter",
serialiers="BannerModelSerializerToRedis",
table="banner",
filter_value={}).run()
]
if userid:
user = Users.objects.get(userid=userid)
#新品数据
for item in RedisCaCheHandler(method="filter",
serialiers="GoodsModelSerializerToRedis",
table="goods",
filter_value={
"gdstatus": "0"
}).run():
obj = RedisCaCheHandler(
method="get",
serialiers="GoodsCateGoryModelSerializerToRedis",
table="goodscategory",
must_key_value=item.get('gdcgid')).run()
# if userid :
# if LimitGoods(userid=userid,limit_goods=item['limit_goods'],gdid=item['gdid']).calsBool():
# gdnum = 0 if request.addressBool else \
# sum([ i.stock for i in GoodsLinkSku.objects.filter(id__in=item['gdskulist']).order_by('sort') ])
# else:
# gdnum = 0
# else:
gdnum = 0 if request.addressBool else \
sum([i.stock for i in GoodsLinkSku.objects.filter(id__in=item['gdskulist']).order_by('sort')])
if userid and user.isvip == '1' and item['isvip'] == '0' and obj[
'status'] == '0':
rdata['newgoods'].append(
dict(gdid=item['gdid'],
gdname=item['gdname'],
gdimg=item['gdimg'],
gdtext=item['gdtext'],
gdprice=item['gdprice'],
gdnum=gdnum,
sort=item['sort']))
if obj['status'] == '0' and item['isvip'] != '0':
rdata['newgoods'].append(
dict(gdid=item['gdid'],
gdname=item['gdname'],
gdimg=item['gdimg'],
gdtext=item['gdtext'],
gdprice=item['gdprice'],
gdnum=gdnum,
sort=item['sort']))
if len(rdata['newgoods']) >= 20:
rdata['newgoods'] = rdata['newgoods'][:20]
else:
rdata['newgoods'] = rdata['newgoods'][:len(rdata['newgoods'])]
rdata['newgoods'].sort(key=lambda k: (k.get('sort', 0)), reverse=False)
rdata['settings'] = RedisUserSysSetting().get()
return {"data": rdata}
def getHomeData(self, request):
userid = None
user = None
ticket = request.META.get('HTTP_TICKET')
if ticket:
result = RedisTokenHandler(key=ticket).redis_dict_get()
if result:
userid = result.get("userid")
print("用户代码:{}".format(userid))
rdata = {"banners": [], "newgoods": []}
#轮播图数据
rdata['banners'] = [
dict(id=item['id'], url=item['url']) for item in RedisCaCheHandler(
method="filter",
serialiers="BannerModelSerializerToRedis",
table="banner",
filter_value={}).run()
]
if userid:
user = Users.objects.get(userid=userid)
#新品数据
for item in RedisCaCheHandler(method="filter",
serialiers="GoodsModelSerializerToRedis",
table="goods",
filter_value={
"gdstatus": "0"
}).run():
obj = RedisCaCheHandler(
method="get",
serialiers="GoodsCateGoryModelSerializerToRedis",
table="goodscategory",
must_key_value=item.get('gdcgid')).run()
if userid and user.isvip == '1' and item['isvip'] == '0' and obj[
'status'] == '0':
rdata['newgoods'].append(
dict(gdid=item['gdid'],
gdname=item['gdname'],
gdimg=item['gdimg'],
gdtext=item['gdtext'],
gdprice=item['gdprice'],
sort=item['sort']))
if obj['status'] == '0' and item['isvip'] != '0':
rdata['newgoods'].append(
dict(gdid=item['gdid'],
gdname=item['gdname'],
gdimg=item['gdimg'],
gdtext=item['gdtext'],
gdprice=item['gdprice'],
sort=item['sort']))
if len(rdata['newgoods']) >= 6:
rdata['newgoods'] = rdata['newgoods'][:6]
else:
rdata['newgoods'] = rdata['newgoods'][:len(rdata['newgoods'])]
rdata['newgoods'].sort(key=lambda k: (k.get('sort', 0)), reverse=False)
return {"data": rdata}
import time, json
def getGoods(self, request):
userid = None
ticket = request.META.get('HTTP_TICKET')
if ticket:
result = RedisTokenHandler(key=ticket).redis_dict_get()
if result:
userid = result.get("userid")
print("用户代码:{}".format(userid))
res = RedisCaCheHandler(
method="get",
serialiers="GoodsModelSerializerToRedis",
table="goods",
must_key_value=request.query_params_format.get('gdid')).run()
if res['gdstatus'] == '0':
goodslinksku = GoodsLinkSkuSearchSerializer(
GoodsLinkSku.objects.filter(
id__in=res['gdskulist']).order_by('sort'),
many=True).data
# if userid :
# if LimitGoods(userid=userid,limit_goods=res['limit_goods'],gdid=res['gdid']).calsBool():
# gdnum = 0 if request.addressBool else sum([ i['stock'] for i in goodslinksku])
# else:
# gdnum = 0
# else:
gdnum = 0 if request.addressBool else sum(
[i['stock'] for i in goodslinksku])
data = dict(gdid=res['gdid'],
gdimg=res['gdimg'],
gdnum=gdnum,
gdname=res['gdname'],
gdprice=res['gdprice'],
detail=res['detail'],
gdsku=res['gdsku'],
goodslinksku=goodslinksku)
data['yf'] = calyf(res['yf'])
active_id = request.query_params_format.get('active_id', None)
if active_id:
try:
active = Active.objects.get(id=active_id)
except Active.DoesNotExist:
active = None
try:
active.makes = Makes.objects.get(active_id=active.id,
userid=userid)
except Makes.DoesNotExist:
active.makes = None
if active:
data['active'] = ActiveModelSerializer1(active,
many=False).data
else:
data['active'] = None
return {"data": data}
else:
return {"data": False}
def logout(self, request, *args, **kwargs):
RedisTokenHandler(key=request.ticket).delete()
return None
import time, json
def OrderPayByThm(self, request):
thms = request.data_format.get("thms", [])
gdid = request.data_format.get("gdid", None)
memo = request.data_format.get("memo", "")
address = json.dumps(request.data_format.get('address', {}))
if not len(thms):
raise PubErrorCustom("提货码为空!")
try:
user = Users.objects.get(userid=request.user['userid'])
except Users.DoesNotExist:
raise PubErrorCustom("用户非法!")
thmObj = None
for index, thm in enumerate(thms):
try:
deli = DeliveryCode.objects.select_for_update().get(
gdid=gdid, account=thm, status='1')
deli.useuserid = request.user['userid']
deli.status = '0'
deli.save()
if index == 0:
thmObj = deli
except DeliveryCode.DoesNotExist:
raise PubErrorCustom("提货码{}不正确".format(index + 1))
if not thmObj:
raise PubErrorCustom("提货码为空!")
orderObj = Order.objects.create(**dict(userid=request.user['userid']))
orderObj.linkid = {"linkids": []}
orderObj.amount = Decimal("0.0")
res = RedisCaCheHandler(
method="get",
table="goods",
must_key_value=gdid,
).run()
if not res or res['gdstatus'] == '1':
raise PubErrorCustom("{}商品已下架,请在购物车删除此商品!".format(res['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=len(thms),
thm='0',
thms=json.dumps({"thms": thms}),
virtual=res['virtual']))
orderObj.linkid['linkids'].append(link.linkid)
orderObj.amount += link.gdprice * int(link.gdnum)
orderObj.isthm = '0'
orderObj.address = address
orderObj.memo = memo
orderObj.status = '1'
orderObj.isvirtual = res['virtual']
orderObj.linkid = json.dumps(orderObj.linkid)
orderObj.save()
if link.virtual == '0':
cards = Cardvirtual.objects.filter(
gdid=link.gdid, status='1').order_by('createtime')
if cards.exists():
if len(cards) < link.gdnum:
raise PubErrorCustom("暂无存货!")
virtualids = json.loads(link.virtualids)
count = 0
for card in cards:
count += 1
virtualids['ids'].append({
"id": card.id,
"account": card.account,
"password": card.account
})
card.status = '0'
card.useuserid = link.userid
card.save()
if count == link.gdnum:
break
link.virtualids = json.dumps(virtualids)
link.save()
else:
raise PubErrorCustom("暂无存货!")
rUser = None
if thmObj.rolecode == user.rolecode:
flag = False
else:
request.user['rolecode'] = thmObj.rolecode
RedisTokenHandler(key=request.ticket).redis_dict_set(request.user)
rUser = UsersSerializers(user, many=False).data
flag = True
user.rolecode = thmObj.rolecode
user.save()
return {"data": {"b": flag, "rUser": rUser}}
