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))