def getRankedMainSeasonOnHeader(season, itemID):
title = backport.text(R.strings.ranked_battles.rankedBattle.title())
leftSideText = ''
rightSideText = ''
tooltip = TOOLTIPS_CONSTANTS.RANKED_CALENDAR_DAY_INFO
if itemID in _EMPTY_WEB_PAGES:
title = ''
tooltip = ''
elif itemID == RANKEDBATTLES_CONSTS.RANKED_BATTLES_INFO_ID:
leftSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.infoPage.header())
tooltip = ''
elif season is not None:
startDate = season.getStartDate()
endDate = season.getEndDate()
timeDelta = time_utils.getTimeDeltaFromNowInLocal(
time_utils.makeLocalServerTime(endDate))
if timeDelta > time_utils.ONE_WEEK:
leftSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.date.period(),
start=backport.getLongDateFormat(startDate),
finish=backport.getLongDateFormat(endDate))
else:
leftSideText = backport.getTillTimeStringByRClass(
timeDelta, R.strings.ranked_battles.rankedBattleMainView.date)
rightSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.season(),
season=season.getUserName())
return {
'title': title,
'leftSideText': leftSideText,
'rightSideText': rightSideText,
'tooltip': tooltip
}
def getProfileCommonInfo(userName, dossier):
lastBattleTimeUserString = None
if dossier['total']['lastBattleTime']:
lbt = dossier['total']['lastBattleTime']
lastBattleTimeUserString = '%s %s' % (backport.getLongDateFormat(lbt), backport.getShortTimeFormat(lbt))
return {'name': userName,
'registrationDate': '%s' % backport.getLongDateFormat(dossier['total']['creationTime']),
'lastBattleDate': lastBattleTimeUserString}
def getRankedMainSeasonOffHeader(prevSeason, nextSeason, isYearGap, itemID):
title = backport.text(R.strings.ranked_battles.rankedBattle.title())
leftSideText = ''
rightSideText = ''
if itemID == RANKEDBATTLES_CONSTS.RANKED_BATTLES_RANKS_ID and isYearGap:
rightSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.yearGap.header())
elif itemID in _EMPTY_WEB_PAGES:
title = ''
elif itemID == RANKEDBATTLES_CONSTS.RANKED_BATTLES_INFO_ID:
rightSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.infoPage.header())
else:
rightSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.seasonCompleteSingle(
),
season=prevSeason.getUserName())
if nextSeason is not None:
rightSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.seasonComplete(),
season=prevSeason.getUserName())
leftSideText = backport.text(
R.strings.ranked_battles.rankedBattleMainView.seasonGap(),
newSeason=nextSeason.getUserName(),
date=backport.getLongDateFormat(nextSeason.getStartDate()))
return {
'title': title,
'leftSideText': leftSideText,
'rightSideText': rightSideText,
'tooltip': ''
}
def formatUpdateTime(recalculationTS):
statusDay = event_boards_timer.getUpdateStatus_ts(recalculationTS)
statusTime = backport.getShortTimeFormat(recalculationTS)
day = _ms(EVENT_BOARDS.time_day(statusDay)
) if statusDay else backport.getLongDateFormat(recalculationTS)
status = _ms(EVENT_BOARDS.SUMMARY_STATUS, day=day, time=statusTime)
return status
def __updateHeader(self):
event = self.__eventData
name = event.getName()
eType = event.getType()
leaderboard = self.__leaderboard
leaderboardValue = event.getLeaderboard(self.__leaderboardID)
if event.isFinished():
date = backport.getLongDateFormat(event.getEndDateTs())
status = text_styles.main(
_ms(EVENT_BOARDS.TIME_EVENTFINISHED, date=date))
statusTooltip = None
elif leaderboard:
recalculationTS = leaderboard.getLastLeaderboardRecalculationTS()
recalculationInterval = leaderboard.getRecalculationInterval()
interval = int(recalculationInterval / ONE_MINUTE)
status = text_styles.main(formatUpdateTime(recalculationTS))
statusTooltip = _ms(TOOLTIPS.SUMMARY_STATUS_TOOLTIP,
interval=interval)
else:
status = None
statusTooltip = None
self.as_setHeaderDataS(
makeTableViewHeaderVO(eType, leaderboardValue, name, status,
statusTooltip))
return
def _requestClanInfo(self):
isShowClanProfileBtnVisible = False
if self.lobbyContext.getServerSettings().clanProfile.isEnabled():
isShowClanProfileBtnVisible = True
clanDBID, clanInfo = self.itemsCache.items.getClanInfo(self._userID)
if clanInfo is not None:
clanInfo = ClanInfo(*clanInfo)
clanData = {
'id':
clanDBID,
'header':
clanInfo.getClanName(),
'topLabel':
_ms(PROFILE.PROFILE_SUMMARY_CLAN_POST),
'topValue':
text_styles.main(getClanRoleString(
clanInfo.getMembersFlags())),
'bottomLabel':
_ms(PROFILE.PROFILE_SUMMARY_CLAN_JOINDATE),
'bottomValue':
text_styles.main(
backport.getLongDateFormat(clanInfo.getJoiningTime()))
}
btnParams = self._getClanBtnParams(isShowClanProfileBtnVisible)
clanData.update(btnParams)
self.as_setClanDataS(clanData)
self.requestClanEmblem32x32(clanDBID)
return
def getDueDateOrTimeStr(finishTime, localization=''):
if not finishTime or time_utils.isPast(finishTime):
return ''
if time_utils.isToday(finishTime):
strTime = backport.getShortTimeFormat(finishTime)
else:
strTime = backport.getLongDateFormat(finishTime)
return ' '.join([localization, strTime]) if localization else strTime
def _getActiveDateTimeString(self):
name = self.discount.getParamName()
if name == 'set_MarathonAnnounce':
timeStr = backport.getLongDateFormat(self.getFinishTime())
if timeStr is not None and self._marathonEvent:
return text_styles.main(i18n.makeString(self._marathonEvent.data.quests.announceTime, startTime=timeStr))
elif name == 'set_MarathonInProgress':
return super(MarathonEventActionInfo, self)._getActiveDateTimeString()
return ''
def __init__(self, name, block, dossier, value=None):
super(LoyalServiceAchievement, self).__init__(name, block, dossier,
value)
if dossier is not None:
self.__registrationDate = backport.getLongDateFormat(
dossier.getDossierDescr()['total']['creationTime'])
else:
self.__registrationDate = None
return
def getMessage(self):
if self._endTime:
banEndTime = backport.getLongDateFormat(
self._endTime) + ' ' + backport.getShortTimeFormat(
self._endTime)
msg = i18n.makeString('#chat:errors/chatbanned',
banEndTime=banEndTime,
banReason=self._reason)
else:
msg = i18n.makeString('#chat:errors/chatbannedpermanent',
banReason=self._reason)
return msg
def onShopResync():
yield ServicesLocator.itemsCache.update(CACHE_SYNC_REASON.SHOP_RESYNC)
if not ServicesLocator.itemsCache.isSynced():
Waiting.hide('sinhronize')
return
yield ServicesLocator.eventsCache.update()
Waiting.hide('sinhronize')
now = time_utils.getCurrentTimestamp()
SystemMessages.pushI18nMessage(SYSTEM_MESSAGES.SHOP_RESYNC,
date=backport.getLongDateFormat(now),
time=backport.getShortTimeFormat(now),
type=SystemMessages.SM_TYPE.Information)
def getMessage(self):
formatArgs = {'reason': '', 'expiryTime': ''}
if self.reason:
formatArgs['reason'] = i18n.makeString(
DIALOGS.DISCONNECTED_REASON, i18n.makeString(self.reason))
if self.expiryTime:
expiryTime = time_utils.makeLocalServerTime(int(self.expiryTime))
formatArgs['expiryTime'] = '%s %s' % (backport.getLongDateFormat(
expiryTime), backport.getLongTimeFormat(expiryTime))
key = DIALOGS.DISCONNECTED_MESSAGEKICK
if self.isBan:
key = DIALOGS.DISCONNECTED_MESSAGEBANPERIOD if self.expiryTime else DIALOGS.DISCONNECTED_MESSAGEBAN
return i18n.makeString(key, **formatArgs)
def getMessage(self):
formatArgs = {'reason': '',
'expiryTime': ''}
if self.reason:
formatArgs['reason'] = i18n.makeString(DIALOGS.DISCONNECTED_REASON, i18n.makeString(self.reason))
if self.expiryTime:
expiryTime = time_utils.makeLocalServerTime(int(self.expiryTime))
formatArgs['expiryTime'] = '%s %s' % (backport.getLongDateFormat(expiryTime), backport.getLongTimeFormat(expiryTime))
key = DIALOGS.DISCONNECTED_MESSAGEKICK
if self.kickReasonType in ACCOUNT_KICK_REASONS.BAN_RANGE:
if IS_CHINA and self.kickReasonType == ACCOUNT_KICK_REASONS.CURFEW_BAN:
return i18n.makeString(self.reason)
key = DIALOGS.DISCONNECTED_MESSAGEBANPERIOD if self.expiryTime else DIALOGS.DISCONNECTED_MESSAGEBAN
return i18n.makeString(key, **formatArgs)
def create(cls, chatAction):
banInfo = chatAction['data']
banEndTime = makeLocalServerTime(banInfo.get('banEndTime', None))
if banEndTime is None:
if banEndTime in banInfo:
del banInfo['banEndTime']
bannedMessage = i18n.makeString('#chat:errors/bannedpermanent',
**banInfo)
else:
banInfo['banEndTime'] = backport.getLongDateFormat(
banEndTime) + ' ' + backport.getShortTimeFormat(banEndTime)
bannedMessage = i18n.makeString('#chat:errors/banned', **banInfo)
return MemberBannedError(cls._makeTitle('memberBanned'),
bannedMessage,
isModal=True)
def __prepareAccountResult(self, accountDBID, dossier):
if dossier is None:
return {}
res = self.__prepareCommonResult(accountDBID, dossier)
stats = self.__getStatsBlock(dossier)
glob = dossier.getGlobalStats()
lbt = glob.getLastBattleTime()
res.update({
'maxXPVehCD': stats.getMaxXpVehicle(),
'maxFragsVehCD': stats.getMaxFragsVehicle(),
'maxDamageVehCD': stats.getMaxDamageVehicle(),
'creationTime': glob.getCreationTime(),
'lastBattleTime': lbt,
'lastBattleTimeStr': makeString(MENU.PROFILE_HEADER_LASTBATTLEDATETITLE) + ' ' +
('%s %s' % (backport.getLongDateFormat(lbt), backport.getShortTimeFormat(lbt))),
'vehicles': {}})
vehicles = stats.getVehicles()
for (vehCD, vdata) in vehicles.iteritems():
res['vehicles'][str(vehCD)] = {
'battles': vdata.battlesCount,
'wins': vdata.wins,
'mastery': stats.getMarkOfMasteryForVehicle(vehCD),
'xp': vdata.xp}
# add tanks with 0 battles
vehicles = self.itemsCache.items.getVehicles(REQ_CRITERIA.INVENTORY)
for (vehCD, vdata) in vehicles.iteritems():
if str(vehCD) not in res['vehicles']:
res['vehicles'][str(vehCD)] = {
'battles': 0,
'wins': 0,
'mastery': 0,
'xp': 0}
return res
def getTimerInfo(self):
def formatToEnd(iconPath, text, dateType, isEndSoon):
iconPath = icons.makeImageTag(iconPath)
timeData = event.getFormattedRemainingTime(dateType)
text = _ms(text, time=formatTimeToEnd(timeData[0], timeData[1]))
if isEndSoon:
formatedText = timeEndStyle(text)
else:
formatedText = text_styles.vehicleStatusInfoText(text)
return '{} {}'.format(iconPath, formatedText)
event = self._event
sday, smonth, _ = event_boards_timer.getDayMonthYear(event.getStartDate())
eday, emonth, _ = event_boards_timer.getDayMonthYear(event.getEndDate())
finished = event.isFinished()
if not finished:
icon = icons.makeImageTag(RES_ICONS.MAPS_ICONS_EVENTBOARDS_FLAGICONS_DATE_ICON)
timePeriod = '{} {} {} - {} {} {}'.format(str(sday), _ms(MENU.datetime_months(str(smonth))), event_boards_timer.getShortTimeString(event.getStartDate()), str(eday), _ms(MENU.datetime_months(str(emonth))), event_boards_timer.getShortTimeString(event.getEndDate()))
result = '{} {} '.format(icon, text_styles.vehicleStatusInfoText(timePeriod))
startSoon = event.isStartSoon()
if startSoon:
result += formatToEnd(RES_ICONS.MAPS_ICONS_EVENTBOARDS_FLAGICONS_TIME_ICON, EVENT_BOARDS.TIME_TIMETO_START, EVENT_DATE_TYPE.START, startSoon)
elif not self._joined and not event.isRegistrationFinished():
finishSoon = event.isRegistrationFinishSoon()
if finishSoon:
result += formatToEnd(RES_ICONS.MAPS_ICONS_EVENTBOARDS_FLAGICONS_TIME_ICON, EVENT_BOARDS.TIME_TIMETO_ENDREGISTRATION, EVENT_DATE_TYPE.PARTICIPANTS_FREEZE, finishSoon)
else:
result += formatToEnd(RES_ICONS.MAPS_ICONS_EVENTBOARDS_FLAGICONS_ICON_FLAG, EVENT_BOARDS.TIME_TIMETO_ENDREGISTRATION, EVENT_DATE_TYPE.PARTICIPANTS_FREEZE, finishSoon)
else:
endSoon = event.isEndSoon()
if endSoon:
result += formatToEnd(RES_ICONS.MAPS_ICONS_EVENTBOARDS_FLAGICONS_TIME_ICON, EVENT_BOARDS.TIME_TIMETO_END, EVENT_DATE_TYPE.END, endSoon)
else:
result += formatToEnd(RES_ICONS.MAPS_ICONS_EVENTBOARDS_FLAGICONS_ICON_FLAG, EVENT_BOARDS.TIME_TIMETO_END, EVENT_DATE_TYPE.END, endSoon)
else:
date = backport.getLongDateFormat(event.getEndDateTs())
result = text_styles.main(_ms(EVENT_BOARDS.TIME_EVENTFINISHED, date=date))
return {'timer': result}
def getExpiryDate(self):
return backport.getLongDateFormat(
self.expiryTime) if self.expiryTime is not None else ''
def _populate(self):
super(MissionsTokenPopover, self)._populate()
mainQuest = self.eventsCache.getQuests()[self._questId]
children = mainQuest.getChildren()[self._tokenId]
def filterfunc(quest):
return quest.getGroupID() == mainQuest.getGroupID(
) and quest.getID() in children
quests = self.eventsCache.getQuests(filterfunc)
for token in mainQuest.accountReqs.getTokens():
if token.getID() == self._tokenId:
self._token = token
break
result = []
for quest in sorted(quests.values(),
key=missionsSortFunc,
reverse=True):
header = text_styles.main(quest.getUserName())
if quest.isCompleted():
icon = RES_ICONS.MAPS_ICONS_LIBRARY_FORTIFICATION_CHECKMARK
descr = text_styles.bonusAppliedText(
QUESTS.MISSIONS_TOKENPOPOVER_QUEST_DESCR_READY)
elif not quest.isAvailable()[0]:
icon = RES_ICONS.MAPS_ICONS_LIBRARY_CYBERSPORT_NOTAVAILABLEICON
descr = text_styles.error(
QUESTS.MISSIONS_TOKENPOPOVER_QUEST_DESCR_NOTAVAILABLE)
else:
icon = ''
descr = text_styles.standard(
ms(QUESTS.MISSIONS_TOKENPOPOVER_QUEST_DESCR_DATE,
date=backport.getLongDateFormat(quest.getFinishTime())))
tooltip = makeTooltip(
ms(TOOLTIPS.MISSIONS_TOKENPOPOVER_QUEST_HEADER,
name=quest.getUserName()),
ms(TOOLTIPS.MISSIONS_TOKENPOPOVER_QUEST_BODY))
result.append({
'headerText': header,
'descrText': descr,
'imgSrc': icon,
'questId': quest.getID(),
'tooltip': tooltip
})
self.as_setListDataProviderS(result)
buyBtnVisible = self._token.isOnSale() or mainQuest.isTokensOnSale()
if buyBtnVisible:
descrText = ms(QUESTS.MISSIONS_TOKENPOPOVER_DESCR_SHOP,
name=text_styles.neutral(
ms(self._token.getUserName())))
else:
descrText = ms(QUESTS.MISSIONS_TOKENPOPOVER_DESCR,
name=text_styles.neutral(
ms(self._token.getUserName())))
if not GUI_SETTINGS.tokenShopURL:
buyBtnVisible = False
self.as_setStaticDataS({
'headerText':
text_styles.highTitle(
ms(QUESTS.MISSIONS_TOKENPOPOVER_HEADER,
name=ms(self._token.getUserName()))),
'descrText':
text_styles.main(descrText),
'imageSrc':
self._token.getImage(TOKEN_SIZES.MEDIUM),
'buyBtnLabel':
QUESTS.MISSIONS_TOKENPOPOVER_BUYBTN_LABEL,
'buyBtnVisible':
buyBtnVisible
})
def getSeniorityAwardsAutoOpenDate(lobbyContext=None):
config = lobbyContext.getServerSettings().getSeniorityAwardsConfig()
autoOpenTime = config.autoOpenTimestamp()
autoOpenLocalTime = time_utils.makeLocalServerTime(autoOpenTime)
return backport.getLongDateFormat(autoOpenLocalTime)
def _getDescrBlock(self):
minStartTime = min([ q.getStartTime() for q in self._suitableEvents ])
maxFinishTime = max([ q.getFinishTime() for q in self._suitableEvents ])
return {'period': text_styles.middleTitle(_ms(QUESTS.MISSIONS_TAB_MARATHONS_HEADER_PERIOD, startDate=backport.getLongDateFormat(minStartTime), endDate=backport.getLongDateFormat(maxFinishTime))),
'isMultiline': True,
'hasCalendarIcon': True}
def _getValue(self, value):
return backport.getLongDateFormat(self._getLocalTime(value))
def _getDateTimeString(cls, timeValue):
return '{0:>s} {1:>s}'.format(backport.getLongDateFormat(timeValue),
backport.getShortTimeFormat(timeValue))
def _formatFinishTime(self):
return '' if self._marathonEvent is None else ' '.join((text_styles.main(i18n.makeString(self._marathonEvent.data.quests.timeFinish)), backport.getLongDateFormat(self.getFinishTime())))
def getPrebattleStartTimeString(startTime):
startTimeString = backport.getLongTimeFormat(startTime)
if startTime - time.time() > 86400:
startTimeString = '{0:>s} {1:>s}'.format(
backport.getLongDateFormat(startTime), startTimeString)
return startTimeString
