def getScheduleBlock(modeCtrl, modeName, actualSeason, seasonIsStarted, timeStringGetter): block = [] if actualSeason.hasActiveCycle( time_utils.getCurrentLocalServerTimestamp()): currentCycle = actualSeason.getCycleInfo() block.append(getTimeTableBlock(modeCtrl, modeName)) block.append( _getTimeBlock(seasonIsStarted, True, time_utils.makeLocalServerTime(currentCycle.endDate), modeName, timeStringGetter)) elif actualSeason is not None: nextCycle = actualSeason.getNextByTimeCycle( time_utils.getCurrentLocalServerTimestamp()) if nextCycle: block.append( _getTimeBlock( seasonIsStarted, False, time_utils.makeLocalServerTime(nextCycle.startDate), modeName, timeStringGetter)) else: wait = backport.text( R.strings.menu.headerButtons.battle.types.dyn( modeName).extra.finished()) block.append( formatters.packTitleDescBlock(title=text_styles.main(wait))) return block
def __getStatusTitle(self): currServerName = self._connectionMgr.serverUserNameShort status, timeLeft, _ = self._getController().getPrimeTimeStatus() if not self._hasAvailableServers(): return text_styles.grandTitle( backport.text(R.strings.mapbox.primeTimeView.status. allServersDisabled())) if status == PrimeTimeStatus.NOT_AVAILABLE: if not timeLeft: currentSeason = self._getController().getCurrentSeason() return text_styles.grandTitle( backport.text( R.strings.mapbox.primeTimeView.status.seasonDisabled(), season=currentSeason.getUserName(), server=currServerName)) if timeLeft < time_utils.ONE_DAY: startTime = time_formatters.formatDate( '%H:%M', time_utils.getCurrentLocalServerTimestamp() + timeLeft) else: startTime = time_formatters.formatDate( '%d.%m.%Y', time_utils.getCurrentLocalServerTimestamp() + timeLeft) return text_styles.grandTitle( backport.text(R.strings.mapbox.primeTimeView.status.untill(), startTime=startTime, server=currServerName)) return text_styles.grandTitle( backport.text( R.strings.mapbox.primeTimeView.status.disableFirst(), server=currServerName)) if status in ( PrimeTimeStatus.FROZEN, PrimeTimeStatus.NOT_SET) else text_styles.grandTitle( backport.text(R.strings.mapbox.primeTimeView.status. allServersDisabled()))
def __getScheduleStr(self): if self.__isFrozen: return backport.text(R.strings.menu.headerButtons.battle.types. battleRoyale.extra.frozen()) else: currentSeason = self.__battleRoyaleController.getCurrentSeason() if currentSeason is not None and currentSeason.hasActiveCycle( time_utils.getCurrentLocalServerTimestamp()): seasonResID = R.strings.battle_royale.season.num( currentSeason.getSeasonID()) seasonName = backport.text( seasonResID.name()) if seasonResID else None scheduleStr = backport.text( R.strings.menu.headerButtons.battle.types.battleRoyale. extra.currentCycle(), season=seasonName, cycle=int2roman(currentSeason.getCycleOrdinalNumber())) return text_styles.main(scheduleStr) currentOrNextSeason = currentSeason or self.__battleRoyaleController.getNextSeason( ) if currentOrNextSeason is not None: nextCycle = currentOrNextSeason.getNextByTimeCycle( time_utils.getCurrentLocalServerTimestamp()) if nextCycle: scheduleStr = backport.text( R.strings.menu.headerButtons.battle.types.battleRoyale. extra.startsAt(), time=backport.getDateTimeFormat(nextCycle.startDate)) return text_styles.main(scheduleStr) scheduleStr = backport.text(R.strings.menu.headerButtons.battle. types.battleRoyale.extra.finished()) return text_styles.main(scheduleStr)
def __getScheduleStr(self): if self._isDisabled: return text_styles.error( backport.text(_R_BATTLE_TYPES.epic.extra.frozen())) else: currentSeason = self.__epicController.getCurrentSeason() if currentSeason: if currentSeason.hasActiveCycle( time_utils.getCurrentLocalServerTimestamp()): scheduleStr = None else: nextCycle = currentSeason.getNextCycleInfo( time_utils.getCurrentLocalServerTimestamp()) if nextCycle is None: nextCycle = currentSeason.getNextByTimeCycle( time_utils.getCurrentLocalServerTimestamp()) if nextCycle: nextCycleStartTime = backport.getDateTimeFormat( nextCycle.startDate) scheduleStr = backport.text( _R_BATTLE_TYPES.epic.extra.startsAt(), time=nextCycleStartTime) else: scheduleStr = None else: nextSeason = self.__epicController.getNextSeason() nextCycle = nextSeason.getNextByTimeCycle( time_utils.getCurrentLocalServerTimestamp()) if nextCycle: startTime = backport.getDateTimeFormat(nextCycle.startDate) scheduleStr = backport.text( _R_BATTLE_TYPES.epic.extra.startsAt(), time=startTime) else: scheduleStr = None return text_styles.main(scheduleStr) if scheduleStr else None
def packEpicBattleInfoBlock(epicController=None): descLvl = text_styles.stats( backport.text( R.strings.epic_battle.selectorTooltip.epicBattle.bodyVehicleLevel( ), level=toRomanRangeString(epicController.getValidVehicleLevels()))) season = epicController.getCurrentSeason() cycle = None cycleNumber = None if season is not None and not season.isSingleCycleSeason(): hasActiveCycle = season.hasActiveCycle( time_utils.getCurrentLocalServerTimestamp()) if epicController.isEnabled() and hasActiveCycle: cycle = season.getCycleInfo() else: cycle = season.getNextByTimeCycle( time_utils.getCurrentLocalServerTimestamp()) if cycle is not None: cycleNumber = cycle.getEpicCycleNumber() if cycleNumber: titleStr = R.strings.epic_battle.tooltips.common.titleWithCycle() else: titleStr = R.strings.epic_battle.tooltips.common.title() return formatters.packTitleDescBlock( title=text_styles.middleTitle( backport.text(titleStr, season=int2roman(cycleNumber))), desc=text_styles.main( backport.text( R.strings.epic_battle.selectorTooltip.epicBattle.body(), bodyVehicleLevel=descLvl)), padding=formatters.packPadding(top=20, left=20, right=20), descPadding=formatters.packPadding(right=30))
def getSeasonEndTime(self): generalSettings = self.lobbyContext.getServerSettings().epicBattles if time_utils.getCurrentLocalServerTimestamp( ) < generalSettings.season['start']: return (generalSettings.season['start'], False) else: return (None, False) if time_utils.getCurrentLocalServerTimestamp( ) > generalSettings.season['end'] else ( generalSettings.season['end'], True)
def _update(self): calendar = self.getCalendar() if calendar is not None: lowerTimeBound = time_utils.getCurrentLocalServerTimestamp() - self.TIME_LIMITS.LOW higherTimeBound = time_utils.getCurrentLocalServerTimestamp() + self.TIME_LIMITS.HIGH calendar.as_setMinAvailableDateS(lowerTimeBound) calendar.as_setMaxAvailableDateS(higherTimeBound) calendar.as_openMonthS(self.__selectedDate) calendar.as_selectDateS(self.__selectedDate) self._populateMonthEvents() self._populatePreviewBlock() self._populateCalendarMessage()
def isDailyQuestsRefreshAvailable(self): if self.hasPrimeTimesLeftForCurrentCycle(): return True primeTimePeriodsForDay = self.getPrimeTimesForDay( time_utils.getCurrentLocalServerTimestamp()) if primeTimePeriodsForDay: _, periodTimeEnd = max(primeTimePeriodsForDay.values(), key=itemgetter(1)) periodTimeLeft = periodTimeEnd - time_utils.getCurrentLocalServerTimestamp( ) return periodTimeLeft > time_utils.getDayTimeLeft() return False
def isDailyQuestsRefreshAvailable(self): if self.hasPrimeTimesLeftForCurrentCycle(): return True serversPeriodsMapping = self.getPrimeTimesForDay( time_utils.getCurrentLocalServerTimestamp()) periods = [] for _, dayPeriods in serversPeriodsMapping.items(): periods.append(max([periodEnd for _, periodEnd in dayPeriods])) if periods: periodTimeLeft = max( periods) - time_utils.getCurrentLocalServerTimestamp() return periodTimeLeft > time_utils.getDayTimeLeft() return False
def getPrimeTimeStatus(self, peripheryID=None): if peripheryID is None: peripheryID = self.__connectionMgr.peripheryID primeTime = self.getPrimeTimes().get(peripheryID) if primeTime is None: return (PrimeTimeStatus.NOT_SET, 0, False) elif not primeTime.hasAnyPeriods(): return (PrimeTimeStatus.FROZEN, 0, False) else: season = self.getCurrentSeason() currTime = time_utils.getCurrentLocalServerTimestamp() if season and season.hasActiveCycle(currTime): isNow, timeTillUpdate = primeTime.getAvailability( currTime, season.getCycleEndDate()) else: timeTillUpdate = 0 if season: nextCycle = season.getNextByTimeCycle(currTime) if nextCycle: primeTimeStart = primeTime.getNextPeriodStart( nextCycle.startDate, season.getEndDate(), includeBeginning=True) if primeTimeStart: timeTillUpdate = max( primeTimeStart, nextCycle.startDate) - currTime isNow = False return (PrimeTimeStatus.AVAILABLE, timeTillUpdate, isNow) if isNow else (PrimeTimeStatus.NOT_AVAILABLE, timeTillUpdate, False)
def __getStatusTitle(self): currServerName = self._connectionMgr.serverUserNameShort status, timeLeft, _ = self.__rankedController.getPrimeTimeStatus() if status == PrimeTimeStatus.NOT_AVAILABLE: if not timeLeft: currentSeason = self.__rankedController.getCurrentSeason() return text_styles.grandTitle( backport.text(R.strings.ranked_battles.primeTime.status. seasonDisabled(), season=currentSeason.getUserName(), server=currServerName)) if not self._hasAvailableServers(): return text_styles.grandTitle( backport.text(R.strings.ranked_battles.primeTime.status. allServersDisabled())) startTime = formatDate( '%H:%M', time_utils.getCurrentLocalServerTimestamp() + timeLeft) return text_styles.grandTitle( backport.text( R.strings.ranked_battles.primeTime.status.untill(), startTime=startTime, server=currServerName)) return text_styles.grandTitle( backport.text( R.strings.ranked_battles.primeTime.status.disableFirst(), server=currServerName))
def __startRentTimeNotifyCallback(self): if not self.itemsCache.isSynced(): return self.__vehiclesForUpdate = [] rentedVehicles = self.itemsCache.items.getVehicles(REQ_CRITERIA.VEHICLE.RENT ^ REQ_CRITERIA.VEHICLE.RENT_PROMOTION).values() notificationList = [] for vehicle in rentedVehicles: delta = vehicle.rentLeftTime if delta > 0: notificationList.append((vehicle.intCD, self.getDeltaPeriod(delta), vehicle.isRentPromotion)) nextRentNotification = maxint if notificationList: _, nextRentNotification, forceUpdate = min(notificationList, key=itemgetter(1)) for item in notificationList: if item[1] == nextRentNotification or forceUpdate: self.__vehiclesForUpdate.append(item[0]) nextRentNotification = max(nextRentNotification, 0) for seasonType in SEASON_NAME_BY_TYPE: currentSeason = self.seasonsController.getCurrentSeason(seasonType) if currentSeason: now = time_utils.getCurrentLocalServerTimestamp() if currentSeason.hasActiveCycle(now): nextCycleChange = currentSeason.getCycleEndDate() else: nextCycleChange = currentSeason.getCycleStartDate() delta = int(time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(nextCycleChange))) if delta > 0: nextRentNotification = min(nextRentNotification, self.getDeltaPeriod(delta)) + 1 if not notificationList and nextRentNotification == maxint: return self.__rentNotifyTimeCallback = BigWorld.callback(nextRentNotification, self.__notifyRentTime)
def __updateViewModel(self): if not isMapboxEntryPointAvailable(): return with self.viewModel.transaction() as model: currServerTime = time_utils.getCurrentLocalServerTimestamp() model.setEndDate(self.__mapboxCtrl.getEventEndTimestamp() + time_utils.getCurrentTimestamp() - currServerTime)
def __invalidatePrimeTimeStatus(self): currTime = int(time_utils.getCurrentLocalServerTimestamp()) if self.__invalidationTime < currTime: primeTimeData = self._periodsController.getPrimeTimeStatus( peripheryID=self.__peripheryID) self.__primeTimeStatus, self.__timeLeft, self.__isAvailable = primeTimeData self.__invalidationTime = currTime
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 getSeasonAchievements(self, _): achievements = self.__itemsCache.items.getAccountDossier( ).getDossierDescr().expand('epicSeasons') seasonsAchievements = [] season = self.__epicController.getCurrentSeason( ) or self.__epicController.getPreviousSeason() if not season: return seasonsAchievements for seasonID, cycleID in achievements: if season.getSeasonID( ) == seasonID and cycleID in season.getAllCycles(): key = (seasonID, cycleID) seasonsAchievements.append( EpicSeasonAchievements(*(key + achievements[key]))._asdict()) if season.hasActiveCycle(time_utils.getCurrentLocalServerTimestamp()): stats = self.__epicController.getStats() seasonsAchievements.append( EpicSeasonAchievements( season_id=season.getSeasonID(), episode_id=season.getCycleID(), battle_count=stats.battleCount, average_xp=stats.averageXP, lvl=stats.playerLevelInfo[0], battle_bp_points=stats.seasonData[2].get( 'battlePassPoints', 0), season_bp_points=stats.seasonData[2].get( 'seasonBattlePassPoints', 0))._asdict()) return seasonsAchievements
def _getAlertStatusText(timeLeft, hasAvailableServers, connectionMgr=None, epicController=None): rAlertMsgBlock = R.strings.epic_battle.widgetAlertMessageBlock alertStr = '' if hasAvailableServers: alertStr = backport.text(rAlertMsgBlock.somePeripheriesHalt(), serverName=connectionMgr.serverUserNameShort) else: currSeason = epicController.getCurrentSeason() currTime = time_utils.getCurrentLocalServerTimestamp() primeTime = epicController.getPrimeTimes().get(connectionMgr.peripheryID) isCycleNow = currSeason and currSeason.hasActiveCycle(currTime) and primeTime and primeTime.getPeriodsBetween(currTime, currSeason.getCycleEndDate()) if isCycleNow: if connectionMgr.isStandalone(): key = rAlertMsgBlock.singleModeHalt else: key = rAlertMsgBlock.allPeripheriesHalt timeLeftStr = time_formatters.getTillTimeByResource(timeLeft, R.strings.epic_battle.status.timeLeft, removeLeadingZeros=True) alertStr = backport.text(key(), time=timeLeftStr) else: nextSeason = currSeason or epicController.getNextSeason() if nextSeason is not None: nextCycle = nextSeason.getNextByTimeCycle(currTime) if nextCycle is not None: if nextCycle.announceOnly: alertStr = backport.text(rAlertMsgBlock.announcement()) else: timeLeftStr = time_formatters.getTillTimeByResource(nextCycle.startDate - currTime, R.strings.epic_battle.status.timeLeft, removeLeadingZeros=True) alertStr = backport.text(rAlertMsgBlock.startIn(), time=timeLeftStr) if not alertStr: prevSeason = currSeason or epicController.getPreviousSeason() if prevSeason is not None: prevCycle = prevSeason.getLastActiveCycleInfo(currTime) if prevCycle is not None: alertStr = backport.text(rAlertMsgBlock.noCycleMessage()) return text_styles.vehicleStatusCriticalText(alertStr)
def getPrimeTimeStatus(self, peripheryID=None): if not self.isEnabled(): return (PRIME_TIME_STATUS.DISABLED, 0, False) else: if peripheryID is None: peripheryID = self.connectionMgr.peripheryID primeTimes = self.getPrimeTimes() hasAnyPeriods = False for pId in primeTimes: hasAnyPeriods = primeTimes[pId].hasAnyPeriods() if hasAnyPeriods: break if not hasAnyPeriods: LOG_WARNING('RankedBattles enabled but primetimes did not have any period to play or they are frozen!') primeTime = primeTimes.get(peripheryID) if primeTime is None: if hasAnyPeriods: return (PRIME_TIME_STATUS.NOT_SET, 0, False) LOG_WARNING('RankedBattles primetimes did not have playable period on pID:', peripheryID) return (PRIME_TIME_STATUS.DISABLED, 0, False) if not primeTime.hasAnyPeriods(): return (PRIME_TIME_STATUS.FROZEN, 0, False) currentSeason = self.getCurrentSeason() if currentSeason is None: return (PRIME_TIME_STATUS.NO_SEASON, 0, False) isNow, timeLeft = primeTime.getAvailability(time_utils.getCurrentLocalServerTimestamp(), self.getCurrentSeason().getCycleEndDate()) return (PRIME_TIME_STATUS.AVAILABLE, timeLeft, isNow) if isNow else (PRIME_TIME_STATUS.NOT_AVAILABLE, timeLeft, False)
def _packBlocks(self, *_): items = super(PeriodicCalendarDayTooltip, self)._packBlocks() if not self._controller.isAvailable(): return items now = time_utils.getCurrentLocalServerTimestamp() serversPeriodsMapping = self._controller.getPrimeTimesForDay(now) blocks = [self._packHeaderBlock()] timeFmt = backport.getShortTimeFormat for serverName in natsorted(serversPeriodsMapping.keys()): dayPeriods = serversPeriodsMapping[serverName] if dayPeriods: periodsStr = [ backport.text(self._RES_ROOT.time(), start=timeFmt(periodStart), end=timeFmt(periodEnd)) for periodStart, periodEnd in dayPeriods ] else: periodsStr = backport.text(R.strings.common.common.dash()) blocks.append( self.__packServerTimeBlock(serverStr=text_styles.main( backport.text(self._RES_ROOT.serverName(), server=serverName)), timeStr=text_styles.stats( '\n'.join(periodsStr)))) items.append(formatters.packBuildUpBlockData(blocks, _TOOLTIP_MARGIN)) return items
def _getLastFutureCycleRentInfo(self): now = time_utils.getCurrentLocalServerTimestamp() for seasonType, rentTypes in self.seasonRent.iteritems(): currentSeason = self.seasonsController.getCurrentSeason(seasonType) if currentSeason: currentCycleID = currentSeason.getCycleID( ) or currentSeason.getLastActiveCycleID(now) futureCycleRents = first( sorted([ item[0] for item in rentTypes if item[1] == SeasonRentDuration.SEASON_CYCLE and item[0] > currentCycleID ], reverse=True)) if futureCycleRents: lastFutureCycleRentID = futureCycleRents cycleInfo = currentSeason.getCycleInfo( lastFutureCycleRentID) if cycleInfo: return SeasonRentInfo(seasonType, lastFutureCycleRentID, SeasonRentDuration.SEASON_CYCLE, cycleInfo.endDate) return None
def _getTimeLeft(self, pID): primeTime = self.rankedController.getPrimeTimes().get(pID) currentSeason = self.rankedController.getCurrentSeason() _, timeLeft = primeTime.getAvailability( time_utils.getCurrentLocalServerTimestamp(), currentSeason.getCycleEndDate()) return timeLeft
def __getTimeText(self, serverInfo): if serverInfo: timeLeft = serverInfo.getTimeLeft() isAvailable = serverInfo.isAvailable() serverName = serverInfo.getName() else: _, timeLeft, isAvailable = self.__eventProgression.getPrimeTimeStatus( ) serverName = '' currentSeason = self.__eventProgression.getCurrentSeason() if currentSeason and not timeLeft: return _ms(EPIC_BATTLE.PRIMETIME_ENDOFCYCLE, server=serverName) if not timeLeft and not isAvailable and not currentSeason: nextSeason = self.__eventProgression.getNextSeason() if nextSeason: currTime = time_utils.getCurrentLocalServerTimestamp() primeTime = self.__eventProgression.getPrimeTimes().get( serverInfo.getPeripheryID()) startTime = primeTime.getNextPeriodStart( currTime, nextSeason.getEndDate()) if startTime: timeLeft = startTime - currTime else: self.destroy() return '' timeLeftStr = time_utils.getTillTimeString(timeLeft, MENU.TIME_TIMEVALUESHORT) i18nKey = EPIC_BATTLE.PRIMETIME_PRIMEISAVAILABLE if isAvailable else EPIC_BATTLE.PRIMETIME_PRIMEWILLBEAVAILABLE return _ms(i18nKey, server=serverName, time=text_styles.neutral(timeLeftStr))
def getSeasonAchievements(self, _): dossierDescr = self.__itemsCache.items.getAccountDossier( ).getDossierDescr() seasonsAchievements = self.__getSeasonAchievements( dossierDescr.expand('battleRoyaleSeasons'), BattleRoyaleSeasonAchievements) currentSeason = self.__battleRoyale.getCurrentSeason() if currentSeason and currentSeason.getCycleID(): now = time_utils.getCurrentLocalServerTimestamp() stats = self.__battleRoyale.getStats() seasonsAchievements[currentSeason.getSeasonID(), currentSeason.getCycleID()] = { 'battle_count': stats.battleCount, 'kill_count': stats.killCount, 'top1': stats.topCount, 'season_id': currentSeason.getSeasonID(), 'episode_id': currentSeason.getCycleID() or currentSeason.getLastActiveCycleID(now) } return seasonsAchievements.values()
def getRentalPeriodInCycles(self): activeSeasonRentInfo = self.getActiveSeasonRent() if not activeSeasonRentInfo: return else: seasonType, rentID, duration, _ = activeSeasonRentInfo currentSeason = self.seasonsController.getCurrentSeason(seasonType) if currentSeason: if duration == SeasonRentDuration.ENTIRE_SEASON: if self.seasonsController.isWithinSeasonTime( rentID, seasonType): curCycle = currentSeason.getCycleInfo() lastCycle = currentSeason.getLastCycleInfo() if curCycle is None or lastCycle is None: return if curCycle == lastCycle: return (curCycle, ) return (curCycle, lastCycle) elif duration == SeasonRentDuration.SEASON_CYCLE: now = time_utils.getCurrentLocalServerTimestamp() curCycle = currentSeason.getCycleInfo( ) or currentSeason.getNextByTimeCycle(now) if curCycle: lastFutureCycleInfo = self._getLastFutureCycleRentInfo( ) if lastFutureCycleInfo and lastFutureCycleInfo.seasonID != curCycle.ID: lastCycle = currentSeason.getCycleInfo( lastFutureCycleInfo.seasonID) return (curCycle, lastCycle) return (curCycle, ) return
def packEpicBattleSeasonBlock(epicController=None): if not epicController.isEnabled(): return else: season = epicController.getCurrentSeason( ) or epicController.getNextSeason() currentTime = time_utils.getCurrentLocalServerTimestamp() if epicController.isCurrentCycleActive(): cycle = season.getCycleInfo() getDate = lambda c: c.endDate getTimeToStr = getTimeToEndStr else: cycle = season.getNextByTimeCycle(currentTime) if season else None if cycle and cycle.announceOnly: return getDate = lambda c: c.startDate getTimeToStr = getTimeToStartStr if cycle is not None: description = getTimeToStr(getDate(cycle) - currentTime) else: description = backport.text( R.strings.epic_battle.tooltips.widget.finished()) return formatters.packBuildUpBlockData([ formatters.packImageTextBlockData( desc=text_styles.main(description), padding=formatters.packPadding(left=20, right=20)) ])
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 _packBlocks(self, selectedTime): if selectedTime is None: selectedTime = time_utils.getCurrentLocalServerTimestamp() items = super(RankedCalendarDayTooltip, self)._packBlocks() seasonEnd = None if self.rankedController.getCurrentSeason(): seasonEnd = self.rankedController.getCurrentSeason().getEndDate() seasonEnd = datetime.fromtimestamp(seasonEnd).date() if datetime.fromtimestamp(selectedTime).date() > seasonEnd: return items else: blocks = [self.__packHeaderBlock()] serversPeriodsMapping = self.rankedController.getPrimeTimesForDay(selectedTime) frmt = backport.getShortTimeFormat for serverName in sorted(serversPeriodsMapping.keys()): periodsStr = [] dayPeriods = serversPeriodsMapping[serverName] if dayPeriods: for periodStart, periodEnd in dayPeriods: periodsStr.append(backport.text(R.strings.ranked_battles.calendarDay.time(), start=frmt(periodStart), end=frmt(periodEnd))) else: periodsStr = backport.text(R.strings.common.common.dash()) blocks.append(self.__packServerTimeBlock(serverStr=text_styles.main(backport.text(R.strings.ranked_battles.calendarDay.serverName(), server=serverName)), timeStr=text_styles.stats('\n'.join(periodsStr)))) items.append(formatters.packBuildUpBlockData(blocks, 13)) return items
def _onLoading(self, engravingId): viewModel = self.getViewModel() dtHelper = BigWorld.player().dogTags with viewModel.transaction() as model: engravingComponent = dtHelper.getDogTagComponentForAccount( engravingId) engravingId = engravingComponent.compId skillRecords = sorted(dtHelper.getSkillData(engravingId), key=lambda e: e.date) indexMax = -1 if skillRecords: maxValue = max(skillRecords[::-1], key=attrgetter('value')) if maxValue.value >= engravingComponent.componentDefinition.grades[ 0]: indexMax = skillRecords.index(maxValue) model.setHighlightedIndex(indexMax) monthNames = model.getMonthNames() monthlyValues = model.getMonthlyValues() for date, value in skillRecords: monthRes = self._getMonthRes(date[1]) monthNames.addResource(monthRes) if value is not None: monthlyValues.addReal(value) currentMonth = getTimeStructInLocal( getCurrentLocalServerTimestamp()).tm_mon model.setCurrentMonth(self._getMonthRes(currentMonth)) model.setProgressNumberType( engravingComponent.componentDefinition.numberType.value) return
def __getAlertStatusText(self, timeLeft, unsuitablePeriphery, hasAvailableServers): rAlertMsgBlock = R.strings.battle_royale.widgetAlertMessageBlock alertStr = '' if hasAvailableServers: if unsuitablePeriphery: alertStr = backport.text( R.strings.battle_royale.alertMessage.unsuitablePeriphery()) else: alertStr = backport.text( rAlertMsgBlock.somePeripheriesHalt(), serverName=self.__connectionMgr.serverUserNameShort) else: currSeason = self.__battleRoyaleController.getCurrentSeason() currTime = time_utils.getCurrentLocalServerTimestamp() primeTime = self.__battleRoyaleController.getPrimeTimes().get( self.__connectionMgr.peripheryID) isCycleNow = currSeason and currSeason.hasActiveCycle( currTime) and primeTime and primeTime.getPeriodsBetween( currTime, currSeason.getCycleEndDate()) if isCycleNow: if self.__connectionMgr.isStandalone(): key = rAlertMsgBlock.singleModeHalt else: key = rAlertMsgBlock.allPeripheriesHalt timeLeftStr = time_utils.getTillTimeString( timeLeft, EPIC_BATTLE.STATUS_TIMELEFT, removeLeadingZeros=True) alertStr = backport.text(key(), time=timeLeftStr) else: nextSeason = currSeason or self.__battleRoyaleController.getNextSeason( ) if nextSeason is not None: nextCycle = nextSeason.getNextByTimeCycle(currTime) if nextCycle is not None: cycleNumber = nextCycle.getEpicCycleNumber() timeLeftStr = time_utils.getTillTimeString( nextCycle.startDate - currTime, EPIC_BATTLE.STATUS_TIMELEFT, removeLeadingZeros=True) alertStr = backport.text( rAlertMsgBlock.startIn.single() if nextSeason.isSingleCycleSeason() else rAlertMsgBlock.startIn.multi(), cycle=int2roman(cycleNumber), time=timeLeftStr) if not alertStr: prevSeason = currSeason or self.__battleRoyaleController.getPreviousSeason( ) if prevSeason is not None: prevCycle = prevSeason.getLastActiveCycleInfo(currTime) if prevCycle is not None: cycleNumber = prevCycle.getEpicCycleNumber() alertStr = backport.text( rAlertMsgBlock.noCycleMessage.single() if prevSeason.isSingleCycleSeason() else rAlertMsgBlock.noCycleMessage.multi(), cycle=int2roman(cycleNumber)) return text_styles.vehicleStatusCriticalText(alertStr)
def _getTimeText(self, serverInfo): if serverInfo: timeLeft = serverInfo.getTimeLeft() isAvailable = serverInfo.isAvailable() serverName = serverInfo.getName() else: _, timeLeft, isAvailable = self._getController().getPrimeTimeStatus() serverName = '' currentSeason = self._getController().getCurrentSeason() if currentSeason and not timeLeft: return '' if not timeLeft and not isAvailable and not currentSeason: nextSeason = self._getController().getNextSeason() if nextSeason: currTime = time_utils.getCurrentLocalServerTimestamp() primeTime = self._getController().getPrimeTimes().get(serverInfo.getPeripheryID()) startTime = primeTime.getNextPeriodStart(currTime, nextSeason.getEndDate()) if startTime: timeLeft = startTime - currTime else: self.destroy() return '' timeLeftStr = time_formatters.getTillTimeByResource(timeLeft, R.strings.menu.Time.timeValueShort) if isAvailable: stringR = R.strings.epic_battle.primeTime.primeIsAvailable() else: stringR = R.strings.epic_battle.primeTime.primeWillBeAvailable() return backport.text(stringR, server=serverName, time=text_styles.neutral(timeLeftStr))
def __setAttacksAndDefenses(self): clanID = self.itemData.clanDBID currentUserTime = time_utils.getCurrentLocalServerTimestamp() self.__upcomingAttacks = self.__fort.getAttacks(clanID, lambda item: item.isPlanned()) self.__attacksInCooldown = self.__fort.getAttacks( clanID, lambda item: currentUserTime < item.getStartTime() + fortified_regions.g_cache.attackCooldownTime and item.isEnded(), ) self.__defencesInCooldown = self.__fort.getDefences( clanID, lambda item: currentUserTime > item.getStartTime() and item.isEnded() )
def getDisplayableData(self): return {'name': i18n.makeString(TOOLTIPS.FORTWRONGTIME_HEADER), 'descr': i18n.makeString(TOOLTIPS.FORTWRONGTIME_BODY, local=BigWorld.wg_getShortTimeFormat(time_utils.getCurrentTimestamp()), server=BigWorld.wg_getShortTimeFormat(time_utils.getCurrentLocalServerTimestamp()))}
def __init__(self, ctx): super(FortDatePickerPopover, self).__init__() self.__selectedDate = ctx['data'].timestamp self.__lowerTimeBound = time_utils.getCurrentLocalServerTimestamp() + fortified_regions.g_cache.attackPreorderTime self.__higherTimeBound = self.__lowerTimeBound + (FORTIFICATION_ALIASES.ACTIVE_EVENTS_FUTURE_LIMIT - 1) * time_utils.ONE_DAY
def _getTimeStamp(self): return time_utils.getCurrentLocalServerTimestamp()