def _onMatchmakingTimerChanged(self, event): if self.currentState and self.prbEntity.hasLockedState(): data = event.ctx timerState = data['textid'] if data['dtime'] > 0 and timerState == TOOLTIPS.STRONGHOLDS_TIMER_SQUADINQUEUE: self.as_changeAutoSearchMainLabelS( i18n.makeString( CYBERSPORT.WINDOW_AUTOSEARCH_SEARCHENEMY_MAINTEXT)) self.as_changeAutoSearchCountDownSecondsS(data['dtime']) else: self.as_changeAutoSearchTimeDirectionS(1) _, unit = self.prbEntity.getUnit() startTimer = 0 if unit: timestamp = unit.getModalTimestamp() if timestamp: startTimer = max( 0, int(time_utils.getCurrentTimestamp() - time_utils.makeLocalServerTime(timestamp))) LOG_DEBUG('time direction change, timers: ', time_utils.getCurrentTimestamp(), time_utils.makeLocalServerTime(timestamp)) self.as_changeAutoSearchCountDownSecondsS(startTimer) LOG_DEBUG('changeAutoSearchCountDownSeconds', startTimer) if data['isSortie'] or data['isFirstBattle']: self.as_changeAutoSearchMainLabelS( i18n.makeString( TOOLTIPS.STRONGHOLDS_TIMER_SEARCHENEMY)) else: self.as_changeAutoSearchMainLabelS( i18n.makeString( CYBERSPORT.WINDOW_AUTOSEARCH_SEARCHENEMY_MAINTEXT))
def __systemMessageTimeProcessor(self, actionData): isSystemMessage = CHAT_ACTIONS[actionData['action']] in ( CHAT_ACTIONS.personalSysMessage, CHAT_ACTIONS.sysMessage) if isSystemMessage: if actionData.has_key('data'): messageData = actionData['data'] messageType = messageData['type'] if 'created_at' in messageData: messageData['created_at'] = tm.makeLocalServerDatetime( messageData['created_at']) if 'finished_at' in messageData: messageData['finished_at'] = tm.makeLocalServerDatetime( messageData['finished_at']) if 'started_at' in messageData: messageData['started_at'] = tm.makeLocalServerDatetime( messageData['started_at']) if messageType == SYS_MESSAGE_TYPE.serverReboot.index(): messageData['data'] = tm.makeLocalServerDatetime( messageData['data']) elif messageType == SYS_MESSAGE_TYPE.battleResults.index(): messageData['data'][ 'arenaCreateTime'] = tm.makeLocalServerTime( messageData['data']['arenaCreateTime']) elif messageType == SYS_MESSAGE_TYPE.goldReceived.index(): messageData['data']['date'] = tm.makeLocalServerTime( messageData['data']['date']) elif messageType in ( SYS_MESSAGE_TYPE.accountTypeChanged.index(), SYS_MESSAGE_TYPE.premiumBought.index(), SYS_MESSAGE_TYPE.premiumExtended.index(), SYS_MESSAGE_TYPE.premiumExpired.index()): if 'expiryTime' in messageData['data']: messageData['data'][ 'expiryTime'] = tm.makeLocalServerTime( messageData['data']['expiryTime'])
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 __systemMessageTimeProcessor(self, actionData): isSystemMessage = CHAT_ACTIONS[actionData['action']] in (CHAT_ACTIONS.personalSysMessage, CHAT_ACTIONS.sysMessage) if isSystemMessage: if actionData.has_key('data'): messageData = actionData['data'] messageType = messageData['type'] if 'created_at' in messageData: messageData['created_at'] = tm.makeLocalServerDatetime(messageData['created_at']) if 'finished_at' in messageData: messageData['finished_at'] = tm.makeLocalServerDatetime(messageData['finished_at']) if 'started_at' in messageData: messageData['started_at'] = tm.makeLocalServerDatetime(messageData['started_at']) if messageType == SYS_MESSAGE_TYPE.serverReboot.index(): messageData['data'] = tm.makeLocalServerDatetime(messageData['data']) elif messageType == SYS_MESSAGE_TYPE.battleResults.index(): for value in messageData['data'].itervalues(): value['arenaCreateTime'] = tm.makeLocalServerTime(value['arenaCreateTime']) elif messageType == SYS_MESSAGE_TYPE.goldReceived.index(): messageData['data']['date'] = tm.makeLocalServerTime(messageData['data']['date']) elif messageType in (SYS_MESSAGE_TYPE.accountTypeChanged.index(), SYS_MESSAGE_TYPE.premiumBought.index(), SYS_MESSAGE_TYPE.premiumExtended.index(), SYS_MESSAGE_TYPE.premiumExpired.index()): if 'expiryTime' in messageData['data']: messageData['data']['expiryTime'] = tm.makeLocalServerTime(messageData['data']['expiryTime'])
def __canBuyPremium(self): if self.__isPremiumAccount(): premiumExpiryTime = self._items.stats.premiumExpiryTime else: premiumExpiryTime = 0 deltaInSeconds = float(time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(premiumExpiryTime))) return deltaInSeconds < time_utils.ONE_YEAR
def __setAccountsAttrs(self, isPremiumAccount, premiumExpiryTime = 0): disableTTHeader = '' disableTTBody = '' isNavigationEnabled = True if self.prbDispatcher: isNavigationEnabled = not self.prbDispatcher.getFunctionalState().isNavigationDisabled() if isPremiumAccount: if not premiumExpiryTime > 0: raise AssertionError deltaInSeconds = float(time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(premiumExpiryTime))) if deltaInSeconds > time_utils.ONE_DAY: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_DAY) timeMetric = i18n.makeString('#menu:header/account/premium/days') else: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_HOUR) timeMetric = i18n.makeString('#menu:header/account/premium/hours') buyPremiumLabel = i18n.makeString('#menu:headerButtons/doLabel/premium') premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'premium-account-label', {'timeMetric': timeMetric, 'timeLeft': timeLeft}) canUpdatePremium = deltaInSeconds < time_utils.ONE_YEAR else: canUpdatePremium = True premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'base-account-label') buyPremiumLabel = i18n.makeString('#menu:common/premiumBuy') if not canUpdatePremium: disableTTHeader = i18n.makeString(TOOLTIPS.LOBBY_HEADER_BUYPREMIUMACCOUNT_DISABLED_HEADER) disableTTBody = i18n.makeString(TOOLTIPS.LOBBY_HEADER_BUYPREMIUMACCOUNT_DISABLED_BODY, number=time_utils.ONE_YEAR / time_utils.ONE_DAY) self.as_doDisableHeaderButtonS(self.BUTTONS.PREM, canUpdatePremium and isNavigationEnabled) hasPersonalDiscount = len(g_itemsCache.items.shop.personalPremiumPacketsDiscounts) > 0 tooltip = canUpdatePremium or {'header': disableTTHeader, 'body': disableTTBody} else: tooltip = TOOLTIPS.HEADER_PREMIUM_EXTEND if isPremiumAccount else TOOLTIPS.HEADER_PREMIUM_BUY self.as_setPremiumParamsS(isPremiumAccount, premiumBtnLbl, buyPremiumLabel, canUpdatePremium, disableTTHeader, disableTTBody, hasPersonalDiscount, tooltip, TOOLTIP_TYPES.COMPLEX)
def __populateArenaData(self, commonData, pData): arenaTypeID = commonData.get('arenaTypeID', 0) guiType = commonData.get('guiType', 0) arenaType = ArenaType.g_cache[arenaTypeID] if arenaTypeID > 0 else None if guiType == ARENA_GUI_TYPE.RANDOM: arenaGuiName = ARENA_TYPE.format(arenaType.gameplayName) else: arenaGuiName = ARENA_SPECIAL_TYPE.format(guiType) commonData['arenaStr'] = ARENA_NAME_PATTERN.format(i18n.makeString(arenaType.name), i18n.makeString(arenaGuiName)) createTime = commonData.get('arenaCreateTime') createTime = time_utils.makeLocalServerTime(createTime) commonData['arenaCreateTimeStr'] = BigWorld.wg_getShortDateFormat(createTime) + ' ' + BigWorld.wg_getShortTimeFormat(createTime) commonData['arenaCreateTimeOnlyStr'] = BigWorld.wg_getShortTimeFormat(createTime) commonData['arenaIcon'] = ARENA_SCREEN_FILE.format(arenaType.geometryName) duration = commonData.get('duration', 0) minutes = int(duration / 60) seconds = int(duration % 60) commonData['duration'] = i18n.makeString(TIME_DURATION_STR, minutes, seconds) commonData['playerKilled'] = '-' if pData.get('killerID', 0): lifeTime = pData.get('lifeTime', 0) minutes = int(lifeTime / 60) seconds = int(lifeTime % 60) commonData['playerKilled'] = i18n.makeString(TIME_DURATION_STR, minutes, seconds) commonData['timeStats'] = [] for key in TIME_STATS_KEYS: commonData['timeStats'].append({'label': i18n.makeString(TIME_STATS_KEY_BASE.format(key)), 'value': commonData[key]}) return
def __setAccountsAttrs(self, isPremiumAccount, premiumExpiryTime=0): if not (isPremiumAccount and premiumExpiryTime > 0): raise AssertionError deltaInSeconds = float( time_utils.getTimeDeltaFromNow( time_utils.makeLocalServerTime(premiumExpiryTime))) if deltaInSeconds > time_utils.ONE_DAY: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_DAY) timeMetric = i18n.makeString( '#menu:header/account/premium/days') else: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_HOUR) timeMetric = i18n.makeString( '#menu:header/account/premium/hours') premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'premium-account-label', { 'timeMetric': timeMetric, 'timeLeft': timeLeft }) canUpdatePremium = deltaInSeconds < time_utils.ONE_YEAR buyPremiumLabel = self._getPremiumLabelText(True, canUpdatePremium) else: canUpdatePremium = True premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'base-account-label') buyPremiumLabel = self._getPremiumLabelText(False, False) hasPersonalDiscount = self.__hasPremiumPacketDiscount() tooltip = self._getPremiumTooltipText(isPremiumAccount, canUpdatePremium) self.as_setPremiumParamsS(premiumBtnLbl, buyPremiumLabel, hasPersonalDiscount, tooltip, TOOLTIP_TYPES.COMPLEX)
def __canBuyPremium(self): if self.__isPremiumAccount(): premiumExpiryTime = self.itemsCache.items.stats.premiumExpiryTime else: premiumExpiryTime = 0 deltaInSeconds = float(time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(premiumExpiryTime))) return deltaInSeconds < time_utils.ONE_YEAR
def __setAccountsAttrs(self, isPremiumAccount, premiumExpiryTime = 0): disableTTHeader = '' disableTTBody = '' if isPremiumAccount: if not premiumExpiryTime > 0: raise AssertionError deltaInSeconds = float(time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(premiumExpiryTime))) if deltaInSeconds > time_utils.ONE_DAY: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_DAY) timeMetric = i18n.makeString('#menu:header/account/premium/days') else: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_HOUR) timeMetric = i18n.makeString('#menu:header/account/premium/hours') buyPremiumLabel = i18n.makeString('#menu:headerButtons/doLabel/premium') premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'premium-account-label', {'timeMetric': timeMetric, 'timeLeft': timeLeft}) canUpdatePremium = deltaInSeconds < time_utils.ONE_YEAR else: canUpdatePremium = True premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'base-account-label') buyPremiumLabel = i18n.makeString('#menu:common/premiumBuy') disableTTHeader = canUpdatePremium or i18n.makeString(TOOLTIPS.LOBBY_HEADER_BUYPREMIUMACCOUNT_DISABLED_HEADER) disableTTBody = i18n.makeString(TOOLTIPS.LOBBY_HEADER_BUYPREMIUMACCOUNT_DISABLED_BODY, number=time_utils.ONE_YEAR / time_utils.ONE_DAY) self.as_doDisableHeaderButtonS(self.BUTTONS.PREM, canUpdatePremium) self.as_setPremiumParamsS(isPremiumAccount, premiumBtnLbl, buyPremiumLabel, canUpdatePremium, disableTTHeader, disableTTBody)
def __makePeripheryData(self): fort = self.fortCtrl.getFort() optionsList = g_preDefinedHosts.getSimpleHostsList(g_preDefinedHosts.hostsWithRoaming()) servername = None for key, name, csisStatus, peripheryID in optionsList: if fort.peripheryID == peripheryID: servername = name if servername is None: servername = connectionManager.serverUserName _, inCooldown = fort.getPeripheryProcessing() timestamp, _, _ = fort.events.get(FORT_EVENT_TYPE.PERIPHERY_COOLDOWN, (0, 0, 0)) buttonEnabled = not inCooldown buttonToolTip = self.__makePeripheryBtnToolTip( buttonEnabled, time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(timestamp)) ) descriptionTooltip = TOOLTIPS.FORTIFICATION_FORTSETTINGSWINDOW_PERIPHERYDESCRIPTION if self._isFortFrozen(): peripheryName = text_styles.standard(str(servername)) else: peripheryName = text_styles.neutral(str(servername)) return { "peripheryTitle": text_styles.main(i18n.makeString(FORTIFICATIONS.SETTINGSWINDOW_PEREPHERYTITLE)), "peripheryName": peripheryName, "buttonEnabled": buttonEnabled, "buttonToolTip": buttonToolTip, "descriptionTooltip": descriptionTooltip, }
def getStartTimeLeft(startTime): if startTime: startTime = makeLocalServerTime(startTime) if datetime.utcfromtimestamp(startTime) > datetime.utcnow(): return (datetime.utcfromtimestamp(startTime) - datetime.utcnow()).seconds return 0
def format(self, message, callback): isSynced = yield self._waitForSyncItems() formatted, settings = (None, None) if isSynced: data = message.data or {} completedQuestIDs = self.getQuestOfThisGroup( data.get('completedQuestIDs', set())) questsData = getRewardsForQuests( message, self.getQuestOfThisGroup(completedQuestIDs)) questsData['popUpRecords'] = self.getPopUps(message) fmt = self._achievesFormatter.formatQuestAchieves( questsData, asBattleFormatter=False) if fmt is not None: operationTime = message.sentTime if operationTime: fDatetime = TimeFormatter.getLongDatetimeFormat( time_utils.makeLocalServerTime(operationTime)) else: fDatetime = 'N/A' formatted = g_settings.msgTemplates.format( self.__TEMPLATE_NAME, ctx={ 'at': fDatetime, 'desc': '', 'op': fmt }) settings = self._getGuiSettings(message, self.__TEMPLATE_NAME) callback([MessageData(formatted, settings)]) return
class PrbInviteWrapper(_PrbInviteData): @staticmethod def __new__(cls, id=-1L, createTime=None, type=0, comment=str(), creator=str(), creatorDBID=-1L, creatorClanAbbrev=None, receiver=str(), receiverDBID=-1L, receiverClanAbbrev=None, state=None, count=0, peripheryID=0, **kwargs): if createTime is not None: createTime = time_utils.makeLocalServerTime(createTime) result = _PrbInviteData.__new__(cls, id, createTime, type, comment, creator, creatorDBID, creatorClanAbbrev, receiver, receiverDBID, receiverClanAbbrev, state, count, peripheryID) return result
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 handleLoginRejectedBan(self, status, message): try: LOG_DEBUG('handleLoginRejectedBan', message) msg_dict = json.loads(message) if not isinstance(msg_dict, dict): self.handleLoginCustomDefinedError(status, message) return self.__loginDataLoader.token2 = msg_dict.get('token2', '') self.__loginDataLoader.saveUserToken(self.__loginDataLoader.passLength, self.__loginDataLoader.token2) json_dict = msg_dict.get('bans') msg_dict = json.loads(json_dict) except Exception: LOG_CURRENT_EXCEPTION() self.handleLoginCustomDefinedError(status, message) return expiryTime = 0 reason = '' if isinstance(msg_dict, dict): expiryTime = int(msg_dict.get('expiryTime', 0)) reason = i18n.encodeUtf8(msg_dict.get('reason', '')) if reason == BAN_REASON.CHINA_MIGRATION: self.__handleMigrationNeeded() if reason.startswith('#'): reason = i18n.makeString(reason) if expiryTime > 0: expiryTime = makeLocalServerTime(expiryTime) expiryTime = BigWorld.wg_getLongDateFormat(expiryTime) + ' ' + BigWorld.wg_getLongTimeFormat(expiryTime) errorMessage = i18n.makeString(MENU.LOGIN_STATUS_LOGIN_REJECTED_BAN, time=expiryTime, reason=reason) else: errorMessage = i18n.makeString(MENU.LOGIN_STATUS_LOGIN_REJECTED_BAN_UNLIMITED, reason=reason) self.onSetStatus(errorMessage, self.ALL_VALID)
def __setAccountsAttrs(self, isPremiumAccount, premiumExpiryTime = 0): if isPremiumAccount: if not premiumExpiryTime > 0: raise AssertionError deltaInSeconds = float(time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(premiumExpiryTime))) if deltaInSeconds > time_utils.ONE_DAY: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_DAY) timeMetric = i18n.makeString('#menu:header/account/premium/days') else: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_HOUR) timeMetric = i18n.makeString('#menu:header/account/premium/hours') premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'premium-account-label', {'timeMetric': timeMetric, 'timeLeft': timeLeft}) canUpdatePremium = deltaInSeconds < time_utils.ONE_YEAR buyPremiumLabel = '' if canUpdatePremium: buyPremiumLabel = i18n.makeString('#menu:headerButtons/doLabel/premium') else: canUpdatePremium = True premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'base-account-label') buyPremiumLabel = i18n.makeString('#menu:common/premiumBuy') hasPersonalDiscount = len(g_itemsCache.items.shop.personalPremiumPacketsDiscounts) > 0 tooltip = canUpdatePremium or formatters.getLimitExceededPremiumTooltip() elif isPremiumAccount: tooltip = TOOLTIPS.HEADER_PREMIUM_EXTEND else: tooltip = TOOLTIPS.HEADER_PREMIUM_BUY self.as_setPremiumParamsS(premiumBtnLbl, buyPremiumLabel, hasPersonalDiscount, tooltip, TOOLTIP_TYPES.COMPLEX)
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 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 getVisibilityTime(self): tm = None invite = self.getEntity() if not invite.isActive() and invite.getUpdatingTime() is not None: tm = time_utils.makeLocalServerTime( invite.getUpdatingTime() + _CLUB_INVITE_VISIBILITY_INTERVAL) return tm
def getTimeLeft(self): if self.rentExpiryTime != float('inf'): expiryTime = max(self.rentExpiryTime, self._getSeasonExpiryTime()) return float( time_utils.getTimeDeltaFromNow( time_utils.makeLocalServerTime(expiryTime))) return float('inf')
def __getRankedOverrides(self, quest): header = body = '' isLeagues = self.__rankedController.isAccountMastered() isAnyPrimeNow = self.__rankedController.hasAvailablePrimeTimeServers() isAnyPrimeLeftTotal = self.__rankedController.hasPrimeTimesTotalLeft() isAnyPrimeLeftNext = self.__rankedController.hasPrimeTimesNextDayLeft() if not isAnyPrimeLeftTotal or not isAnyPrimeLeftNext and quest.isCompleted() and quest.bonusCond.isDaily(): header = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.header.seasonEnd()) body = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.body.seasonEnd.default()) season = self.__rankedController.getCurrentSeason() if season is not None: seasonEnd = time_utils.getTimeDeltaFromNowInLocal(time_utils.makeLocalServerTime(season.getEndDate())) timeRes = R.strings.ranked_battles.quests.tooltip.unavailable.body.seasonEnd body = backport.getTillTimeStringByRClass(seasonEnd, timeRes) elif not isLeagues: header = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.header.notInLeagues()) body = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.body.notInLeagues()) elif not isAnyPrimeNow: header = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.header.allServersPrime()) body = backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.body.allServersPrime()) if body and header: body = text_styles.main(body) bullet = backport.text(R.strings.tooltips.quests.unavailable.bullet()) return [formatters.packTextBlockData(text=text_styles.highTitle(header)), formatters.packBuildUpBlockData(self.__getList([{'text': body, 'bullet': bullet}]), linkage=BLOCKS_TOOLTIP_TYPES.TOOLTIP_BUILDUP_BLOCK_WHITE_BG_LINKAGE), self.__getBootom(backport.text(R.strings.ranked_battles.quests.tooltip.unavailable.bottom()))] else: return []
def getProductionCooldown(self): productionTime = self.orderInProduction.get('timeFinish') if productionTime: return time_utils.getTimeDeltaFromNow( time_utils.makeLocalServerTime(productionTime)) else: return 0
def __setAccountsAttrs(self, isPremiumAccount, premiumExpiryTime = 0): disableTTHeader = '' disableTTBody = '' if isPremiumAccount: assert premiumExpiryTime > 0 deltaInSeconds = float(time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(premiumExpiryTime))) if deltaInSeconds > time_utils.ONE_DAY: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_DAY) timeMetric = i18n.makeString('#menu:header/account/premium/days') else: timeLeft = math.ceil(deltaInSeconds / time_utils.ONE_HOUR) timeMetric = i18n.makeString('#menu:header/account/premium/hours') buyPremiumLabel = i18n.makeString('#menu:headerButtons/doLabel/premium') premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'premium-account-label', {'timeMetric': timeMetric, 'timeLeft': timeLeft}) canUpdatePremium = deltaInSeconds < time_utils.ONE_YEAR else: canUpdatePremium = True premiumBtnLbl = makeHtmlString('html_templates:lobby/header', 'base-account-label') buyPremiumLabel = i18n.makeString('#menu:common/premiumBuy') if not canUpdatePremium: disableTTHeader = i18n.makeString(TOOLTIPS.LOBBY_HEADER_BUYPREMIUMACCOUNT_DISABLED_HEADER) disableTTBody = i18n.makeString(TOOLTIPS.LOBBY_HEADER_BUYPREMIUMACCOUNT_DISABLED_BODY, number=time_utils.ONE_YEAR / time_utils.ONE_DAY) self.as_doDisableHeaderButtonS(self.BUTTONS.PREM, canUpdatePremium) hasPersonalDiscount = len(g_itemsCache.items.shop.personalPremiumPacketsDiscounts) > 0 if not canUpdatePremium: tooltip = {'header': disableTTHeader, 'body': disableTTBody} else: tooltip = TOOLTIPS.HEADER_PREMIUM_EXTEND if isPremiumAccount else TOOLTIPS.HEADER_PREMIUM_BUY self.as_setPremiumParamsS(isPremiumAccount, premiumBtnLbl, buyPremiumLabel, canUpdatePremium, disableTTHeader, disableTTBody, hasPersonalDiscount, tooltip, TOOLTIP_TYPES.COMPLEX)
def fetchCurrentItem(self, vehDescr): if vehDescr is not None: self.updateSlotsPosition(vehDescr) inscription = vehDescr.playerInscriptions[self.getRealPosition()] if inscription is not None and inscription[0] is not None: self._currentItemID, startTime, days, _ = inscription startTime = time_utils.makeLocalServerTime(startTime) self._currentLifeCycle = (startTime, days)
def getAcceptDelta(self, acceptDeadlineUTC): if acceptDeadlineUTC: return max( 0, int( time_utils.makeLocalServerTime(acceptDeadlineUTC) - time.time())) return 0
def _makeLocalTimeString(cls, value, formatter): result = time_utils.makeLocalServerTime(value) if result: result = formatter(value) else: _logger.warning('Timestamp is not defined: %r', value) result = '' return result
def __canUpdatePremium(self): if self.__isPremiumAccount(): deltaInSeconds = float( time_utils.getTimeDeltaFromNow( time_utils.makeLocalServerTime( self._items.stats.premiumExpiryTime))) return deltaInSeconds < time_utils.ONE_YEAR return True
def _makeLocalTimeString(cls, value, formatter): result = time_utils.makeLocalServerTime(value) if result: result = formatter(value) else: LOG_WARNING('Timestamp is not defined', value) result = '' return result
def _getPremiumLabelText(self, timeDelta): if settings.main[PREMIUM.PREMIUM_TIME]: delta = float(getTimeDeltaFromNow(makeLocalServerTime(timeDelta))) self.macros["days"], delta = divmod(delta, ONE_DAY) self.macros["hours"], delta = divmod(delta, ONE_HOUR) self.macros["minutes"], self.macros["seconds"] = divmod( delta, ONE_MINUTE) return settings.main[PREMIUM.PREMIUM_FORMAT] % self.macros
def start(self, ctx): serverTime = ctx.get('aogasStartedAt') if serverTime is not None: self.__aogasStartedAt = time_utils.makeLocalServerTime(serverTime) else: self.__aogasStartedAt = time.time() self.__isAogasEnabled = ctx.get('isAogasEnabled', True) if not self.__notificator.isStarted(): self.__requestRequiredInfo()
def onLobbyStarted(self, ctx): serverTime = ctx.get('aogasStartedAt') if serverTime is not None: self.__aogasStartedAt = time_utils.makeLocalServerTime(serverTime) else: self.__aogasStartedAt = time.time() self.__isAogasEnabled = ctx.get('isAogasEnabled', True) if not self.__notificator.isStarted(): self.__requestRequiredInfo()
def __getTimeGone(self): """ Get time gone in seconds from last operation (restore operation for notInShop vehicles or sell operation for regular premium vehicles) :return: <int> """ if self.changedAt: return float(time_utils.getTimeDeltaTilNow(time_utils.makeLocalServerTime(self.changedAt))) return 0
def getAcceptDelta(self, acceptDeadlineUTC): """ Get acceptance time delta Args: acceptDeadlineUTC: time when approval expires """ if acceptDeadlineUTC: return max(0, int(time_utils.makeLocalServerTime(acceptDeadlineUTC) - time.time())) return 0
def fetchCurrentItem(self, vehDescr): if vehDescr is not None: self.updateSlotsPosition(vehDescr) self.defaultPlayerEmblemID = vehDescr.type.defaultPlayerEmblemID emblem = vehDescr.playerEmblems[self.getRealPosition()] if emblem is not None: self._currentItemID, startTime, days = emblem startTime = time_utils.makeLocalServerTime(startTime) self._currentLifeCycle = (startTime, days)
def __updateEventTime(self, model=None): model.setEndDate(round(time_utils.makeLocalServerTime(self.__resourceWell.getFinishTime()), -1)) isEventEnding = isEventEndingsSoon(resourceWell=self.__resourceWell) model.setIsEventEndingSoon(isEventEnding) model.setTimeLeft(self.__resourceWell.getFinishTime() - time_utils.getServerUTCTime()) if isEventEnding: self.__notifier.stopNotification() else: self.__notifier.startNotification()
def fetchCurrentItem(self, vehDescr): if vehDescr is not None: camouflages = vehDescr.camouflages if camouflages is not None: for camouflage in camouflages: itemId, startTime, days = camouflage if itemId is not None: lifeCycle = None if itemId is None else (time_utils.makeLocalServerTime(startTime), days) camouflageObject = self._itemsDP.getCamouflageDescr(itemId) self.setCurrentItem(camouflageObject.get('kind'), itemId, lifeCycle, None, self._rentalPackageDP.getIndexByDays(days, self._itemsDP.isIGRItem(itemId)))
def __packMainBlock(self): header = backport.text(R.strings.tooltips.battleTypes.battleRoyale.header()) body = backport.text(R.strings.tooltips.battleTypes.battleRoyale.body2()) currentCycleInfo = self._battleController.getCurrentCycleInfo() if currentCycleInfo[1]: timeLeft = time_utils.getTimeDeltaFromNow(time_utils.makeLocalServerTime(currentCycleInfo[0])) scheduleStr = ' '.join((backport.text(R.strings.tooltips.battleTypes.battleRoyale.tillEnd()), backport.getTillTimeStringByRClass(timeLeft, R.strings.menu.headerButtons.battle.types.ranked.availability))) body = '{}\n\n\n{}'.format(scheduleStr, backport.text(R.strings.tooltips.battleTypes.battleRoyale.body2())) background = backport.image(R.images.gui.maps.icons.battleRoyale.backgrounds.widget_tooltip_background()) return formatters.packImageTextBlockData(title=text_styles.middleTitle(header), txtPadding=formatters.packPadding(top=16, left=20), desc=text_styles.main(body), descPadding=formatters.packPadding(top=16, left=20), txtOffset=1, txtGap=-1, img=background)
def __fillEventTime(self, model=None): model.setEndDate( round( time_utils.makeLocalServerTime( self.__resourceWell.getFinishTime()), -1)) isEventEnding = isEventEndingsSoon(resourceWell=self.__resourceWell) model.setIsEventEndingSoon(isEventEnding) if isEventEnding: model.setTimeLeft(self.__resourceWell.getFinishTime() - time_utils.getServerUTCTime())
def createBroadcastError(args, broadcastID): errorID = args['int32Arg1'] if not _ACTIONS.isRateLimitedBroadcastFromClient(broadcastID): raise AssertionError error = errorID == _ERRORS.IN_CHAT_BAN and ChatBanError(makeLocalServerTime(args['floatArg1']), args['strArg1']) elif errorID == _ERRORS.IN_COOLDOWN: error = _ActionCoolDownError(broadcastID, _LIMITS.BROADCASTS_FROM_CLIENT_COOLDOWN_SEC) else: error = _SimpleActionError(broadcastID, errorID) return error
def _merge(self, other): data = {} if other.createTime is not None: data['createTime'] = time_utils.makeLocalServerTime(other.createTime) if other.state > 0: data['state'] = other.state if other.count > 0: data['count'] = other.count if len(other.comment): data['comment'] = other.comment return self._replace(**data)
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/chatbannedpermanent', **banInfo) else: banInfo['banEndTime'] = BigWorld.wg_getLongDateFormat(banEndTime) + ' ' + BigWorld.wg_getShortTimeFormat(banEndTime) bannedMessage = i18n.makeString('#chat:errors/chatbanned', **banInfo) return ChatBannedError(cls._makeTitle('chatBanned'), bannedMessage, isModal=True)
def __init__(self, floatArg1 = 0, int32Arg1 = False, int64Arg1 = 0, strArg1 = '', **kwargs): super(_MessageVO, self).__init__() self.accountDBID = int64Arg1 if isinstance(strArg1, types.UnicodeType): self.text = strArg1 else: self.text = unicode(strArg1, 'utf-8', errors='ignore') if floatArg1 > 0: self.sentAt = makeLocalServerTime(floatArg1) else: self.sentAt = 0
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' % (BigWorld.wg_getLongDateFormat(expiryTime), BigWorld.wg_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 __startPremiumTimeNotifyCallback(self): self.__clearPremiumTimeNotifyCallback() premiumTime = time_utils.makeLocalServerTime(g_itemsCache.items.stats.premiumExpiryTime) delta = time_utils.getTimeDeltaFromNow(premiumTime) if delta > time_utils.ONE_DAY: period = time_utils.ONE_DAY elif delta > time_utils.ONE_HOUR: period = time_utils.ONE_HOUR else: return nextNotification = delta % period or period self.__premiumTimeCallback = BigWorld.callback(nextNotification, self.__notifyPremiumTime)
def update(self, vehicleDescr): inscription = vehicleDescr.playerInscriptions[self.getRealPosition()] inscriptionID = inscription[0] if inscription is not None else None if inscriptionID != self._currentItemID: self._currentItemID = inscriptionID self._itemsDP.currentItemID = self._currentItemID if inscription is not None: _, startTime, days, colorId = inscription startTime = time_utils.makeLocalServerTime(startTime) self._currentLifeCycle = (startTime, days) else: self._currentLifeCycle = None self.onCurrentItemChange(self._name)
def update(self, vehicleDescr): emblem = vehicleDescr.playerEmblems[self.getRealPosition()] emblemID = emblem[0] if emblem is not None else None if emblemID != self._currentItemID: self._currentItemID = emblemID self._itemsDP.currentItemID = self._currentItemID if emblem is not None: _, startTime, days = emblem startTime = time_utils.makeLocalServerTime(startTime) self._currentLifeCycle = (startTime, days) else: self._currentLifeCycle = None self.onCurrentItemChange(self._name)
def __init__(self, prbID, type = PREBATTLE_TYPE.CLAN, peripheryID = 0, description = None, startTime = 0, isValid = True): super(AutoInviteItem, self).__init__() self.prbID = prbID self.peripheryID = peripheryID self.prbType = type if description: self.description = description else: self.description = {} if startTime > 0: self.startTime = makeLocalServerTime(startTime) else: self.startTime = time.time() self.isValid = isValid
def show(self, reason = None, isBan = None, expiryTime = None): Waiting.close() g_cursorDelegator.syncMousePosition(self, None, None) params = {'reason': '', 'expiryTime': ''} if reason: params['reason'] = makeString('#dialogs:disconnected/reason', makeString(reason)) if expiryTime: from helpers.time_utils import makeLocalServerTime expiryTime = makeLocalServerTime(int(expiryTime)) params['expiryTime'] = BigWorld.wg_getLongDateFormat(expiryTime) + ' ' + BigWorld.wg_getLongTimeFormat(expiryTime) message = 'messageKick' if not isBan else 'messageBanPeriod' if expiryTime else 'messageBan' message = makeString('#dialogs:disconnected/' + message) % params self.setMovieVariable('_root._level0.setMessage', [message])
def __loginRejectedBan(self, responseData): bansJSON = responseData.get('bans') bans = json.loads(bansJSON) expiryTime = int(bans.get('expiryTime', '0')) reason = bans.get('reason', '') if reason == BAN_REASON.CHINA_MIGRATION: g_eventBus.handleEvent(OpenLinkEvent(OpenLinkEvent.MIGRATION)) if reason.startswith('#'): reason = _ms(reason) if expiryTime > 0: expiryTime = makeLocalServerTime(expiryTime) expiryTime = BigWorld.wg_getLongDateFormat(expiryTime) + ' ' + BigWorld.wg_getLongTimeFormat(expiryTime) self.as_setErrorMessageS(_ms(MENU.LOGIN_STATUS_LOGIN_REJECTED_BAN, time=expiryTime, reason=reason), INVALID_FIELDS.ALL_VALID) else: self.as_setErrorMessageS(_ms(MENU.LOGIN_STATUS_LOGIN_REJECTED_BAN_UNLIMITED, reason=reason), INVALID_FIELDS.ALL_VALID)
def fetchCurrentItem(self, vehDescr): if vehDescr is not None: self._vehicleLevel = vehDescr.type.level slotsCount = self.getSlotsCount(vehDescr.turret, 'inscription') self.isTurret = slotsCount > self._position if self._position == 1 and slotsCount == 1: self._positionShift = 1 if not self.isTurret: slotsCount += self.getSlotsCount(vehDescr.hull, 'inscription') self._isEnabled = slotsCount > self._position inscription = vehDescr.playerInscriptions[self.getRealPosition()] if inscription is not None and inscription[0] is not None: self._currentItemID, startTime, days, _ = inscription startTime = time_utils.makeLocalServerTime(startTime) self._currentLifeCycle = (startTime, days) return
def _merge(self, other): data = {} if other.creator: data['creator'] = other.creator if other.creatorDBID > 0L: data['creatorDBID'] = other.creatorDBID if other.creatorClanAbbrev: data['creatorClanAbbrev'] = other.creatorClanAbbrev if other.createTime is not None: data['createTime'] = time_utils.makeLocalServerTime(other.createTime) if other.state > 0: data['state'] = other.state if other.count > 0: data['count'] = other.count if len(other.comment) or other.isActive(): data['comment'] = other.comment return self._replaceEx(**data)
def fetchCurrentItem(self, vehDescr): if vehDescr is not None: self._vehicleLevel = vehDescr.type.level slotsCount = self.getSlotsCount(vehDescr.turret, "player") self.isTurret = slotsCount > self._position if self._position == 1 and slotsCount == 1: self._positionShift = 1 if not self.isTurret: slotsCount += self.getSlotsCount(vehDescr.hull, "player") self._isEnabled = slotsCount > self._position self.defaultPlayerEmblemID = vehDescr.type.defaultPlayerEmblemID emblem = vehDescr.playerEmblems[self.getRealPosition()] if emblem is not None: self._currentItemID, startTime, days = emblem startTime = time_utils.makeLocalServerTime(startTime) self._currentLifeCycle = (startTime, days) return
def update(self, vehicleDescr): camouflages = vehicleDescr.camouflages isUpdated = False for index, camouflage in enumerate(camouflages): camouflageID = camouflage[0] if camouflage is not None else None item = self.currentItemsByKind[index] if camouflageID != item.get('id'): isUpdated = True item['id'] = camouflageID if camouflage is not None: _, startTime, days = camouflage startTime = time_utils.makeLocalServerTime(startTime) item['lifeCycle'] = (startTime, days) else: item['lifeCycle'] = None if CAMOUFLAGE_KINDS.get(self._itemsDP.currentGroup) == index: self._itemsDP.currentItemID = item['id'] if isUpdated: self.onCurrentItemChange(self._name)
def setAccountsAttrs(self, attrs, premiumExpiryTime = 0): if not GUI_SETTINGS.goldTransfer and attrs & constants.ACCOUNT_ATTR.TRADING: attrs ^= constants.ACCOUNT_ATTR.TRADING isPremiumAccount = account_helpers.isPremiumAccount(attrs) if g_hangarSpace.inited: g_hangarSpace.refreshSpace(isPremiumAccount) self.as_setProfileTypeS(makeHtmlString('html_templates:lobby/header', 'premium-account-label' if isPremiumAccount else 'base-account-label')) if not (isPremiumAccount and premiumExpiryTime > 0): raise AssertionError lExpiryTime = makeLocalServerTime(premiumExpiryTime) delta = datetime.datetime.utcfromtimestamp(lExpiryTime) - datetime.datetime.utcnow() if delta.days > 0: timeLeft = delta.days + 1 if delta.seconds > 0 else delta.days timeMetric = makeString('#menu:header/account/premium/days') elif not delta.days: import math timeLeft = math.ceil(delta.seconds / 3600.0) timeMetric = makeString('#menu:header/account/premium/hours') else: LOG_ERROR('timedelta with negative days', premiumExpiryTime, delta) return self.as_setPremiumParamsS(makeHtmlString('html_templates:lobby/header', 'premium-time-label', {'timeMetric': timeMetric, 'timeLeft': timeLeft}), makeString('#menu:common/premiumContinue'), delta.days > 360) self.as_premiumResponseS(isPremiumAccount)