def _populate(self):
super(SwitchPeripheryWindow, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_setImageS(RES_ICONS.MAPS_ICONS_WINDOWS_SWITCH_PERIPHERY_WINDOW_BG, 0)
self.as_setWindowTitleS(_ms(DIALOGS.SWITCHPERIPHERYWINDOW_WINDOWTITLE))
currentServer = self.connectionMgr.serverUserName
self.as_setTextS(_ms(self.__ctx.getHeader()), _ms(self.__ctx.getDescription(), server=text_styles.error(currentServer)))
self.addNotificator(SimpleNotifier(self.__ctx.getUpdateTime, self.__onServersUpdate))
self.startNotification()
self._updateServersList()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
self.as_setButtonsS([{'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNSWITCH),
'btnLinkage': BUTTON_LINKAGES.BUTTON_NORMAL,
'action': self._SWITCH_BTN_ACTION,
'isFocused': True,
'tooltip': ''}, {'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNCANCEL),
'btnLinkage': BUTTON_LINKAGES.BUTTON_BLACK,
'action': self._CLOSE_BTN_ACTION,
'isFocused': False,
'tooltip': ''}], TEXT_ALIGN.RIGHT, self._BTN_WIDTH)
def _populate(self):
super(ServerStats, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
if constants.IS_SHOW_SERVER_STATS:
self._updateCurrentServerInfo()
self._updateServersList()
self._updateRoamingCtrl()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
game_control.g_instance.serverStats.onStatsReceived += self.__onStatsReceived
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self._updateRoamingCtrl, scope=EVENT_BUS_SCOPE.LOBBY)
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
self.connectionMgr.onRejected += self._onLoginRejected
self.connectionMgr.onKickWhileLoginReceived += self._onKickedWhileLogin
self.connectionMgr.onQueued += self._onHandleQueue
self.connectionMgr.onLoggedOn += self._onLoggedOn
g_playerEvents.onAccountShowGUI += self._clearLoginView
g_playerEvents.onEntityCheckOutEnqueued += self._onEntityCheckoutEnqueued
g_playerEvents.onAccountBecomeNonPlayer += self._onAccountBecomeNonPlayer
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
self.sessionProvider.getCtx().lastArenaUniqueID = None
self._loginMode.init()
self.update()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.0, self.__checkUserInputState)
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
ScaleformFileLoader.enableStreaming(
[getPathForFlash(_LOGIN_VIDEO_FILE)])
self.__backgroundMode.show()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(
0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
if BigWorld.isLowProductivityPC():
self._showOnlyStaticBackground()
else:
self._showBackground()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(
0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
super(ServerStats, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
if constants.IS_SHOW_SERVER_STATS:
self._updateCurrentServerInfo()
self._updateServersList()
self._updateRoamingCtrl()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
game_control.g_instance.serverStats.onStatsReceived += self.__onStatsReceived
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self._updateRoamingCtrl, scope=EVENT_BUS_SCOPE.LOBBY)
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
g_playerEvents.onLoginQueueNumberReceived += self._onHandleQueue
g_playerEvents.onKickWhileLoginReceived += self._onKickedWhileLogin
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
self.__loadRandomBgImage()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
ScaleformFileLoader.enableStreaming([getPathForFlash(_LOGIN_VIDEO_FILE)])
self.__backgroundMode.show()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _populate(self):
super(SwitchPeripheryWindow, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_setImageS(RES_ICONS.MAPS_ICONS_WINDOWS_SWITCH_PERIPHERY_WINDOW_BG, 0)
self.as_setWindowTitleS(_ms(DIALOGS.SWITCHPERIPHERYWINDOW_WINDOWTITLE))
currentServer = connectionManager.serverUserName
self.as_setTextS(_ms(self.__ctx.getHeader()), _ms(self.__ctx.getDescription(), server=text_styles.error(currentServer)))
self._updateServersList()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
self.as_setButtonsS([{'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNSWITCH),
'btnLinkage': BUTTON_LINKAGES.BUTTON_NORMAL,
'action': self._SWITCH_BTN_ACTION,
'isFocused': True,
'tooltip': ''}, {'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNCANCEL),
'btnLinkage': BUTTON_LINKAGES.BUTTON_BLACK,
'action': self._CLOSE_BTN_ACTION,
'isFocused': False,
'tooltip': ''}], TEXT_ALIGN.RIGHT, self._BTN_WIDTH)
class LoginView(LoginPageMeta):
loginManager = dependency.descriptor(ILoginManager)
connectionMgr = dependency.descriptor(IConnectionManager)
sessionProvider = dependency.descriptor(IBattleSessionProvider)
statsCollector = dependency.descriptor(IStatisticsCollector)
def __init__(self, ctx=None):
LoginPageMeta.__init__(self, ctx=ctx)
self.__isListInitialized = False
self.__loginRetryDialogShown = False
self.__loginQueueDialogShown = False
self.__capsLockState = None
self.__lang = None
self.__capsLockCallbackID = None
self.__customLoginStatus = None
self._autoSearchVisited = False
self._entityEnqueueCancelCallback = None
self._servers = self.loginManager.servers
self.loginManager.servers.updateServerList()
self._loginMode = createLoginMode(self)
return
def onRegister(self, host):
self.fireEvent(OpenLinkEvent(OpenLinkEvent.REGISTRATION))
def onSetRememberPassword(self, rememberUser):
self._loginMode.setRememberPassword(rememberUser)
def onLogin(self, userName, password, serverName, isSocialToken2Login):
self._loginMode.doLogin(userName, password, serverName, isSocialToken2Login)
def _onLoggedOn(self, *args):
self.statsCollector.noteHangarLoadingState(HANGAR_LOADING_STATE.LOGIN, True)
self.statsCollector.needCollectSystemData(True)
selectedServer = self._servers.selectedServer
self._autoSearchVisited = selectedServer['data'] == AUTO_LOGIN_QUERY_URL if selectedServer is not None else False
self.__customLoginStatus = None
return
def resetToken(self):
self._loginMode.resetToken()
def showLegal(self):
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.LEGAL_INFO_WINDOW), EVENT_BUS_SCOPE.LOBBY)
def isPwdInvalid(self, password):
isInvalid = False
if not constants.IS_DEVELOPMENT and not self._loginMode.isToken2():
isInvalid = not isPasswordValid(password)
return isInvalid
def isLoginInvalid(self, login):
isInvalid = False
if not constants.IS_DEVELOPMENT and not self._loginMode.isToken2():
isInvalid = not isAccountLoginValid(login)
return isInvalid
def onRecovery(self):
self.fireEvent(OpenLinkEvent(OpenLinkEvent.RECOVERY_PASSWORD))
def isToken(self):
return self._loginMode.isToken2()
def onEscape(self):
def buttonHandler(isOk):
if isOk:
self.destroy()
BigWorld.quit()
DialogsInterface.showI18nConfirmDialog('quit', buttonHandler, focusedID=DIALOG_BUTTON_ID.CLOSE)
def changeAccount(self):
self._loginMode.changeAccount()
def musicFadeOut(self):
self._loginMode.musicFadeOut()
def videoLoadingFailed(self):
self._loginMode.videoLoadingFailed()
def setMute(self, value):
self._loginMode.setMute(value)
def onVideoLoaded(self):
self._loginMode.onVideoLoaded()
def switchBgMode(self):
self._loginMode.switchBgMode()
def startListenCsisUpdate(self, startListenCsis):
self.loginManager.servers.startListenCsisQuery(startListenCsis)
@uniprof.regionDecorator(label='offline.login', scope='enter')
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
self.connectionMgr.onRejected += self._onLoginRejected
self.connectionMgr.onKickWhileLoginReceived += self._onKickedWhileLogin
self.connectionMgr.onQueued += self._onHandleQueue
self.connectionMgr.onLoggedOn += self._onLoggedOn
g_playerEvents.onAccountShowGUI += self._clearLoginView
g_playerEvents.onEntityCheckOutEnqueued += self._onEntityCheckoutEnqueued
g_playerEvents.onAccountBecomeNonPlayer += self._onAccountBecomeNonPlayer
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
self.sessionProvider.getCtx().lastArenaUniqueID = None
self._loginMode.init()
self.update()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.0, self.__checkUserInputState)
return
@uniprof.regionDecorator(label='offline.login', scope='exit')
def _dispose(self):
self._loginMode.destroy()
self._loginMode = None
if self.__capsLockCallbackID is not None:
BigWorld.cancelCallback(self.__capsLockCallbackID)
self.__capsLockCallbackID = None
self.connectionMgr.onRejected -= self._onLoginRejected
self.connectionMgr.onKickWhileLoginReceived -= self._onKickedWhileLogin
self.connectionMgr.onQueued -= self._onHandleQueue
self.connectionMgr.onLoggedOn -= self._onLoggedOn
self._servers.onServersStatusChanged -= self.__updateServersList
g_playerEvents.onAccountShowGUI -= self._clearLoginView
g_playerEvents.onEntityCheckOutEnqueued -= self._onEntityCheckoutEnqueued
g_playerEvents.onAccountBecomeNonPlayer -= self._onAccountBecomeNonPlayer
if self._entityEnqueueCancelCallback:
g_eventBus.removeListener(BootcampEvent.QUEUE_DIALOG_CANCEL, self._onEntityCheckoutCanceled, EVENT_BUS_SCOPE.LOBBY)
self._serversDP.fini()
self._serversDP = None
self._entityEnqueueCancelCallback = None
super(LoginView, self)._dispose()
return
def update(self):
self.as_setDefaultValuesS({'loginName': self._loginMode.login,
'pwd': self._loginMode.password,
'memberMe': self._loginMode.rememberUser,
'memberMeVisible': self._loginMode.rememberPassVisible,
'isIgrCredentialsReset': GUI_SETTINGS.igrCredentialsReset,
'showRecoveryLink': not GUI_SETTINGS.isEmpty('recoveryPswdURL')})
self._loginMode.updateForm()
self.__updateServersList()
def _clearLoginView(self, *args):
Waiting.hide('login')
if self.__loginQueueDialogShown:
self.__closeLoginQueueDialog()
if self.__loginRetryDialogShown:
self.__closeLoginRetryDialog()
def _onKickedWhileLogin(self, peripheryID):
if peripheryID >= 0:
self.__customLoginStatus = 'another_periphery' if peripheryID else 'checkout_error'
if not self.__loginRetryDialogShown:
self.__showLoginRetryDialog({'waitingOpen': WAITING.titles(self.__customLoginStatus),
'waitingClose': WAITING.BUTTONS_CEASE,
'message': _ms(WAITING.message(self.__customLoginStatus), self.connectionMgr.serverUserName)})
elif peripheryID == -2:
self.__customLoginStatus = 'centerRestart'
elif peripheryID == -3:
self.__customLoginStatus = 'versionMismatch'
def _onHandleQueue(self, queueNumber):
serverName = self.connectionMgr.serverUserName
showAutoSearchBtn = AUTO_LOGIN_QUERY_ENABLED and not self._autoSearchVisited
cancelBtnLbl = WAITING.BUTTONS_CANCEL if showAutoSearchBtn else WAITING.BUTTONS_EXITQUEUE
message = _ms(WAITING.MESSAGE_QUEUE, serverName, queueNumber)
if showAutoSearchBtn:
message = _ms(WAITING.MESSAGE_USEAUTOSEARCH, serverName, queueNumber, serverName)
if not self.__loginQueueDialogShown:
self._clearLoginView()
self.__loginQueueDialogShown = True
self.fireEvent(LoginEventEx(LoginEventEx.SET_LOGIN_QUEUE, '', WAITING.TITLES_QUEUE, message, cancelBtnLbl, showAutoSearchBtn), EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self._onLoginQueueClosed, EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.SWITCH_LOGIN_QUEUE_TO_AUTO, self._onLoginQueueSwitched, EVENT_BUS_SCOPE.LOBBY)
else:
ctx = {'title': WAITING.TITLES_QUEUE,
'message': message,
'cancelLabel': cancelBtnLbl,
'showAutoLoginBtn': showAutoSearchBtn}
self.fireEvent(ArgsEvent(ArgsEvent.UPDATE_ARGS, VIEW_ALIAS.LOGIN_QUEUE, ctx), EVENT_BUS_SCOPE.LOBBY)
def _onLoginQueueClosed(self, event):
self.__closeLoginQueueDialog()
def _onEntityCheckoutEnqueued(self, cancelCallback):
g_eventBus.addListener(BootcampEvent.QUEUE_DIALOG_CANCEL, self._onEntityCheckoutCanceled, EVENT_BUS_SCOPE.LOBBY)
g_eventBus.handleEvent(BootcampEvent(BootcampEvent.QUEUE_DIALOG_SHOW), EVENT_BUS_SCOPE.LOBBY)
self._entityEnqueueCancelCallback = cancelCallback
def _onAccountBecomeNonPlayer(self):
if self._entityEnqueueCancelCallback:
self._entityEnqueueCancelCallback = None
g_eventBus.removeListener(BootcampEvent.QUEUE_DIALOG_CANCEL, self._onEntityCheckoutCanceled, EVENT_BUS_SCOPE.LOBBY)
return
def _onEntityCheckoutCanceled(self, _):
Waiting.show('login')
g_eventBus.removeListener(BootcampEvent.QUEUE_DIALOG_CANCEL, self._onEntityCheckoutCanceled, EVENT_BUS_SCOPE.LOBBY)
if self._entityEnqueueCancelCallback:
self._entityEnqueueCancelCallback()
self._entityEnqueueCancelCallback = None
return
def _onLoginQueueSwitched(self, event):
self.__closeLoginQueueDialog()
self.as_switchToAutoAndSubmitS(AUTO_LOGIN_QUERY_URL)
def _onLoginRejected(self, loginStatus, responseData):
Waiting.hide('login')
if not self._loginMode.skipRejectionError(loginStatus, responseData):
if loginStatus == LOGIN_STATUS.LOGIN_REJECTED_BAN:
self.__loginRejectedBan(responseData)
elif loginStatus == LOGIN_STATUS.LOGIN_REJECTED_RATE_LIMITED:
self.__loginRejectedRateLimited()
elif loginStatus in (LOGIN_STATUS.LOGIN_REJECTED_BAD_DIGEST, LOGIN_STATUS.LOGIN_BAD_PROTOCOL_VERSION):
self.__loginRejectedUpdateNeeded()
elif loginStatus == LOGIN_STATUS.NOT_SET and self.__customLoginStatus is not None:
self.__loginRejectedWithCustomState()
else:
self.as_setErrorMessageS(_ms('#menu:login/status/' + loginStatus), _STATUS_TO_INVALID_FIELDS_MAPPING[loginStatus])
self.__clearFields(_STATUS_TO_INVALID_FIELDS_MAPPING[loginStatus])
self._dropLoginQueue(loginStatus)
return
def _dropLoginQueue(self, loginStatus):
if loginStatus != LOGIN_STATUS.LOGIN_REJECTED_RATE_LIMITED and self.__loginRetryDialogShown:
self.__closeLoginQueueDialog()
def __clearFields(self, invalidField):
if invalidField == INVALID_FIELDS.PWD_INVALID:
self.as_resetPasswordS()
@process
def __loginRejectedUpdateNeeded(self):
success = yield DialogsInterface.showI18nConfirmDialog('updateNeeded')
if success and not BigWorld.wg_quitAndStartLauncher():
self.as_setErrorMessageS(_ms(MENU.LOGIN_STATUS_LAUNCHERNOTFOUND), INVALID_FIELDS.ALL_VALID)
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 __loginRejectedRateLimited(self):
self.as_setErrorMessageS(_ms(MENU.LOGIN_STATUS_LOGIN_REJECTED_RATE_LIMITED), INVALID_FIELDS.ALL_VALID)
if not self.__loginRetryDialogShown:
self.__showLoginRetryDialog({'waitingOpen': WAITING.TITLES_QUEUE,
'waitingClose': WAITING.BUTTONS_EXITQUEUE,
'message': _ms(WAITING.MESSAGE_AUTOLOGIN, self.connectionMgr.serverUserName)})
def __loginRejectedWithCustomState(self):
self.as_setErrorMessageS(_ms('#menu:login/status/' + self.__customLoginStatus), INVALID_FIELDS.ALL_VALID)
self.__clearFields(INVALID_FIELDS.ALL_VALID)
def __showLoginRetryDialog(self, data):
self._clearLoginView()
self.fireEvent(LoginEventEx(LoginEventEx.SET_AUTO_LOGIN, '', data['waitingOpen'], data['message'], data['waitingClose'], False), EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self.__closeLoginRetryDialog, EVENT_BUS_SCOPE.LOBBY)
self.__loginRetryDialogShown = True
def __closeLoginRetryDialog(self, event=None):
self.connectionMgr.stopRetryConnection()
self.fireEvent(LoginEvent(LoginEventEx.CANCEL_LGN_QUEUE, ''))
self.removeListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self.__closeLoginRetryDialog, EVENT_BUS_SCOPE.LOBBY)
self.__loginRetryDialogShown = False
def __closeLoginQueueDialog(self):
self.fireEvent(LoginEvent(LoginEvent.CANCEL_LGN_QUEUE, ''))
g_preDefinedHosts.resetQueryResult()
self.removeListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self._onLoginQueueClosed, EVENT_BUS_SCOPE.LOBBY)
self.removeListener(LoginEventEx.SWITCH_LOGIN_QUEUE_TO_AUTO, self._onLoginQueueSwitched, EVENT_BUS_SCOPE.LOBBY)
self.__loginQueueDialogShown = False
def __checkUserInputState(self):
self.__capsLockCallbackID = None
caps = BigWorld.wg_isCapsLockOn()
if self.__capsLockState != caps:
self.__capsLockState = caps
self.as_setCapsLockStateS(self.__capsLockState)
lang = BigWorld.wg_getLangCode()
if self.__lang != lang:
self.__lang = lang
self.as_setKeyboardLangS(self.__lang)
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
return
def __updateServersList(self, *args):
self._serversDP.rebuildList(self._servers.serverList)
if not self.__isListInitialized and self._servers.serverList:
self.__isListInitialized = True
self.as_setSelectedServerIndexS(self._servers.selectedServerIdx)
class LoginView(LoginPageMeta):
def __init__(self, ctx=None):
LoginPageMeta.__init__(self, ctx=ctx)
self.__isListInitialized = False
self.__loginRetryDialogShown = False
self.__loginQueueDialogShown = False
self.__capsLockState = None
self.__lang = None
self.__capsLockCallbackID = None
self.__backgroundMode = BackgroundMode(self)
self.__customLoginStatus = None
self._autoSearchVisited = False
self._rememberUser = False
g_loginManager.servers.updateServerList()
self._servers = g_loginManager.servers
return
def onRegister(self, host):
self.fireEvent(OpenLinkEvent(OpenLinkEvent.REGISTRATION))
def onSetRememberPassword(self, rememberUser):
self._rememberUser = rememberUser
def onLogin(self, userName, password, serverName, isSocialToken2Login):
g_statistics.noteHangarLoadingState(HANGAR_LOADING_STATE.LOGIN, True)
self._autoSearchVisited = serverName == AUTO_LOGIN_QUERY_URL
self.__customLoginStatus = None
result = self.__validateCredentials(
userName.lower().strip(), password.strip(),
bool(g_loginManager.getPreference('token2')))
if result.isValid:
Waiting.show('login')
g_loginManager.initiateLogin(
userName, password, serverName, isSocialToken2Login,
isSocialToken2Login or self._rememberUser)
else:
self.as_setErrorMessageS(result.errorMessage, result.invalidFields)
return
def resetToken(self):
g_loginManager.clearToken2Preference()
def showLegal(self):
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.LEGAL_INFO_WINDOW),
EVENT_BUS_SCOPE.LOBBY)
def isPwdInvalid(self, password):
isInvalid = False
if not constants.IS_DEVELOPMENT and not g_loginManager.getPreference(
'token2'):
from external_strings_utils import isPasswordValid
isInvalid = not isPasswordValid(password)
return isInvalid
def isLoginInvalid(self, login):
isInvalid = False
if not constants.IS_DEVELOPMENT and not g_loginManager.getPreference(
'token2'):
from external_strings_utils import isAccountLoginValid
isInvalid = not isAccountLoginValid(login)
return isInvalid
def onRecovery(self):
self.fireEvent(OpenLinkEvent(OpenLinkEvent.RECOVERY_PASSWORD))
def isToken(self):
return bool(g_loginManager.getPreference('token2'))
def onEscape(self):
def buttonHandler(isOk):
if isOk:
self.destroy()
BigWorld.quit()
DialogsInterface.showI18nConfirmDialog(
'quit', buttonHandler, focusedID=DIALOG_BUTTON_ID.CLOSE)
def startListenCsisUpdate(self, startListenCsis):
g_loginManager.servers.startListenCsisQuery(startListenCsis)
def onExitFromAutoLogin(self):
pass
def saveLastSelectedServer(self, server):
pass
def switchBgMode(self):
self.__backgroundMode.switch()
def musicFadeOut(self):
self.__backgroundMode.fadeSound()
def setMute(self, value):
self.__backgroundMode.toggleMute(value)
def onVideoLoaded(self):
self.__backgroundMode.startVideoSound()
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
connectionManager.onKickWhileLoginReceived += self._onKickedWhileLogin
connectionManager.onQueued += self._onHandleQueue
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
ScaleformFileLoader.enableStreaming(
[getPathForFlash(_LOGIN_VIDEO_FILE)])
self.__backgroundMode.show()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(
0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _dispose(self):
ScaleformFileLoader.disableStreaming()
self.__backgroundMode.hide()
if self.__capsLockCallbackID is not None:
BigWorld.cancelCallback(self.__capsLockCallbackID)
self.__capsLockCallbackID = None
connectionManager.onRejected -= self._onLoginRejected
connectionManager.onKickWhileLoginReceived -= self._onKickedWhileLogin
connectionManager.onQueued -= self._onHandleQueue
self._servers.onServersStatusChanged -= self.__updateServersList
g_playerEvents.onAccountShowGUI -= self._clearLoginView
self._serversDP.fini()
self._serversDP = None
View._dispose(self)
return
def _showForm(self):
self.as_showSimpleFormS(False, None)
return
def _setData(self):
self._rememberUser = g_loginManager.getPreference('remember_user')
if self._rememberUser:
password = '******' * g_loginManager.getPreference('password_length')
else:
password = ''
if GUI_SETTINGS.clearLoginValue:
login = password = ''
else:
login = g_loginManager.getPreference('login')
self.as_setDefaultValuesS(login, password, self._rememberUser,
GUI_SETTINGS.rememberPassVisible,
GUI_SETTINGS.igrCredentialsReset,
not GUI_SETTINGS.isEmpty('recoveryPswdURL'))
self.__updateServersList()
def _clearLoginView(self, *args):
Waiting.hide('login')
if self.__loginQueueDialogShown:
self.__closeLoginQueueDialog()
if self.__loginRetryDialogShown:
self.__closeLoginRetryDialog()
def _onKickedWhileLogin(self, peripheryID):
if peripheryID >= 0:
self.__customLoginStatus = 'another_periphery' if peripheryID else 'checkout_error'
if not self.__loginRetryDialogShown:
self.__showLoginRetryDialog({
'waitingOpen':
WAITING.titles(self.__customLoginStatus),
'waitingClose':
WAITING.BUTTONS_CEASE,
'message':
_ms(WAITING.message(self.__customLoginStatus),
connectionManager.serverUserName)
})
elif peripheryID == -2:
self.__customLoginStatus = 'centerRestart'
elif peripheryID == -3:
self.__customLoginStatus = 'versionMismatch'
def _onHandleQueue(self, queueNumber):
serverName = connectionManager.serverUserName
showAutoSearchBtn = AUTO_LOGIN_QUERY_ENABLED and not self._autoSearchVisited
cancelBtnLbl = WAITING.BUTTONS_CANCEL if showAutoSearchBtn else WAITING.BUTTONS_EXITQUEUE
message = _ms(WAITING.MESSAGE_QUEUE, serverName, queueNumber)
if showAutoSearchBtn:
message = _ms(WAITING.MESSAGE_USEAUTOSEARCH, serverName,
queueNumber, serverName)
if not self.__loginQueueDialogShown:
self._clearLoginView()
self.__loginQueueDialogShown = True
self.fireEvent(
LoginEventEx(LoginEventEx.SET_LOGIN_QUEUE, View.alias,
WAITING.TITLES_QUEUE, message, cancelBtnLbl,
showAutoSearchBtn), EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED,
self._onLoginQueueClosed, EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.SWITCH_LOGIN_QUEUE_TO_AUTO,
self._onLoginQueueSwitched, EVENT_BUS_SCOPE.LOBBY)
else:
ctx = {
'title': WAITING.TITLES_QUEUE,
'message': message,
'cancelLabel': cancelBtnLbl,
'showAutoLoginBtn': showAutoSearchBtn
}
self.fireEvent(
ArgsEvent(ArgsEvent.UPDATE_ARGS, VIEW_ALIAS.LOGIN_QUEUE, ctx),
EVENT_BUS_SCOPE.LOBBY)
def _onLoginQueueClosed(self, event):
self.__closeLoginQueueDialog()
def _onLoginQueueSwitched(self, event):
self.__closeLoginQueueDialog()
self.as_switchToAutoAndSubmitS(AUTO_LOGIN_QUERY_URL)
def _onLoginRejected(self, loginStatus, responseData):
Waiting.hide('login')
if loginStatus == LOGIN_STATUS.LOGIN_REJECTED_BAN:
self.__loginRejectedBan(responseData)
elif loginStatus == LOGIN_STATUS.LOGIN_REJECTED_RATE_LIMITED:
self.__loginRejectedRateLimited()
elif loginStatus in (LOGIN_STATUS.LOGIN_REJECTED_BAD_DIGEST,
LOGIN_STATUS.LOGIN_BAD_PROTOCOL_VERSION):
self.__loginRejectedUpdateNeeded()
elif loginStatus == LOGIN_STATUS.NOT_SET and self.__customLoginStatus is not None:
self.__loginRejectedWithCustomState()
else:
self.as_setErrorMessageS(
_ms('#menu:login/status/' + loginStatus),
_STATUS_TO_INVALID_FIELDS_MAPPING[loginStatus])
self.__clearFields(_STATUS_TO_INVALID_FIELDS_MAPPING[loginStatus])
self._dropLoginQueue(loginStatus)
return
def _dropLoginQueue(self, loginStatus):
"""Safely drop login queue considering login status and current state of login queue.
"""
if loginStatus != LOGIN_STATUS.LOGIN_REJECTED_RATE_LIMITED and self.__loginRetryDialogShown:
self.__closeLoginQueueDialog()
def __clearFields(self, invalidField):
if invalidField == INVALID_FIELDS.PWD_INVALID:
self.as_resetPasswordS()
@process
def __loginRejectedUpdateNeeded(self):
success = yield DialogsInterface.showI18nConfirmDialog('updateNeeded')
if success and not BigWorld.wg_quitAndStartLauncher():
self.as_setErrorMessageS(_ms(MENU.LOGIN_STATUS_LAUNCHERNOTFOUND),
INVALID_FIELDS.ALL_VALID)
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 __loginRejectedRateLimited(self):
self.as_setErrorMessageS(
_ms(MENU.LOGIN_STATUS_LOGIN_REJECTED_RATE_LIMITED),
INVALID_FIELDS.ALL_VALID)
if not self.__loginRetryDialogShown:
self.__showLoginRetryDialog({
'waitingOpen':
WAITING.TITLES_QUEUE,
'waitingClose':
WAITING.BUTTONS_EXITQUEUE,
'message':
_ms(WAITING.MESSAGE_AUTOLOGIN,
connectionManager.serverUserName)
})
def __loginRejectedWithCustomState(self):
self.as_setErrorMessageS(
_ms('#menu:login/status/' + self.__customLoginStatus),
INVALID_FIELDS.ALL_VALID)
self.__clearFields(INVALID_FIELDS.ALL_VALID)
def __showLoginRetryDialog(self, data):
self._clearLoginView()
self.fireEvent(
LoginEventEx(LoginEventEx.SET_AUTO_LOGIN, View.alias,
data['waitingOpen'], data['message'],
data['waitingClose'], False), EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED,
self.__closeLoginRetryDialog, EVENT_BUS_SCOPE.LOBBY)
self.__loginRetryDialogShown = True
def __closeLoginRetryDialog(self, event=None):
connectionManager.stopRetryConnection()
self.fireEvent(LoginEvent(LoginEventEx.CANCEL_LGN_QUEUE, View.alias))
self.removeListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED,
self.__closeLoginRetryDialog,
EVENT_BUS_SCOPE.LOBBY)
self.__loginRetryDialogShown = False
def __closeLoginQueueDialog(self):
self.fireEvent(LoginEvent(LoginEvent.CANCEL_LGN_QUEUE, View.alias))
g_preDefinedHosts.resetQueryResult()
self.removeListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED,
self._onLoginQueueClosed, EVENT_BUS_SCOPE.LOBBY)
self.removeListener(LoginEventEx.SWITCH_LOGIN_QUEUE_TO_AUTO,
self._onLoginQueueSwitched, EVENT_BUS_SCOPE.LOBBY)
self.__loginQueueDialogShown = False
def __checkUserInputState(self):
self.__capsLockCallbackID = None
caps = BigWorld.wg_isCapsLockOn()
if self.__capsLockState != caps:
self.__capsLockState = caps
self.as_setCapsLockStateS(self.__capsLockState)
lang = BigWorld.wg_getLangCode()
if self.__lang != lang:
self.__lang = lang
self.as_setKeyboardLangS(self.__lang)
self.__capsLockCallbackID = BigWorld.callback(
0.1, self.__checkUserInputState)
return
def __validateCredentials(self, userName, password, isToken2Login):
isValid = True
errorMessage = None
invalidFields = None
if isToken2Login or constants.IS_DEVELOPMENT:
return _ValidateCredentialsResult(isValid, errorMessage,
invalidFields)
else:
if len(userName) < _LOGIN_NAME_MIN_LENGTH:
isValid = False
errorMessage = _ms(MENU.LOGIN_STATUS_INVALID_LOGIN_LENGTH,
count=_LOGIN_NAME_MIN_LENGTH)
invalidFields = INVALID_FIELDS.LOGIN_INVALID
elif not isAccountLoginValid(userName):
isValid = False
errorMessage = _ms(MENU.LOGIN_STATUS_INVALID_LOGIN)
invalidFields = INVALID_FIELDS.LOGIN_INVALID
elif not isPasswordValid(password):
isValid = False
errorMessage = _ms(MENU.LOGIN_STATUS_INVALID_PASSWORD,
minLength=_PASSWORD_MIN_LENGTH,
maxLength=_PASSWORD_MAX_LENGTH)
invalidFields = INVALID_FIELDS.PWD_INVALID
return _ValidateCredentialsResult(isValid, errorMessage,
invalidFields)
def __updateServersList(self, *args):
self._serversDP.rebuildList(self._servers.serverList)
if not self.__isListInitialized and self._servers.serverList:
self.__isListInitialized = True
self.as_setSelectedServerIndexS(self._servers.selectedServerIdx)
class SwitchPeripheryWindow(SwitchPeripheryWindowMeta):
_BTN_WIDTH = 140
_CLOSE_BTN_ACTION = 'closeAction'
_SWITCH_BTN_ACTION = 'switchAction'
def __init__(self, ctx):
super(SwitchPeripheryWindow, self).__init__()
self.__ctx = ctx
def onBtnClick(self, action):
if action == self._CLOSE_BTN_ACTION:
self.onWindowClose()
def requestForChange(self, peripheryId):
if connectionManager.peripheryID != peripheryId:
self.__relogin(peripheryId)
else:
LOG_DEBUG('Current server for relogin has been chosen: %s' % peripheryId)
def onWindowClose(self):
self.destroy()
def onDropDownOpened(self, opened):
r"""
Invokes by DAAPI when user open\close dropdown menu
:param opened: true - list has been opened, false - list has been closed
"""
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ON_REQUEST:
if opened:
g_preDefinedHosts.startCSISUpdate()
else:
g_preDefinedHosts.stopCSISUpdate()
self._updateServersList()
if opened:
g_preDefinedHosts.requestPing(True)
def _updateServersList(self):
hostsList = g_preDefinedHosts.getSimpleHostsList(g_preDefinedHosts.hostsWithRoaming())
serversList = []
for hostName, name, csisStatus, peripheryID in hostsList:
if peripheryID not in self.__ctx.getForbiddenPeripherieIDs():
serversList.append({'label': name,
'id': peripheryID,
'csisStatus': csisStatus,
'data': hostName})
label = _ms(self.__ctx.getSelectServerLabel())
if len(serversList) == 1:
label = _ms(self.__ctx.getApplySwitchLabel(), server=text_styles.stats(serversList[0]['label']))
self._serversDP.rebuildList(serversList)
self.as_setServerParamsS(label, len(serversList) > 1)
self.as_setSelectedIndexS(0)
def _populate(self):
super(SwitchPeripheryWindow, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_setImageS(RES_ICONS.MAPS_ICONS_WINDOWS_SWITCH_PERIPHERY_WINDOW_BG, 0)
self.as_setWindowTitleS(_ms(DIALOGS.SWITCHPERIPHERYWINDOW_WINDOWTITLE))
currentServer = connectionManager.serverUserName
self.as_setTextS(_ms(self.__ctx.getHeader()), _ms(self.__ctx.getDescription(), server=text_styles.error(currentServer)))
self._updateServersList()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
self.as_setButtonsS([{'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNSWITCH),
'btnLinkage': BUTTON_LINKAGES.BUTTON_NORMAL,
'action': self._SWITCH_BTN_ACTION,
'isFocused': True,
'tooltip': ''}, {'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNCANCEL),
'btnLinkage': BUTTON_LINKAGES.BUTTON_BLACK,
'action': self._CLOSE_BTN_ACTION,
'isFocused': False,
'tooltip': ''}], TEXT_ALIGN.RIGHT, self._BTN_WIDTH)
def _dispose(self):
if not constants.IS_CHINA:
g_preDefinedHosts.stopCSISUpdate()
g_preDefinedHosts.onCsisQueryStart -= self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete -= self.__onServersUpdate
g_preDefinedHosts.onPingPerformed -= self.__onServersUpdate
self._serversDP.fini()
self._serversDP = None
super(SwitchPeripheryWindow, self)._dispose()
return
@process
def __relogin(self, peripheryID):
self.__isGuiUpdateSuppressed = True
if g_preDefinedHosts.isRoamingPeriphery(peripheryID):
success = yield DialogsInterface.showI18nConfirmDialog('changeRoamingPeriphery')
else:
success = yield DialogsInterface.showI18nConfirmDialog('changePeriphery')
if success:
game_control.g_instance.relogin.doRelogin(peripheryID, extraChainSteps=self.__ctx.getExtraChainSteps())
def __onServersUpdate(self, _):
self._updateServersList()
class SwitchPeripheryWindow(SwitchPeripheryWindowMeta, Notifiable):
_BTN_WIDTH = 140
_CLOSE_BTN_ACTION = 'closeAction'
_SWITCH_BTN_ACTION = 'switchAction'
relogin = dependency.descriptor(IReloginController)
connectionMgr = dependency.descriptor(IConnectionManager)
def __init__(self, ctx):
super(SwitchPeripheryWindow, self).__init__()
self.__ctx = ctx
def onBtnClick(self, action):
if action == self._CLOSE_BTN_ACTION:
self.onWindowClose()
def requestForChange(self, peripheryId):
if self.connectionMgr.peripheryID != peripheryId:
self.__relogin(peripheryId)
else:
LOG_DEBUG('Current server for relogin has been chosen: %s' % peripheryId)
def onWindowClose(self):
self.destroy()
def onDropDownOpened(self, opened):
r"""
Invokes by DAAPI when user open\close dropdown menu
:param opened: true - list has been opened, false - list has been closed
"""
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ON_REQUEST:
if opened:
g_preDefinedHosts.startCSISUpdate()
else:
g_preDefinedHosts.stopCSISUpdate()
self._updateServersList()
if opened:
g_preDefinedHosts.requestPing(True)
def _updateServersList(self):
hostsList = g_preDefinedHosts.getSimpleHostsList(g_preDefinedHosts.hostsWithRoaming())
serversList = []
for hostName, name, csisStatus, peripheryID in hostsList:
if self.__ctx.isPeripheryAvailable(peripheryID):
serversList.append({'label': name,
'id': peripheryID,
'csisStatus': csisStatus,
'data': hostName})
label = _ms(self.__ctx.getSelectServerLabel())
if not serversList:
self.onWindowClose()
return
if len(serversList) == 1:
label = _ms(self.__ctx.getApplySwitchLabel(), server=text_styles.stats(serversList[0]['label']))
self._serversDP.rebuildList(serversList)
self.as_setServerParamsS(label, len(serversList) > 1)
self.as_setSelectedIndexS(0)
def _populate(self):
super(SwitchPeripheryWindow, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_setImageS(RES_ICONS.MAPS_ICONS_WINDOWS_SWITCH_PERIPHERY_WINDOW_BG, 0)
self.as_setWindowTitleS(_ms(DIALOGS.SWITCHPERIPHERYWINDOW_WINDOWTITLE))
currentServer = self.connectionMgr.serverUserName
self.as_setTextS(_ms(self.__ctx.getHeader()), _ms(self.__ctx.getDescription(), server=text_styles.error(currentServer)))
self.addNotificator(SimpleNotifier(self.__ctx.getUpdateTime, self.__onServersUpdate))
self.startNotification()
self._updateServersList()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
self.as_setButtonsS([{'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNSWITCH),
'btnLinkage': BUTTON_LINKAGES.BUTTON_NORMAL,
'action': self._SWITCH_BTN_ACTION,
'isFocused': True,
'tooltip': ''}, {'label': _ms(DIALOGS.SWITCHPERIPHERYWINDOW_BTNCANCEL),
'btnLinkage': BUTTON_LINKAGES.BUTTON_BLACK,
'action': self._CLOSE_BTN_ACTION,
'isFocused': False,
'tooltip': ''}], TEXT_ALIGN.RIGHT, self._BTN_WIDTH)
def _dispose(self):
self.stopNotification()
self.clearNotification()
if not constants.IS_CHINA:
g_preDefinedHosts.stopCSISUpdate()
g_preDefinedHosts.onCsisQueryStart -= self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete -= self.__onServersUpdate
g_preDefinedHosts.onPingPerformed -= self.__onServersUpdate
self._serversDP.fini()
self._serversDP = None
super(SwitchPeripheryWindow, self)._dispose()
return
@process
def __relogin(self, peripheryID):
if g_preDefinedHosts.isRoamingPeriphery(peripheryID):
success = yield DialogsInterface.showI18nConfirmDialog('changeRoamingPeriphery')
else:
success = yield DialogsInterface.showI18nConfirmDialog('changePeriphery')
if success:
self.relogin.doRelogin(peripheryID, extraChainSteps=self.__ctx.getExtraChainSteps())
def __onServersUpdate(self, *args):
self._updateServersList()
class ServerStats(ServerStatsMeta, PrbListener):
def __init__(self):
super(ServerStats, self).__init__()
self.__isListSelected = False
@process
def relogin(self, peripheryID):
if g_preDefinedHosts.isRoamingPeriphery(peripheryID):
LOG_DEBUG('g_preDefinedHosts.isRoamingPeriphery(peripheryID)', peripheryID)
success = yield DialogsInterface.showI18nConfirmDialog('changeRoamingPeriphery')
else:
success = yield DialogsInterface.showI18nConfirmDialog('changePeriphery')
if success:
game_control.g_instance.relogin.doRelogin(peripheryID)
if not success:
self.as_changePeripheryFailedS()
def startListenCsisUpdate(self, startListen):
r"""
Invokes by DAAPI when user open\close dropdown menu
:param startListen: true - list has been opened, false - list has been closed
"""
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ON_REQUEST:
if startListen:
g_preDefinedHosts.startCSISUpdate()
else:
g_preDefinedHosts.stopCSISUpdate()
self._updateServersList()
if startListen:
g_preDefinedHosts.requestPing(True)
def _populate(self):
super(ServerStats, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
if constants.IS_SHOW_SERVER_STATS:
self._updateCurrentServerInfo()
self._updateServersList()
self._updateRoamingCtrl()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
game_control.g_instance.serverStats.onStatsReceived += self.__onStatsReceived
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self._updateRoamingCtrl, scope=EVENT_BUS_SCOPE.LOBBY)
def _dispose(self):
self.removeListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE, self._updateRoamingCtrl, scope=EVENT_BUS_SCOPE.LOBBY)
game_control.g_instance.serverStats.onStatsReceived -= self.__onStatsReceived
if not constants.IS_CHINA:
g_preDefinedHosts.stopCSISUpdate()
g_preDefinedHosts.onCsisQueryComplete -= self.__onServersUpdate
g_preDefinedHosts.onCsisQueryStart -= self.__onServersUpdate
g_preDefinedHosts.onPingPerformed -= self.__onServersUpdate
self._serversDP.fini()
self._serversDP = None
super(ServerStats, self)._dispose()
return
def _updateCurrentServerInfo(self):
from ConnectionManager import connectionManager
if connectionManager.serverUserName:
tooltipBody = i18n.makeString('#tooltips:header/info/players_online_full/body')
tooltipFullData = makeTooltip('#tooltips:header/info/players_online_full/header', tooltipBody % {'servername': connectionManager.serverUserName})
self.as_setServerStatsInfoS(tooltipFullData)
self.__onStatsReceived(game_control.g_instance.serverStats.getStats())
def _updateServersList(self):
result = []
simpleHostList = g_preDefinedHosts.getSimpleHostsList(g_preDefinedHosts.hostsWithRoaming())
if len(simpleHostList):
for idx, (hostName, name, csisStatus, peripheryID) in enumerate(simpleHostList):
result.append({'label': self.__wrapServerName(name),
'data': hostName,
'id': peripheryID,
'csisStatus': csisStatus})
if connectionManager.peripheryID == 0:
result.insert(0, {'label': self.__wrapServerName(connectionManager.serverUserName),
'id': 0,
'csisStatus': HOST_AVAILABILITY.IGNORED,
'data': connectionManager.url})
if not self.__isListSelected:
self.__isListSelected = True
index = 0
if connectionManager.peripheryID != 0:
for idx, (hostName, name, csisStatus, peripheryID) in enumerate(simpleHostList):
if hostName == connectionManager.url:
index = idx
break
self.as_setSelectedServerIndexS(index)
self._serversDP.rebuildList(result)
def _updateRoamingCtrl(self, event = None):
isRoamingCtrlDisabled = False
if self.prbDispatcher:
for func in self.prbDispatcher.getFunctionalCollection().getIterator():
if func.hasLockedState():
isRoamingCtrlDisabled = True
break
self.as_disableRoamingDDS(isRoamingCtrlDisabled)
def __onStatsReceived(self, stats):
if constants.IS_SHOW_SERVER_STATS:
self.as_setServerStatsS(*game_control.g_instance.serverStats.getFormattedStats())
def __onServersUpdate(self, _ = None):
self._updateServersList()
def __wrapServerName(self, name):
if constants.IS_CHINA:
return makeHtmlString('html_templates:lobby/serverStats', 'serverName', {'name': name})
return name
class ServerStats(ServerStatsMeta, ILegacyListener):
serverStats = dependency.descriptor(IServerStatsController)
reloginCtrl = dependency.descriptor(IReloginController)
connectionMgr = dependency.descriptor(IConnectionManager)
def __init__(self):
super(ServerStats, self).__init__()
self.__isListSelected = False
@process
def relogin(self, peripheryID):
if g_preDefinedHosts.isRoamingPeriphery(peripheryID):
LOG_DEBUG('g_preDefinedHosts.isRoamingPeriphery(peripheryID)',
peripheryID)
success = yield DialogsInterface.showI18nConfirmDialog(
'changeRoamingPeriphery')
else:
success = yield DialogsInterface.showI18nConfirmDialog(
'changePeriphery')
if success:
self.reloginCtrl.doRelogin(peripheryID, self.__onReloing)
else:
self.as_changePeripheryFailedS()
def startListenCsisUpdate(self, startListen):
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ON_REQUEST:
if startListen:
g_preDefinedHosts.startCSISUpdate()
else:
g_preDefinedHosts.stopCSISUpdate()
self._updateServersList()
if startListen:
g_preDefinedHosts.requestPing(True)
def _populate(self):
super(ServerStats, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
if constants.IS_SHOW_SERVER_STATS:
self._updateCurrentServerInfo()
self._updateServersList()
self._updateRoamingCtrl()
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
self.serverStats.onStatsReceived += self.__onStatsReceived
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE,
self._updateRoamingCtrl,
scope=EVENT_BUS_SCOPE.LOBBY)
def _dispose(self):
self.removeListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE,
self._updateRoamingCtrl,
scope=EVENT_BUS_SCOPE.LOBBY)
self.serverStats.onStatsReceived -= self.__onStatsReceived
g_preDefinedHosts.stopCSISUpdate()
g_preDefinedHosts.onCsisQueryComplete -= self.__onServersUpdate
g_preDefinedHosts.onCsisQueryStart -= self.__onServersUpdate
g_preDefinedHosts.onPingPerformed -= self.__onServersUpdate
self._serversDP.fini()
self._serversDP = None
super(ServerStats, self)._dispose()
return
def _updateCurrentServerInfo(self):
if self.connectionMgr.serverUserName:
tooltipBody = i18n.makeString(
'#tooltips:header/info/players_online_full/body')
tooltipFullData = makeTooltip(
'#tooltips:header/info/players_online_full/header',
tooltipBody %
{'servername': self.connectionMgr.serverUserName})
self.as_setServerStatsInfoS(tooltipFullData)
self.__onStatsReceived()
def _updateServersList(self):
result = []
simpleHostList = g_preDefinedHosts.getSimpleHostsList(
g_preDefinedHosts.hostsWithRoaming())
if simpleHostList:
for idx, (hostName, name, csisStatus,
peripheryID) in enumerate(simpleHostList):
result.append({
'label': name,
'data': hostName,
'id': peripheryID,
'csisStatus': csisStatus
})
if self.connectionMgr.peripheryID == 0:
result.insert(
0, {
'label': self.connectionMgr.serverUserName,
'id': 0,
'csisStatus': HOST_AVAILABILITY.IGNORED,
'data': self.connectionMgr.url
})
if not self.__isListSelected:
self.__isListSelected = True
index = 0
if self.connectionMgr.peripheryID != 0:
for idx, (hostName, name, csisStatus,
peripheryID) in enumerate(simpleHostList):
if hostName == self.connectionMgr.url:
index = idx
break
self.as_setSelectedServerIndexS(index)
self._serversDP.rebuildList(result)
def _updateRoamingCtrl(self, event=None):
isRoamingCtrlDisabled = False
if self.prbDispatcher:
isRoamingCtrlDisabled = self.prbDispatcher.getEntity(
).hasLockedState()
self.as_disableRoamingDDS(isRoamingCtrlDisabled)
def __onStatsReceived(self):
if constants.IS_SHOW_SERVER_STATS:
self.as_setServerStatsS(*self.serverStats.getFormattedStats())
def __onServersUpdate(self, _=None):
self._updateServersList()
def __onReloing(self, isCompleted):
if not isCompleted:
self.as_changePeripheryFailedS()
class ServerStats(ServerStatsMeta, PrbListener):
def __init__(self):
super(ServerStats, self).__init__()
self.__isListSelected = False
@process
def relogin(self, peripheryID):
if g_preDefinedHosts.isRoamingPeriphery(peripheryID):
LOG_DEBUG('g_preDefinedHosts.isRoamingPeriphery(peripheryID)',
peripheryID)
success = yield DialogsInterface.showI18nConfirmDialog(
'changeRoamingPeriphery')
else:
success = yield DialogsInterface.showI18nConfirmDialog(
'changePeriphery')
if success:
game_control.g_instance.relogin.doRelogin(peripheryID)
if not success:
self.as_changePeripheryFailedS()
def startListenCsisUpdate(self, startListen):
r"""
Invokes by DAAPI when user open\close dropdown menu
:param startListen: true - list has been opened, false - list has been closed
"""
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ON_REQUEST:
if startListen:
g_preDefinedHosts.startCSISUpdate()
else:
g_preDefinedHosts.stopCSISUpdate()
self._updateServersList()
if startListen:
g_preDefinedHosts.requestPing(True)
def _populate(self):
super(ServerStats, self)._populate()
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
if constants.IS_SHOW_SERVER_STATS:
self._updateCurrentServerInfo()
self._updateServersList()
self._updateRoamingCtrl()
if not constants.IS_CHINA:
if GUI_SETTINGS.csisRequestRate == REQUEST_RATE.ALWAYS:
g_preDefinedHosts.startCSISUpdate()
g_preDefinedHosts.onCsisQueryStart += self.__onServersUpdate
g_preDefinedHosts.onCsisQueryComplete += self.__onServersUpdate
g_preDefinedHosts.onPingPerformed += self.__onServersUpdate
game_control.g_instance.serverStats.onStatsReceived += self.__onStatsReceived
self.addListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE,
self._updateRoamingCtrl,
scope=EVENT_BUS_SCOPE.LOBBY)
def _dispose(self):
self.removeListener(events.FightButtonEvent.FIGHT_BUTTON_UPDATE,
self._updateRoamingCtrl,
scope=EVENT_BUS_SCOPE.LOBBY)
game_control.g_instance.serverStats.onStatsReceived -= self.__onStatsReceived
if not constants.IS_CHINA:
g_preDefinedHosts.stopCSISUpdate()
g_preDefinedHosts.onCsisQueryComplete -= self.__onServersUpdate
g_preDefinedHosts.onCsisQueryStart -= self.__onServersUpdate
g_preDefinedHosts.onPingPerformed -= self.__onServersUpdate
self._serversDP.fini()
self._serversDP = None
super(ServerStats, self)._dispose()
return
def _updateCurrentServerInfo(self):
from ConnectionManager import connectionManager
if connectionManager.serverUserName:
tooltipBody = i18n.makeString(
'#tooltips:header/info/players_online_full/body')
tooltipFullData = makeTooltip(
'#tooltips:header/info/players_online_full/header',
tooltipBody % {'servername': connectionManager.serverUserName})
self.as_setServerStatsInfoS(tooltipFullData)
self.__onStatsReceived(game_control.g_instance.serverStats.getStats())
def _updateServersList(self):
result = []
simpleHostList = g_preDefinedHosts.getSimpleHostsList(
g_preDefinedHosts.hostsWithRoaming())
if len(simpleHostList):
for idx, (hostName, name, csisStatus,
peripheryID) in enumerate(simpleHostList):
result.append({
'label': self.__wrapServerName(name),
'data': hostName,
'id': peripheryID,
'csisStatus': csisStatus
})
if connectionManager.peripheryID == 0:
result.insert(
0, {
'label':
self.__wrapServerName(connectionManager.serverUserName),
'id':
0,
'csisStatus':
HOST_AVAILABILITY.IGNORED,
'data':
connectionManager.url
})
if not self.__isListSelected:
self.__isListSelected = True
index = 0
if connectionManager.peripheryID != 0:
for idx, (hostName, name, csisStatus,
peripheryID) in enumerate(simpleHostList):
if hostName == connectionManager.url:
index = idx
break
self.as_setSelectedServerIndexS(index)
self._serversDP.rebuildList(result)
def _updateRoamingCtrl(self, event=None):
isRoamingCtrlDisabled = False
if self.prbDispatcher:
for func in self.prbDispatcher.getFunctionalCollection(
).getIterator():
if func.hasLockedState():
isRoamingCtrlDisabled = True
break
self.as_disableRoamingDDS(isRoamingCtrlDisabled)
def __onStatsReceived(self, stats):
if constants.IS_SHOW_SERVER_STATS:
self.as_setServerStatsS(
*game_control.g_instance.serverStats.getFormattedStats())
def __onServersUpdate(self, _=None):
self._updateServersList()
def __wrapServerName(self, name):
if constants.IS_CHINA:
return makeHtmlString('html_templates:lobby/serverStats',
'serverName', {'name': name})
return name
class LoginView(LoginPageMeta):
def __init__(self, ctx = None):
LoginPageMeta.__init__(self, ctx=ctx)
self.__isListInitialized = False
self.__loginRetryDialogShown = False
self.__loginQueueDialogShown = False
self.__capsLockState = None
self.__lang = None
self.__capsLockCallbackID = None
self.__showLoginWallpaperNode = 'showLoginWallpaper'
self._autoSearchVisited = False
self._rememberUser = False
g_loginManager.servers.updateServerList()
self._servers = g_loginManager.servers
return
def onRegister(self, host):
self.fireEvent(OpenLinkEvent(OpenLinkEvent.REGISTRATION))
def onSetRememberPassword(self, rememberUser):
self._rememberUser = rememberUser
def onLogin(self, userName, password, serverName, isSocialToken2Login):
g_statistics.noteHangarLoadingState(HANGAR_LOADING_STATE.LOGIN, True)
self._autoSearchVisited = serverName == AUTO_LOGIN_QUERY_URL
result = self.__validateCredentials(userName.lower().strip(), password.strip(), bool(g_loginManager.getPreference('token2')))
if result.isValid:
Waiting.show('login')
g_loginManager.initiateLogin(userName, password, serverName, isSocialToken2Login, isSocialToken2Login or self._rememberUser)
else:
self.as_setErrorMessageS(result.errorMessage, result.invalidFields)
def resetToken(self):
g_loginManager.clearToken2Preference()
def showLegal(self):
self.fireEvent(events.LoadViewEvent(VIEW_ALIAS.LEGAL_INFO_WINDOW), EVENT_BUS_SCOPE.LOBBY)
def isPwdInvalid(self, password):
isInvalid = False
if not constants.IS_DEVELOPMENT and not g_loginManager.getPreference('token2'):
from external_strings_utils import isPasswordValid
isInvalid = not isPasswordValid(password)
return isInvalid
def isLoginInvalid(self, login):
isInvalid = False
if not constants.IS_DEVELOPMENT and not g_loginManager.getPreference('token2'):
from external_strings_utils import isAccountLoginValid
isInvalid = not isAccountLoginValid(login)
return isInvalid
def onRecovery(self):
self.fireEvent(OpenLinkEvent(OpenLinkEvent.RECOVERY_PASSWORD))
def isToken(self):
return bool(g_loginManager.getPreference('token2'))
def onEscape(self):
def buttonHandler(isOk):
if isOk:
self.destroy()
BigWorld.quit()
DialogsInterface.showI18nConfirmDialog('quit', buttonHandler, focusedID=DIALOG_BUTTON_ID.CLOSE)
def startListenCsisUpdate(self, startListenCsis):
g_loginManager.servers.startListenCsisQuery(startListenCsis)
def onExitFromAutoLogin(self):
pass
def saveLastSelectedServer(self, server):
pass
def _populate(self):
View._populate(self)
self._serversDP = ServersDataProvider()
self._serversDP.setFlashObject(self.as_getServersDPS())
self.as_enableS(True)
self._servers.onServersStatusChanged += self.__updateServersList
connectionManager.onRejected += self._onLoginRejected
g_playerEvents.onLoginQueueNumberReceived += self._onHandleQueue
g_playerEvents.onKickWhileLoginReceived += self._onKickedWhileLogin
g_playerEvents.onAccountShowGUI += self._clearLoginView
self.as_setVersionS(getFullClientVersion())
self.as_setCopyrightS(_ms(MENU.COPY), _ms(MENU.LEGAL))
self.__loadRandomBgImage()
if self.__capsLockCallbackID is None:
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
g_sessionProvider.getCtx().lastArenaUniqueID = None
self._setData()
self._showForm()
return
def _dispose(self):
if self.__capsLockCallbackID is not None:
BigWorld.cancelCallback(self.__capsLockCallbackID)
self.__capsLockCallbackID = None
connectionManager.onRejected -= self._onLoginRejected
self._servers.onServersStatusChanged -= self.__updateServersList
g_playerEvents.onLoginQueueNumberReceived -= self.__loginQueueDialogShown
g_playerEvents.onKickWhileLoginReceived -= self._onKickedWhileLogin
g_playerEvents.onAccountShowGUI -= self._clearLoginView
self._serversDP.fini()
self._serversDP = None
View._dispose(self)
return
def _showForm(self):
self.as_showSimpleFormS(False, None)
return
def _setData(self):
self._rememberUser = g_loginManager.getPreference('remember_user')
if self._rememberUser:
password = '******' * g_loginManager.getPreference('password_length')
else:
password = ''
if GUI_SETTINGS.clearLoginValue:
login = password = ''
else:
login = g_loginManager.getPreference('login')
self.as_setDefaultValuesS(login, password, self._rememberUser, GUI_SETTINGS.rememberPassVisible, GUI_SETTINGS.igrCredentialsReset, not GUI_SETTINGS.isEmpty('recoveryPswdURL'))
self.__updateServersList()
def _clearLoginView(self, *args):
Waiting.hide('login')
if self.__loginQueueDialogShown:
self.__closeLoginQueueDialog()
if self.__loginRetryDialogShown:
self.__closeLoginRetryDialog()
def _onKickedWhileLogin(self, peripheryID):
Waiting.hide('login')
messageType = 'another_periphery' if peripheryID else 'checkout_error'
self.as_setErrorMessageS(_ms(SYSTEM_MESSAGES.all(messageType)), INVALID_FIELDS.ALL_VALID)
if not self.__loginRetryDialogShown:
self.__showLoginRetryDialog({'waitingOpen': WAITING.titles(messageType),
'waitingClose': WAITING.BUTTONS_CEASE,
'message': _ms(WAITING.message(messageType), connectionManager.serverUserName)})
def _onHandleQueue(self, queueNumber):
serverName = connectionManager.serverUserName
showAutoSearchBtn = AUTO_LOGIN_QUERY_ENABLED and not self._autoSearchVisited
cancelBtnLbl = WAITING.BUTTONS_CANCEL if showAutoSearchBtn else WAITING.BUTTONS_EXITQUEUE
message = _ms(WAITING.MESSAGE_QUEUE, serverName, queueNumber)
if showAutoSearchBtn:
message = _ms(WAITING.MESSAGE_USEAUTOSEARCH, serverName, queueNumber, serverName)
if not self.__loginQueueDialogShown:
self._clearLoginView()
self.__loginQueueDialogShown = True
self.fireEvent(LoginEventEx(LoginEventEx.SET_LOGIN_QUEUE, View.alias, WAITING.TITLES_QUEUE, message, cancelBtnLbl, showAutoSearchBtn), EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self._onLoginQueueClosed, EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.SWITCH_LOGIN_QUEUE_TO_AUTO, self._onLoginQueueSwitched, EVENT_BUS_SCOPE.LOBBY)
else:
ctx = {'title': WAITING.TITLES_QUEUE,
'message': message,
'cancelLabel': cancelBtnLbl,
'showAutoLoginBtn': showAutoSearchBtn}
self.fireEvent(ArgsEvent(ArgsEvent.UPDATE_ARGS, VIEW_ALIAS.LOGIN_QUEUE, ctx), EVENT_BUS_SCOPE.LOBBY)
def _onLoginQueueClosed(self, event):
self.__closeLoginQueueDialog()
def _onLoginQueueSwitched(self, event):
self.__closeLoginQueueDialog()
self.as_switchToAutoAndSubmitS(AUTO_LOGIN_QUERY_URL)
def _onLoginRejected(self, loginStatus, responseData):
Waiting.hide('login')
if loginStatus == LOGIN_STATUS.LOGIN_REJECTED_BAN:
self.__loginRejectedBan(responseData)
elif loginStatus == LOGIN_STATUS.LOGIN_REJECTED_RATE_LIMITED:
self.__loginRejectedRateLimited()
elif loginStatus in (LOGIN_STATUS.LOGIN_REJECTED_BAD_DIGEST, LOGIN_STATUS.LOGIN_BAD_PROTOCOL_VERSION):
self.__loginRejectedUpdateNeeded()
else:
self.as_setErrorMessageS(_ms('#menu:login/status/' + loginStatus), _STATUS_TO_INVALID_FIELDS_MAPPING[loginStatus])
self.__clearFields(_STATUS_TO_INVALID_FIELDS_MAPPING[loginStatus])
self._dropLoginQueue(loginStatus)
def _dropLoginQueue(self, loginStatus):
"""Safely drop login queue considering login status and current state of login queue.
"""
if loginStatus != LOGIN_STATUS.LOGIN_REJECTED_RATE_LIMITED and self.__loginRetryDialogShown:
self.__closeLoginQueueDialog()
def __clearFields(self, invalidField):
if invalidField == INVALID_FIELDS.PWD_INVALID:
self.as_resetPasswordS()
@process
def __loginRejectedUpdateNeeded(self):
success = yield DialogsInterface.showI18nConfirmDialog('updateNeeded')
if success and not BigWorld.wg_quitAndStartLauncher():
self.as_setErrorMessageS(_ms(MENU.LOGIN_STATUS_LAUNCHERNOTFOUND), INVALID_FIELDS.ALL_VALID)
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 __loginRejectedRateLimited(self):
self.as_setErrorMessageS(_ms(MENU.LOGIN_STATUS_LOGIN_REJECTED_RATE_LIMITED), INVALID_FIELDS.ALL_VALID)
if not self.__loginRetryDialogShown:
self.__showLoginRetryDialog({'waitingOpen': WAITING.TITLES_QUEUE,
'waitingClose': WAITING.BUTTONS_EXITQUEUE,
'message': _ms(WAITING.MESSAGE_AUTOLOGIN, connectionManager.serverUserName)})
def __showLoginRetryDialog(self, data):
self._clearLoginView()
self.fireEvent(LoginEventEx(LoginEventEx.SET_AUTO_LOGIN, View.alias, data['waitingOpen'], data['message'], data['waitingClose'], False), EVENT_BUS_SCOPE.LOBBY)
self.addListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self.__closeLoginRetryDialog, EVENT_BUS_SCOPE.LOBBY)
self.__loginRetryDialogShown = True
def __closeLoginRetryDialog(self, event = None):
connectionManager.stopRetryConnection()
self.fireEvent(LoginEvent(LoginEventEx.CANCEL_LGN_QUEUE, View.alias))
self.removeListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self.__closeLoginRetryDialog, EVENT_BUS_SCOPE.LOBBY)
self.__loginRetryDialogShown = False
def __closeLoginQueueDialog(self):
self.fireEvent(LoginEvent(LoginEvent.CANCEL_LGN_QUEUE, View.alias))
g_preDefinedHosts.resetQueryResult()
self.removeListener(LoginEventEx.ON_LOGIN_QUEUE_CLOSED, self._onLoginQueueClosed, EVENT_BUS_SCOPE.LOBBY)
self.removeListener(LoginEventEx.SWITCH_LOGIN_QUEUE_TO_AUTO, self._onLoginQueueSwitched, EVENT_BUS_SCOPE.LOBBY)
self.__loginQueueDialogShown = False
def __checkUserInputState(self):
self.__capsLockCallbackID = None
caps = BigWorld.wg_isCapsLockOn()
if self.__capsLockState != caps:
self.__capsLockState = caps
self.as_setCapsLockStateS(self.__capsLockState)
lang = BigWorld.wg_getLangCode()
if self.__lang != lang:
self.__lang = lang
self.as_setKeyboardLangS(self.__lang)
self.__capsLockCallbackID = BigWorld.callback(0.1, self.__checkUserInputState)
return
def __validateCredentials(self, userName, password, isToken2Login):
isValid = True
errorMessage = None
invalidFields = None
if isToken2Login or constants.IS_DEVELOPMENT:
return _ValidateCredentialsResult(isValid, errorMessage, invalidFields)
else:
if len(userName) < _LOGIN_NAME_MIN_LENGTH:
isValid = False
errorMessage = _ms(MENU.LOGIN_STATUS_INVALID_LOGIN_LENGTH, count=_LOGIN_NAME_MIN_LENGTH)
invalidFields = INVALID_FIELDS.LOGIN_INVALID
elif not isAccountLoginValid(userName):
isValid = False
errorMessage = _ms(MENU.LOGIN_STATUS_INVALID_LOGIN)
invalidFields = INVALID_FIELDS.LOGIN_INVALID
elif not isPasswordValid(password):
isValid = False
errorMessage = _ms(MENU.LOGIN_STATUS_INVALID_PASSWORD, minLength=_PASSWORD_MIN_LENGTH, maxLength=_PASSWORD_MAX_LENGTH)
invalidFields = INVALID_FIELDS.PWD_INVALID
return _ValidateCredentialsResult(isValid, errorMessage, invalidFields)
def __loadRandomBgImage(self):
wallpaperSettings = self.__loadLastBackgroundImage()
wallpaperFiles = self.__getWallpapersList()
BG_IMAGES_PATH = '../maps/login/%s.png'
if wallpaperSettings['show'] and len(wallpaperFiles) > 0:
if len(wallpaperFiles) == 1:
newFile = wallpaperFiles[0]
else:
newFile = ''
while True:
newFile = random.choice(wallpaperFiles)
if newFile != wallpaperSettings['filename']:
break
self.__saveLastBackgroundImage(newFile)
bgImage = BG_IMAGES_PATH % newFile
else:
bgImage = BG_IMAGES_PATH % '__login_bg'
wallpaperSettings['show'] = False
self.as_showWallpaperS(wallpaperSettings['show'], bgImage)
@staticmethod
def __getWallpapersList():
result = []
ds = ResMgr.openSection(SCALEFORM_WALLPAPER_PATH)
for filename in ds.keys():
if filename[-4:] == '.png' and filename[0:2] != '__':
result.append(filename[0:-4])
return result
def __loadLastBackgroundImage(self):
result = {'show': True,
'filename': ''}
userPrefs = Settings.g_instance.userPrefs
ds = None
if not userPrefs.has_key(Settings.KEY_LOGINPAGE_PREFERENCES):
userPrefs.write(Settings.KEY_LOGINPAGE_PREFERENCES, '')
self.__saveLastBackgroundImage(result['filename'])
else:
ds = userPrefs[Settings.KEY_LOGINPAGE_PREFERENCES]
result['filename'] = ds.readString('lastLoginBgImage', '')
if ds is None:
ds = userPrefs[Settings.KEY_LOGINPAGE_PREFERENCES]
if not ds.has_key(self.__showLoginWallpaperNode):
self.__createNodeShowWallpaper()
result['show'] = ds.readBool(self.__showLoginWallpaperNode, True)
return result
@staticmethod
def __saveLastBackgroundImage(filename):
ds = Settings.g_instance.userPrefs[Settings.KEY_LOGINPAGE_PREFERENCES]
ds.writeString('lastLoginBgImage', filename)
def __createNodeShowWallpaper(self):
ds = Settings.g_instance.userPrefs[Settings.KEY_LOGINPAGE_PREFERENCES]
ds.writeBool(self.__showLoginWallpaperNode, True)
def __updateServersList(self, *args):
self._serversDP.rebuildList(self._servers.serverList)
if not self.__isListInitialized and self._servers.serverList:
self.__isListInitialized = True
self.as_setSelectedServerIndexS(self._servers.selectedServerIdx)
