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
