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 __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 __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 _makeCantJoinReasonTooltip(stateReasons, playerData, limits):
def _addItem(name, error):
formatter = formatNotAvailableTextWithIcon if error else formatOkTextWithIcon
return (error, formatter(name))
header = TOOLTIPS.ELEN_STATUS_REQUIREMENTS_HEADER
body = ''
date = backport.getShortDateFormat(limits.getRegistrationDateMaxTs())
winRateMin = limits.getWinRateMin()
winRateMax = limits.getWinRateMax()
battlesCount = limits.getBattlesCountMin()
winRate = playerData.getWinRate()
items = list()
items.append(_addItem(_ms(TOOLTIPS.ELEN_STATUS_CANTJOIN_REASON_BYAGE, date=date), _psr.BYAGE in stateReasons))
items.append(_addItem(_ms(TOOLTIPS.ELEN_STATUS_CANTJOIN_REASON_BYVEHICLE), _psr.VEHICLESMISSING in stateReasons))
if battlesCount:
items.append(_addItem(_ms(TOOLTIPS.ELEN_STATUS_CANTJOIN_REASON_BYBATTLESCOUNT, number=battlesCount), _psr.BYBATTLESCOUNT in stateReasons))
if winRateMin:
items.append(_addItem(_ms(TOOLTIPS.ELEN_STATUS_CANTJOIN_REASON_BYWINRATELOW, number=winRateMin), _psr.BYWINRATE in stateReasons and winRate < winRateMin))
if winRateMax:
items.append(_addItem(_ms(TOOLTIPS.ELEN_STATUS_CANTJOIN_REASON_BYWINRATEHIGH, number=winRateMax), _psr.BYWINRATE in stateReasons and winRate > winRateMax))
items.sort(key=lambda item: item[0], reverse=True)
body = '\n'.join([ item[1] for item in items ])
return makeTooltip(header, body)
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 _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 __fillViewModel(self):
with self.viewModel.transaction() as vm:
self.__resetViewModel(vm)
currentSeason = self.__epicController.getCurrentSeason()
nextSeason = self.__epicController.getNextSeason()
season = currentSeason or nextSeason
currentTime = time_utils.getCurrentLocalServerTimestamp()
vm.setConditions(
backport.text(
R.strings.mode_selector.mode.epicBattle.condition(),
levels=toRomanRangeString(
self.__epicController.getValidVehicleLevels())))
vm.setDescription(
backport.text(
R.strings.mode_selector.mode.epicBattle.description()))
if season is None:
return
if season.hasActiveCycle(currentTime):
vm.setStatusActive(
backport.text(
R.strings.mode_selector.mode.epicBattle.seasonActive(),
cycle=int2roman(currentSeason.getCycleInfo().
getEpicCycleNumber())))
self._addReward(ModeSelectorRewardID.CREDITS)
self._addReward(ModeSelectorRewardID.EXPERIENCE)
timeLeftStr = ''
cycleInfo = season.getCycleInfo()
if cycleInfo is not None:
timeLeftStr = time_formatters.getTillTimeByResource(
cycleInfo.endDate - currentTime,
R.strings.menu.Time.timeLeftShort,
removeLeadingZeros=True)
vm.setTimeLeft(timeLeftStr)
else:
cycleInfo = season.getNextByTimeCycle(currentTime)
if cycleInfo is not None:
if cycleInfo.announceOnly:
vm.setStatusNotActive(
backport.text(R.strings.mode_selector.mode.
epicBattle.cycleSoon(),
cycle=int2roman(
cycleInfo.getEpicCycleNumber())))
else:
vm.setStatusNotActive(
backport.text(R.strings.mode_selector.mode.
epicBattle.cycleNext(),
cycle=int2roman(
cycleInfo.getEpicCycleNumber()),
date=backport.getShortDateFormat(
cycleInfo.startDate)))
self.viewModel.setBattlePassState(BattlePassState.NONE)
else:
vm.setStatusNotActive(
backport.text(R.strings.mode_selector.mode.epicBattle.
seasonEnd()))
setBattlePassState(self.viewModel)
return
def getDueDateOrTimeStr(finishTime, localization='', isShortDateFormat=False):
if not finishTime or time_utils.isPast(finishTime):
return ''
if time_utils.isToday(finishTime):
strTime = backport.getShortTimeFormat(finishTime)
elif isShortDateFormat:
strTime = backport.getShortDateFormat(finishTime)
else:
strTime = backport.getLongDateFormat(finishTime)
return ' '.join([localization, strTime]) if localization else strTime
def _onLoading(self):
super(WotPlusTooltip, self)._onLoading()
with self.viewModel.transaction() as model:
isWotPlusEnabled = self.__lobbyContext.getServerSettings(
).isRenewableSubEnabled()
isWotPlusSubscribed = BigWorld.player(
).renewableSubscription.isEnabled()
expirationTime = BigWorld.player(
).renewableSubscription.getExpiryTime()
model.setNextCharge(backport.getShortDateFormat(expirationTime))
model.setIsActivated(isWotPlusSubscribed and isWotPlusEnabled)
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 __getRankedNotActiveStatus(self):
msR = R.strings.mode_selector.event
if self.__rankedBattleController.hasAnySeason():
currentSeason = self.__rankedBattleController.getCurrentSeason()
if currentSeason is None:
nextSeason = self.__rankedBattleController.getNextSeason()
if nextSeason is not None:
startDate = nextSeason.getStartDate()
name = self.__getRankedBattlesSeasonName(nextSeason)
return backport.text(msR.notStarted(), eventName=name, date=backport.getShortDateFormat(startDate))
prevSeason = self.__rankedBattleController.getPreviousSeason()
if prevSeason is not None:
name = self.__getRankedBattlesSeasonName(prevSeason)
return backport.text(msR.finished(), eventName=name)
return ''
def makeCantJoinReasonTextVO(event, playerData):
playerState = playerData.getPlayerStateByEventId(event.getEventID())
stateReasons = playerState.getPlayerStateReasons() if playerState else []
stateReason = stateReasons[0] if stateReasons else None
tooltip = None
buttonVisible = False
if event.isRegistrationFinished():
result = formatErrorTextWithIcon(EVENT_BOARDS.STATUS_CANTJOIN_REASON_ENDREGISTRATION)
elif _psr.SPECIALACCOUNT in stateReasons:
result = getStatusTitleStyle(_ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_SPECIAL))
elif stateReason is _psr.WASUNREGISTERED:
result = getStatusTitleStyle(_ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_LEFTEVENT))
tooltip = makeTooltip(EVENT_BOARDS.STATUS_CANTJOIN_REASON_LEFTEVENT, EVENT_BOARDS.STATUS_CANTJOIN_REASON_LEFTEVENT_TOOLTIP)
else:
limits = event.getLimits()
if len(stateReasons) > 1:
reasonText = _ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_MANY, number=len(stateReasons))
tooltip = _makeCantJoinReasonTooltip(stateReasons, playerData, limits)
elif stateReason is _psr.BYWINRATE:
winRate = playerData.getWinRate()
winRateMin = limits.getWinRateMin()
winRateMax = limits.getWinRateMax()
if winRate < winRateMin:
reasonText = _ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_BYWINRATELOW, number=str(winRateMin))
else:
reasonText = _ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_BYWINRATEHIGH, number=str(winRateMax))
elif stateReason is _psr.BYAGE:
date = backport.getShortDateFormat(limits.getRegistrationDateMaxTs())
reasonText = _ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_BYAGE, date=date)
elif stateReason is _psr.BYBATTLESCOUNT:
battlesCount = playerData.getBattlesCount()
reasonText = _ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_BYBATTLESCOUNT, number=battlesCount)
elif stateReason is _psr.BYBAN:
reasonText = _ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_BANNED)
elif stateReason is _psr.VEHICLESMISSING:
reasonText = _ms(EVENT_BOARDS.STATUS_CANTJOIN_REASON_VEHICLESMISSING)
else:
reasonText = ''
notAvailableText = formatErrorTextWithIcon(EVENT_BOARDS.STATUS_CANTJOIN_NOTAVAILABLE)
reasonText = text_styles.main(reasonText)
result = '{} {}'.format(notAvailableText, reasonText)
buttonVisible = True
return (result, tooltip, buttonVisible)
def _packBlocks(self, *args, **kwargs):
items = super(RankedUnavailableTooltip,
self)._packBlocks(*args, **kwargs)
tooltipData = R.strings.tooltips.battleTypes.ranked
header = backport.text(tooltipData.header())
body = backport.text(tooltipData.body())
nextSeason = self.rankedController.getNextSeason()
if self.rankedController.isFrozen(
) and self.rankedController.getCurrentSeason() is not None:
additionalInfo = backport.text(tooltipData.body.frozen())
elif nextSeason is not None:
date = backport.getShortDateFormat(
time_utils.makeLocalServerTime(nextSeason.getStartDate()))
additionalInfo = backport.text(tooltipData.body.coming(),
date=date)
else:
additionalInfo = backport.text(tooltipData.body.disabled())
body = '%s\n\n%s' % (body, additionalInfo)
items.append(
formatters.packImageTextBlockData(
title=text_styles.middleTitle(header),
desc=text_styles.main(body)))
return items
def getShortDatetimeFormat(cls, time):
return '{0:>s} {1:>s}'.format(backport.getShortDateFormat(time),
backport.getShortTimeFormat(time))
def getDateTimeFormat(cls, value):
return cls._makeLocalTimeString(
value, lambda localTime: '{0:>s} {1:>s}'.format(
backport.getShortDateFormat(value),
backport.getLongTimeFormat(value)))
def _updateClanInfo(self):
self.as_setClanInfoS({'name': self.clanProfile.getClanFullName(),
'bgIcon': RES_ICONS.MAPS_ICONS_CLANS_INVITESWINDOW_CC_HEADER_BACK,
'creationDate': i18n.makeString(CLANS.CLAN_HEADER_CREATIONDATE, creationDate=backport.getShortDateFormat(self.clanInfo.getCreatedAt()))})
def __getDate(self, date):
timeStamp = time_utils.makeLocalServerTime(date)
return backport.getShortDateFormat(timeStamp)
def _convert(self, record, reusable):
return ' '.join((backport.getShortDateFormat(record),
backport.getShortTimeFormat(record)))
def getExpiryTime(self):
return backport.getShortDateFormat(self._expiryTime) if self._expiryTime and self._expiryTime < ENDLESS_TOKEN_TIME else ''
def __fillViewModel(self):
with self.viewModel.transaction() as vm:
season = self.__battleRoyaleController.getCurrentSeason() or self.__battleRoyaleController.getNextSeason()
currTime = time_utils.getCurrentLocalServerTimestamp()
if season is None:
return
self.__resetViewModel(vm)
if season.hasActiveCycle(currTime):
if self.__battleRoyaleController.isEnabled():
timeLeftStr = time_utils.getTillTimeString(season.getCycleEndDate() - currTime, EPIC_BATTLE.STATUS_TIMELEFT, removeLeadingZeros=True)
vm.setTimeLeft(timeLeftStr)
self._addReward(ModeSelectorRewardID.CREDITS)
self._addReward(ModeSelectorRewardID.OTHER)
else:
cycleInfo = season.getNextByTimeCycle(currTime)
if cycleInfo is not None:
if cycleInfo.announceOnly:
text = backport.text(R.strings.battle_royale.modeSelector.cycleIsComing())
else:
text = backport.text(R.strings.battle_royale.modeSelector.cycleNotStarted(), date=backport.getShortDateFormat(cycleInfo.startDate))
vm.setStatusNotActive(text)
vm.setTimeLeft('')
setBattlePassState(self.viewModel)
return
def _formatFinishTime(self):
return ' '.join((text_styles.main(i18n.makeString(QUESTS.ACTION_TIME_FINISH)), backport.getShortDateFormat(self.getFinishTime())))
def getMessageLongDatetimeFormat(cls, time):
return '({0:>s} {1:>s}) '.format(
backport.getShortDateFormat(time),
backport.getLongTimeFormat(time)).decode('utf-8', 'ignore')
def formatDate(ts, default='--'):
return str(backport.getShortDateFormat(ts)) if ts is not None else default
def formatShortDateShortTimeString(timestamp):
return str(' ').join((backport.getShortDateFormat(timestamp), ' ', backport.getShortTimeFormat(timestamp)))
def _getValue(self, value):
return backport.getShortDateFormat(self._getLocalTime(value))
def _getStartTime(self):
startTimeStr = backport.getShortDateFormat(self.__startTime)
return text_styles.main(i18n.makeString(QUESTS.ACTION_COMINGSOON_TIME, startTime=startTimeStr)) if startTimeStr is not None else ''
def _getValue(self, value):
value = self._getLocalTime(value)
return '{0:>s} {1:>s}'.format(backport.getShortDateFormat(value),
backport.getLongTimeFormat(value))
