def mustShow(self): result = False lastShowTstamp = self.__getShowTimestamp() if not lastShowTstamp or lastShowTstamp < 0: return True else: now = time_utils.getServerUTCTime() if lastShowTstamp > now: return True actions = self.eventsCache.getActions(calendarEnabledActionFilter).values() for action in actions: if action.getFinishTime() < now: continue stepDuration = None for modifier in action.getModifiers(): duration = modifier.getDuration() if modifier else None if duration: stepDuration = min(stepDuration, duration) if stepDuration else duration popupIntervalInHours = self.lobbyContext.getServerSettings().adventCalendar.popupIntervalInHours stepDuration = (stepDuration or popupIntervalInHours) * ONE_HOUR offerChangedTime = now - int(now - action.getStartTime()) % stepDuration wasntVisibleAtAll = not lastShowTstamp or lastShowTstamp > now wasntVisibleCurrentOffer = not wasntVisibleAtAll and lastShowTstamp < offerChangedTime result = wasntVisibleAtAll or wasntVisibleCurrentOffer return result
def __onMatchmakingTimerChanged(self, event): data = event.ctx if data['dtime'] > 0 and data['textid'] in ( TOOLTIPS.STRONGHOLDS_TIMER_SQUADINQUEUE, FORTIFICATIONS. ROSTERINTROWINDOW_INTROVIEW_FORTBATTLES_NEXTTIMEOFBATTLESOON): timerLabel = i18n.makeString(FORTIFICATIONS.BATTLEQUEUE_WAITBATTLE) currentTime = data['dtime'] else: _, unit = self.prbEntity.getUnit() currentTime = 0 if unit: timestamp = unit.getModalTimestamp() if timestamp: currentTime = max( 0, int(time_utils.getServerUTCTime() - timestamp)) if data['isSortie'] or data['isFirstBattle']: timerLabel = i18n.makeString( FORTIFICATIONS.BATTLEQUEUE_SEARCHENEMY) else: timerLabel = i18n.makeString( FORTIFICATIONS.BATTLEQUEUE_WAITBATTLE) timeLabel = '%d:%02d' % divmod(currentTime, 60) self.as_setTimerS(timerLabel, timeLabel) n = len(self.__groups) if n != 0: self.as_hideWaitingS() if self.__startAnimationTime is None: self.__startAnimationTime = time_utils.getCurrentTimestamp() i, r = divmod( int(time_utils.getCurrentTimestamp() - self.__startAnimationTime), self.__animationDuration) if r == 0: self.as_setLeaguesS(self.__groups[i % n]) return
def __doLogin(self, callback): if not LOGIN_STATE.canDoLogin(self.__loginState): callback(self.isLoggedOn()) return LOG_DEBUG('Wgcg gate login processing...') self.__loginState = LOGIN_STATE.LOGGING_IN nextLoginState = LOGIN_STATE.LOGGED_OFF LOG_DEBUG('Requesting spa token...') response = yield self._tokenRequester.request(allowDelay=True) if response and response.isValid(): pDbID = getPlayerDatabaseID() if response.getDatabaseID() == pDbID: LOG_DEBUG('Trying to login to the wgcg lib...') responseTime = time_utils.getServerUTCTime() result = yield self.sendRequest( LogInCtx(pDbID, response.getToken())) if result.isSuccess(): nextLoginState = LOGIN_STATE.LOGGED_ON data = result.getData() self.__accessTokenData = AccessTokenData( data['access_token'], responseTime + float(data['expires_in'])) else: nextLoginState = LOGIN_STATE.LOGGED_OFF else: LOG_WARNING('There is error while getting spa token for wgcg gate', response) self.__loginState = nextLoginState self.__clanSync = False self.__processWaitingRequests() callback(self.isLoggedOn())
def __updateInfo(self, vehicleCD, endTimestamp): oldInfo = self.getInfo() self.__actionInfo = _HeroAdventActionInfo( self.__isByServerSwitchEnabled() and vehicleCD > 0 and endTimestamp > time_utils.getServerUTCTime(), vehicleCD, endTimestamp) if self.__actionInfo != oldInfo: self.__dispatchStateChanged()
def _dispose(self): if self.__tutorStorage is not None: self.__tutorStorage.setValue( GLOBAL_FLAG.BADGE_PAGE_HAS_NEW_SUFFIX_BADGE, False) self.badgesController.onUpdated -= self.__updateBadges AccountSettings.setSettings(LAST_BADGES_VISIT, getServerUTCTime()) super(BadgesPage, self)._dispose() return
def _onLoading(self, *args, **kwargs): super(FunRandomWidgetTooltipView, self)._onLoading(*args, **kwargs) currentSeason = self.__funRandomCtrl.getCurrentSeason() if currentSeason is None: return else: with self.getViewModel().transaction() as model: model.setLeftTime(currentSeason.getEndDate() - time_utils.getServerUTCTime()) return
def __getTimeLeft(self): if self.__notifierState == NotifierStates.ACTIVE_PHASE_FINISH: event = self.__tenYearsCountdown.getActivePhaseDates(self.__blockNumber).finish elif self.__notifierState == NotifierStates.NEXT_ACTIVE_PHASE_START: event = self.__tenYearsCountdown.getActivePhaseDates(self.__blockNumber + 1).start else: event = self.__tenYearsCountdown.getEventFinish() timeLeft = int(event - time_utils.getServerUTCTime()) return max(0, timeLeft)
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 __getCooldownForUpdate(self): currentTime = getServerUTCTime() nearestDate = currentTime + ONE_DAY for entry in self.__entries.itervalues(): if entry.getIsEarlyDate(): nearestDate = min(nearestDate, entry.startDate) nearestDate = min(nearestDate, entry.endDate) return nearestDate - currentTime + _SECONDS_BEFORE_UPDATE
def __init__(self, feature, group, action, level, params): self.feature = str(feature) self.group = str(group) self.action = str(action) self.level = int(level) self.params = dict(params) _time = time_utils.getServerUTCTime() self.time = int(_time) if self.params.pop('__intTime__', False) else _time
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 __getTimeToNotifyUnlockVideo(self): if not self.__videosConfig: return 0 serverVideosIDs = self.__getVideoIndexAndIDFromConfig( self.__videosConfig) for videoIndex in sorted(serverVideosIDs.keys()): video = self.__videosConfig[serverVideosIDs[videoIndex]] if not video.get('is_available'): publicationTime = video.get('condition', {}).get('publication_start', 0) return max(0, publicationTime - time_utils.getServerUTCTime())
def _loadExpiryCallback(self): self._clearExpiryCallback() if self.__invitations: inviteId = min(self.__invitations, key=lambda k: self.__invitations[k]['expiresAt']) invite = self.__invitations[inviteId] expTime = max(invite['expiresAt'] - getServerUTCTime(), 0.0) self.__expCbID = BigWorld.callback( expTime, partial(self.__onInviteExpired, inviteId)) LOG_DEBUG('Invite expiration callback has been loaded', inviteId, expTime)
def getAccessTokenData(self, force=False, callback=None): yield lambda callback: callback(True) timeOut = self.__accessTokenData is None or time_utils.getServerUTCTime( ) > self.__accessTokenData.expiresAt if force or timeOut: if self.__loginState is LOGIN_STATE.LOGGING_IN: self.__accessTokenCallbacks.append(callback) return self.__loginState = LOGIN_STATE.LOGGED_OFF yield self.__doLogin() callback(self.__accessTokenData) return
def _onLoading(self, *args, **kwargs): super(BattlePassNotStartedTooltipView, self)._onLoading(*args, **kwargs) with self.getViewModel().transaction() as model: timeStart = self.__battlePassController.getSeasonStartTime() date = '' if timeStart > time_utils.getServerUTCTime(): sday, smonth = self.__getDayMonth(timeStart) date = backport.text( R.strings.battle_pass_2020.tooltips.notStarted.date(), day=str(sday), month=backport.text( R.strings.menu.dateTime.months.num(smonth)())) model.setDate(date)
def __timerTick(self): timeLeft = int( self.__teaserData.get('finishTime') - time_utils.getServerUTCTime()) if timeLeft > 0: timerStr = time_utils.getTillTimeString( timeLeft, MENU.PROMO_TEASERTIMEFORMAT) if self.__prevTimerValue != timerStr: self.__viewProxy.as_setTeaserTimerS(self.__timeIcon + timerStr) self.__prevTimerValue = timerStr self.__callbackID = BigWorld.callback(self._TIMER_PERIOD, self.__timerTick) else: self.__stopTimer()
def _packBlocks(self, selectedTime): items = [] if self.__isSeasonEnded(selectedTime): return items blocks = [] currentSeason = self.rankedController.getCurrentSeason() if currentSeason: daysLeft = int((currentSeason.getEndDate() - time_utils.getServerUTCTime()) / time_utils.ONE_DAY) seasonName = currentSeason.getUserName() or currentSeason.getNumber() blocks.append(self.__packTimeLeftBlock(seasonName, daysLeft)) blocks.append(self._packHeaderBlock()) blocks += self.__packCalendarBlock(selectedTime) items.append(formatters.packBuildUpBlockData(blocks, 13)) return items
def __updateVideosConfig(self): for video in self.__videosConfig.values(): if not video.get('is_available'): publicationTime = video.get('publication_start') needLevel = video.get('level') needVote = video.get('need_vote') if publicationTime > time_utils.getServerUTCTime(): continue if needLevel > self.__battlePassController.getCurrentLevel(): continue if needVote and not self.__battlePassController.isPlayerVoted( ): continue self.__requestVideoData() break
def onLobbyStarted(self, event): if self.__showOnSplash: lastShowTstamp = self.__getShowTimestamp() now = time_utils.getServerUTCTime() if lastShowTstamp is not None: today = time_utils.getDayTimeBoundsForUTC(now)[0] offset = _START_OF_DAY_OFFSET.get(constants.CURRENT_REALM, timedelta(0)).total_seconds() dayStart = today + offset mustShow = lastShowTstamp < dayStart <= now or lastShowTstamp > now else: mustShow = True if mustShow: self.showCalendar(CalendarInvokeOrigin.SPLASH) self.__setShowTimestamp(now) return
def __getTimeLeft(self): if self.__currentBlock.state == EventBlockStates.NOT_STARTED: event = self.__activePhaseDates[FIRST_BLOCK_NUMBER].start elif self.__currentBlock.state == EventBlockStates.ACTIVE: event = self.__activePhaseDates[self.__currentBlock.number].finish elif self.__currentBlock.number < self.__blocksCount: event = self.__activePhaseDates[self.__currentBlock.number + 1].start elif self.__currentBlock.number == self.__blocksCount and self.__currentBlock.state == EventBlockStates.PASSIVE: event = self.__eventFinish else: return 0 now = time_utils.getServerUTCTime() timeLeft = event - now return max(0, timeLeft)
def __onLeftTimeUpdated(self): leftTime = self.__endTime - time_utils.getServerUTCTime() self.__timeCallbackID = None if leftTime < 0: self.__timeOver() elif leftTime > time_utils.ONE_DAY: self.__setDateLeftTime() self.__startTimer(leftTime - time_utils.ONE_DAY) else: gmTime = time.gmtime(leftTime) if gmTime.tm_min == 0: self.__setShortLeftTime(leftTime) else: self.__setUsageLeftTime(leftTime) self.__startTimer(gmTime.tm_sec + 1) return
def _openWindow(self, url, invokedFrom=None): if self.appLoader.getSpaceID() != GuiGlobalSpaceID.LOBBY: return elif self.__getBrowserView() is not None: return else: try: while self.__browserID is None: browserID = next(_browserIDGen) if self.browserCtrl.getBrowser(browserID) is None: self.__browserID = browserID except StopIteration: _logger.error('Could not allocate a browser ID for calendar') return self.__openBrowser(self.__browserID, url, _BROWSER_SIZE, invokedFrom) self.__setShowTimestamp(time_utils.getServerUTCTime()) _logger.debug('Calendar opened in web browser (browserID=%d)', self.__browserID) return
def __update(self): actions = self.__eventsCache.getActions() eventState = self.__getEventParams(actions, _EVENT_STATE_NAME) try: dateFinishDT = datetime.strptime(eventState.strip(), FORMAT_DATE) self.__dateFinish = calendar.timegm(dateFinishDT.timetuple()) except (AttributeError, TypeError): self.__updateEvent(False) self.__dateFinish = None return currtime = time_utils.getServerUTCTime() eventState = self.__dateFinish > currtime self.__updateEvent(eventState) self.__clearNotifier() if eventState: self.__notifier = SimpleNotifier(self.__getTimeDelta, self.__update) self.__notifier.startNotification() else: self.__dateFinish = None return
def __getCurrentBlock(activePhases, eventFinish): if not activePhases: return else: now = time_utils.getServerUTCTime() if now < activePhases[FIRST_BLOCK_NUMBER].start: _logger.error("Event hasn't started yet.") return _CurrentBlock(FIRST_BLOCK_NUMBER, EventBlockStates.NOT_STARTED) if now >= eventFinish: return _CurrentBlock(5, EventBlockStates.FINISHED) nextBlockNumber = first( (block for block, date in activePhases.iteritems() if date.start > now)) if nextBlockNumber is None: blockNumber = activePhases.keys()[-1] else: blockNumber = nextBlockNumber - 1 blockState = EventBlockStates.ACTIVE if now < activePhases[ blockNumber].finish else EventBlockStates.PASSIVE currentBlock = _CurrentBlock(blockNumber, blockState) return currentBlock
def __getTimeLeft(self): currentSeason = self.__rankedBattleController.getCurrentSeason() return getFormattedTimeLeft( max(0, currentSeason.getEndDate() - time_utils.getServerUTCTime())) if currentSeason else ''
def isSeasonEndingSoon(): battlePassController = dependency.instance(IBattlePassController) return battlePassController.getFinalOfferTime( ) <= time_utils.getServerUTCTime()
def needShowNotification(self): coins = self.getSACoin() notificationShown = AccountSettings.getSessionSettings(SENIORITY_AWARDS_WINDOW_SHOWN) return 0 < self.__endTimestamp - time_utils.getServerUTCTime() < _NOTIFICATION_REMIND_BEFORE_END and coins > 0 and not notificationShown and self.__isEnabled
def getIsEarlyDate(self): return self.startDate > getServerUTCTime()
def getIsExpiredDate(self): return getServerUTCTime() > self.endDate
def getIsValidDateForCreation(self): return self.startDate < getServerUTCTime() < self.endDate