def format(self, message, callback):
from new_year.celebrity.celebrity_quests_helpers import marathonTokenCountExtractor
isSynced = yield self._waitForSyncItems()
if isSynced:
templateName = self._TEMPLATE_NAME
messageSubtype = None
data = message.data or {}
completedQuestIDs = data.get('completedQuestIDs', set())
quests = self._eventsCache.getAllQuests(lambda q: q.getID() in completedQuestIDs)
completedCount = 0
for quest in quests.values():
bonuses = quest.getBonuses()
extraSlotBonus = findFirst(lambda b: b.getName() == 'battleToken' and VEH_BRANCH_EXTRA_SLOT_TOKEN in b.getTokens(), bonuses)
if extraSlotBonus:
templateName = self._TEMPLATE_BUTTON_NAME
messageSubtype = SCH_CLIENT_MSG_TYPE.NY_CELEBRITY_REWARD
completedCount = max(completedCount, marathonTokenCountExtractor(quest))
fmt = QuestAchievesFormatter.formatQuestAchieves(data, asBattleFormatter=False)
text = backport.text(R.strings.system_messages.newYear.celebrityChallenge.progressReward(), value=completedCount)
formatted = g_settings.msgTemplates.format(templateName, ctx={'text': text,
'rewards': fmt})
settings = self._getGuiSettings(message, templateName, messageSubtype=messageSubtype)
callback([MessageData(formatted, settings)])
else:
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
if isSynced:
messages = []
data = message.data or {}
bonusConfig = getBonusConfig()
questIDs = filter(self._isQuestOfThisGroup, data.get('completedQuestIDs', set()))
levelSettings = self._getGuiSettings(message, 'InformationHeaderSysMessage', priorityLevel=NotificationPriorityLevel.LOW)
rewardsSettings = self._getGuiSettings(message, self._getTemplateName())
header = backport.text(R.strings.ny.notification.levelUp.congrats.header())
questsMap = {int(questID.split(':')[-1]):questID for questID in questIDs}
for level in sorted(questsMap.keys()):
factor = bonusConfig.getAtmosphereMultiplierForLevel(level)
text = backport.text(R.strings.ny.notification.levelUp.congrats.body(), level=level, factor=factor)
formatted = g_settings.msgTemplates.format('InformationHeaderSysMessage', ctx={'header': header,
'text': text})
messages.append(MessageData(formatted, levelSettings))
fmt = BattlePassQuestAchievesFormatter.formatQuestAchieves(data.get('detailedRewards', {}).get(questsMap[level], {}), asBattleFormatter=False, processTokens=False)
if fmt is not None:
formatted = g_settings.msgTemplates.format(self._getTemplateName(), ctx={'text': fmt})
messages.append(MessageData(formatted, rewardsSettings))
callback(messages)
else:
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
messageDataList = []
if isSynced:
data = message.data or {}
completedQuestIDs = self.getQuestOfThisGroup(
data.get('completedQuestIDs', set()))
rewards = getRewardsForQuests(message, completedQuestIDs)
fmt = self._achievesFormatter.formatQuestAchieves(
rewards, asBattleFormatter=False, processCustomizations=True)
if fmt is not None:
templateParams = {
'title':
backport.text(R.strings.messenger.serviceChannelMessages.
wotPlus.freeDirectives.received.title()),
'text':
fmt
}
settings = self._getGuiSettings(message,
self.__MESSAGE_TEMPLATE)
formatted = g_settings.msgTemplates.format(
self.__MESSAGE_TEMPLATE, templateParams)
messageDataList.append(MessageData(formatted, settings))
if messageDataList:
callback(messageDataList)
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
messageData = MessageData(None, None)
if isSynced:
data = message.data or {}
completedQuestIDs = data.get('completedQuestIDs', set())
finalQuests = self.getQuestOfThisGroup(completedQuestIDs)
if not finalQuests:
callback([messageData])
return
if len(finalQuests) > 1:
_logger.error('There can not be 2 or more ranked final quests at the same time')
questID = finalQuests.pop()
points = ranked_helpers.getDataFromFinalTokenQuestID(questID)
detailedRewards = data.get('detailedRewards', {})
questData = detailedRewards.get(questID, {}).copy()
pointsTemplate = self.__generatePointsTemplate(points, questData)
awardType = self.__rankedController.getAwardTypeByPoints(points)
if awardType is not None:
fmt = self._achievesFormatter.formatQuestAchieves(questData, asBattleFormatter=False)
rServiceChannelMessages = R.strings.messenger.serviceChannelMessages
awardsTitle = rServiceChannelMessages.rankedFinaleAwardsNotification.dyn(awardType).awardsTitle()
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE_NAME, ctx={'pointsTemplate': pointsTemplate,
'awardsTitle': backport.text(awardsTitle) if awardsTitle else '',
'awardsBlock': fmt if fmt else ''}, data={'savedData': {'questID': questID,
'awards': detailedRewards.get(questID, {})}})
else:
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE_WITHOUT_AWARDS_NAME, ctx={'pointsTemplate': pointsTemplate})
messageData = MessageData(formatted, self._getGuiSettings(message))
callback([messageData])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
if isSynced:
completedQuestIDs = self.getQuestOfThisGroup(message.data.get('completedQuestIDs', set()))
questsData = getRewardsForQuests(message, self.getQuestOfThisGroup(completedQuestIDs))
messages = self.__formatTokenQuests(completedQuestIDs, questsData)
callback([ MessageData(formattedMessage, self._getGuiSettings(message)) for formattedMessage in messages ])
else:
callback([MessageData(None, self._getGuiSettings(message))])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
messageDataList = []
templateName = self._DEFAULT_TEMPLATE
if isSynced:
data = message.data or {}
dataQuestIDs = data.get('completedQuestIDs', set())
dataQuestIDs.update(data.get('rewardsGottenQuestIDs', set()))
completedQuestIDs = self.getQuestOfThisGroup(dataQuestIDs)
pmQuestsIDs = set(
(qID for qID in completedQuestIDs
if personal_missions.g_cache.isPersonalMission(qID)))
rewards = getRewardsForQuests(message, completedQuestIDs)
potapovQuestID = data.get('potapovQuestID', None)
if potapovQuestID is not None:
rewards.update({'potapovQuestID': potapovQuestID})
rewards['popUpRecords'] = self.getPopUps(message)
specialMessage = self.__formatSpecialMissions(
completedQuestIDs, pmQuestsIDs, message, rewards)
fmt = self._achievesFormatter.formatQuestAchieves(
rewards,
asBattleFormatter=False,
processCustomizations=not specialMessage)
if fmt is not None:
templateParams = {'achieves': fmt}
campaigns = set()
for qID in pmQuestsIDs:
pmID = personal_missions.g_cache.getPersonalMissionIDByUniqueID(
qID)
mission = self.__eventsCache.getPersonalMissions(
).getAllQuests()[pmID]
campaigns.add(mission.getCampaignID())
if campaigns:
templateName = self.__PERSONAL_MISSIONS_CUSTOM_TEMPLATE
campaignNameKey = 'both' if len(
campaigns) == 2 else 'c_{}'.format(first(campaigns))
templateParams['text'] = backport.text(
R.strings.messenger.serviceChannelMessages.
battleResults.personalMissions.dyn(campaignNameKey)())
settings = self._getGuiSettings(message, templateName)
formatted = g_settings.msgTemplates.format(
templateName, templateParams)
messageDataList.append(MessageData(formatted, settings))
messageDataList.extend(specialMessage)
if messageDataList:
callback(messageDataList)
else:
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
messages = [MessageData(None, None)]
if isSynced and message.data:
data = message.data
completedQuestIDs = self.getQuestOfThisGroup(data.get('completedQuestIDs', set()))
rewards = getRewardsForQuests(message, completedQuestIDs)
if rewards:
achieves = self._achievesFormatter.formatQuestAchieves(rewards, asBattleFormatter=False)
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE, ctx={'achieves': achieves})
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
messages = [MessageData(formatted, settings)]
callback(messages)
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
if isSynced:
openedBoxesIDs = self.getBoxesOfThisGroup(message.data.keys())
rewards = getRewardsForBoxes(message, openedBoxesIDs)
fmt = self._achievesFormatter.formatQuestAchieves(
rewards, asBattleFormatter=False, processTokens=False)
formattedData = g_settings.msgTemplates.format(
self.__MESSAGE_TEMPLATE, ctx={'achieves': fmt})
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
settings.showAt = BigWorld.time()
callback([MessageData(formattedData, settings)])
else:
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
messages = [MessageData(None, None)]
if isSynced and message.data:
data = message.data
completedQuestIDs = self.getQuestOfThisGroup(data.get('completedQuestIDs', set()))
rewards = getRewardsForQuests(message, completedQuestIDs)
tokensCount = rewards.get('tokens', {}).get(NY_GIFT_SYSTEM_PROGRESSION_TOKEN, {}).get('count', 0)
if tokensCount:
achieves = backport.text(R.strings.ny.giftSystem.progressionToken())
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE, ctx={'achieves': achieves})
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
messages = [MessageData(formatted, settings)]
callback(messages)
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
formatted, settings = (None, None)
if isSynced:
data = message.data or {}
completedQuestIDs = self.getQuestOfThisGroup(
data.get('completedQuestIDs', set()))
questsData = getRewardsForQuests(
message, self.getQuestOfThisGroup(completedQuestIDs))
questsData['popUpRecords'] = self.getPopUps(message)
fmt = self._achievesFormatter.formatQuestAchieves(
questsData, asBattleFormatter=False)
if fmt is not None:
operationTime = message.sentTime
if operationTime:
fDatetime = TimeFormatter.getLongDatetimeFormat(
time_utils.makeLocalServerTime(operationTime))
else:
fDatetime = 'N/A'
formatted = g_settings.msgTemplates.format(
self.__TEMPLATE_NAME,
ctx={
'at': fDatetime,
'desc': '',
'op': fmt
})
settings = self._getGuiSettings(message, self.__TEMPLATE_NAME)
callback([MessageData(formatted, settings)])
return
def __buildMessage(self, questID, message):
data = message.data or {}
questData = {}
rewards = data.get('detailedRewards', {}).get(questID, {})
popUps = set()
for dossierRecord in chain.from_iterable(
rewards.get('dossier', {}).values()):
if dossierRecord[0] in ACHIEVEMENT_BLOCK.ALL:
achievementID = RECORD_DB_IDS.get(dossierRecord, None)
popUps.update((popUp
for popUp in data.get('popUpRecords', set())
if popUp[0] == achievementID))
if popUps:
questData['popUpRecords'] = popUps
questData.update(rewards)
fmt = self._achievesFormatter.formatQuestAchieves(
questData, asBattleFormatter=False)
if fmt is not None:
templateParams = {'achieves': fmt}
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE,
templateParams)
return MessageData(formatted, settings)
else:
return
def format(self, message, callback=None):
isSynced = yield self._waitForSyncItems()
formatted, settings = (None, None)
if isSynced:
data = message.data or {}
completedQuestIDs = self.getQuestOfThisGroup(data.get('completedQuestIDs', set()))
questsData = getRewardsForQuests(message, self.getQuestOfThisGroup(completedQuestIDs))
questsData['popUpRecords'] = self.getPopUps(message)
templateParams = {}
rate = {}
exchangeQ = self.__eventsCache.getAllQuests().get(self.__FRONTLINE_PRESTIGE_POINTS_EXCHANGE_TEMPLATE)
if exchangeQ:
for b in exchangeQ.getBonuses():
rate[b.getName()] = b.getValue()
crystal = questsData.get(Currency.CRYSTAL, 0)
if crystal:
templateParams[Currency.CRYSTAL] = makeHtmlString('html_templates:lobby/battle_results', 'crystal_small_label', {'value': backport.getIntegralFormat(int(crystal))})
if Currency.CRYSTAL in rate:
crystalRate = rate[Currency.CRYSTAL]
if crystalRate:
templateParams['points'] = int(crystal / crystalRate)
gold = questsData.get(Currency.GOLD, 0)
if gold:
templateParams[Currency.GOLD] = makeHtmlString('html_templates:lobby/battle_results', 'gold_small_label', {'value': backport.getIntegralFormat(int(gold))})
if Currency.GOLD in rate and 'points' not in templateParams:
goldRate = rate[Currency.GOLD]
if goldRate:
templateParams['points'] = int(gold / goldRate)
settings = self._getGuiSettings(message, self.__TEMPLATE_NAME)
formatted = g_settings.msgTemplates.format(self.__TEMPLATE_NAME, templateParams)
callback([MessageData(formatted, settings)])
return None
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
if isSynced:
messages = BattleResultsFormatter().getCelebrityQuestsMessages(message)
callback(messages)
else:
callback([MessageData(None, None)])
return
def __buildMessage(self, questID, message):
rewards = getRewardsForQuests(message, set((questID,)))
fmt = self._achievesFormatter.formatQuestAchieves(rewards, asBattleFormatter=False, processCustomizations=True)
if fmt is not None:
templateParams = {'achieves': fmt}
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE, templateParams)
return MessageData(formatted, settings)
else:
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
if isSynced:
openedBoxesIDs = self.getBoxesOfThisGroup(message.data.keys())
rewards = getRewardsForBoxes(message, openedBoxesIDs)
if 'charms' in rewards:
rewards.pop('charms')
if 'customizationSum' in rewards:
rewards.pop('customizationSum')
fmt = self.formatAchieves(rewards, self._achievesFormatter)
formattedRewards = g_settings.msgTemplates.format(
self.__MESSAGE_TEMPLATE, ctx={'rewards': fmt})
settingsRewards = self._getGuiSettings(message,
self.__MESSAGE_TEMPLATE)
settingsRewards.showAt = BigWorld.time()
callback([MessageData(formattedRewards, settingsRewards)])
else:
callback([MessageData(None, None)])
return
def __getRewardsMessage(self, message, openedBoxesIDs):
allRewards = getRewardsForBoxes(message, openedBoxesIDs)
fmt = self._achievesFormatter.formatQuestAchieves(
allRewards, asBattleFormatter=False, processTokens=False)
formattedRewards = g_settings.msgTemplates.format(
self.__REWARDS_TEMPLATE, ctx={'text': fmt})
settingsRewards = self._getGuiSettings(message,
self.__REWARDS_TEMPLATE)
settingsRewards.showAt = BigWorld.time()
return MessageData(formattedRewards, settingsRewards)
def __formatSpecialMissions(self, questIDs, pmQuestsIDs, message, rewards):
result = []
newAwardListCount = 0
retAwardListCount = 0
tankmenAward = False
camouflageGivenFor = set()
camouflageUnlockedFor = set()
badges = []
for quest in self.__eventsCache.getHiddenQuests(lambda q: q.getID() in questIDs).values():
camouflageGivenFor.update(self.__getCamouflageGivenFor(quest))
camouflageUnlockedFor.update(self.__getCamouflageUnlockedFor(quest))
badges.extend(self.__getBadges(quest))
for qID in pmQuestsIDs:
pmType = personal_missions.g_cache.questByUniqueQuestID(qID)
quest = self.__eventsCache.getPersonalMissions().getAllQuests().get(pmType.id)
if quest and (qID.endswith('_main') or qID.endswith('_main_award_list')):
tmBonus = quest.getTankmanBonus()
if tmBonus.tankman:
tankmenAward = True
if qID.endswith('add_award_list'):
addAwardListQI = pmType.addAwardListQuestInfo
tokensBonuses = addAwardListQI.get('bonus', {}).get('tokens', {})
retAwardListCount += sum([ tokensBonuses[token]['count'] for token in self.__TOKENS_NAME if token in tokensBonuses ])
if qID.endswith('add'):
addAwardListQI = pmType.addQuestInfo
tokensBonuses = addAwardListQI.get('bonus', {}).get('tokens', {})
newAwardListCount += sum([ tokensBonuses[token]['count'] for token in self.__TOKENS_NAME if token in tokensBonuses ])
if retAwardListCount > 0:
text = backport.text(R.strings.system_messages.personalMissions.freeAwardListReturn(), count=retAwardListCount)
result.append(text)
if newAwardListCount > 0:
text = backport.text(R.strings.system_messages.personalMissions.freeAwardListGain(), count=newAwardListCount)
result.append(text)
for vehIntCD in camouflageGivenFor:
vehicle = self._itemsCache.items.getItemByCD(vehIntCD)
text = backport.text(R.strings.system_messages.personalMissions.camouflageGiven(), vehicleName=vehicle.userName)
result.append(text)
for vehIntCD in camouflageUnlockedFor:
vehicle = self._itemsCache.items.getItemByCD(vehIntCD)
nationName = backport.text(R.strings.menu.nations.dyn(vehicle.nationName)())
text = backport.text(R.strings.system_messages.personalMissions.camouflageUnlocked(), vehicleName=vehicle.userName, nation=nationName)
result.append(text)
if badges:
text = backport.text(R.strings.system_messages.personalMissions.badge(), name=', '.join(badges))
result.append(text)
if tankmenAward:
result.append(backport.text(R.strings.system_messages.personalMissions.tankmenGain()))
if result:
if not rewards.get('tankmen', None):
return [MessageData(getDefaultMessage(normal=EOL.join(result)), self._getGuiSettings(message, DEFAULT_MESSAGE))]
return []
def format(self, message, *args):
if message is None:
return []
else:
formatted = g_settings.msgTemplates.format(self._template,
ctx=self.getCtx(
message, *args))
return [
MessageData(formatted,
self._getGuiSettings(message, self._template))
]
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
if isSynced:
openedBoxesIDs = self.getBoxesOfThisGroup(message.data.keys())
callback([
self.__getMainMessage(message, openedBoxesIDs),
self.__getRewardsMessage(message, openedBoxesIDs)
])
else:
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
if isSynced:
openedBoxesIDs = self.getBoxesOfThisGroup(message.data.keys())
rewards = getRewardsForBoxes(message, openedBoxesIDs)
fmtBoxes = self.__getFormattedBoxes(message, openedBoxesIDs)
fmt = self._achievesFormatter.formatQuestAchieves(
rewards, asBattleFormatter=False, processTokens=False)
ctx = {
'boxes':
fmtBoxes,
'rewards':
backport.text(self.__R_LOOT_BOXES.rewards(), rewards=fmt)
}
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE,
ctx=ctx)
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
callback([MessageData(formatted, settings)])
else:
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
formattedMessage = None
if isSynced:
yearPosition = AccountSettings.getSettings(RANKED_YEAR_POSITION)
completedIDs = message.data.get('completedQuestIDs', set())
rewardsData = getRewardsForQuests(message, self.getQuestOfThisGroup(completedIDs))
if yearPosition is not None and rewardsData:
formattedMessage = self.__formatFullMessage(yearPosition, rewardsData)
else:
formattedMessage = self.__formatShortMessage()
callback([MessageData(formattedMessage, self._getGuiSettings(message))])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
messages = []
if isSynced:
data = message.data or {}
detailedRewards = data.get('detailedRewards', {})
questIDs = filter(self._isQuestOfThisGroup, data.get('completedQuestIDs', set()))
for questID in questIDs:
rewards = detailedRewards.get(questID, {})
yearId, _, collectionKey, _ = questID.split(':')
year = backport.text(R.strings.ny.systemMessage.dyn(yearId)())
collectionName = self.__getCollectionName(yearId, collectionKey)
rows = [backport.text(R.strings.ny.notification.collectionComplete(), setting=collectionName, year=year)]
self._addFormattedRewards(rewards, rows)
settings = self._getGuiSettings(message, self._TEMPLATE_NAME, messageSubtype=SCH_CLIENT_MSG_TYPE.NY_EVENT_BUTTON_MESSAGE)
savedData = {'savedData': {'completedCollectionsQuests': [questID]}}
formatted = g_settings.msgTemplates.format(self._TEMPLATE_NAME, ctx={'text': EOL.join(rows)}, data=savedData)
messages.append(MessageData(formatted, settings))
callback(messages)
else:
callback([MessageData(None, None)])
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
messageDataList = []
if isSynced:
data = message.data or {}
completedQuestIDs = self.getQuestOfThisGroup(data.get('completedQuestIDs', set()))
for qID in completedQuestIDs:
messageData = self.__buildMessage(qID, message)
if messageData is not None:
messageDataList.append(messageData)
if messageDataList:
callback(messageDataList)
callback([MessageData(None, None)])
return
def __buildMessage(self, questID, message):
data = message.data or {}
questData = {}
rewards = data.get('detailedRewards', {}).get(questID, {})
questData.update(rewards)
header = backport.text(R.strings.messenger.serviceChannelMessages.battlePassReward.header.voted())
fmt = self._achievesFormatter.formatQuestAchieves(questData, asBattleFormatter=False)
if fmt is not None:
templateParams = {'text': fmt,
'header': header}
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
formatted = g_settings.msgTemplates.format(self.__MESSAGE_TEMPLATE, templateParams)
return MessageData(formatted, settings)
else:
return
def format(self, message, callback):
isSynced = yield self._waitForSyncItems()
formatted, settings = (None, None)
if isSynced:
data = message.data or {}
questID = findFirst(self._isQuestOfThisGroup, data.get('completedQuestIDs', set()))
yearId, _, _, _ = questID.split(':')
collectionName = backport.text(self._STR_PATH.collectionMegaComplete(), year=backport.text(R.strings.ny.systemMessage.dyn(yearId)()))
rows = [collectionName]
rewards = data.get('detailedRewards', {}).get(questID)
self._addFormattedRewards(rewards, rows)
settings = self._getGuiSettings(message, self._TEMPLATE_NAME)
formatted = g_settings.msgTemplates.format(self._TEMPLATE_NAME, ctx={'text': EOL.join(rows)})
callback([MessageData(formatted, settings)])
return None
def __getMainMessage(self, message, openedBoxesIDs):
oldStyleCount = {
bID: message.data[bID]['count']
for bID in openedBoxesIDs
}
rewards = getRewardsForBoxes(message, openedBoxesIDs)
formatted = g_settings.msgTemplates.format(
self.__MESSAGE_TEMPLATE,
ctx={},
data={'savedData': {
'rewards': rewards,
'boxIDs': oldStyleCount
}})
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
settings.groupID = NotificationGroup.OFFER
settings.showAt = BigWorld.time()
return MessageData(formatted, settings)
def __getMainMessage(self, message, openedBoxesIDs):
count = backport.text(R.strings.messenger.serviceChannelMessages.
lootBoxesAutoOpen.counter(),
count=sum((message.data[boxId]['count']
for boxId in openedBoxesIDs)))
oldStyleCount = {
bID: message.data[bID]['count']
for bID in openedBoxesIDs
}
rewards = getRewardsForBoxes(message, openedBoxesIDs)
formatted = g_settings.msgTemplates.format(
self.__MESSAGE_TEMPLATE,
ctx={'count': count},
data={'savedData': {
'rewards': rewards,
'boxIDs': oldStyleCount
}})
settings = self._getGuiSettings(message, self.__MESSAGE_TEMPLATE)
settings.groupID = NotificationGroup.OFFER
settings.showAt = BigWorld.time()
return MessageData(formatted, settings)
