def withParams(func): ''' @param func function( 'study'= db.Studies, 'languages'= [db.Languages], 'words'= [db.Words]) -> flask response @return flask response ''' params = ['study', 'languages', 'words'] for p in params: if p not in flask.request.args: return 'GET parameters should be: ' + str(params) fetched = {} for p in params: try: val = flask.request.args[p] if p == 'study': fetched[p] = db.getSession().query(db.Studies).filter_by(Name=val).limit(1).one() else: val = val.split(',') if p == 'languages': langs = [] for lIx in val: langs.append(db.getSession().query(db.Languages).filter_by(LanguageIx=lIx).limit(1).one()) fetched[p] = langs elif p == 'words': words = [] for wId in val: where = sqlalchemy.func.concat(db.Words.IxElicitation, db.Words.IxMorphologicalInstance).like(wId) words.append(db.getSession().query(db.Words).filter(where).limit(1).one()) fetched[p] = words except: return 'Could not fetch data for parameter: ' + p return func(**fetched)
def getData(): # Checking if global portion of data is requested: if 'global' in flask.request.args: return getGlobal() # Checking if study depandant portion of data is requested: if 'study' in flask.request.args: studyName = flask.request.args['study'] if studyName == '': return 'You need to supply a value for that study parameter!' else: studyCount = db.getSession().query(db.Studies).filter_by(Name = studyName).limit(1).count() if studyCount == 1: return getStudy(studyName) else: return ("Couldn't find study: "+studyName) # Normal response in case of no get parameters: try: latest = db.getSession().query(db.EditImports).order_by(db.EditImports.Time.desc()).limit(1).one() dict = { 'lastUpdate': latest.getTimeStampString(), 'Description': 'Add a global parameter to fetch global data, and add a study parameter to fetch a study.' } return flask.jsonify(**dict) except sqlalchemy.orm.exc.NoResultFound: return flask.jsonify(**{})
def buildCSV(): ''' Build after the preimage of php/export/csv.php Expected GET parameters are: * study, containing the name of a study * languages, containing ',' delimited languageIds * words, containing ',' delimited wordIds Example route: export/csv?study=Slavic&languages=13111210507&words=10,20,30 ''' args = flask.request.args # Checking parameters: params = ['study', 'languages', 'words'] for p in params: if p not in args: msg = "Missing parameter: '%s'! Parameters should be: %s" % (p, params) return msg, 400 # Querying languages: lIds = {int(id) for id in args['languages'].split(',')} languages = db.getSession().query(db.Languages).filter_by(StudyName=args['study']).filter(db.Languages.LanguageIx.in_(lIds)).all() # Querying words: wIds = {int(id) for id in args['words'].split(',')} words = db.getSession().query(db.Words).filter_by(StudyName=args['study']).all() words = [w for w in words if int(str(w.IxElicitation) + str(w.IxMorphologicalInstance)) in wIds] def quote(x): # Compossing csv: return '"' + x + '"' head = ['LanguageId', 'LanguageName', 'Latitude', 'Longitude', 'WordId', 'WordModernName1', 'WordModernName2', 'WordProtoName1', 'WordProtoName2', 'Phonetic', 'SpellingAltv1', 'SpellingAltv2', 'NotCognateWithMainWordInThisFamily'] csv = [[quote(h) for h in head]] for l in languages: lPart = [str(l.LanguageIx), quote(l.ShortName), str(l.Latitude or ''), str(l.Longtitude or '')] for w in words: wPart = [str(w.IxElicitation) + str(w.IxMorphologicalInstance), quote(w.FullRfcModernLg01), quote(w.FullRfcModernLg02), quote(w.FullRfcProtoLg01), quote(w.FullRfcProtoLg02)] transcriptions = [t for t in w.Transcriptions if t.LanguageIx in lIds] for t in transcriptions: tPart = [quote(t.Phonetic), quote(t.SpellingAltv1), quote(t.SpellingAltv2), str(t.NotCognateWithMainWordInThisFamily)] csv.append(lPart + wPart + tPart) # Transform csv to string: csv = "\n".join([','.join(line) for line in csv]) # filename to use: filename = 'Customexport_%s.csv' % datetime.datetime.utcnow().isoformat() # Build and return response: response = flask.make_response(csv) response.headers["Pragma"] = "public" response.headers["Expires"] = "0" response.headers["Cache-Control"] = "must-revalidate, post-check=0, pre-check=0" response.headers["Content-Type"] = "text/csv; charset=utf-8" response.headers["Content-Disposition"] = ('attachment;filename="%s"' % filename) response.headers["Content-Transfer-Encoding"] = "binary" return response
def _insert(): for i in xrange(1, len(s['str'])+1): prefix = s['str'][:i] # Find first non inserted prefix: try: exists = db.getSession().query(db.ShortLinks).filter_by(Name = prefix).limit(1).one() continue except: entry = db.ShortLinks(Hash = s['hex'], Name = prefix, Target = s['url']) db.getSession().add(entry) db.getSession().commit() print 'Inserted!' return toShortUrlDict(entry)
def initModels(): """Initialize timebot DB tables and mappers""" engine = db.getEngine() meta = db.getMeta() session = db.getSession() tb_user = Table( 'tb_user', meta, Column('id', Integer, primary_key=True, autoincrement=True), Column('company_id', None, ForeignKey('tb_company.id'), nullable=True), Column('jid', Unicode(50), unique=True, nullable=False), Column('name', Unicode(50)), Column('rate', Integer)) tb_worktime = Table( 'tb_time', meta, Column('id', Integer, primary_key=True), Column('user_id', None, ForeignKey('tb_user.id'), nullable=False), Column('start', DateTime, default=datetime.now), Column('stop', DateTime, nullable=True)) tb_company = Table( 'tb_company', meta, Column('id', Integer, primary_key=True), Column('name', Unicode(50), nullable=True)) meta.create_all() mapper(TUser, tb_user, properties=dict( worktime=relation(TWorktime), company=relation(TCompany))) mapper(TWorktime, tb_worktime, properties=dict( user=relation(TUser))) mapper(TCompany, tb_company, properties=dict( users=relation(TUser)))
def insert(url): # Transform a ShortLinks instance to a dict like it's returned by shorten: def toShortUrlDict(shortLink): return { 'url': shortLink.Target, 'hex': shortLink.Hash, 'str': shortLink.Name } # Shortened data: s = shorten(url) # Helper to find prefix: def _insert(): for i in xrange(1, len(s['str'])+1): prefix = s['str'][:i] # Find first non inserted prefix: try: exists = db.getSession().query(db.ShortLinks).filter_by(Name = prefix).limit(1).one() continue except: entry = db.ShortLinks(Hash = s['hex'], Name = prefix, Target = s['url']) db.getSession().add(entry) db.getSession().commit() print 'Inserted!' return toShortUrlDict(entry) # Return existing entry rather than creating a new one: try: exists = db.getSession().query(db.ShortLinks).filter_by(Hash = s['hex']).limit(1).one() return toShortUrlDict(exists) except: return _insert()
def dictAll(model): ''' @param model (db.Model, SndCompModel) @return [{}] A list of Dicts Fetch all models and make them a list of ditcs. ''' return [m.toDict() for m in db.getSession().query(model).all()]
def testAuth(self): sanicRequests.newSession() dSession = getSession() username = "******" password = "******" userData = { "username": username, "password": password, "email": "*****@*****.**", "isStaff": True, "isActive": True, "verified": True } deleteUser(username, dSession=dSession) token = sanicRequests.get("api/forms/token").json() userData.update(token) sanicRequests.post("api/auth/createUser", data=userData) login = {"ident": "testUser", "password": "******"} login.update(token) response = sanicRequests.post("api/auth/login", data=login) print("logged in", response.cookies.get("authenticated")) print("response", response.json())
def getSummary(): tMap = {}#TranslationId -> Page_Translations.toDict() ts = db.getSession().query(db.Page_Translations).filter( sqlalchemy.or_( db.Page_Translations.Active == 1, db.Page_Translations.TranslationId == 1) ).all() for t in ts: tMap[str(t.TranslationId)] = t.toDict() return flask.jsonify(**tMap)
def getGlobal(): # Structure to fill up: data = { 'studies': [s.Name for s in db.getSession().query(db.Studies).all()] , 'global': { 'soundPath': 'static/sound' , 'shortLinks': {l.Name: l.Target for l in db.getSession().query(db.ShortLinks).all()} , 'contributors': dictAll(db.Contributors) , 'contributorCategories': dictAll(db.ContributorCategories) , 'flagTooltip': dictAll(db.FlagTooltip) , 'languageStatusTypes': dictAll(db.LanguageStatusTypes) , 'meaningGroups': dictAll(db.MeaningGroups) , 'transcrSuperscriptInfo': dictAll(db.TranscrSuperscriptInfo) , 'transcrSuperscriptLenderLgs': dictAll(db.TranscrSuperscriptLenderLgs) , 'wikipediaLinks': dictAll(db.WikipediaLinks) } } # Return stuff encoded as JSON: return flask.jsonify(**data)
def upsertCorporation(eve, corporationID, session=None): try: if session == None: session = getSession() commitOnEnd = True else: commitOnEnd = False # Check if we already have the corp in the database query = session.query(Corporation).filter( Corporation.corporationID == corporationID) if query.count() > 0: dbCorp = query[0] # Don't update if it's been done within the last 6hrs if (dbCorp.lastUpdated + datetime.timedelta(0, 21600)) > datetime.datetime.now(): return True else: # Create the Corporation object dbCorp = Corporation() dbCorp.corporationID = corporationID # Call the XMLAPI corpSheet = eve.corp.CorporationSheet(corporationID=corporationID) # Update the object dbCorp.corporationName = corpSheet.corporationName dbCorp.ticker = corpSheet.ticker dbCorp.taxRate = corpSheet.taxRate dbCorp.memberCount = corpSheet.memberCount dbCorp.lastUpdated = datetime.datetime.now() if corpSheet.allianceID == 0: dbCorp.allianceID = None else: # Upsert the alliance if not upsertAlliance(eve=eve, allianceID=corpSheet.allianceID): apiLog( "An error occurred upserting allianceID=%d, so we'll rollback and try later" % corpSheet.allianceID) session.rollback() return False dbCorp.allianceID = corpSheet.allianceID # Commit the changes session.add(dbCorp) if commitOnEnd == True: session.commit() return True except Exception as e: apiLog( "Exception occurred doing public corp update on corporationID=%d: %s" % (corporationID, str(e))) session.rollback() return False
def getSummary(): ''' @return flask reply Provides a JSON encoded summary of available translations to the client. ''' tMap = {} # TranslationId -> Page_Translations.toDict() ts = db.getSession().query(db.Page_Translations).filter(sqlalchemy.or_( db.Page_Translations.Active == 1, db.Page_Translations.TranslationId == 1)).all() for t in ts: tMap[str(t.TranslationId)] = t.toDict() return flask.jsonify(**tMap)
def addApi(user, keyID, vCode, name, session=getSession()): try: if session.query(Api).filter(Api.keyID == keyID, Api.vCode==vCode).count() > 0: return "This API Key is already in the database" # We NEED APIKeyInfo, AccountStatus, CharacterSheet and AssetList eveapi.set_user_agent("eveapi.py/1.3") eve = eveapi.EVEAPIConnection() try: keyInfo = eve.account.APIKeyInfo(keyID=keyID, vCode=vCode) if keyInfo.key.type == "Corporation": return "This is a corp API, it's need to be a Character or Account API" except eveapi.Error as e: return "This API key is invalid or expired" try: accStatus = eve.account.AccountStatus(keyID=keyID, vCode=vCode) apiChar = eve.char.CharacterSheet(keyID=keyID, vCode=vCode, characterID=keyInfo.key.characters[0].characterID) assetList = eve.char.AssetList(keyID=keyID, vCode=vCode, characterID=keyInfo.key.characters[0].characterID, flat=1) charInfo = eve.eve.CharacterInfo(keyID=keyID, vCode=vCode, characterID=keyInfo.key.characters[0].characterID) except eveapi.Error as e: return "Your API key doesn't have enough permissions, at minimum it needs to be an active key with AccountStatus and CharacterInfo" # Build the key object api = Api() api.userId = user.id api.keyID = keyID api.vCode = vCode api.accessMask = keyInfo.key.accessMask api.type = keyInfo.key.type api.paidUntil = datetime.datetime.fromtimestamp(accStatus.paidUntil) api.createDate = datetime.datetime.fromtimestamp(accStatus.createDate) api.logonCount = accStatus.logonCount api.logonMinutes = accStatus.logonMinutes api.name = name api.lastUpdated = datetime.datetime.now() api.added = datetime.datetime.now() session.add(api) session.commit() # Now update the api key updateApiKey(session=session, api=api) return api except eveapi.Error as e: session.rollback() return "An error occurred on the EVE API, it's probably not your fault, try again later" except Exception as e: session.rollback() return "An error occurred querying this key: %s" % str(e)
def getI18n(lngs): i18n = defaultdict(dict) for l in lngs: try: translation = db.getSession().query(db.Page_Translations).filter_by(BrowserMatch = l).limit(1).one() tDict = {} for s in translation.Page_StaticTranslation: tDict[s.Req] = s.Trans for d in translation.Page_DynamicTranslation: tDict[d.Category+d.Field] = d.Trans i18n[l]['translation'] = tDict except sqlalchemy.orm.exc.NoResultFound: pass return flask.jsonify(**i18n)
def chkTranslationId(func): if 'translationId' in flask.request.args: tId = flask.request.args['translationId'] try: t = db.getSession().query(db.Page_Translations).filter_by(TranslationId = tId).limit(1).one() return func(t) except sqlalchemy.orm.exc.NoResultFound: return flask.jsonify(**{ 'msg': 'Specified translationId not found in database: '+tId }) action = flask.request.args['action'] return flask.jsonify(**{ 'msg': 'You need to specify a translationId for action='+action+'.' })
def upsertCorporation(eve, corporationID, session=None): try: if session == None: session = getSession() commitOnEnd = True else: commitOnEnd = False # Check if we already have the corp in the database query = session.query(Corporation).filter(Corporation.corporationID == corporationID) if query.count() > 0: dbCorp = query[0] # Don't update if it's been done within the last 6hrs if (dbCorp.lastUpdated + datetime.timedelta(0, 21600)) > datetime.datetime.now(): return True else: # Create the Corporation object dbCorp = Corporation() dbCorp.corporationID = corporationID # Call the XMLAPI corpSheet = eve.corp.CorporationSheet(corporationID=corporationID) # Update the object dbCorp.corporationName = corpSheet.corporationName dbCorp.ticker = corpSheet.ticker dbCorp.taxRate = corpSheet.taxRate dbCorp.memberCount = corpSheet.memberCount dbCorp.lastUpdated = datetime.datetime.now() if corpSheet.allianceID == 0: dbCorp.allianceID = None else: # Upsert the alliance if not upsertAlliance(eve=eve, allianceID=corpSheet.allianceID): apiLog("An error occurred upserting allianceID=%d, so we'll rollback and try later" % corpSheet.allianceID) session.rollback() return False dbCorp.allianceID = corpSheet.allianceID # Commit the changes session.add(dbCorp) if commitOnEnd == True: session.commit() return True except Exception as e: apiLog("Exception occurred doing public corp update on corporationID=%d: %s" % (corporationID, str(e))) session.rollback() return False
def supercheck(): session = getSession() supers = [] #for x in session.query(Asset, InvType, Character, Corporation).join(InvType).join(Character).join(Corporation).filter(InvType.groupID.in_((659, 30))).order_by(InvType.groupID, InvType.typeID, Character.lastKnownLocation).all(): for x in session.query(Asset, InvType, Character, Corporation).join(InvType).join(InvGroup).join(Character).join(Corporation).filter(InvGroup.categoryID == 6).filter(Asset.singleton == 1).order_by(InvType.groupID, InvType.typeID, Character.lastKnownLocation).all(): sup = {} sup['ship'] = x.Asset sup['type'] = x.InvType sup['char'] = x.Character sup['corp'] = x.Corporation supers.append(sup) return render_template("viewship.html", config=config.auth, supers=supers)
def upsertAlliance(eve, allianceID, session=None): try: if session == None: session = getSession() commitOnEnd = True else: commitOnEnd = False # Check if we already have the alliance in the database query = session.query(Alliance).filter( Alliance.allianceID == allianceID) if query.count() > 0: dbAlliance = query[0] # Don't update if it's been done within the last 6hrs if (dbAlliance.lastUpdated + datetime.timedelta(0, 21600)) > datetime.datetime.now(): return True else: # Create the Alliance object dbAlliance = Alliance() dbAlliance.allianceID = allianceID # Call the XMLAPI allianceList = eve.eve.AllianceList(version=1) indAllianceList = allianceList.alliances.IndexedBy("allianceID") apiAlliance = indAllianceList.Get(allianceID) # Update the object dbAlliance.allianceName = apiAlliance.name dbAlliance.ticker = apiAlliance.shortName dbAlliance.memberCount = apiAlliance.memberCount dbAlliance.startDate = datetime.datetime.fromtimestamp( apiAlliance.startDate) dbAlliance.lastUpdated = datetime.datetime.now() # Commit the changes session.add(dbAlliance) if commitOnEnd == True: session.commit() return True except Exception as e: apiLog( "Exception occurred doing public alliance update on allianceID=%d: %s" % (allianceID, str(e))) session.rollback() return False
def getStudy(studyName): ''' @param studyName String @throws sqlalchemy.orm.exc.NoResultFound if studyName not found. Replies with a JSON encoded, study dependant chunk of the database. ''' # Study to fetch stuff for: study = db.getSession().query(db.Studies).filter_by(Name=studyName).limit(1).one() def filterDicts(xs): # Helper to remove StudyName from dicts ys = [] for x in xs: d = x.toDict() d.pop('StudyName', None) ys.append(d) return ys # Structure to fill up: data = { 'study': study.toDict(), 'families': dictAll(db.Families), 'regions': filterDicts(study.Regions), 'regionLanguages': filterDicts(study.RegionLanguages), 'languages': filterDicts(study.Languages), 'words': filterDicts(study.Words), 'meaningGroupMembers': [m.toDict() for m in study.MeaningGroupMembers], 'transcriptions': filterDicts(study.Transcriptions), 'defaults': { 'language': None, 'word': None, 'languages': [{'LanguageIx': l.LanguageIx} for l in study.DefaultMultipleLanguages], 'words': [{'IxElicitation': w.IxElicitation, 'IxMorphologicalInstance': w.IxMorphologicalInstance} for w in study.DefaultMultipleWords], 'excludeMap': [{'LanguageIx': l.LanguageIx} for l in study.DefaultLanguagesExcludeMap]}} # Single defaults: if len(study.DefaultLanguages) > 0: l = study.DefaultLanguages[0] data['defaults']['language'] = {'LanguageIx': l.LanguageIx} if len(study.DefaultWords) > 0: w = study.DefaultWords[0] data['defaults']['word'] = {'IxElicitation': w.IxElicitation, 'IxMorphologicalInstance': w.IxMorphologicalInstance} # Handling dummies: dummies = db.getDummyTranscriptions(study.Name) if len(dummies): data['transcriptions'] += dummies # Return stuff encoded as JSON: return flask.jsonify(**data)
def getI18n(lngs): ''' @param lngs [String] @return flask reply Returns the JSON encoded data for translation that can be consumed by i18n client side. ''' i18n = defaultdict(dict) for l in lngs: try: translation = db.getSession().query(db.Page_Translations).filter_by(BrowserMatch=l).limit(1).one() tDict = {} for s in translation.Page_StaticTranslation: tDict[s.Req] = s.Trans for d in translation.Page_DynamicTranslation: tDict[d.Category + d.Field] = d.Trans i18n[l]['translation'] = tDict except sqlalchemy.orm.exc.NoResultFound: pass return flask.jsonify(**i18n)
def upsertAlliance(eve, allianceID, session=None): try: if session == None: session = getSession() commitOnEnd = True else: commitOnEnd = False # Check if we already have the alliance in the database query = session.query(Alliance).filter(Alliance.allianceID == allianceID) if query.count() > 0: dbAlliance = query[0] # Don't update if it's been done within the last 6hrs if (dbAlliance.lastUpdated + datetime.timedelta(0, 21600)) > datetime.datetime.now(): return True else: # Create the Alliance object dbAlliance = Alliance() dbAlliance.allianceID = allianceID # Call the XMLAPI allianceList = eve.eve.AllianceList(version=1) indAllianceList = allianceList.alliances.IndexedBy("allianceID") apiAlliance = indAllianceList.Get(allianceID) # Update the object dbAlliance.allianceName = apiAlliance.name dbAlliance.ticker = apiAlliance.shortName dbAlliance.memberCount = apiAlliance.memberCount dbAlliance.startDate = datetime.datetime.fromtimestamp(apiAlliance.startDate) dbAlliance.lastUpdated = datetime.datetime.now() # Commit the changes session.add(dbAlliance) if commitOnEnd == True: session.commit() return True except Exception as e: apiLog("Exception occurred doing public alliance update on allianceID=%d: %s" % (allianceID, str(e))) session.rollback() return False
def testCreateUser(self): app = createApp() username = "******" password = "******" userData = { "username": username, "password": password, "email": "*****@*****.**", "isStaff": True, "isActive": True, "verified": True } deleteUser(username) request, response = app.test_client.post("/api/auth/createUser", data=userData) dSession = getSession() self.assertTrue(userExists(username, dSession), "user exist") dSession.close()
def testManageUser(self): dSession = getSession(env) username = "******" password = "******" userData = { "username": username, "password": password, "email": "*****@*****.**", "isStaff": True, "isActive": True, "verified": True } deleteUser(username, dSession) createUser(userData, dSession) self.assertTrue(userExists(username, dSession), "this user should exist") deleteUser(username, dSession) self.assertFalse(userExists(username, dSession), "this user should not exist")
def chkTranslationId(func): ''' @param func Page_Translation -> flask reply @return flask reply Check the existence of a translationId parameter. If the parameter exists and the corresponding instance of Page_Translations can be fetched, the given func is called and it's result returned. Otherwise a JSON encoded error message is returned. ''' if 'translationId' in flask.request.args: tId = flask.request.args['translationId'] try: t = db.getSession().query(db.Page_Translations).filter_by(TranslationId=tId).limit(1).one() return func(t) except sqlalchemy.orm.exc.NoResultFound: return flask.jsonify(**{ 'msg': 'Specified translationId not found in database: ' + tId }) action = flask.request.args['action'] return flask.jsonify(**{ 'msg': ('You need to specify a translationId for action=%s.' % action)})
def supercheck(): session = getSession() supers = [] #for x in session.query(Asset, InvType, Character, Corporation).join(InvType).join(Character).join(Corporation).filter(InvType.groupID.in_((659, 30))).order_by(InvType.groupID, InvType.typeID, Character.lastKnownLocation).all(): for x in session.query( Asset, InvType, Character, Corporation).join(InvType).join(InvGroup).join(Character).join( Corporation).filter(InvGroup.categoryID == 6).filter( Asset.singleton == 1).order_by( InvType.groupID, InvType.typeID, Character.lastKnownLocation).all(): sup = {} sup['ship'] = x.Asset sup['type'] = x.InvType sup['char'] = x.Character sup['corp'] = x.Corporation supers.append(sup) return render_template("viewship.html", config=config.auth, supers=supers)
def singleTextFile(): ''' Build after the preimage of php/export/singleTextFile.php Expected GET parameters are: * word, only containing digits of a wordId * language, only containing digits of a languageId * study, containing the name of a study * n, number of Phonetic entry to use, starts at 0 Example route: /export/singleTextFile?word=7660&language=11111230301&study=Germanic&n=0 ''' args = flask.request.args # Checking parameters: params = ['word', 'language', 'study', 'n'] for p in params: if p not in args: msg = "Missing parameter: '%s'! Parameters should be: %s" % (p, params) return msg, 400 # Getting data to respond with: where = sqlalchemy.func.concat( db.Transcriptions.LanguageIx, db.Transcriptions.IxElicitation, db.Transcriptions.IxMorphologicalInstance).like(args['language'] + args['word']) transcriptions = db.getSession().query(db.Transcriptions).filter_by(StudyName=args['study']).filter(where).all() # Picking the element: n = int(args['n']) if n < 0: return "Parameter 'n' must be >= 0!", 400 if n > len(transcriptions): return ("Parameter 'n' cannot be >= %s for this query." % len(transcriptions)), 400 transcription = transcriptions[n].toDict() # Building and returning response: name = "transcription.txt" if len(transcription['soundPaths']) > 0: path = transcription['soundPaths'][0] name = os.path.basename(path).replace('.ogg', '.txt').replace('.mp3', '.txt') response = flask.make_response(transcription['Phonetic']) response.headers["Content-Type"] = 'text/plain; charset=utf-8' response.headers["Content-Disposition"] = "attachment; filename=%s" % name return response
def testCreateUser(self): sanicRequests.newSession() dSession = getSession() username = "******" password = "******" userData = { "username": username, "password": password, "email": "*****@*****.**", "isStaff": True, "isActive": True, "verified": True } deleteUser(username) response = sanicRequests.get("api/auth/createUser") userData.update(response.json()) print(userData) sanicRequests.post("api/auth/createUser", data=userData) self.assertTrue(userExists(username, dSession), "user should exist") dSession.close()
def addApi(user, keyID, vCode, name, session=getSession()): try: if session.query(Api).filter(Api.keyID == keyID, Api.vCode == vCode).count() > 0: return "This API Key is already in the database" # We NEED APIKeyInfo, AccountStatus, CharacterSheet and AssetList eveapi.set_user_agent("eveapi.py/1.3") eve = eveapi.EVEAPIConnection() try: keyInfo = eve.account.APIKeyInfo(keyID=keyID, vCode=vCode) if keyInfo.key.type == "Corporation": return "This is a corp API, it's need to be a Character or Account API" except eveapi.Error as e: return "This API key is invalid or expired" try: accStatus = eve.account.AccountStatus(keyID=keyID, vCode=vCode) apiChar = eve.char.CharacterSheet( keyID=keyID, vCode=vCode, characterID=keyInfo.key.characters[0].characterID) assetList = eve.char.AssetList( keyID=keyID, vCode=vCode, characterID=keyInfo.key.characters[0].characterID, flat=1) charInfo = eve.eve.CharacterInfo( keyID=keyID, vCode=vCode, characterID=keyInfo.key.characters[0].characterID) except eveapi.Error as e: return "Your API key doesn't have enough permissions, at minimum it needs to be an active key with AccountStatus and CharacterInfo" # Build the key object api = Api() api.userId = user.id api.keyID = keyID api.vCode = vCode api.accessMask = keyInfo.key.accessMask api.type = keyInfo.key.type api.paidUntil = datetime.datetime.fromtimestamp(accStatus.paidUntil) api.createDate = datetime.datetime.fromtimestamp(accStatus.createDate) api.logonCount = accStatus.logonCount api.logonMinutes = accStatus.logonMinutes api.name = name api.lastUpdated = datetime.datetime.now() api.added = datetime.datetime.now() session.add(api) session.commit() # Now update the api key updateApiKey(session=session, api=api) return api except eveapi.Error as e: session.rollback() return "An error occurred on the EVE API, it's probably not your fault, try again later" except Exception as e: session.rollback() return "An error occurred querying this key: %s" % str(e)
def calculateTags(dbUser, session=None): # Create a session if one didn't already exist if session == None: session = getSession() commitOnEnd = True else: commitOnEnd = False # Get the config config = getConfig() # Get a set of the current tags currTags = map(lambda x: x.tag, session.query(Tag).filter(Tag.userId == dbUser.id).all()) currTags = frozenset(currTags) newTags = [] # Grab Ship Groups for x in session.query(Asset, InvGroup.groupName).join(InvType).join(InvGroup).join(Character).join(Api)\ .filter(InvGroup.categoryID == 6,\ Api.userId == dbUser.id).group_by(InvGroup.groupID).all(): newTags.append("owns:%s" % x.groupName) # Grab Ship Types for x in session.query(Asset, InvType.typeName).join(InvType).join(InvGroup).join(Character).join(Api)\ .filter(InvGroup.categoryID == 6,\ Api.userId == dbUser.id).group_by(InvType.typeID).all(): newTags.append("owns:%s" % x.typeName) # Check membership on chars for a few things for x in session.query(Character, Corporation.corporationID, Corporation.allianceID).join(Corporation).join(Api).join(User).filter(User.id == dbUser.id).all(): # Check if the character meets any of the membership requirements for test in config.auth.members: if test.type not in ["alliance", "corporation"]: continue if test.type == "alliance" and x.allianceID != test.id: continue if test.type == "corporation" and x.corporationID != test.id: continue # Grab Skills for skill in session.query(Skill, InvType.typeName).join(InvType).filter(Skill.characterID == x.Character.characterID).all(): newTags.append("has:%s" % skill.typeName) if skill.Skill.level == 5 and skill.Skill.skillpoints >= 1280000: newTags.append("has:%s 5" % skill.typeName) # Grab Implant sets excluding supercap pilots #for x in session.query(Implant).join(InvType) # Purge old sets for x in frozenset(currTags).difference(newTags): session.delete(session.query(Tag).filter(Tag.userId == dbUser.id, Tag.tag == x).first()) # Add new sets for x in frozenset(newTags).difference(currTags): newTag = Tag() newTag.userId = dbUser.id newTag.tag = x session.add(newTag) # Commit the session as it was created within this method if commitOnEnd == True: session.commit()
def updateApiKey(api, session=getSession()): eveapi.set_user_agent("eveapi.py/1.3") eve = eveapi.EVEAPIConnection() # Open our main rollback try try: # Check that the API is still active... try: keyinfo = eve.account.APIKeyInfo(keyID=api.keyID, vCode=api.vCode) except eveapi.Error as e: # ...and delete the api if it isn't if e.code == 403: apiLog("\tDeleting API ID %d as it has been deleted or expired" % api.id) session.delete(api) session.commit() else: apiLog("The XMLAPI returned an error [%d] checking API ID %d, lets try again later" % (e.code, api.id)) return except Exception as e: apiLog("Generic Exception checking API ID %d: %s" % (api.id, str(e))) return # Grab AccountStatus too accStatus = eve.account.AccountStatus(keyID=api.keyID, vCode=api.vCode) # Update the key info api.accessMask = keyinfo.key.accessMask api.type = keyinfo.key.type api.paidUntil = datetime.datetime.fromtimestamp(accStatus.paidUntil) api.createDate = datetime.datetime.fromtimestamp(accStatus.createDate) api.logonCount = accStatus.logonCount api.logonMinutes = accStatus.logonMinutes api.lastUpdated = datetime.datetime.now() if keyinfo.key.expires == "": api.expires = None else: api.expires = datetime.datetime.fromtimestamp(keyinfo.key.expires) key = keyinfo.key # Purge characters from database that aren't on the API for dbChar in api.characters: if dbChar.characterID not in map(lambda x: x.characterID, key.characters): apiLog("Deleted character as they were no longer on the API characterID=%d, characterName=%s" % (dbChar.characterID, dbChar.characterName)) session.delete(dbChar) # Add or update characters from the API into the database for apiChar in key.characters: if apiChar.characterID not in map(lambda x: x.characterID, api.characters): dbChar = Character() dbChar.characterID = apiChar.characterID dbChar.apiId = api.id session.add(dbChar) else: for dbChar in api.characters: if dbChar.characterID == apiChar.characterID: # Suppresed this check as it doesn't make logical sense to limit it this far down stream # Check its not been updated within the last 119 mins #if (dbChar.lastUpdated + datetime.timedelta(0, 7140)) > datetime.datetime.now(): # return break # Get the CharacterSheet charSheet = eve.char.CharacterSheet(keyID=api.keyID, vCode=api.vCode, characterID=apiChar.characterID) charInfo = eve.eve.CharacterInfo(keyID=api.keyID, vCode=api.vCode, characterID=apiChar.characterID) # Upsert the corporation if not upsertCorporation(eve=eve, corporationID=charSheet.corporationID): apiLog("An error occurred upserting corporationID=%d, so we'll rollback and try later" % charSheet.corporationID) session.rollback() return # Update the characters values dbChar.characterName = apiChar.characterName dbChar.corporationID = apiChar.corporationID dbChar.factionID = apiChar.factionID dbChar.balance = charSheet.balance dbChar.cloneJumpDate = datetime.datetime.fromtimestamp(charSheet.cloneJumpDate) dbChar.jumpActivation = datetime.datetime.fromtimestamp(charSheet.jumpActivation) dbChar.jumpFatigue = datetime.datetime.fromtimestamp(charSheet.jumpFatigue) dbChar.jumpLastUpdate = datetime.datetime.fromtimestamp(charSheet.jumpLastUpdate) dbChar.DoB = datetime.datetime.fromtimestamp(charSheet.DoB) dbChar.remoteStationDate = datetime.datetime.fromtimestamp(charSheet.remoteStationDate) dbChar.homeStationID = charSheet.homeStationID dbChar.shipTypeID = charInfo.shipTypeID dbChar.shipName = charInfo.shipName dbChar.lastKnownLocation = charInfo.lastKnownLocation dbChar.lastUpdated = datetime.datetime.now() # Get the Asset List assetList = eve.char.AssetList(keyID=api.keyID, vCode=api.vCode, characterID=apiChar.characterID, flat=1) apiAssetsById = assetList.assets.IndexedBy("itemID") # Purge assets from the database that aren't on the API for dbAsset in session.query(Asset).filter(Asset.characterID == apiChar.characterID).all(): try: apiAssetsById.Get(dbAsset.itemID) except: session.delete(dbAsset) # Add or update assets from the API into the database dbAssets = session.query(Asset).filter(Asset.characterID == apiChar.characterID).all() dbAssetsDict = {} for dbAsset in dbAssets: dbAssetsDict[dbAsset.itemID] = dbAsset newAssets = [] dbAssetSet = frozenset(frozenset(map(lambda x: x.itemID, dbAssets))) for apiAsset in assetList.assets: if apiAsset.itemID not in dbAssetSet: dbAsset = Asset() dbAsset.itemID = apiAsset.itemID dbAsset.characterID = apiChar.characterID newAssets.append(dbAsset) else: dbAsset = dbAssetsDict[apiAsset.itemID] # Update the asset values dbAsset.locationID = apiAsset.locationID dbAsset.typeID = apiAsset.typeID dbAsset.quantity = apiAsset.quantity dbAsset.flag = apiAsset.flag dbAsset.singleton = apiAsset.singleton # Add the assets to the session session.add_all(newAssets) # Add or update skills from the API into the database newSkills = [] dbSkillsDict = {} for dbSkill in dbChar.skills: dbSkillsDict[dbSkill.typeID] = dbSkill dbSkillSet = frozenset(map(lambda x: "%d:%d" % (x.characterID, x.typeID), dbChar.skills)) for apiSkill in charSheet.skills: if "%d:%d" % (apiChar.characterID, apiSkill.typeID) not in dbSkillSet: dbSkill = Skill() dbSkill.characterID = apiChar.characterID dbSkill.typeID = apiSkill.typeID newSkills.append(dbSkill) else: dbSkill = dbSkillsDict[apiSkill.typeID] # Update the skills values dbSkill.level = apiSkill.level dbSkill.skillpoints = apiSkill.skillpoints # Add the skills to the session session.add_all(newSkills) # Purge jump clones from the database that aren't on the API jumpClonesById = charSheet.jumpClones.IndexedBy("jumpCloneID") for dbJumpClone in session.query(JumpClone).filter(JumpClone.characterID == dbChar.characterID).all(): try: jumpClonesById.Get(dbJumpClone.jumpCloneID) except: session.delete(dbJumpClone) # Add or update jump clones from the API into the database newJumpClones = [] dbJumpClonesDict = {} dbJumpClones = session.query(JumpClone).filter(JumpClone.characterID == dbChar.characterID).all() for x in dbJumpClones: dbJumpClonesDict[x.jumpCloneID] = x dbJumpCloneSet = frozenset(map(lambda x: x.jumpCloneID, dbJumpClones)) for apiJumpClone in charSheet.jumpClones: if apiJumpClone.jumpCloneID not in dbJumpCloneSet: dbJumpClone = JumpClone() dbJumpClone.jumpCloneID = apiJumpClone.jumpCloneID dbJumpClone.characterID = charSheet.characterID newJumpClones.append(dbJumpClone) else: dbJumpClone = dbJumpClonesDict[apiJumpClone.jumpCloneID] # Update the values dbJumpClone.cloneName = apiJumpClone.cloneName dbJumpClone.locationID = apiJumpClone.locationID dbJumpClone.typeID = apiJumpClone.typeID # Add the new jump clones to the session session.add_all(newJumpClones) # Handle current implants apiCurrImplants = frozenset(map(lambda x: x.typeID, charSheet.implants)) for x in session.query(Implant).filter(Implant.characterID == dbChar.characterID).filter(Implant.jumpCloneID == None).all(): if x.typeID not in apiCurrImplants: session.delete(x) dbImplantSet = frozenset(map(lambda x: x.typeID, session.query(Implant).filter(Implant.characterID == dbChar.characterID).filter(Implant.jumpCloneID == None).all())) for x in charSheet.implants: if x.typeID not in dbImplantSet: dbImplant = Implant() dbImplant.characterID = dbChar.characterID dbImplant.jumpCloneID = None dbImplant.typeID = x.typeID session.add(dbImplant) # Handle Jump Clone implants apiJCImplants = frozenset(map(lambda x: "%d:%d" % (x.jumpCloneID, x.typeID), charSheet.jumpCloneImplants)) for x in session.query(Implant).filter(Implant.characterID == dbChar.characterID).filter(Implant.jumpCloneID != None).all(): if "%d:%d" % (x.jumpCloneID, x.typeID) not in apiJCImplants: session.delete(x) dbImplantSet = frozenset(map(lambda x: "%d:%d" % (x.jumpCloneID, x.typeID), session.query(Implant).filter(Implant.characterID == dbChar.characterID).filter(Implant.jumpCloneID != None).all())) for x in charSheet.jumpCloneImplants: if "%d:%d" % (x.jumpCloneID, x.typeID) not in dbImplantSet: dbImplant = Implant() dbImplant.characterID = dbChar.characterID dbImplant.jumpCloneID = x.jumpCloneID dbImplant.typeID = x.typeID session.add(dbImplant) # Log line apiLog("\tUpdated characterID=%d, characterName='%s'" % (dbChar.characterID, dbChar.characterName)) # Commit all of the updates to the database session.commit() # Exceptions for our main rollback try except eveapi.Error as e: if e.code == 403: session.rollback() session.delete(api) session.commit() apiLog("\tDeleted API as it has lost permissions we need, into the trash you go") else: apiLog("\tXMLAPI returned the following error: [%d] '%s'" % (e.code, e.message)) session.rollback()
def __init__(self): """TWorktimeManager constructor Inits session""" self.session = db.getSession()
def dictAll(model): return [m.toDict() for m in db.getSession().query(model).all()]
def getFamily(name): # May throw! family = db.getSession().query(db.Families).filter_by(FamilyNm=name).limit(1).one() if family.ProjectActive: return family raise RuntimeError("Family {} is not marked as active.".format(name))
def updateApiKey(api, session=getSession()): eveapi.set_user_agent("eveapi.py/1.3") eve = eveapi.EVEAPIConnection() # Open our main rollback try try: # Check that the API is still active... try: keyinfo = eve.account.APIKeyInfo(keyID=api.keyID, vCode=api.vCode) except eveapi.Error as e: # ...and delete the api if it isn't if e.code == 403: apiLog( "\tDeleting API ID %d as it has been deleted or expired" % api.id) session.delete(api) session.commit() else: apiLog( "The XMLAPI returned an error [%d] checking API ID %d, lets try again later" % (e.code, api.id)) return except Exception as e: apiLog("Generic Exception checking API ID %d: %s" % (api.id, str(e))) return # Grab AccountStatus too accStatus = eve.account.AccountStatus(keyID=api.keyID, vCode=api.vCode) # Update the key info api.accessMask = keyinfo.key.accessMask api.type = keyinfo.key.type api.paidUntil = datetime.datetime.fromtimestamp(accStatus.paidUntil) api.createDate = datetime.datetime.fromtimestamp(accStatus.createDate) api.logonCount = accStatus.logonCount api.logonMinutes = accStatus.logonMinutes api.lastUpdated = datetime.datetime.now() if keyinfo.key.expires == "": api.expires = None else: api.expires = datetime.datetime.fromtimestamp(keyinfo.key.expires) key = keyinfo.key # Purge characters from database that aren't on the API for dbChar in api.characters: if dbChar.characterID not in map(lambda x: x.characterID, key.characters): apiLog( "Deleted character as they were no longer on the API characterID=%d, characterName=%s" % (dbChar.characterID, dbChar.characterName)) session.delete(dbChar) # Add or update characters from the API into the database for apiChar in key.characters: if apiChar.characterID not in map(lambda x: x.characterID, api.characters): dbChar = Character() dbChar.characterID = apiChar.characterID dbChar.apiId = api.id session.add(dbChar) else: for dbChar in api.characters: if dbChar.characterID == apiChar.characterID: # Suppresed this check as it doesn't make logical sense to limit it this far down stream # Check its not been updated within the last 119 mins #if (dbChar.lastUpdated + datetime.timedelta(0, 7140)) > datetime.datetime.now(): # return break # Get the CharacterSheet charSheet = eve.char.CharacterSheet( keyID=api.keyID, vCode=api.vCode, characterID=apiChar.characterID) charInfo = eve.eve.CharacterInfo(keyID=api.keyID, vCode=api.vCode, characterID=apiChar.characterID) # Upsert the corporation if not upsertCorporation(eve=eve, corporationID=charSheet.corporationID): apiLog( "An error occurred upserting corporationID=%d, so we'll rollback and try later" % charSheet.corporationID) session.rollback() return # Update the characters values dbChar.characterName = apiChar.characterName dbChar.corporationID = apiChar.corporationID dbChar.factionID = apiChar.factionID dbChar.balance = charSheet.balance dbChar.cloneJumpDate = datetime.datetime.fromtimestamp( charSheet.cloneJumpDate) dbChar.jumpActivation = datetime.datetime.fromtimestamp( charSheet.jumpActivation) dbChar.jumpFatigue = datetime.datetime.fromtimestamp( charSheet.jumpFatigue) dbChar.jumpLastUpdate = datetime.datetime.fromtimestamp( charSheet.jumpLastUpdate) dbChar.DoB = datetime.datetime.fromtimestamp(charSheet.DoB) dbChar.remoteStationDate = datetime.datetime.fromtimestamp( charSheet.remoteStationDate) dbChar.homeStationID = charSheet.homeStationID dbChar.shipTypeID = charInfo.shipTypeID dbChar.shipName = charInfo.shipName dbChar.lastKnownLocation = charInfo.lastKnownLocation dbChar.lastUpdated = datetime.datetime.now() # Get the Asset List assetList = eve.char.AssetList(keyID=api.keyID, vCode=api.vCode, characterID=apiChar.characterID, flat=1) apiAssetsById = assetList.assets.IndexedBy("itemID") # Purge assets from the database that aren't on the API for dbAsset in session.query(Asset).filter( Asset.characterID == apiChar.characterID).all(): try: apiAssetsById.Get(dbAsset.itemID) except: session.delete(dbAsset) # Add or update assets from the API into the database dbAssets = session.query(Asset).filter( Asset.characterID == apiChar.characterID).all() dbAssetsDict = {} for dbAsset in dbAssets: dbAssetsDict[dbAsset.itemID] = dbAsset newAssets = [] dbAssetSet = frozenset(frozenset(map(lambda x: x.itemID, dbAssets))) for apiAsset in assetList.assets: if apiAsset.itemID not in dbAssetSet: dbAsset = Asset() dbAsset.itemID = apiAsset.itemID dbAsset.characterID = apiChar.characterID newAssets.append(dbAsset) else: dbAsset = dbAssetsDict[apiAsset.itemID] # Update the asset values dbAsset.locationID = apiAsset.locationID dbAsset.typeID = apiAsset.typeID dbAsset.quantity = apiAsset.quantity dbAsset.flag = apiAsset.flag dbAsset.singleton = apiAsset.singleton # Add the assets to the session session.add_all(newAssets) # Add or update skills from the API into the database newSkills = [] dbSkillsDict = {} for dbSkill in dbChar.skills: dbSkillsDict[dbSkill.typeID] = dbSkill dbSkillSet = frozenset( map(lambda x: "%d:%d" % (x.characterID, x.typeID), dbChar.skills)) for apiSkill in charSheet.skills: if "%d:%d" % (apiChar.characterID, apiSkill.typeID) not in dbSkillSet: dbSkill = Skill() dbSkill.characterID = apiChar.characterID dbSkill.typeID = apiSkill.typeID newSkills.append(dbSkill) else: dbSkill = dbSkillsDict[apiSkill.typeID] # Update the skills values dbSkill.level = apiSkill.level dbSkill.skillpoints = apiSkill.skillpoints # Add the skills to the session session.add_all(newSkills) # Purge jump clones from the database that aren't on the API jumpClonesById = charSheet.jumpClones.IndexedBy("jumpCloneID") for dbJumpClone in session.query(JumpClone).filter( JumpClone.characterID == dbChar.characterID).all(): try: jumpClonesById.Get(dbJumpClone.jumpCloneID) except: session.delete(dbJumpClone) # Add or update jump clones from the API into the database newJumpClones = [] dbJumpClonesDict = {} dbJumpClones = session.query(JumpClone).filter( JumpClone.characterID == dbChar.characterID).all() for x in dbJumpClones: dbJumpClonesDict[x.jumpCloneID] = x dbJumpCloneSet = frozenset( map(lambda x: x.jumpCloneID, dbJumpClones)) for apiJumpClone in charSheet.jumpClones: if apiJumpClone.jumpCloneID not in dbJumpCloneSet: dbJumpClone = JumpClone() dbJumpClone.jumpCloneID = apiJumpClone.jumpCloneID dbJumpClone.characterID = charSheet.characterID newJumpClones.append(dbJumpClone) else: dbJumpClone = dbJumpClonesDict[apiJumpClone.jumpCloneID] # Update the values dbJumpClone.cloneName = apiJumpClone.cloneName dbJumpClone.locationID = apiJumpClone.locationID dbJumpClone.typeID = apiJumpClone.typeID # Add the new jump clones to the session session.add_all(newJumpClones) # Handle current implants apiCurrImplants = frozenset( map(lambda x: x.typeID, charSheet.implants)) for x in session.query(Implant).filter( Implant.characterID == dbChar.characterID).filter( Implant.jumpCloneID == None).all(): if x.typeID not in apiCurrImplants: session.delete(x) dbImplantSet = frozenset( map( lambda x: x.typeID, session.query(Implant).filter( Implant.characterID == dbChar.characterID).filter( Implant.jumpCloneID == None).all())) for x in charSheet.implants: if x.typeID not in dbImplantSet: dbImplant = Implant() dbImplant.characterID = dbChar.characterID dbImplant.jumpCloneID = None dbImplant.typeID = x.typeID session.add(dbImplant) # Handle Jump Clone implants apiJCImplants = frozenset( map(lambda x: "%d:%d" % (x.jumpCloneID, x.typeID), charSheet.jumpCloneImplants)) for x in session.query(Implant).filter( Implant.characterID == dbChar.characterID).filter( Implant.jumpCloneID != None).all(): if "%d:%d" % (x.jumpCloneID, x.typeID) not in apiJCImplants: session.delete(x) dbImplantSet = frozenset( map( lambda x: "%d:%d" % (x.jumpCloneID, x.typeID), session.query(Implant).filter( Implant.characterID == dbChar.characterID).filter( Implant.jumpCloneID != None).all())) for x in charSheet.jumpCloneImplants: if "%d:%d" % (x.jumpCloneID, x.typeID) not in dbImplantSet: dbImplant = Implant() dbImplant.characterID = dbChar.characterID dbImplant.jumpCloneID = x.jumpCloneID dbImplant.typeID = x.typeID session.add(dbImplant) # Log line apiLog("\tUpdated characterID=%d, characterName='%s'" % (dbChar.characterID, dbChar.characterName)) # Commit all of the updates to the database session.commit() # Exceptions for our main rollback try except eveapi.Error as e: if e.code == 403: session.rollback() session.delete(api) session.commit() apiLog( "\tDeleted API as it has lost permissions we need, into the trash you go" ) else: apiLog("\tXMLAPI returned the following error: [%d] '%s'" % (e.code, e.message)) session.rollback()
def calculateTags(dbUser, session=None): # Create a session if one didn't already exist if session == None: session = getSession() commitOnEnd = True else: commitOnEnd = False # Get the config config = getConfig() # Get a set of the current tags currTags = map(lambda x: x.tag, session.query(Tag).filter(Tag.userId == dbUser.id).all()) currTags = frozenset(currTags) newTags = [] # Grab Ship Groups for x in session.query(Asset, InvGroup.groupName).join(InvType).join(InvGroup).join(Character).join(Api)\ .filter(InvGroup.categoryID == 6,\ Api.userId == dbUser.id).group_by(InvGroup.groupID).all(): newTags.append("owns:%s" % x.groupName) # Grab Ship Types for x in session.query(Asset, InvType.typeName).join(InvType).join(InvGroup).join(Character).join(Api)\ .filter(InvGroup.categoryID == 6,\ Api.userId == dbUser.id).group_by(InvType.typeID).all(): newTags.append("owns:%s" % x.typeName) # Check membership on chars for a few things for x in session.query( Character, Corporation.corporationID, Corporation.allianceID).join(Corporation).join(Api).join( User).filter(User.id == dbUser.id).all(): # Check if the character meets any of the membership requirements for test in config.auth.members: if test.type not in ["alliance", "corporation"]: continue if test.type == "alliance" and x.allianceID != test.id: continue if test.type == "corporation" and x.corporationID != test.id: continue # Grab Skills for skill in session.query( Skill, InvType.typeName).join(InvType).filter( Skill.characterID == x.Character.characterID).all(): newTags.append("has:%s" % skill.typeName) if skill.Skill.level == 5 and skill.Skill.skillpoints >= 1280000: newTags.append("has:%s 5" % skill.typeName) # Grab Implant sets excluding supercap pilots #for x in session.query(Implant).join(InvType) # Purge old sets for x in frozenset(currTags).difference(newTags): session.delete( session.query(Tag).filter(Tag.userId == dbUser.id, Tag.tag == x).first()) # Add new sets for x in frozenset(newTags).difference(currTags): newTag = Tag() newTag.userId = dbUser.id newTag.tag = x session.add(newTag) # Commit the session as it was created within this method if commitOnEnd == True: session.commit()
import sys from flask import Flask, Request, render_template from flask.ext.login import LoginManager, UserMixin, login_required from config import getConfig from db import getSession from models import * from ships import * from dispfuncs import * # Setup config = getConfig() session = getSession() reload(sys) sys.setdefaultencoding("utf-8") app = Flask(__name__) login_manager = LoginManager() login_manager.init_app(app) # Jinja functions app.jinja_env.globals.update(fitModHtml=fitModHtml) @app.route("/") def index(): return render_template("index.html", config=config.auth) @app.route("/viewship/<int:itemID>")
import sys from flask import Flask, Request, render_template from flask.ext.login import LoginManager, UserMixin, login_required from config import getConfig from db import getSession from models import * from ships import * from dispfuncs import * # Setup config = getConfig() session = getSession() reload(sys) sys.setdefaultencoding("utf-8") app = Flask(__name__) login_manager = LoginManager() login_manager.init_app(app) # Jinja functions app.jinja_env.globals.update(fitModHtml=fitModHtml) @app.route("/") def index(): return render_template("index.html", config=config.auth) @app.route("/viewship/<int:itemID>") def viewship(itemID):
import networkx import numpy.linalg import pylab n = 100 m = 500 g = networkx.gnm_random_graph(n, m) l = networkx.generalized_laplacian(g) e = numpy.linalg.eigvals(l) max(e), min(e) pylab.hist(e, bins=10) pylab.xlim(0, 2) pylab.show() import networkx as nx import db s = db.getSession() def makeGraph(session): g = nx.DiGraph() for src, dest in session.query(db.Anchor.source, db.Anchor.destination): g.add_edge(src, dest) return g def islowfrequency(anchor): return anchor.frequency < 2 def rel(anchor, other): return 0.0