def _getBody(self, eventID):
items = []
source = self._questController.getAllAvailableQuests()
svrEvents = {e.getID(): e for e in source}
event = svrEvents.get(eventID)
weekDays = event.getWeekDays()
if weekDays:
days = [
_ms(MENU.datetime_weekdays_full(idx))
for idx in event.getWeekDays()
]
items.append(
self._getSubBlock(TOOLTIPS.QUESTS_SCHEDULE_WEEKDAYS, days))
intervals = event.getActiveTimeIntervals()
if intervals:
times = []
for low, high in intervals:
times.append('{} - {}'.format(
backport.getShortTimeFormat(low),
backport.getShortTimeFormat(high)))
items.append(
self._getSubBlock(TOOLTIPS.QUESTS_SCHEDULE_INTERVALS, times,
formatters.packPadding(top=18)))
return formatters.packBuildUpBlockData(
blocks=items,
linkage=BLOCKS_TOOLTIP_TYPES.
TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE,
padding=formatters.packPadding(top=-3))
def _getActiveDateTimeString(self):
i18nKey, args = None, {}
if self.event.getFinishTimeLeft() <= time_utils.ONE_DAY:
gmtime = time.gmtime(self.event.getFinishTimeLeft())
if gmtime.tm_hour > 0:
fmt = i18n.makeString(
QUESTS.ITEM_TIMER_TILLFINISH_LONGFULLFORMAT)
else:
fmt = i18n.makeString(
QUESTS.ITEM_TIMER_TILLFINISH_SHORTFULLFORMAT)
fmt %= {'hours': time.strftime('%H', gmtime)}
return fmt
else:
if self.event.getStartTimeLeft() > 0:
i18nKey = '#quests:details/header/activeDuration'
args = {
'startTime':
self._getDateTimeString(self.event.getStartTime()),
'finishTime':
self._getDateTimeString(self.event.getFinishTime())
}
elif self.event.getFinishTimeLeft() <= time_utils.HALF_YEAR:
i18nKey = '#quests:details/header/tillDate'
args = {
'finishTime':
self._getDateTimeString(self.event.getFinishTime())
}
weekDays = self.event.getWeekDays()
intervals = self.event.getActiveTimeIntervals()
if weekDays or intervals:
if i18nKey is None:
i18nKey = '#quests:details/header/schedule'
if weekDays:
days = ', '.join([
i18n.makeString('#menu:dateTime/weekDays/full/%d' %
idx)
for idx in self.event.getWeekDays()
])
i18nKey += 'Days'
args['days'] = days
if intervals:
times = []
for low, high in intervals:
times.append('%s - %s' %
(backport.getShortTimeFormat(low),
backport.getShortTimeFormat(high)))
i18nKey += 'Times'
times = ', '.join(times)
args['times'] = times
return None if i18nKey is None else i18n.makeString(
i18nKey, **args)
def __getStatusText(self):
if not self.__eventProgression.hasAvailablePrimeTimeServers():
return EPIC_BATTLE.PRIMETIME_STATUS_NOPRIMETIMESONALLSERVERS
else:
currServerName = self._connectionMgr.serverUserName
primeTime = self.__eventProgression.getPrimeTimes().get(
self._connectionMgr.peripheryID)
timestamp, status = self.__eventProgression.getCurrentCycleInfo()
currTime = time_utils.getCurrentLocalServerTimestamp()
if status and primeTime:
startTime = primeTime.getNextPeriodStart(currTime, timestamp)
if startTime:
if startTime - currTime > time_utils.ONE_DAY:
startTimeStr = backport.getShortDateFormat(startTime)
else:
startTimeStr = backport.getShortTimeFormat(startTime)
return _ms(
EPIC_BATTLE.PRIMETIME_STATUS_NOPRIMETIMEONTHISSERVER,
startTime=startTimeStr,
server=currServerName)
season = self.__eventProgression.getCurrentSeason()
if season is not None and primeTime is not None:
lastCycle = season.getLastActiveCycleInfo(currTime)
if lastCycle:
return _ms(
EPIC_BATTLE.PRIMETIME_STATUS_CYCLEFINISHEDONTHISSERVER,
cycleNo=lastCycle.ordinalNumber,
server=currServerName)
return _ms(EPIC_BATTLE.PRIMETIME_STATUS_DISABLEDONTHISSERVER,
server=currServerName)
def setProxy(self, proxy, clanDossier):
self._proxy = weakref.proxy(proxy)
self._clanDossier = clanDossier
proxy.showWaiting()
globalMapStats = yield clanDossier.requestGlobalMapStats()
ratings = yield clanDossier.requestClanRatings()
favouriteAttrs = yield clanDossier.requestFavouriteAttributes()
if self.isDisposed():
return
primeTime = items.formatField(
getter=favouriteAttrs.getFavoritePrimetime,
formatter=lambda x: backport.getShortTimeFormat(
x.hour * time_utils.ONE_HOUR + x.minute * time_utils.ONE_MINUTE
))
primeTime = text_styles.standard(
_ms(CLANS.GLOBALMAPVIEW_POPULARPRIMETIME,
time=text_styles.main(primeTime)))
data = FortGlobalMapStatistics({
'stats': globalMapStats,
'ratings': ratings,
'favouriteAttrs': favouriteAttrs
})
data['primeTimeText'] = primeTime
self.as_setDataS(data)
proxy.hideWaiting()
def _getStatusText(self):
if not self._getController().hasAvailablePrimeTimeServers():
return backport.text(R.strings.epic_battle.primeTime.status.
noPrimeTimesOnAllServers())
else:
currServerName = self._connectionMgr.serverUserName
primeTime = self._getController().getPrimeTimes().get(
self._connectionMgr.peripheryID)
timestamp, status = self._getController().getCurrentCycleInfo()
currTime = time_utils.getCurrentLocalServerTimestamp()
if status and primeTime:
startTime = primeTime.getNextPeriodStart(currTime, timestamp)
if startTime:
if startTime - currTime > time_utils.ONE_DAY:
startTimeStr = backport.getShortDateFormat(startTime)
else:
startTimeStr = backport.getShortTimeFormat(startTime)
return backport.text(R.strings.epic_battle.primeTime.
status.noPrimeTimeOnThisServer(),
startTime=startTimeStr,
server=currServerName)
season = self._getController().getCurrentSeason()
if season is not None and primeTime is not None:
lastCycle = season.getLastActiveCycleInfo(currTime)
if lastCycle:
return self._getCycleFinishedOnThisServerText(
cycleNumber=lastCycle.ordinalNumber,
serverName=currServerName)
return backport.text(
R.strings.epic_battle.primeTime.status.disabledOnThisServer(),
server=currServerName)
def __getAvailabilityStr(self):
if self._isVisible and self.rankedController.hasAnySeason():
resShortCut = R.strings.menu.headerButtons.battle.types.ranked
currentSeason = self.rankedController.getCurrentSeason()
if currentSeason is not None:
if self.rankedController.isUnset():
return backport.text(resShortCut.availability.notSet())
if self.rankedController.isFrozen():
return backport.text(resShortCut.availability.frozen())
seasonName = currentSeason.getUserName(
) or currentSeason.getNumber()
return backport.text(resShortCut.availability.season(),
season=seasonName)
nextSeason = self.rankedController.getNextSeason()
if nextSeason is not None:
timeStamp = time_utils.makeLocalServerTime(
nextSeason.getStartDate())
date = backport.getShortDateFormat(timeStamp)
time = backport.getShortTimeFormat(timeStamp)
return backport.text(resShortCut.availability.until(),
date=date,
time=time)
if self.rankedController.isYearGap():
return backport.text(resShortCut.availability.yearEnded())
return backport.text(resShortCut.availability.ended())
else:
return
def _getVO(self, offer):
gifts = backport.text(R.strings.storage.offers.giftAmount(),
clicks=text_styles.neutral(offer.clicksCount),
gifts=text_styles.neutral(
offer.availableGiftsCount))
date = backport.getShortDateFormat(offer.expiration)
time = backport.getShortTimeFormat(offer.expiration)
expiration = backport.text(R.strings.storage.offers.expiration(),
date=text_styles.neutral(date),
time=text_styles.neutral(time))
description = '\n'.join([gifts, expiration])
localization = ResMgr.openSection(
self._offersProvider.getCdnResourcePath(offer.cdnLocFilePath,
relative=False))
title = localization.readString('name') if localization else ''
vo = createStorageDefVO(offer.id,
title,
description,
0,
None,
self._offersProvider.getCdnResourcePath(
offer.cdnLogoPath, relative=False),
'altimage',
contextMenuId=None)
return vo
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 __getEfficiencyBlock(self, efficiency, updateTime, resID):
text = text_styles.main(backport.text(resID)).format(
value=text_styles.stats(
ranked_formatters.getFloatPercentStrStat(efficiency)),
date=text_styles.standard(backport.getShortDateFormat(updateTime)),
time=text_styles.standard(backport.getShortTimeFormat(updateTime)))
return formatters.packTextBlockData(text)
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 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 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):
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 __onListReceived(self, sessions):
item = first(sorted(sessions, key=operator.attrgetter('startTime')))
if item:
self.viewModel.setStatusActive(
backport.text(
R.strings.mode_selector.mode.specBattlesList.call.c_2(),
date=backport.getShortDateFormat(item.startTime),
time=backport.getShortTimeFormat(item.startTime)))
else:
self.viewModel.setStatusActive(
backport.text(
R.strings.mode_selector.mode.specBattlesList.call.c_1()))
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 _convert(self, record, reusable):
return ' '.join((backport.getShortDateFormat(record),
backport.getShortTimeFormat(record)))
def getUserPrimeTime(self):
return backport.getShortTimeFormat(
self.prime_time.hour * time_utils.ONE_HOUR +
self.prime_time.minute * time_utils.ONE_MINUTE)
def _getDateTimeString(cls, timeValue):
return '{0:>s} {1:>s}'.format(backport.getLongDateFormat(timeValue),
backport.getShortTimeFormat(timeValue))
def formatTime(ts):
return str(backport.getShortTimeFormat(ts))
def formatShortDateShortTimeString(timestamp):
return str(' ').join((backport.getShortDateFormat(timestamp), ' ', backport.getShortTimeFormat(timestamp)))
def _getValue(self, value):
return backport.getShortTimeFormat(self._getLocalTime(value))
def getShortDatetimeFormat(cls, time):
return '{0:>s} {1:>s}'.format(backport.getShortDateFormat(time),
backport.getShortTimeFormat(time))
def getShortTimeString(strDate):
if strDate:
dateTimestamp = getTimeStampFromDate(strDate)
return backport.getShortTimeFormat(dateTimestamp)
return FORMAT_EMPTY_STR
def _onMatchmakingTimerChanged(self, event):
data = event.ctx
isBattleTimerVisible = False
wfbDescr = None
playerClanName = None
enemyClanName = None
currentBattle = data['currentBattle']
mapId = currentBattle.getMapId() if currentBattle else 0
enemyclanData = data['enemyClan']
enemyVisible = enemyclanData is not None
isInBattle = self.prbEntity.getFlags().isInArena()
textid = data['textid']
maxLvl = data['maxLevel']
level = int2roman(maxLvl)
if data['isSortie']:
headerDescr = i18n.makeString(
FORTIFICATIONS.STRONGHOLDINFO_SORTIE) % {
'level': level
}
timetext = None
if textid == FORTIFICATIONS.SORTIE_INTROVIEW_FORTBATTLES_ENDOFBATTLESOON or textid == FORTIFICATIONS.SORTIE_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLESOON:
timetext = makeHtmlString(
'html_templates:lobby/fortifications/introView',
'fortBattles',
{'text': time_utils.getTimeLeftFormat(data['dtime'])})
elif textid == FORTIFICATIONS.SORTIE_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLETOMORROW or textid == FORTIFICATIONS.SORTIE_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLETODAY:
timetext = makeHtmlString(
'html_templates:lobby/fortifications/introView',
'fortBattles', {
'text':
backport.getShortTimeFormat(
data['peripheryStartTimestamp'])
})
wfbDescr = i18n.makeString(textid, nextDate=timetext)
else:
direction = vo_converters.getDirection(data['direction'])
headerDescr = i18n.makeString(
FORTIFICATIONS.STRONGHOLDINFO_STRONGHOLD) % {
'direction': direction
}
if textid != FORTIFICATIONS.ROSTERINTROWINDOW_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLESOON:
timetext = None
if textid == FORTIFICATIONS.SORTIE_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLETOMORROW or textid == FORTIFICATIONS.SORTIE_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLETODAY:
timetext = makeHtmlString(
'html_templates:lobby/fortifications/introView',
'fortBattles', {
'text':
backport.getShortTimeFormat(
data['matchmakerNextTick'])
})
wfbDescr = i18n.makeString(textid, nextDate=timetext)
else:
isBattleTimerVisible = True
fontColors = GUI_SETTINGS.lookup('StrongholdsTimerColors')
colorRegular = fontColors.get('regular', '#FFDD99')
colorAlarm = fontColors.get('alarm', '#ff7f00')
enemyClanName = '?'
if enemyVisible:
clColor = enemyclanData.getColor()
clColor = '#%06x' % clColor if clColor else '#ffffff'
enemyClanName = "<b><font face='$FieldFont' color='{0}'>[{1}]</font></b>".format(
clColor, enemyclanData.getTag())
clan = data['clan']
if clan:
clColor = clan.getColor()
clColor = '#%06x' % clColor if clColor else '#ffffff'
playerClanName = "<b><font face='$FieldFont' color='{0}'>[{1}]</font></b>".format(
clColor, clan.getTag())
self.as_setTimerDeltaS(
vo_converters.makeClanBattleTimerVO(
data['dtime'] if not isInBattle else 0,
"<font face='$FieldFont' size='18' color='{0}'>###</font>"
.format(colorRegular),
"<font face='$FieldFont' size='18' color='{0}'>###</font>"
.format(colorAlarm), self.TIMER_GLOW_COLORS.NORMAL,
self.TIMER_GLOW_COLORS.ALERT, '00',
0 if data['isFirstBattle'] else 1))
self.as_updateReadyStatusS(
self.prbEntity.getFlags().isInQueue(),
self.__enemyReadyIndicator)
self.as_setBattleRoomDataS(
self._makeFortClanBattleRoomVO(mapId, headerDescr, playerClanName,
enemyClanName, wfbDescr,
enemyVisible, isBattleTimerVisible,
data['isSortie']))
if data['forceUpdateBuildings']:
self.__forceUpdateBuildings()
return
def getShortTimeString_ts(tsDate):
return backport.getShortTimeFormat(tsDate)
def _convert(self, record, reusable):
return style.makeTimeStatsVO(self._field,
backport.getShortTimeFormat(record))
def __notifyTimeTillKick(self):
messageText = backport.text(R.strings.system_messages.gameSessionControl.parentControl.kickTime(), kickTime=backport.getShortTimeFormat(self._gameRestrictions.getKickAt()))
SystemMessages.pushMessage(messageText, SM_TYPE.Warning, NotificationPriorityLevel.HIGH)
def getPeripheryTime(primeTime):
currentTimeUTC = _getCurrentUTCTime()
prStartTimeUTC, prEndTimeUTC = _calculatePeripheryTimeHelper(currentTimeUTC, primeTime)
dateStartTimestamp = int(time_utils.getTimestampFromUTC(prStartTimeUTC.utctimetuple()))
dateEndTimestamp = int(time_utils.getTimestampFromUTC(prEndTimeUTC.utctimetuple()))
return (backport.getShortTimeFormat(dateStartTimestamp), backport.getShortTimeFormat(dateEndTimestamp))
