def setAttachMent(self, request):
if not request.data_format.get("grouid"):
raise PubErrorCustom("请先添加分组!")
before_groupid = ""
if request.data_format.get("id"):
obj = AttachMent.objects.get(id=request.data_format.get("id"))
before_groupid = obj.grouid
obj.title = request.data_format.get("title")
obj.grouid = request.data_format.get("grouid")
obj.save()
obj2 = AttachMentGroup.objects.select_for_update().get(
id=before_groupid)
obj2.number -= 1
obj2.save()
else:
obj = AttachMent.objects.create(
**dict(url=request.data_format.get("url"),
title=request.data_format.get("title"),
grouid=request.data_format.get("grouid"),
type=request.data_format.get("type")))
obj1 = AttachMentGroup.objects.select_for_update().get(id=obj.grouid)
obj1.number += 1
obj1.save()
RedisCaCheHandler(
method="save",
serialiers="AttachMentGroupModelSerializerToRedis",
table="AttachMentGroup",
filter_value=obj1,
must_key="id",
).run()
if before_groupid:
RedisCaCheHandler(
method="save",
serialiers="AttachMentGroupModelSerializerToRedis",
table="AttachMentGroup",
filter_value=obj2,
must_key="id",
).run()
RedisCaCheHandler(
method="save",
serialiers="AttachMentModelSerializerToRedis",
table="AttachMent",
filter_value=obj,
must_key="id",
).run()
return {"data": {"id": obj.id, "url": obj.url}}
def getBuyData(self,request):
# redis_cli_ctypes = RedisCaCheHandlerBase(db="default",key="cptypes")
# res = [ value for key, value in redis_cli_ctypes.redis_dict_get_all().items() ]
# res.sort(key=lambda k: (k.get('id', 0)), reverse=False)
res = RedisCaCheHandler(
method="filter",
serialiers="CpBigTypeModelSerializerToRedis",
table="cpbigtype",
filter_value={}
).run()
res.sort(key=lambda k: (k.get('id', 0)), reverse=False)
return {"data":res}
def getSkukey(self, request, *args, **kwargs):
obj = RedisCaCheHandler(method="filter",
serialiers="SkuKeyModelSerializerToRedis",
table="skukey").run()
for item in obj:
item['data'] = RedisCaCheHandler(
method="filter",
serialiers="SkuValueModelSerializerToRedis",
table="skuvalue",
filter_value={
"keyid": item['id']
}).run()
return {"data": obj}
def getGoods(self, request):
res = RedisCaCheHandler(
method="get",
serialiers="GoodsModelSerializerToRedis",
table="goods",
must_key_value=request.query_params_format.get('gdid')).run()
if res['gdstatus'] == '0':
data = dict(gdid=res['gdid'],
gdimg=res['gdimg'],
gdnum=res['gdnum'],
gdname=res['gdname'],
gdprice=res['gdprice'],
detail=res['detail'],
gdsku=res['gdsku'],
goodslinksku=GoodsLinkSkuSearchSerializer(
GoodsLinkSku.objects.filter(
id__in=res['gdskulist']).order_by('sort'),
many=True).data)
data['yf'] = calyf(res['yf'])
return {"data": data}
else:
return {"data": False}
def getHoliday(self, request, *args, **kwargs):
obj = RedisCaCheHandler(method="filter",
serialiers="HolidayModelSerializerToRedis",
table="holiday").run()
return {"data": obj}
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 getVideo(self, request, *args, **kwargs):
obj = RedisCaCheHandler(method="filter",
serialiers="VideoModelSerializerToRedis",
table="video").run()
return {"data": obj}
def getGoodsCategory(self, request):
"""
获取分类数据
:param request:
:return:
"""
obj = RedisCaCheHandler(
method="filter",
serialiers="GoodsCateGoryModelSerializerToRedis",
table="goodscategory",
filter_value=request.query_params_format).run()
obj.sort(key=lambda k: (k.get('sort', 0)), reverse=False)
return {"data": obj}
def getCard(self, request, *args, **kwargs):
obj = RedisCaCheHandler(
method="filter",
serialiers="CardModelSerializerToRedis",
table="card",
filter_value=request.query_params_format).run()
return {"data": obj}
def getAttachMent(self, request):
obj = RedisCaCheHandler(
method="filter",
serialiers="AttachMentModelSerializerToRedis",
table="AttachMent",
filter_value=request.query_params_format).run()
return {"data": obj}
def getGoodsCategorys(self, request, *args, **kwargs):
obj = RedisCaCheHandler(
method="filter",
serialiers="GoodsCateGoryModelSerializerToRedis",
table="goodscategory",
filter_value=request.query_params_format).run()
return {"data": obj}
def getCpMiniType(self, request, *args, **kwargs):
obj = RedisCaCheHandler(
method="filter",
serialiers="CpMiniTypeModelSerializerToRedis",
table="cpminitype"
).run()
return {"data": obj}
def delCard(self, request, *args, **kwargs):
Card.objects.filter(id=request.data_format.get('id')).delete()
RedisCaCheHandler(method="delete",
table="card",
must_key_value=request.data_format.get('id')).run()
return None
def refeshCacheForRedis(self, request):
RedisCaCheHandler(
method="saveAll",
serialiers="CpModelSerializerToRedis",
table="cp",
filter_value=Cp.objects.filter(),
must_key="id",
).run()
RedisCaCheHandler(
method="saveAll",
serialiers="CpBigTypeModelSerializerToRedis",
table="cpbigtype",
filter_value=CpBigType.objects.filter(),
must_key="typeid",
).run()
RedisCaCheHandler(
method="saveAll",
serialiers="CpSmallTypeModelSerializerToRedis",
table="cpsmalltype",
filter_value=CpSmallType.objects.filter(),
must_key="typeid",
).run()
RedisCaCheHandler(
method="saveAll",
serialiers="CpMiniTypeModelSerializerToRedis",
table="cpminitype",
filter_value=CpMiniType.objects.filter(),
must_key="typeid",
).run()
RedisCaCheHandler(
method="saveAll",
serialiers="CpGamesModelSerializerToRedis",
table="cpgames",
filter_value=CpGames.objects.filter(),
must_key="typeid",
).run()
RedisCaCheHandler(
method="saveAll",
serialiers="BannerModelSerializerToRedis",
table="banner",
filter_value=Banner.objects.filter(),
must_key="id",
).run()
RedisCaCheHandler(
method="saveAll",
serialiers="VideoModelSerializerToRedis",
table="video",
filter_value=Video.objects.filter(),
must_key="id",
).run()
return None
def delCpGames(self, request, *args, **kwargs):
CpGames.objects.filter(typeid=request.data_format.get('typeid')).delete()
RedisCaCheHandler(
method="delete",
table="cpgames",
must_key_value=request.data_format.get('typeid')).run()
return None
def getCpGames(self, request, *args, **kwargs):
obj = RedisCaCheHandler(
method="filter",
serialiers="CpGamesModelSerializerToRedis",
table="cpgames",
filter_value=request.query_params_format.get("filter_value")
).run()
return {"data": obj}
def getHomeData(self, request):
rdata = {
"banners": [],
"category": [],
"active": 0,
"type": Sysparams.objects.get(id=1).pushtype
}
#轮播图数据
rdata['banners'] = RedisCaCheHandler(
method="filter",
serialiers="BannerModelSerializerToRedis",
table="banner",
filter_value={}).run()
#分类数据
rdata['category'] = RedisCaCheHandler(
method="filter",
serialiers="GoodsCateGoryModelSerializerToRedis",
table="goodscategory",
filter_value={
"isstart": "0",
"istheme": "1"
}).run()
rdata['category'].sort(key=lambda k: (k.get('sort', 0)), reverse=False)
#第一条分类数据的视频数据
if len(rdata['category']):
rdata['category'][0]['goods'] = RedisCaCheHandler(
method="filter",
serialiers="GoodsModelSerializerToRedis",
table="goods",
filter_value={
"gdcgid": rdata['category'][0]['gdcgid'],
"gdstatus": "0"
}).run()
rdata['active'] = rdata['category'][0]['gdcgid']
print(rdata)
#
return {"data": rdata}
def delSkuvalue(self, request, *args, **kwargs):
print(request.data_format)
SkuValue.objects.filter(id=request.data_format.get('id')).delete()
RedisCaCheHandler(method="delete",
table="skuvalue",
must_key_value=request.data_format.get('id')).run()
return None
def delBatchCard(self, request, *args, **kwargs):
cards = Card.objects.filter(id__in=request.data_format.get('ids'))
cards.delete()
for item in request.data_format.get('ids'):
RedisCaCheHandler(method="delete",
table="card",
must_key_value=item).run()
return None
def delGoodsCategory(self, request, *args, **kwargs):
GoodsCateGory.objects.filter(
gdcgid=request.data_format.get('gdcgid')).delete()
RedisCaCheHandler(
method="delete",
table="goodscategory",
must_key_value=request.data_format.get('gdcgid')).run()
return None
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 delGoodsTheme(self, request, *args, **kwargs):
GoodsTheme.objects.filter(
typeid=request.data_format.get('typeid')).delete()
RedisCaCheHandler(
method="delete",
table="goodstheme",
must_key_value=request.data_format.get('typeid')).run()
return None
def getLxwm(self, request):
"""
获取公告数据
:param request:
:return:
"""
obj = RedisCaCheHandler(method="filter",
serialiers="OtherMemoModelSerializerToRedis",
table="OtherMemo").run()
return {"data": obj[0] if obj else False}
def delGoods(self, request, *args, **kwargs):
print(request.data_format)
Goods.objects.filter(gdid=request.data_format.get('gdid')).delete()
RedisCaCheHandler(
method="delete",
table="goods",
must_key_value=request.data_format.get('gdid')).run()
return None
def getHomeData(self,request):
"""
获取首页数据
"""
rdata={
"banners":[],
"cp":[],
"ggl":RedisUserSysSetting().get()
}
#轮播图数据
rdata['banners'] = [ dict(
id = item['id'],
url = item['url'],
link = item['link'],
sort = item['sort'],
video = item['url'] if item['type'] == '1' else ""
) for item in RedisCaCheHandler(
method="filter",
serialiers="BannerModelSerializerToRedis",
table="banner",
filter_value={}
).run() ]
rdata['banners'].sort(key=lambda k: (k.get('sort', 0)), reverse=False)
#彩票数据
rdata['cp'] = [ dict(
id = item['id'],
url = item['url'],
name=item['name'],
sort = item['sort'],
termnum = "{}分钟一期".format(item['termnum'])
) for item in RedisCaCheHandler(
method="filter",
serialiers="CpModelSerializerToRedis",
table="cp",
filter_value={}
).run() ]
rdata['cp'].sort(key=lambda k: (k.get('sort', 0)), reverse=False)
return {"data":rdata}
def getGoodsCategory(self, request, *args, **kwargs):
obj = RedisCaCheHandler(
method="filter",
serialiers="GoodsCateGoryModelSerializerToRedis",
table="goodscategory",
filter_value=request.query_params_format.get("filter_value", {}),
condition_params=request.query_params_format.get(
"condition_params", []),
).run()
for item in obj:
item['rolecode'] = json.loads(item['rolecode'])['rolecode']
goods = []
for gdid in json.loads(item['goods'])['goods']:
goods.append(
RedisCaCheHandler(method="get",
serialiers="GoodsModelSerializerToRedis",
table="goods",
must_key_value=gdid).run())
item['goods'] = goods
return {"data": obj}
def getOtherMemo(self, request):
"""
获取公告数据
:param request:
:return:
"""
obj = RedisCaCheHandler(
method="filter",
serialiers="OtherMemoModelSerializerToRedis",
table="OtherMemo",
filter_value=request.query_params_format).run()
return {"data": obj[0] if obj else False}
def saveHoliday(self, request, *args, **kwargs):
serializer = kwargs.pop("serializer")
obj = serializer.save()
RedisCaCheHandler(
method="save",
serialiers="HolidayModelSerializerToRedis",
table="holiday",
filter_value=obj,
must_key="id",
).run()
return None
def saveCpGames(self, request, *args, **kwargs):
serializer = kwargs.pop("serializer")
obj = serializer.save()
RedisCaCheHandler(
method="save",
serialiers="CpGamesModelSerializerToRedis",
table="cpgames",
filter_value=obj,
must_key="typeid",
).run()
return None
def getBanner(self, request):
"""
获取轮播图图片
:param request:
:return:
"""
data = RedisCaCheHandler(
method="filter",
serialiers="BannerModelSerializerToRedis",
table="banner",
filter_value=request.query_params_format).run()
return {"data": data}
