def test_table_time_gen(sh):
startdate = datetime(2016, 01, 31, 12, 00, 00)
totalSeconds = 86400
interval = 3600
amount = totalSeconds / interval
pr = Preferences()
prefix = pr.get('DBPrefix')
sh.createNewTableStructure(prefix)
sh.generateTimeSlots(startdate, interval, amount, prefix)
def test_competitor_creation(sh):
global pr
pr = Preferences()
prefix = pr.get('DBPrefix')
sh = SetupHelper.SetupHelper()
sh.setManualDbCursor(DatabaseConnection.DatabaseConnection().getDatabaseCursor())
if random() < 0.5:
print sh.createNewCompetitor(names.get_last_name(), names.get_first_name(gender='male'), "U18M", prefix)
else:
print sh.createNewCompetitor(names.get_last_name(), names.get_first_name(gender='female'), "U18F", prefix)
def mass_test_raw_data_entry_creation(sh, start, end, interval=1):
pr = Preferences()
prefix = pr.get('DBPrefix')
sh.generateRawDataEntrys(start, end, interval, prefix)
def test_get_raw_data_cell(actions, timeSlotID, id, prefix=""):
print actions.getRawDataEntry(timeSlotID, id)
def test_get_competitor_info(actions, uuid, prefix=""):
timeSlots = range(1, 25)
return actions.getCompetitorInfo(timeSlots, uuid, prefix)
if __name__ == "__main__":
actions = Actions.Actions()
actions.setManualDbCursor(DatabaseConnection.DatabaseConnection().getDatabaseCursor())
# test_update_raw_data_cell(actions, 5, 5, 5)
# for i in range(50):
# test_random_update_raw_data_cell(actions)
try:
pr = Preferences()
while True:
test_random_update_raw_data_cell(actions, pr.get("DBPrefix"))
time.sleep(0.5)
except KeyboardInterrupt:
print "\nShutting down!\n"
sys.exit(0)
# test_get_raw_data_cell(actions, 2, 2)
# test_get_raw_data_cell(actions, 8, 7)
# print test_get_competitor_info(actions, 1, "testDB_")
class Manager(ILoginManager):
lobbyContext = dependency.descriptor(ILobbyContext)
connectionMgr = dependency.descriptor(IConnectionManager)
def __init__(self):
self._preferences = None
self.__servers = None
self.__wgcManager = None
self.__triedToInitWGC = False
return
@property
def wgcAvailable(self):
return self.__wgcManager is not None
def init(self):
self.tryPrepareWGCLogin()
self._preferences = Preferences()
if constants.IS_DEVELOPMENT:
self.__servers = DevelopmentServers(self._preferences)
else:
self.__servers = Servers(self._preferences)
self.connectionMgr.onLoggedOn += self._onLoggedOn
def fini(self):
self.connectionMgr.onLoggedOn -= self._onLoggedOn
self._preferences = None
self.__servers.fini()
self.__servers = None
self.stopWgc()
return
def initiateLogin(self, email, password, serverName, isSocialToken2Login, rememberUser):
isToken2Login = isSocialToken2Login or self._preferences['token2']
authMethod = CONNECTION_METHOD.TOKEN2 if isToken2Login else CONNECTION_METHOD.BASIC
serverName = self._getHost(authMethod, serverName)
self._preferences['session'] = BigWorld.wg_cpsalt(self._preferences['session'])
self._preferences['password_length'] = len(password)
self._preferences['remember_user'] = rememberUser
self._preferences['login'] = email
self._preferences['server_name'] = serverName
loginParams = {'login': self._preferences['login'],
'session': self._preferences['session'],
'temporary': str(int(not rememberUser)),
'auth_method': authMethod}
if isToken2Login:
loginParams['token2'] = self._preferences['token2']
if not isSocialToken2Login:
self._preferences['login_type'] = 'credentials'
self.connectionMgr.initiateConnection(loginParams, password, serverName)
self.connectionMgr.setLastLogin(email)
def initiateRelogin(self, login, token2, serverName):
if self.wgcAvailable:
self.__wgcManager.relogin(token2, serverName)
else:
loginParams = {'login': login,
'token2': token2,
'session': BigWorld.wg_cpsalt(self._preferences['session']),
'temporary': str(int(not self._preferences['remember_user'])),
'auth_method': CONNECTION_METHOD.TOKEN2}
self._preferences['server_name'] = serverName
self.connectionMgr.initiateConnection(loginParams, '', serverName)
def getPreference(self, key):
return self._preferences[key]
def clearPreferences(self):
self._preferences.clear()
def clearToken2Preference(self):
self._preferences['token2'] = ''
def writePreferences(self):
self._preferences.writeLoginInfo()
@property
def servers(self):
return self.__servers
def _onLoggedOn(self, responseData):
name = responseData.get('name', 'UNKNOWN')
token2 = responseData.get('token2', '')
self.lobbyContext.setCredentials(name, token2)
if self.wgcAvailable and self.__wgcManager.onLoggedOn(responseData):
self._preferences.clear()
self._preferences.writeLoginInfo()
NonRecruitNotifierSingleton().getInstance().resetFirstShowState()
return
loginCount = self._preferences.get('loginCount', 0)
self._preferences['loginCount'] = 1 if loginCount >= _LIMIT_LOGIN_COUNT else loginCount + 1
if self._preferences['remember_user']:
self._preferences['name'] = name
self._preferences['token2'] = token2
if 'server_name' in self._preferences and AUTO_LOGIN_QUERY_ENABLED:
del self._preferences['server_name']
else:
email = self._preferences['login']
serverName = self._preferences['server_name']
session = self._preferences['session']
loginCount = self._preferences['loginCount']
self._preferences.clear()
if not constants.IS_SINGAPORE and not GUI_SETTINGS.igrCredentialsReset:
self._preferences['login'] = email
if not AUTO_LOGIN_QUERY_ENABLED:
self._preferences['server_name'] = serverName
self._preferences['session'] = session
self._preferences['loginCount'] = loginCount
self._preferences.writeLoginInfo()
self.__dumpUserName(name)
self._showSecurityMessage(responseData)
NonRecruitNotifierSingleton().getInstance().resetFirstShowState()
def _showSecurityMessage(self, responseData):
securityWarningType = responseData.get('security_msg')
if securityWarningType is not None:
securityLink = ''
if not GUI_SETTINGS.isEmpty('securitySettingsURL'):
securityLink = makeHtmlString('html_templates:lobby/system_messages', 'link', {'text': _ms(SYSTEM_MESSAGES.SECURITYMESSAGE_CHANGE_SETINGS),
'linkType': 'securityLink'})
SystemMessages.pushI18nMessage('#system_messages:securityMessage/%s' % securityWarningType, type=SystemMessages.SM_TYPE.Warning, link=securityLink)
return
def writePeripheryLifetime(self):
if AUTO_LOGIN_QUERY_ENABLED and self.connectionMgr.peripheryID:
self._preferences['peripheryLifetime'] = pickle.dumps((self.connectionMgr.peripheryID, time.time() + _PERIPHERY_DEFAULT_LIFETIME))
self._preferences.writeLoginInfo()
@staticmethod
def getAvailableSocialNetworks():
raise SoftException('This method should not be reached in this context')
def initiateSocialLogin(self, socialNetworkName, serverName, rememberUser, isRegistration):
raise SoftException('This method should not be reached in this context')
def _getHost(self, authMethod, hostName):
if hostName != AUTO_LOGIN_QUERY_URL:
return hostName
else:
pickledData = self._preferences['peripheryLifetime']
if pickledData:
try:
peripheryID, expirationTimestamp = pickle.loads(pickledData)
except Exception:
LOG_DEBUG("Couldn't to read pickled periphery data. Connecting to {0}.".format(hostName))
return hostName
if expirationTimestamp > time.time():
host = g_preDefinedHosts.periphery(peripheryID, False)
if host is None:
return hostName
if authMethod != CONNECTION_METHOD.BASIC and host.urlToken:
return host.urlToken
return host.url
return hostName
def __dumpUserName(self, name):
Settings.g_instance.userPrefs[Settings.KEY_LOGIN_INFO].writeString('user', name)
Settings.g_instance.save()
def addOnWgcErrorListener(self, listener):
if self.wgcAvailable:
self.__wgcManager.onWgcError += listener
else:
_logger.warning('Try to addOnWgcErrorListener while WGC is not available')
def removeOnWgcErrorListener(self, listener):
if self.wgcAvailable:
self.__wgcManager.onWgcError -= listener
else:
_logger.warning('Try to removeOnWgcErrorListener while WGC is not available')
def tryWgcLogin(self, serverName=None):
if not self.wgcAvailable:
_logger.warning('WGC is not available, no possibility to login via it, so return')
return
else:
if serverName is None:
selectedServer = self.__servers.selectedServer
if not selectedServer:
_logger.warning('No server was selected when WGC connect happened, so return')
return
serverName = selectedServer['data']
hostName = self._getHost(CONNECTION_METHOD.TOKEN, serverName)
self.__wgcManager.login(hostName)
return
def stopWgc(self):
if self.wgcAvailable:
self.__wgcManager.destroy()
self.__wgcManager = None
return
def tryPrepareWGCLogin(self):
if self.wgcAvailable:
if not BigWorld.WGC_prepareLogin():
self.stopWgc()
elif not self.__triedToInitWGC:
if BigWorld.WGC_prepareLogin():
self.__wgcManager = _WgcModeManager()
self.__triedToInitWGC = True
def checkWgcCouldRetry(self, status):
return self.__wgcManager.checkWgcCouldRetry(status) if self.wgcAvailable else False
