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