def sendLedText(self, activityGameId, userId, prize):
ledsMap = Tool.dictGet(self._clientConf, 'config.server.ledsMap', {})
prizes = Tool.dictGet(self._clientConf, 'config.server.prizes', [])
for item in prizes:
# 根据奖励itemId找到奖励配置
if item['itemId'] != prize['itemId']:
continue
# 获取led发送的配置
ledItem = ledsMap.get(item.get('ledKey'))
if not ledItem:
continue
# 查看是否满足LED发送条件
if ledItem.get('minCount', 0) > prize['count']:
continue
text = ledItem.get('text')
if not text:
continue
prizeContent = hallitem.buildContent(prize['itemId'],
prize['count'], True)
ledtext = strutil.replaceParams(
text, {
'nickname': UserInfo.getNickname(userId),
'prizeContent': prizeContent
})
hallled.sendLed(activityGameId, ledtext, 0, scope='hall6')
if ftlog.is_debug():
ftlog.debug('LuckyMoneyNew.sendLedText', 'activityGameId=',
activityGameId, 'activityId=',
self._clientConf['id'], 'userId=', userId,
'ledtext=', ledtext)
break
def __init__(self, dao, clientConfig, serverConfig):
super(self.__class__, self).__init__(dao, clientConfig, serverConfig)
self._dao = dao
self._serverConf = serverConfig
self._clientConf = clientConfig
self._dataWrapper = DataWrapper(serverConfig)
ftlog.debug("TYActivityDdzRedEnvelope.__init__",
clientConfig.get('id'), self.checkOperative(),
serverConfig, clientConfig)
if not self.checkOperative():
return
if not _redenvelopeWrapper:
ftlog.debug("TYActivityDdzRedEnvelope. global _redenvelopeWrapper")
global _redenvelopeWrapper
general = Tool.dictGet(clientConfig,
"config.activate.generalRedEnvelope")
vip = Tool.dictGet(clientConfig, "config.activate.vipRedEnvelope")
_redenvelopeWrapper = RedEnvelopeWrapper(general, vip)
if not DdzRedEnvelope._timelist:
ftlog.debug("TYActivityDdzRedEnvelope. DdzRedEnvelope._timelist")
timelist = Tool.dictGet(clientConfig, "config.activate.timeList")
datetime_start = datetime.strptime(serverConfig.get("start"),
"%Y-%m-%d %H:%M:%S")
datetime_end = datetime.strptime(serverConfig.get("end"),
"%Y-%m-%d %H:%M:%S")
DdzRedEnvelope._timelist = self.getTimePointListInRange(
timelist, datetime_start, datetime_end)
DdzRedEnvelope._datetime_start = datetime_start
DdzRedEnvelope._datetime_end = datetime_end
DdzRedEnvelope.onHeartBeat(None)
def __init__(self, dao, clientConf, serverConf):
super(self.__class__, self).__init__(dao, clientConf, serverConf)
# 红包池key,用于区分不同红包池，每个活动对应不同(直接使用活动ID)
self.poolId = clientConf['id']
# 配置的活动游戏ID，用于存储用户数据，金流日志记录等
self.activityGameId = Tool.dictGet(clientConf,
'config.server.activityGameId', 6)
# 红包开启时间列表
timesConf = Tool.dictGet(clientConf, 'config.server.times', [])
self.openList = OpenDurationList(timesConf, serverConf)
# 红包发布对象，用于定时发布红包
self.publisher = LuckyMoneyPublisher(clientConf, self.openList,
self.poolId)
# 注册监听事件
self.registerEvents()
if ftlog.is_debug():
ftlog.debug('LuckyMoneyNew.__init__:'
'activityId=', clientConf['id'], 'openList=',
[(item.start, item.end)
for item in self.openList.itemList])
def recommendProductIfCan(self, gameId, userId):
# 没有配置推荐商品，则不推荐
payOrder = Tool.dictGet(self._clientConf, 'config.server.payOrder')
if not payOrder:
return False
clientId = sessiondata.getClientId(userId)
product, _ = hallstore.findProductByPayOrder(gameId, userId, clientId,
payOrder)
ftlog.debug('FunAct.recommendProductIfCan:', 'userId=', userId,
'product=', product)
# 没有在货架中找到商品
if not product:
return False
translateMap = {
'product.displayName': product.displayName,
'product.price': product.price,
'count': payOrder.get('contains', {}).get('count', 0)
}
desc = Tool.dictGet(self._clientConf, 'config.server.lessBuyChipDesc')
note = Tool.dictGet(self._clientConf, 'config.server.lessBuyChipNote')
desc = strutil.replaceParams(desc, translateMap)
note = strutil.replaceParams(note, translateMap)
todotask = TodoTaskLessBuyOrder(desc, None, note, product)
TodoTaskHelper.sendTodoTask(gameId, userId, todotask)
return True
def update(self, userId, gameId, clientId, activityId):
'''
未领取 + 有剩余 = 显示可领取
未领取 + 无剩余 = 显示倒计时
已领取 + xxx = 显示倒计时
{'isOK': True, 'nowTime': 1452161428.0, 'nextTime': 1452218400.0, 'hasGet': False, 'isRemain': True, 'tip': tip}
'''
clientconf = self._clientConf
serverconf = self._serverConf
dataWrapper = self._dataWrapper
timelist = Tool.dictGet(clientconf, "config.activate.timeList")
startdate = serverconf.get("start")
enddate = serverconf.get("end")
#检测是否过期
if not self.checkOperative():
tip = Tool.dictGet(clientconf, "config.activate.outdateTip")
return {"isOK": False, "tip": tip} #活动已经过期
nowstamp = Tool.datetimeToTimestamp(datetime.now())
rconf = {"isOK": True, "nowTime": nowstamp}
# 上次领取的物品
itemconf = dataWrapper.getLastGetItem(userId)
if itemconf:
rconf.update({
"itemDesc": itemconf.get("itemDesc"),
"itemCount": itemconf.get("count")
})
arrive_timepoint = dataWrapper.getLastestTimePoint(timelist, startdate)
next_timepoint = dataWrapper.getNextTimePoint(timelist, enddate)
if next_timepoint: # 若存在下一个时间点
rconf["nextTime"] = Tool.datetimeToTimestamp(next_timepoint)
count = 0
if arrive_timepoint: #已经达到至少一个领取时间点
has_get = dataWrapper.hasGet(userId, arrive_timepoint) # 是否已经领取
isvip = (UserInfo.getVipLevel(userId) > 0)
if isvip:
count = _redenvelopeWrapper.getCount() # 剩余红包数量
else:
count = _redenvelopeWrapper.getGeneralCount() # 非VIP只检测普通红包数量
rconf.update({"hasGet": has_get, "isRemain": (count > 0)})
# 上次领取时间在昨天?
today = datetime.now().replace(None, None, None, 0, 0, 0, 0)
if arrive_timepoint < today:
rconf.update({"isFirst": True})
else: #未达到领取时间
rconf.update({"hasGet": False, "isRemain": False, "isFirst": True})
ftlog.debug("TYActivityDdzRedEnvelope.update: userId", userId,
"rconf=", rconf, "count=", count)
return rconf
def getItemConf(self, clientconf, iteminfo):
isvip = iteminfo.get('isVipItem', False)
conf = Tool.dictGet(clientconf, 'config.activate.generalRedEnvelope')
if isvip:
conf = Tool.dictGet(clientconf, 'config.activate.vipRedEnvelope')
for x in conf:
if x.get('itemId') == iteminfo.get('itemId'):
return x
return False
def onActionBetChip(self, userId, betChip, isLeft, issueNumber):
ftlog.debug('BetGuess.onActionBetChip:', 'userId=', userId, 'betChip=',
betChip, 'isLeft=', isLeft, 'issueNumber=', issueNumber)
clientconf = self._clientConf
activityGameId = clientconf.get('activityGameId')
issueNumberNow = self.issueCalculator.getCurrentIssueNumber()
ftlog.debug('BetGuess.onActionBetChip:', 'userId=', userId,
'issueNumberNow=', issueNumberNow, 'issueNumber=',
issueNumber)
# 参数合理性判断，不合理直接忽略
if betChip <= 0 or isLeft == None:
return self.buildActivityInfo(userId)
# 没有当前一期的竞猜
if not issueNumberNow:
return self.makeResponseMessage(
userId, {
'message':
Tool.dictGet(clientconf, 'config.server.allIssueOutdate')
})
# 客户端展示的期号与当前不一致，强制刷新
if issueNumber != issueNumberNow:
return self.makeResponseMessage(userId, {
'message':
Tool.dictGet(clientconf, 'config.server.issueOutdate')
})
# 若推荐商品，则代表金币不足，直接返回
if self.recommendProductIfNeed(activityGameId, userId, betChip):
return self.buildActivityInfo(userId)
# 消耗用户金币，增加用户存储的活动数据金币
userModel = ActivityUserModel.loadModel(userId, activityGameId,
self.getid())
err = self.userBetChip(userId, activityGameId, issueNumber, userModel,
isLeft, betChip)
if err:
return self.makeResponseMessage(userId, {'message': err})
# 记录玩家
UserRecorder.addUser(userId, activityGameId, self.getid(), issueNumber)
# 增加活动奖池记录数据
activityModel = ActivityModel.loadModel(activityGameId, self.getid(),
issueNumber)
activityModel.incrChip(isLeft, betChip)
ftlog.info('BetGuess.onActionBetChip', 'userId=', userId,
'activityGameId=', activityGameId, 'activityId=',
self.getid(), 'issueNumber=', issueNumber,
'activityModel.resultState=', activityModel.resultState,
'activityModel.countChipLeft=', activityModel.countChipLeft,
'activityModel.countChipRight=',
activityModel.countChipRight)
return self.buildActivityInfo(userId, activityModel, userModel)
def calculateScore(cls, rmb, dashifen):
'''
计算排行分数
:param rmb: 活动期间RMB消费总数
:param dashifen: 活动期间大师分增长数量
'''
actconf = cls.getActivityConf()
dashifen_ratio = Tool.dictGet(actconf,
'config.activate.dashifen_ratio', 0)
charge_ratio = Tool.dictGet(actconf, 'config.activate.charge_ratio', 0)
return dashifen * dashifen_ratio + rmb * charge_ratio
def _generatePackets(cls, bankId, issue):
'''
生成红包,并存储到redis中,多进程利用redis同步生成的红包数据
'''
clientconf = ConfigDatabase.getClientConfig(bankId)
nor_items = Tool.dictGet(clientconf,
"config.activate.generalRedEnvelope")
vip_items = Tool.dictGet(clientconf, "config.activate.vipRedEnvelope")
# {"user:coupon":[...], "item:1007":[...], ...}
nor_packets = {}
nor_packets_num = {} # 每个道具的数量
for item in nor_items:
itemtype = item.get("type")
itemId = item.get("itemId")
num = item.get("num")
if itemtype == "random.split":
total = item.get("total")
minv = item.get("min")
nor_packets[
itemId] = Random.getNormalDistributionRandomSequence(
total, minv, num)
elif itemtype == "random.fixed":
count = item.get("count")
nor_packets[itemId] = [count for _ in xrange(num)]
nor_packets_num[itemId] = num
# {"user:coupon":[...], "item:1007":[...], ...}
vip_packets = {}
vip_packets_num = {} # 每个道具的数量
for item in vip_items:
itemtype = item.get("type")
itemId = item.get("itemId")
num = item.get("num")
if itemtype == "random.split":
total = item.get("total")
minv = item.get("min")
vip_packets[
itemId] = Random.getNormalDistributionRandomSequence(
total, minv, num)
elif itemtype == "random.fixed":
count = item.get("count")
vip_packets[itemId] = [count for _ in xrange(num)]
vip_packets_num[itemId] = num
packets_data = {"nor": nor_packets, "vip": vip_packets}
count_data = {"nor": nor_packets_num, "vip": vip_packets_num}
data = PacketRedisInterface.setPacketData(bankId, issue, packets_data,
count_data)
return json.loads(data)
def getConfigForClient(self, gameId, userId, clientId):
'''
获取客户端要用的活动配置，由TYActivitySystemImpl调用
'''
clientconf = self._clientConf
serverconf = self._serverConf
ftlog.debug("TYActivityDumplings.getConfigForClient: ", "userId=",
userId, "gameId=", gameId, "clientId=", clientId,
"serverconf=", serverconf, "clientconf=", clientconf)
rankingId = DumplingsUtil.getRankingId()
if not rankingId:
return
rankingconf = DumplingsUtil.getRankingConfigById(rankingId)
rewardlist = rankingconf.get('rankRewardList', [])
RankingPriorityLedSender.rankingRewardList = rewardlist
actconf = DumplingsUtil.getActivityConf()
RankingPriorityLedSender.ledFormatText = Tool.dictGet(
actconf, 'config.activate.ranking.userLed')
ftlog.debug("TYActivityDumplings.getConfigForClient: ", "userId=",
userId, "rewardlist=", rewardlist, "ledFormatText=",
RankingPriorityLedSender.ledFormatText)
return clientconf
def handleRequest(self, msg):
clientconf = strutil.deepcopy(self._clientConf)
serverconf = self._serverConf
userId = msg.getParam('userId')
activityId = msg.getParam('activityId')
action = msg.getParam('action')
ftlog.debug('WishingWell.handleRequest',
'userId=', userId,
'activityId=', activityId,
'action=', action)
uniquekey = Utility.buildUniqueKey(serverconf)
model = UserModel().loadsFromRedis(userId, uniquekey)
if action == 'ddz.wishing.update':
return self.handleRequestUpdateStatus(model, userId)
poolItem = Utility.getPoolItemWithStepIndex(clientconf, model.poolStepIndex)
ftlog.debug('WishingWell.handleRequest',
'userId=', userId,
'poolItem=', poolItem,
'model=', model.dict())
## 许愿池已经全部领光
if not poolItem:
return Utility.buildError(Tool.dictGet(clientconf, 'config.nothingPoolItemError'))
## 已经投入,则逻辑走领取
if model.isAlreadyPutted:
return self.handleRequestGetting(model, userId, poolItem)
## 未投入,则走投入逻辑
return self.handleRequestPutting(model, userId, poolItem)
def handleRequestPutting(self, model, userId, poolItem):
'''
投入资本
:param userId:
:return:
'''
clientconf = strutil.deepcopy(self._clientConf)
serverconf = self._serverConf
uniquekey = Utility.buildUniqueKey(serverconf)
ftlog.debug('WishingWell.handleRequestPutting:start',
'userId=', userId,
'model=', model.dict())
## 判断许愿池投入按钮是否过期
if Utility.isPutIntoButtonOutdate(clientconf):
return Utility.buildError(Tool.dictGet(clientconf, 'config.wishingOverError'))
## 许愿消耗费用
expensesConfig = poolItem.get('expenses')
expensesItemId = expensesConfig.get('itemId', 'user:chip')
expensesItemCount = expensesConfig.get('count', 0)
ftlog.debug('WishingWell.handleRequestPutting:consume',
'userId=', userId,
'poolItem=', poolItem,
'expensesItemId=', expensesItemId,
'expensesItemCount=', expensesItemCount)
if not UserBag.consumeAssetsIfEnough(userId, expensesItemId, expensesItemCount, self.EVENT_ID): ## 费用不足
return Utility.buildError(Tool.dictGet(clientconf, 'config.expensesNotEnoughError'))
## 更新Model
model.isAlreadyPutted = True
## 重置计时,重新开始计时
model.resetingCounterToCurrentTimestamp()
model.dumpsToRedis(userId, uniquekey)
ftlog.info('WishingWell.handleRequestPutting, ',
'userId', userId,
'poolstepindex', model.poolStepIndex,
'model=', model.dict())
response = self.getActivityUserStatus(userId, model)
puttingSuccess = Tool.dictGet(clientconf, 'config.puttingSuccess')
if puttingSuccess and len(puttingSuccess) > 0:
response['message'] = puttingSuccess
response['operate'] = 'putting'
return response
def __init__(self, dao, clientConfig, serverConfig):
super(self.__class__, self).__init__(dao, clientConfig, serverConfig)
ftlog.debug('BetGuess.__init__')
issueMap = Tool.dictGet(clientConfig, 'config.issueMap', {})
ftlog.debug('BetGuess.__init__:issueMap=', issueMap)
self.issueCalculator = IssueCalculator(issueMap)
# 注册监听事件
self.registerEvents()
def getPrizeStatus(self, activityModel, userModelItem):
''' 获取发奖状态 '''
clientconf = self._clientConf
# 用户数据记录：未发奖
if activityModel.resultState == activityModel.RESULT_STATE_NONE:
return Tool.dictGet(clientconf,
'config.server.recordCellWaitingResultTip',
'未开奖')
if activityModel.resultState == activityModel.RESULT_STATE_LEFT and userModelItem.leftBetValue > 0:
return Tool.dictGet(clientconf,
'config.server.recordCellResultWinTip', '猜中')
if activityModel.resultState == activityModel.RESULT_STATE_RIGHT and userModelItem.rightBetValue > 0:
return Tool.dictGet(clientconf,
'config.server.recordCellResultWinTip', '猜中')
return Tool.dictGet(clientconf,
'config.server.recordCellResultLoseTip', '未猜中')
def recommendProductIfNeed(self, gameId, userId, chip):
# 当前金币足够则不用推荐商品
curchip = userchip.getChip(userId)
ftlog.debug('BetGuess.recommendProductIfNeed:', 'userId=', userId,
'curchip=', curchip, 'chip=', chip)
if curchip >= chip:
return False
# 没有配置推荐商品，则不推荐
payOrderMap = Tool.dictGet(self._clientConf,
'config.server.payOrderMap')
if not payOrderMap:
return False
# 没有找到推荐商品配置，则不推荐
payOrder = payOrderMap.get(str(int(chip)))
ftlog.debug('BetGuess.recommendProductIfNeed:', 'userId=', userId,
'payOrder=', payOrder)
if not payOrder:
return False
clientId = sessiondata.getClientId(userId)
product, _ = hallstore.findProductByPayOrder(gameId, userId, clientId,
payOrder)
ftlog.debug('BetGuess.recommendProductIfNeed:', 'userId=', userId,
'product=', product)
# 没有在货架中找到商品
if not product:
return False
translateMap = {
'product.displayName': product.displayName,
'product.price': product.price,
'betchip': chip,
}
desc = Tool.dictGet(self._clientConf, 'config.server.lessBuyChipDesc')
note = Tool.dictGet(self._clientConf, 'config.server.lessBuyChipNote')
desc = strutil.replaceParams(desc, translateMap)
note = strutil.replaceParams(note, translateMap)
todotask = TodoTaskLessBuyOrder(desc, None, note, product)
TodoTaskHelper.sendTodoTask(gameId, userId, todotask)
return True
def getPromptTextDictionary(cls, clientconf, model):
'''
获得promptText的变量字典
变量:
assets_expenses_desc 投入花费资源描述
duration_desc 需要等待的时间(秒)
promptdesc 获得资源的范围描述(可以根据bottom和top自动生成)
'''
poolItem = Utility.getPoolItemWithStepIndex(clientconf, model.poolStepIndex)
rewardconf = poolItem.get('reward', {})
if 'promptdesc' not in rewardconf:
assets_range = str(rewardconf.get('bottom', 0)) + '~' + str(rewardconf.get('top', 0))
rewardconf['promptdesc'] = strutil.replaceParams(rewardconf.get('desc'), {'count': assets_range})
if 'durationDesc' not in poolItem:
poolItem['durationDesc'] = str(poolItem.get('duration', 0))
return {
'assets_expenses_desc': Tool.dictGet(poolItem, 'expenses.desc'),
'duration_desc': Tool.dictGet(poolItem, 'durationDesc'),
'promptdesc': Tool.dictGet(poolItem, 'reward.promptdesc')
}
def buildActivityInfo(self, userId):
if ftlog.is_debug():
ftlog.debug('TableReplayRanking.buildActivityInfo',
'userId=', userId)
clientconf = copy.deepcopy(self._clientConf)
# 分享按钮的todotask
todoconf = clientconf['config']['client']['buttonShare'].get('todotask')
if todoconf:
clientId = sessiondata.getClientId(userId)
todotask = TodoTaskRegister.decodeFromDict(todoconf).newTodoTask(DIZHU_GAMEID, userId, clientId)
clientconf['config']['client']['buttonShare']['todotask'] = todotask.toDict()
# 活动期间奖励累计总数
model = ActivityUserModel.loadModel(DIZHU_GAMEID, self.getid(), userId)
clientconf['config']['client']['myPrizeCount'] = model.prizeCounter
rankingDisplayRankNumberList = Tool.dictGet(self._clientConf, 'config.server.rankingDisplayRankNumberList', [])
myRankNumberNotOnRanking = Tool.dictGet(self._clientConf, 'config.server.myRankNumberNotOnRanking', '')
myRankNumberFormat = Tool.dictGet(self._clientConf, 'config.server.myRankNumberFormat', '')
rankingMax = Tool.dictGet(self._clientConf, 'config.server.rankingMax', 50)
# 获得玩家排名信息
clientconf['config']['client']['myRankNumber'] = myRankNumberNotOnRanking
rankNumber = RankingProxy.getRankNumberByUserId(rankingMax, userId)
if ftlog.is_debug():
ftlog.debug('TableReplayRanking.buildActivityInfo',
'userId=', userId,
'rankNumber=', rankNumber)
if rankNumber > 0:
myRankNumber = strutil.replaceParams(myRankNumberFormat, {'rankNumber': rankNumber})
clientconf['config']['client']['myRankNumber'] = myRankNumber
# 摘取固定的几个排名数据
rankingList = RankingProxy.getRankingListByRankNumberList(rankingMax, rankingDisplayRankNumberList)
clientconf['config']['client']['rankingList'] = rankingList
if ftlog.is_debug():
ftlog.debug('TableReplayRanking.buildActivityInfo',
'userId=', userId,
'clientInfo=', clientconf['config']['client'])
return clientconf
def userBetChip(self, userId, activityGameId, issueNumber, userModel,
isLeft, betChip):
# 加载用户活动数据
ftlog.debug('BetGuess.userBetChip:', 'userId=', userId,
'activityGameId=', activityGameId, 'issueNumber=',
issueNumber, 'isLeft=', isLeft, 'betChip=', betChip)
# 先查看玩家投注是否超额
issueConf = self.issueCalculator.getCurrentIssueConf(issueNumber)
userMaxBetChip = issueConf.get('userMaxBetChip', -1)
item = userModel.findOrCreateItemByIssueNumber(issueNumber)
if userMaxBetChip and userMaxBetChip > 0 and \
(item.leftBetValue + item.rightBetValue + betChip) > userMaxBetChip:
return Tool.dictGet(self._clientConf,
'config.server.betChipOverflow')
# 消耗玩家金币
clientId = sessiondata.getClientId(userId)
trueDelta, _ = userchip.incrChip(userId, activityGameId, -betChip,
daoconst.CHIP_NOT_ENOUGH_OP_MODE_NONE,
'ACT_BETGUESS_CHIP', 0, clientId)
datachangenotify.sendDataChangeNotify(activityGameId, userId, 'chip')
ftlog.debug('BetGuess.userBetChip:', 'userId=', userId, 'trueDelta=',
trueDelta)
if trueDelta != -betChip:
ftlog.debug('BetGuess.userBetChip:chipNotEnough')
return Tool.dictGet(self._clientConf,
'config.server.chipNotEnough')
# 玩家记录数据
userModel.incrChip(issueNumber, isLeft, betChip)
userModel.save()
# 日志记录每个UID每场的下注额及下注项
packageGameId = strutil.getGameIdFromHallClientId(
sessiondata.getClientId(userId))
ftlog.info('BetGuess.userBetChip', 'userId', userId, 'packageGameId',
packageGameId, 'activityGameId', activityGameId,
'activityId', self.getid(), 'issueNumber', issueNumber,
'isLeft', isLeft, 'betChip', betChip)
return None
def update(self, userId, gameId, clientId, activityId, bankId):
'''
未领取 + 有剩余 = 显示可领取
未领取 + 无剩余 = 显示倒计时
已领取 + xxx = 显示倒计时
{'isOK': True, 'nowTime': 1452161428.0, 'nextTime': 1452218400.0, 'hasGet': False, 'isRemain': True, 'tip': tip}
'''
clientconf = self._clientConf
#检测是否过期
if not self.checkOperative():
tip = Tool.dictGet(clientconf, "config.activate.outdateTip")
return {"isOK": False, "tip": tip} #活动已经过期
nowstamp = Tool.datetimeToTimestamp(datetime.now())
rconf = {"isOK": True, "nowTime": nowstamp}
iteminfo = LuckyPacketHelper.getUserGetLastlyHistory(bankId, userId)
if iteminfo:
rconf.update({
"itemDesc": iteminfo.get("itemDesc"),
"itemCount": iteminfo.get("count")
})
timeservices = ConfigDatabase.getTimeServices(bankId)
next_timepoint = timeservices.getFirstUnreachedDatetime()
if next_timepoint:
rconf["nextTime"] = Tool.datetimeToTimestamp(next_timepoint)
arrive_timepoint = timeservices.getLastlyReachedDatetime()
if arrive_timepoint: #已经达到至少一个领取时间点
current_issue = timeservices.getIssueNumber(arrive_timepoint)
isget = LuckyPacketHelper.isUserGet(bankId, userId, current_issue)
isvip = (UserInfo.getVipLevel(userId) > 0)
if isvip:
count = PacketRedisInterface.getAllPacketNumber(
bankId, current_issue) # 剩余红包数量
else:
count = PacketRedisInterface.getNormalPacketNumber(
bankId, current_issue) # 非VIP只检测普通红包数量
rconf.update({"hasGet": isget, "isRemain": (count > 0)})
# 上次领取时间在昨天?
today = datetime.now().replace(None, None, None, 0, 0, 0, 0)
if arrive_timepoint < today:
rconf.update({"isFirst": True})
else: #未达到领取时间
rconf.update({"hasGet": False, "isRemain": False, "isFirst": True})
ftlog.debug("LuckyPacket.update: userId=", userId, "bankId=", bankId,
"rconf=", rconf, "count=", count)
return rconf
def onConfigChanged(self, event):
clientConf = self._clientConf
serverConf = self._serverConf
timesConf = Tool.dictGet(self._clientConf, 'config.server.times', [])
self.openList.build(timesConf, serverConf)
self.publisher.reload(clientConf)
if ftlog.is_debug():
ftlog.debug('LuckyMoneyNew.onConfigChanged:'
'event.keylist=', event.keylist, 'poolId=',
self.poolId, 'activityId=', clientConf['id'],
'openList=', [(item.start, item.end)
for item in self.openList.itemList])
ftlog.info('LuckyMoneyNew.onConfigChanged: ok')
def getRankingId(cls):
'''
根据配置的rankingkey获取rankingId
'''
clientconf = cls.getActivityConf()
rankingkey = Tool.dictGet(clientconf, 'config.activate.rankingKey')
allrankingconf = hallconf.getRankingConf()
ranking_templates = allrankingconf.get('rankingKeys', {})
if not ranking_templates:
return
l = ranking_templates.get(rankingkey, {}).get('default')
if l:
return l[0]
return
def _creditTypeSendRewardsIfNeed(cls, userId):
'''
积分发奖类型,当积分达到发奖值后,自动发奖(仅供积分发奖类型使用:"rewardsType": "credit")
'''
actconf = DumplingsUtil.getActivityConf()
isRanking = Tool.dictGet(actconf, 'config.activate.rewardsType',
'credit') == 'ranking'
if isRanking:
return
rediskey = cls.getRedisKey()
mail = Tool.dictGet(actconf, 'config.activate.mail')
reward = Tool.dictGet(actconf, 'config.activate.credit.rewards')
jsondict = Redis.readJson(userId, rediskey)
helper = CreditRewardHelper(userId, reward)
reachedlist = helper.getReachedConfList() # 达到发奖条件的所有奖励配置的list
getlist = jsondict.get('getlist',
[]) # 已经领取的奖励list,使用score字段记录,score字段值不可重复
for item in reachedlist:
for assets in item.get('items'):
if item['score'] not in getlist:
getlist.append(item['score'])
ranking_num = cls.getRankingWithUserId(userId)
mailstr = strutil.replaceParams(mail, {
'assets': item.get('desc'),
'ranking_num': ranking_num
})
UserBag.sendAssetsToUser(6, userId, assets,
'DDZ_ACT_DUMPLINGS', mailstr)
# 记录奖励已经领取
jsondict['getlist'] = getlist
Redis.writeJson(userId, rediskey, jsondict)
ftlog.debug("DumplingsUtil.creditTypeSendRewardsIfNeed: userId=",
userId, "jsondict=", jsondict)
def hasGet(self, userId, datetime):
'''
是否已经领取
:param datetime: 判断这个时间点是否有领取红包
'''
rediskey = self.getRedisKey()
dictobj = Redis.readJson(userId, rediskey)
key = "get.%s" % str(datetime)
value = Tool.dictGet(dictobj, key)
ftlog.debug("DataWrapper.hasGet: userId=", userId, "key=", key,
"datetime=", str(datetime), "dictobj=", dictobj, "value=",
value)
if value:
return True
return False
def onTableReplay(self, event):
if ftlog.is_debug():
ftlog.debug('TableReplayRanking.onTableReplay',
'userId=', event.userId)
# 检测活动是否过期
if not self.checkOperative():
ftlog.debug('TableReplayRanking.onTableReplay:checkOperative()->False',
'userId=', event.userId)
return
# 加载最新的活动数据，并且当天重放次数加一
model = ActivityUserModel.loadModel(DIZHU_GAMEID, self.getid(), event.userId)
model.incrReplayCount()
# 同时满足日上限
replayPrizeDayUpperLimit = Tool.dictGet(self._clientConf, 'config.server.replayPrizeDayUpperLimit', 50)
if ftlog.is_debug():
ftlog.debug('TableReplayRanking.onTableReplay',
'userId=', event.userId,
'replayPrizeDayUpperLimit=', replayPrizeDayUpperLimit,
'model.replayDayCounter=', model.replayDayCounter)
if model.replayDayCounter <= replayPrizeDayUpperLimit:
mail = Tool.dictGet(self._clientConf, 'config.server.mail')
replayPrizeList = Tool.dictGet(self._clientConf, 'config.server.replayPrizeList', [])
prizeCount = self.sendPrizeToUser(event.userId, replayPrizeList, mail)
model.prizeCounter += prizeCount
if ftlog.is_debug():
ftlog.debug('TableReplayRanking.onTableReplay',
'userId=', event.userId,
'replayPrizeList=', replayPrizeList,
'prizeCount=', prizeCount,
'model.prizeCounter=', model.prizeCounter)
# 存储用户活动数据
ActivityUserModel.saveModel(model, DIZHU_GAMEID, self.getid(), event.userId)
def isPutIntoButtonOutdate(cls, clientconf):
'''
是否投入按钮已经过期,先于活动过期
:param clientconf:
:return: True/False
'''
buttonconf = Tool.dictGet(clientconf, 'config.putButtonLife', {})
datetime_start = buttonconf.get('start', '')
datetime_end = buttonconf.get('end', '')
ok = not Tool.checkNow(datetime_start, datetime_end)
ftlog.debug('Utility.isPutIntoButtonOutdate',
'buttonconf=', buttonconf,
'datetime_start=', datetime_start,
'datetime_end=', datetime_end,
'ok=', ok)
return ok
def loggingCredit(cls, userId):
'''
当以达到积分获得奖励时——统计每天每个档位达到的玩家数量
实现:每次积分更新时,统计玩家到达第几个档位
'''
clientconf = DumplingsUtil.getActivityConf()
reward = Tool.dictGet(clientconf, 'config.activate.credit.rewards')
helper = CreditRewardHelper(userId, reward)
now = datetime.now()
score = 0
conf = helper.getCurrentReachedConf()
if conf:
score = conf.get('score', 0)
ftlog.info("DdzDumplings.Credit,", "userId", userId, "now", now,
"score", score)
def onUpdate(cls):
ftlog.debug(
"RankingPriorityLedSender.onUpdate", "cls.currentRankingUser="******"cls.rankingRewardList=",
cls.rankingRewardList, "cls.ledFormatText=", cls.ledFormatText,
"ifok=",
not not (not cls.currentRankingUser or not cls.ledFormatText
or not cls.rankingRewardList))
if not cls.currentRankingUser or not cls.ledFormatText or not cls.rankingRewardList:
cls.currentRankingUser = None
cls.oldRankingUser = None
cls.loopTimerCounter = 0
if cls.loopTimer:
cls.loopTimer.cancel()
return
ftlog.debug("RankingPriorityLedSender.onUpdate", "userId=",
cls.currentRankingUser.userId, "cls.loopTimerCounter",
cls.loopTimerCounter)
helper = RankingRewardHelper(cls.currentRankingUser.userId,
cls.rankingRewardList)
reachedlist = helper.getReachedConfList()
currentconf = {}
if reachedlist and len(reachedlist) > 0:
currentconf = reachedlist[-1]
dictionary = {}
dictionary['ranking_current_item'] = Tool.dictGet(
currentconf, 'rewardContent.desc')
dictionary['newuser_nickname'] = UserInfo.getNickname(
cls.currentRankingUser.userId)
dictionary['newuser_ranknumber'] = str(
DumplingsUtil.getRankingWithUserId(cls.currentRankingUser.userId))
dictionary['olduser_nickname'] = UserInfo.getNickname(
cls.oldRankingUser.userId)
led = strutil.replaceParams(cls.ledFormatText, dictionary)
Tool.sendLed(led)
cls.loopTimerCounter += 1
if cls.loopTimerCounter >= 5:
ftlog.debug("RankingPriorityLedSender.onUpdate ",
"cls.loopTimerCounter>=5:", "userId=",
cls.currentRankingUser.userId)
cls.currentRankingUser = None
cls.oldRankingUser = None
cls.loopTimer.cancel()
cls.loopTimerCounter = 0
def getPoolItemWithStepIndex(cls, clientconf, poolStepIndex):
'''
获取许愿池进行第几个的配置
:param clientconf:
:param poolStepIndex:
:return:返回None则代表没有
'''
pool = Tool.dictGet(clientconf, 'config.pool')
ftlog.debug('Utility.getPoolItemWithStepIndex',
'poolStepIndex=', poolStepIndex,
'pool=', pool)
if not pool:
return None
if len(pool) > poolStepIndex:
return pool[poolStepIndex]
return None
def getTimeServices(cls, bankId):
if cls.services_times.get(bankId):
return cls.services_times.get(bankId)
clientconf = cls.getClientConfig(bankId)
serverconf = cls.getServerConfig(bankId)
timelist = Tool.dictGet(clientconf, 'config.activate.timeList')
conf_start = serverconf.get('start')
conf_end = serverconf.get('end')
datetime_start = datetime.strptime(conf_start, '%Y-%m-%d %H:%M:%S')
datetime_end = datetime.strptime(conf_end, '%Y-%m-%d %H:%M:%S')
services_time = PacketTimeHelper(timelist, datetime_start,
datetime_end)
cls.services_times[bankId] = services_time
return services_time
def sendLedIfNeed(self, userId, itemconf, count):
'''
如果满足情况则,发送LED
:param itemconf: 红包奖励配置项{"type":"random.fixed", "itemId": "item:2003", "desc":"记牌器", "num":500, "count":1, "led": "led1"}
:param count: 拆红包真实领取的物品个数
:return: Bool, 是否发送
'''
settingkey = itemconf.get("led", False)
if not settingkey:
return False
ftlog.debug("TYActivityDdzRedEnvelope.sendLedIfNeed: settingkey=",
settingkey)
clientconf = self._clientConf
settingmap = Tool.dictGet(clientconf, "config.activate.ledSetting")
if not settingmap:
return False
ftlog.debug("TYActivityDdzRedEnvelope.sendLedIfNeed: settingmap=",
settingmap)
setting = settingmap.get(settingkey)
if not setting:
return False
ftlog.debug("TYActivityDdzRedEnvelope.sendLedIfNeed: setting=",
setting)
text = setting.get("text")
if (not text) or len(text) <= 0:
return False
ftlog.debug("TYActivityDdzRedEnvelope.sendLedIfNeed: text=", text,
"mincount", setting.get("min", 0))
mincount = setting.get("min", 0)
if count >= mincount:
leddict = {
"assets": str(itemconf.get('desc')),
"count": str(count),
"userId": str(userId),
"nickname": str(UserInfo.getNickname(userId))
}
text = strutil.replaceParams(text, leddict)
Tool.sendLed(text)
return True
return False
