class createKey: def __init__(self): self.aObj = Authentication("msssg"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone = self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); def createKeyPlease(self): keypair_name = "maKey"; self.nova.keypairs.list(); ts = time.time(); st = datetime.datetime.fromtimestamp(ts).strftime('%Y%m%d%H%M%S'); stri = keypair_name+st; print stri; self.nova.keypairs.create(name=stri) def getKeypairsList(self): obj = self.nova.keypairs.list(); keyz = []; for each in obj: keyz.append(each.name); return keyz; # obj = createKey(); # obj.createKeyPlease();
def saveFile(ID, CADFile, filedesc): try: Authentication.authUpload(ID, CADFile, filedesc) except Exception as e: logging.error("Unable to save file: %s" % e) return False return True
class InstancePreReq: def __init__(self): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); def getAllFlavours(self): obj= self.nova.flavors.list(); flvrs=[]; for each in obj: flvrs.append(each.name); return flvrs; def getAllImages(self): obj= self.nova.images.list(); imgz=[]; for each in obj: imgz.append(each.name); return imgz; def getAllNetworks(self): obj= self.nova.networks.list(); netwrk=[]; for each in obj: netwrk.append(each.label); return netwrk; def getKeypairsList(self): obj= self.nova.keypairs.list(); keyz=[]; for each in obj: keyz.append(each.name); return keyz; def getSecurityList(self): obj= self.nova.security_groups.list(); scrty=[]; for each in obj: scrty.append(each.name); return scrty;
def getExpansions(self, sentence): self.getCredentials() self.AuthClient = Authentication(self.username, self.password) self.logger.info('In getExpansions function of UMLSExpander') # get TGT for our session self.tgt = self.AuthClient.gettgt() self.uri = "https://uts-ws.nlm.nih.gov" self.cache = SingletonUMLSCache.Instance().cache synonyms = [] synonyms = sentence.strip().split() metaConcepts = self.getMetaConcepts(sentence) for mconcept in metaConcepts: try: for el in self.cache[mconcept]: synonyms.append(el) self.logger.info('Found UMLS Cached Concept: ' + str(mconcept.cui)) except: try: termSyns = [] self.logger.info('Getting concept expansions from UMLS') # metamap has direct mapping with UMLS based on Concept Unique Identification (CUI) cui = mconcept.cui content_endpoint = "/rest/content/" + str( self.version) + "/CUI/" + str(cui) query = {'ticket': self.AuthClient.getst(self.tgt)} r = requests.get(self.uri + content_endpoint, params=query) r.encoding = 'utf-8' items = json.loads(r.text) jsonData = items["result"] try: query = {'ticket': self.AuthClient.getst(self.tgt)} # THE REST API returns a json object that includes other concepts with different relations r = requests.get(jsonData["relations"], params=query) r.encoding = 'utf-8' items = json.loads(r.text) jsonData = items["result"] for el in jsonData: ''' This is how to access differennt relations in UMLS #if el['relationLabel'] == 'RL' or el['relationLabel'] == 'RQ': ''' termSyns.append(el['relatedIdName']) synonyms.append(el['relatedIdName']) self.cache[mconcept] = termSyns self.logger.info( 'Parsed the JSON object returned from UMLS') except Exception as e: self.logger.debug('Exception in UMLS Expansion ' + str(e)) pass except: pass # class method of Expander that stops the metamap # self.stopMetaMap() listSynonyms = list(set(synonyms)) ExpandedSentence = ' '.join(listSynonyms) return ExpandedSentence
class BillGeneratePreReq: def __init__(self): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); self.dbObj = MongoDatabase(); def getAllBillsCategories(self): checki = self.dbObj.getAllBillCat(); if(checki==False): return False else: return checki; def getAllRunningInstances(self): servers = self.nova.servers.list(); return servers; # obj = BillGeneratePreReq(); # obj.getAllBillsCategories();
def get_category(string): apikey = "" version = "current" uri = "https://uts-ws.nlm.nih.gov" content_endpoint = "/rest/search/" + version string = string AuthClient = Authentication(apikey) tgt = AuthClient.gettgt() pageNumber = 0 ticket = AuthClient.getst(tgt) pageNumber += 1 query = {'string': string, 'ticket': ticket, 'pageNumber': pageNumber} r = requests.get(uri + content_endpoint, params=query) r.encoding = 'utf-8' items = json.loads(r.text) jsonData = items["result"] result = jsonData["results"][0] try: uri = result["uri"].replace("2020AA", "current") # 根据得到的uri进行再一次的查找 ticket = AuthClient.getst(tgt) query = {"ticket": ticket} r = requests.get(uri, params=query) r.encoding = 'utf-8' items = json.loads(r.text) jsonData = items["result"] category = jsonData["semanticTypes"][0]["name"] # print(string, " ", category) return category except Exception as e: # print(string, " ", "error") return "error"
def __init__(self, searchlist=[], searchtype="word"): # self.username=username # self.password=password self.searchlist = searchlist # "[ 'Therapeutic', 'fever' ]" self.searchtype = searchtype # "word" self.sabs = "NANDA-I" self.AuthClient = Authentication(apikey) self.tgt = self.AuthClient.gettgt()
def NewPasives(request): Authentication.QuickCheck(request) Nickname = request.POST["Nickname"] Email = request.POST["Email"] Info = request.POST["Info"] ID = int(request.COOKIES["BasicInfo"]) ActiveID = Authentication.GetID(request) Database.DP6(ID, Email, Nickname, Info, ActiveID) return redirect('PassiveUsers')
def UpdateConversation(request): Authentication.QuickCheck(request) ConversationID = request.GET["ID"] LastTime = request.GET["LastTime"] NewPosts = Database.LoadChat(ConversationID, LastTime) UserID = Authentication.GetID(request) NewPostCount = Database.UnreadChatsCount(ConversationID, UserID) Response = {"NewCount": NewPostCount, "NewPosts": NewPosts} return HttpResponse(json.dumps(Response), content_type="application/json")
async def requestReceived(websocket, session, request): if request['operation'] == 'login': data = request['data'] if 'username' not in data or 'password' not in data: await websocket.send( convertToJson({ 'table': 'TokenAuthentication', 'operation': 'invalidCredentials' })) return token, isSuccessful = Authentication.login(session, data['username'], data['password'], websocket.remote_address[0]) if isSuccessful == 0: await websocket.send( convertToJson({ 'table': 'TokenAuthentication', 'operation': 'invalidCredentials' })) return await websocket.send( convertToJson({ 'table': 'TokenAuthentication', 'operation': 'authenticationGranted', 'data': token })) websocket.authenticated = True elif request['operation'] == 'setToken': data = request['data'] if 'token' not in data: await websocket.send( convertToJson({ 'table': 'TokenAuthentication', 'operation': 'invalidToken' })) return isAuthorized, error = Authentication.checkToken( session, data['token'], websocket.remote_address[0]) if isAuthorized == 0: await websocket.send( convertToJson({ 'table': 'TokenAuthentication', 'operation': 'invalidToken', 'data': { 'error': error } })) return await websocket.send( convertToJson({ 'table': 'TokenAuthentication', 'operation': 'validToken' })) websocket.authenticated = True
def concept_lookup(apikey,version,string): name_l=[] uri = "https://uts-ws.nlm.nih.gov" content_endpoint = "/rest/search/"+version ##get at ticket granting ticket for the session AuthClient = Authentication(apikey) tgt = AuthClient.gettgt() pageNumber=0 while True: ##generate a new service ticket for each page if needed ticket = AuthClient.getst(tgt) pageNumber += 1 query = {'string':string,'ticket':ticket, 'pageNumber':pageNumber} #query['includeObsolete'] = 'true' #query['includeSuppressible'] = 'true' #query['returnIdType'] = "sourceConcept" #query['sabs'] = "SNOMEDCT_US" query['searchType']='exact' r = requests.get(uri+content_endpoint,params=query) r.encoding = 'utf-8' items = json.loads(r.text) jsonData = items["result"] #print (json.dumps(items, indent = 4)) print("Results for page " + str(pageNumber)+"\n") for result in jsonData["results"]: try: print("ui: " + result["ui"]) except: NameError try: print("uri: " + result["uri"]) except: NameError try: print("name: " + result["name"]) name_l.append(result["name"]) except: NameError try: print("Source Vocabulary: " + result["rootSource"]) except: NameError print("\n") ##Either our search returned nothing, or we're at the end if jsonData["results"][0]["ui"] == "NONE": break print("*********") return name_l
def retrieve_from_api_by_source(endpoint,apikey): AuthClient = Authentication(apikey) tgt = AuthClient.gettgt() query = {'ticket':AuthClient.getst(tgt), "language":"ENG", "pageNumber":1, "pageSize":1000} r = requests.get(endpoint, params = query) r.encoding = "utf-8" try: items = json.loads(r.text) return items except ValueError: print("Decode failed...")
def buttonpress2(self): pin = self.lineEdit.text() numTweets = self.lineEdit_2.text() pin = str(pin) numTweets = int(numTweets) print(pin) print(numTweets) Authentication.authenticate_and_scrape(pin, numTweets, auth) sentiment, preds = nnInterface.runNextwork( "C:/Users/bribr/OneDrive - Washington State University (email.wsu.edu)/Downloads/#TweetYourHeartOut/-TweetYourHeartOut/Program/results2.csv", 1) print("Most common sentiment is ", sentiment) analytics.plotBarGraph(preds) analytics.plotPieChart(preds)
def Saving(request): Authentication.QuickCheck(request) FirstName = request.POST["FirstName"] SecondName = request.POST["SecondName"] Email = request.POST["Email"] Year = request.POST["Year"] Info = request.POST["Info"] Sex = request.POST["Sex"] Birthday = request.POST["Birthday"] ID = Authentication.GetID(request) Database.UpdateUser(FirstName, SecondName, Email, Year, Info, Sex, Birthday, ID) response = redirect('Home') response.delete_cookie('MetaInfo') return response
def changePassword(self, sid, safeOld, safeNew): session = self.sessions[sid] if not session: raise SecurityException('No such session id.') challenge = session.challenge account = self.accounts[session.login] oldPassword = Authentication.unwrapUserPassword(safeOld, challenge) newPassword = Authentication.unwrapUserPassword(safeNew, challenge) if not account.verifyPassword(oldPassword): raise SecurityException('Wrong login and/or password.') if len(newPassword) < ige.Const.ACCOUNT_PASSWD_MIN_LEN: raise SecurityException('Password is too short.') account.setPassword(newPassword) log.debug('Password of account {0} successfully changed.'.format(session.login)) return None, None
def checkBalance(self, params): if len(params) != 0: if "TOKEN" in params: wrapData = params['DATA'] splitData = wrapData.split(".") data = helper.decrypt(splitData[0], globalVariable.key, splitData[1]) newStr = re.match("(.*?)}", data).group() newStr= json.loads(newStr) no_rekening = newStr.get("no_rekening") token = newStr.get("token") tokenStatus = Authentication.checkValidToken(self, params['TOKEN']) if tokenStatus[0]["status"] == "success": now = datetime.datetime.now() month = now.month year = now.year sql = 'SELECT no_rekening, SUM(IF(transaction_type="K", balance, 0)) as K, SUM(IF(transaction_type="D", balance, 0)) as D, (SUM(IF(transaction_type="K", balance, 0))-SUM(IF(transaction_type="D", balance, 0))) as saldo, created_date FROM db_kmpay.tbl_transaksi WHERE MONTH(created_date)= %s and YEAR(created_date)=%s AND no_rekening = %s AND status_transaksi = "SUCCESS" GROUP BY no_rekening, MONTH(created_date), YEAR(created_date);' cursorKmPay.execute(sql,([month], [year],[no_rekening])) result = cursorKmPay.fetchall() items = [] for row in result: items.append({'sum_kredit': row[1], 'sum_debit': row[2], 'saldo': row[3]}) if not items: return {'status ':"success",'code': 204, "result":items} else: return {'status ':"success",'code': 200, "result":items[0]} else: return tokenStatus[0] else: return generalNotification.TokenNotAvailable(self) else: return generalNotification.DataNotAvailable(self)
def get_atoms(cuis, tgt=None): auth = Authentication.Authentication(apikeyfile) if not tgt: tgt = auth.get_ticket_granting_ticket() atoms = {} params = {'language': language} for cui in cuis: #print("In CUI loop") #print(cui) params['ticket'] = auth.get_service_ticket(tgt) request = requests.get(base_uri + all_atoms.format(cui), params=params) if request.status_code != 404: #dataform = str(request).strip("'<>() ").replace('\'', '\"') #results = json.loads(dataform) #request = requests.get(base_uri + all_atoms.format(cui), params=params).json() #print(request.text) results = simplejson.loads(request.text) #print(results) atoms[cui] = [] for atom in results['result']: atoms[cui].append(atom['name']) else: atoms[cui] = [] return atoms
def createAccount(self, sid, login, safePasswd, nick, email): log.message('Creating account', login, nick, email) session = self.getSession(sid) plainPassword = Authentication.unwrapUserPassword(safePasswd, session.challenge) login = login.strip() plainPassword = plainPassword.strip() nick = nick.strip() # check requirement if len(login) < ige.Const.ACCOUNT_LOGIN_MIN_LEN: raise SecurityException('Login is too short.') if len(plainPassword) < ige.Const.ACCOUNT_PASSWD_MIN_LEN: raise SecurityException('Password is too short.') if len(nick) < ige.Const.ACCOUNT_NICK_MIN_LEN: raise SecurityException('Nick is too short.') # check login, nick and uid for key in self.accounts.keys(): account = self.accounts[key] if account.login == login: raise SecurityException('Login already used.') elif account.nick == nick: raise SecurityException('Nick already used.') elif account.email == email: raise SecurityException('E-mail already used.') # create account account = Account(login, nick, email, plainPassword) # update self.accounts.create(account, id = str(account.login)) log.message('Account created, confirmation token:', account.confToken) # TODO send confirmation token to the email address return 1, None
def __init__(self, database, authMethod, configDir): self.configDir = configDir self.authMethod = authMethod if not self.authMethod: self.authMethod = Authentication.defaultMethod if ige.igeRuntimeMode == 1: Authentication.init(self.authMethod, 2048) elif ige.igeRuntimeMode == 0: # it is minimum to cater for AI generated passwords Authentication.init(self.authMethod, 512) self._filename = os.path.join(self.configDir, 'accounts') self.sessions = {} # self.accounts = database self._initAdminAccount() self.generateAIList()
def __init__(self): """ """ self._am = Authentication.AccountManager() self._scp = ConfigParser.SafeConfigParser() #settings file name settingsFile = 'settings.cfg' #The file path of the settings file self._filePath = os.path.expanduser('~') + '/.' + settingsFile #config file to read self._scp.read(self._filePath) #Currently set account self._account = None #if there's a persisted setting to use a particular account if self._scp.get('acc_info', 'has_default') == "True": accountName = self._scp.get('acc_info', 'account') #if the account is still available in DBus if accountName in self._am.get_accounts(): self._account = self._am.get_accounts()[accountName] #if there's no default account set else: #get the default account self._account = self._am.get_accounts().itervalues().next()
def NewProjectHero(request): Authentication.QuickCheck(request) ProjectName = request.POST["ProjectName"] HeroName = request.POST["Nickname"] URL = CallEntity(ProjectName, 'Project') Database.ConnectProjectHero(request, HeroName, ProjectName, URL) return redirect(URL)
def SendChat(request): Authentication.QuickCheck(request) ConversationID = request.POST["ID"] Content = request.POST["Message"] Database.AddChatMessage(request, ConversationID, Content) Database.UpdateConersationLastLook(ConversationID, request) return HttpResponse("Done!")
def Project(request): #Load Basics LanguagePack = LanguageLoader.Language("Project", "Czech") ProjectName = request.GET["OldProjectName"] BaseNameForm = re.compile(r'(.*)€') BaseNameQuest = BaseNameForm.search(ProjectName) BasicName = BaseNameQuest.group() PublicProjectName = BasicName[:(len(BasicName) - 1)] LanguagePack["ProjectName"] = ProjectName LanguagePack["PublicProjectName"] = PublicProjectName #Load Team Team = Database.ShowProjectTeam(ProjectName) LanguagePack["TeamMembers"] = Team #Load Role VisitorRole = Database.ProjectVisitorRole(ProjectName, request) if VisitorRole == ["DubiousStranger"]: return redirect('Home') LanguagePack["VisitorRoles"] = VisitorRole #Products Products = Database.GetProjectProducts(ProjectName) LanguagePack["MyProducts"] = Products LanguagePack["ObserverType"] = "Project" #Comments Comments = Database.GetProjectComments(ProjectName) LanguagePack["Comments"] = Comments #Chat Conversations = Database.GetProjectConversations(ProjectName, request) LanguagePack["Conversations"] = Conversations #GoToPage Decision = Authentication.CheckUser(request, "User\Project.html", LanguagePack) return Decision
def checkTransactionByPeriod(self, param): if len(param) != 0: if "TOKEN" in param: wrapData = param['DATA'] splitData = wrapData.split(".") data = helper.decrypt(splitData[0], globalVariable.key, splitData[1]) newStr = re.match("(.*?)}", data).group() newStr= json.loads(newStr) no_rekening = newStr.get("no_rekening") start_period = newStr.get("start_period") end_period = newStr.get("end_period") tokenStatus = Authentication.checkValidToken(self, param['TOKEN']) if tokenStatus[0]["status"] == "success": sql = 'SELECT transaksi_id, transaction_type, description, balance, created_date, status_transaksi FROM tbl_transaksi WHERE no_rekening = %s AND created_date BETWEEN %s AND %s;' cursorKmPay.execute(sql,([no_rekening], [start_period], [end_period])) result = cursorKmPay.fetchall() items = [] for row in result: transaction_date = row[4].strftime('%d-%m-%Y') items.append({'id': row[0], 'transaction_type': row[1], 'description': row[2], 'balance': row[3], 'transaction_date': transaction_date, 'transaction_status':row[5]}) return {'status':'success','code': 200, 'result ': items} else: return tokenStatus else: return generalNotification.TokenNotAvailable(self) else: return generalNotification.DataNotAvailable(self)
def HeroSelfInclude(request): ProductName = request.GET["ProductName"] HeroID = Authentication.GetID(request) ProductID = Database.GetProductID(ProductName) Database.CreateHeroProductConnection(ProductID, HeroID, 'Client') URL = CallProduct(ProductName) return redirect(URL)
def setUp(self): """ """ import Authentication #setup a dummy account self._account = Authentication.Account("Key", "Secret", "Acc_tok", "Acc_tok_sec", "email")
def topupSaldo(self, param): # insertTblLog = 'INSERT INTO tbl_log_topup topup_id, no_rekening, bank_from, bank_to, balance, status, created_date VALUES (%s, %s, %s, %s, %s, %s, %s, %s)' if len(param) != 0: if "TOKEN" in param: now = datetime.datetime.now() wrapData = param['DATA'] splitData = wrapData.split(".") data = helper.decrypt(splitData[0], globalVariable.key, splitData[1]) newStr = re.match("(.*?)}", data).group() newStr = json.loads(newStr) no_rekening = newStr.get("no_rekening") tokenStatus = Authentication.checkValidToken(self, param['TOKEN']) if tokenStatus[0]["status"] == "success": member_id = getMemberIdbyBankAcc(self, no_rekening) domain = helper.getPrefixDomain(self, newStr.get("domain")) order_number = generateOrderNumber(self, domain['alias']) insertTblTopup = 'INSERT INTO tbl_topup (member_id, order_number, payment_type, total_payment, transaction_time, transaction_status, status_message, created_date, created_by) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)' cursorKmPay.execute(insertTblTopup, ([member_id], [order_number], [globalVariable.payment_type], [newStr.get("amount")], [now], [globalVariable.transaction_status], [globalVariable.topup_status_message], [now], [globalVariable.create_by])) connectKmPay.commit() # INSERT transaksi tabel # insertTblTransaksi = 'INSERT INTO tbl_transaksi (no_rekening, transaction_type, point_type, description, balance, transaksi_date, status_transaksi, created_date, created_by) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)' # a.execute(insertTblTopup, ([no_rekening], ["K"], ['TOPUP'], ["description"], [newStr.get("balance")], [now], ['SUCCESS'], [now], ['1'])) # conn.commit() else: return tokenStatus else: return generalNotification.TokenNotAvailable(self) else: return generalNotification.DataNotAvailable(self)
def getValue(cui, concept): try: apikey = "86a68870-ddd3-40d5-8454-de804bffd1b3" identifier = cui AuthClient = Authentication(apikey) tgt = AuthClient.gettgt() uri = "https://uts-ws.nlm.nih.gov" content_endpoint = "/rest/content/current/CUI/" + str( identifier) + "/" + concept query = {'ticket': AuthClient.getst(tgt)} r = requests.get(uri + content_endpoint, params=query) r.encoding = 'utf-8' items = json.loads(r.text) jsonData = items["result"] return jsonData except: return {}
def NewComment(request): Authentication.QuickCheck(request) ProjectName = request.GET["ProjectName"] CommentContent = request.GET["Message"] ProductID = Database.CreateProjectComment(request, ProjectName, CommentContent) URL = CallEntity(ProjectName, 'Project') return redirect(URL)
def __init__(self): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone = self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient();
def AnswerProductComment(request): Authentication.QuickCheck(request) ProjectName = request.GET["ProjectName"] Reaction = request.GET["Reaction"] BornTime = request.GET["BornTime"] ProductID = Database.AnswerProjectComment(request, ProjectName, Reaction, BornTime) URL = CallEntity(ProjectName, 'Project') return redirect(URL)
def NewProduct(request): Authentication.QuickCheck(request) Name = request.GET["ProductName"] Template = request.GET["ProductTemplate"] ReleaseDate = request.GET["ProductRelease"] AbsorbationTime = request.GET["ProductAbsorbation"] Database.CreateProduct(request, Name, Template, ReleaseDate, AbsorbationTime) return redirect('Home')
def Connect(request): if Authentication.ExcludeROB(request): GameToken =request.GET["GameToken"] Token = GameStats.AddPlayer(GameToken) URL = CallGame(Token) cache.set(str(Token),GameToken,2) return redirect(URL) else: return HttpResponse("Leave me!")
def search_term(string, page_limit=2, check=False): #apikey = '6119ca85-39ff-4649-aa79-6c1b1d281a02' #TP# apikey = 'b30cd58c-9d49-40fe-99ca-5b4807458c37' #version = '2018AA' version = 'current' string = string uri = "https://uts-ws.nlm.nih.gov" content_endpoint = "/rest/search/" + version ##get at ticket granting ticket for the session AuthClient = Authentication(apikey) tgt = AuthClient.gettgt() pageNumber = 0 res = [] while True: ##generate a new service ticket for each page if needed ticket = AuthClient.getst(tgt) pageNumber += 1 query = {'string': string, 'ticket': ticket, 'pageNumber': pageNumber} r = requests.get(uri + content_endpoint, params=query) r.encoding = 'utf-8' items = json.loads(r.text) jsonData = items["result"] #print (json.dumps(items, indent = 4))s #print("Results for page " + str(pageNumber)+"\n") if jsonData["results"][0]["ui"] == "NONE" or pageNumber > page_limit: break for result in jsonData["results"]: if check: try: res.append((result["ui"], result["name"])) except: NameError else: try: res.append(result["ui"]) except: NameError ##Either our search returned nothing, or we're at the end return res
def DeleteTask(request): Authentication.QuickCheck(request) StringData = request.GET["ToDelete"] StringData = StringData.replace("\'", "\"") DyingTask = json.loads(StringData) TaskName = DyingTask["TaskName"] ProductName = DyingTask["ProductName"] Database.DeleteTask(TaskName, ProductName) URL = CallProduct(ProductName) return redirect(URL)
def __init__(self,arguments): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); # self.cclient = self.aObj.getCeilometerClient(); self.args=arguments; for each in arguments: print "--->",each
def __init__(self,billName,flvr,price): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); self.price=price; self.billName=billName; self.flvrNames=flvr; self.dbObj = MongoDatabase();
class RouterPreReq: def __init__(self): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); def getAllSubnets(self): subnets = self.neutron.list_subnets(); subList=[]; for each in subnets['subnets']: subList.append(each['name']); return subList; def getAllTenants(self): tenants = self.keystone.tenants.list(); tenNames=[]; for each in tenants: tenNames.append(each.name); return tenNames; def getAllNetworks(self): obj= self.nova.networks.list(); netwrk=[]; for each in obj: netwrk.append(each.label); return netwrk;
class createBillCategory: def __init__(self,billName,flvr,price): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); self.price=price; self.billName=billName; self.flvrNames=flvr; self.dbObj = MongoDatabase(); def saveBillCategory(self): dicti={}; try: for f,b in zip(self.flvrNames,self.price): f = f.replace(".","\uff0e"); dicti[f]=b except: print 'exception..' store={"name":self.billName,"type":"flvr_based","priceList":dicti}; print store; self.addToDatabase(store); def addToDatabase(self,data): self.dbObj.addBillCategory(data); # prici={ "m1\\uff0elarge":"50","m1\\uff0esmall":"60","m1\\uff0emini":"70","m1\\uff0exlarge":"80","m1\\uff0etiny":"90" } # obj = createBillCategory("niki_minhaj","flvr_based",prici); # obj.saveBillCategory();
def hello(self, sid, clientId): log.debug(clientId, 'connected. User', repr(clientId)) # create sort of cookie while 1: sid = hashlib.sha256(str(random.random())).hexdigest() if not self.sessions.has_key(sid): break challenge = Authentication.getWelcomeString(self.authMethod) session = Session(sid) session.challenge = challenge session.clientIdent = clientId self.sessions[sid] = session return (sid, challenge), None
class makeBillPreReq: def __init__(self): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone = self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); def getAllFlavours(self): return self.nova.flavors.list(); def getMyFlavourDetails(self,flvrName): flvrs = self.nova.flavors.list(); for each in flvrs: if (each.name==flvrName): return each; return None;
def login(self, sid, login, cpasswd, hostID): login = login.strip() if not login: raise SecurityException("Specify login, please.") if login in (): raise SecurityException("Account blocked") log.debug(sid, 'login', repr(login), 'hostid', hostID) login = str(login) challenge = self.sessions[sid].challenge account = None # use metaserver login if metaserver is defined if self.metaserver: result = self.metaserver.verifyPassword(login, Authentication.processUserPassword(cpasswd, challenge)) if result: account = Account() account.login = login account.nick = result["nick"] account.email = result["email"] log.debug("User", login, "has valid metaserver account") #else: # raise SecurityException("Wrong login and/or password.") # local login # TBD: option to disable local login completely if not account: log.debug("Trying local login for user", login) if not self.accounts.has_key(login): raise SecurityException('Wrong login and/or password.') account = self.accounts[login] if not Authentication.verify(cpasswd, account.passwd, challenge): raise SecurityException('Wrong login and/or password.') # setup session self.sessions[sid].setAttrs(account.login, account.nick, account.email) account.lastLogin = time.time() account.addHostID(hostID) self.tokens[sid] = hashlib.md5(str(random.random())).hexdigest() return 1, None
class InstanceBill: def __init__(self,instnc,catg): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); self.inst = instnc; slef.catg = catg; def getInstanceID(self): instanceList = nova.servers.list(search_opts={'all_tenants': 1}); for i in range(0,len(instanceList),1): if(instanceList[i].name==self.inst): return instncID = instanceList[i].id; def getTopSamples(self):
def __init__(self,cat,instName): inst = str(instName); cat = str(cat); print 'INST ->', inst; print 'CATG ->', cat; self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); self.dbObj = MongoDatabase(); self.cat = cat; self.instName = inst;
def login(self, sid, login, safePassword, hostID): login = login.strip() if not login: raise SecurityException("Specify login, please.") if login in (): raise SecurityException("Account blocked") log.debug(sid, 'login', repr(login), 'hostid', hostID) login = str(login) challenge = self.sessions[sid].challenge log.debug("Trying local login for user", login) if not self.accounts.has_key(login): raise SecurityException('Wrong login and/or password.') account = self.accounts[login] plainPassword = Authentication.unwrapUserPassword(safePassword, challenge) if not account.verifyPassword(plainPassword): raise SecurityException('Wrong login and/or password.') # setup session self.sessions[sid].setAttrs(account.login, account.nick, account.email) account.lastLogin = time.time() account.addHostID(hostID) return 1, None
parser.add_argument("-k", "--apikey", required = True, dest = "apikey", help = "enter api key from your UTS Profile") parser.add_argument("-v", "--version", required = False, dest="version", default = "current", help = "enter version example-2015AA") parser.add_argument("-o", "--outputfile", required = True, dest = "outputfile", help = "enter a name for your output file") parser.add_argument("-s", "--sabs", required = False, dest="sabs",help = "enter a comma-separated list of vocabularies, like MSH, SNOMEDCT_US, or RXNORM") parser.add_argument("-t", "--ttys", required = False, dest="ttys",help = "enter a comma-separated list of term types, like PT,SY,IN") parser.add_argument("-i", "--inputfile", required = True, dest = "inputfile", help = "enter a name for your input file") args = parser.parse_args() apikey = args.apikey version = args.version outputfile = args.outputfile inputfile = args.inputfile sabs = args.sabs ttys = args.ttys AuthClient = Authentication(apikey) ################################### #get TGT for our session ################################### tgt = AuthClient.gettgt() base_uri = "https://uts-ws.nlm.nih.gov" rxnorm = "https://rxnav.nlm.nih.gov" pageNumber=1 pageCount=1 auis = {} if outputfile: o = open(outputfile, 'w')
class Router: def __init__(self,arguments): self.aObj = Authentication("yess"); self.nova = self.aObj.getComputeClient(); self.neutron = self.aObj.getNeutronClient(); self.keystone= self.aObj.getKeystoneClient(); self.glance = self.aObj.getGlanceClient(); self.cclient = self.aObj.getCeilometerClient(); self.args=arguments; def createRouter(self): routerName = self.args[4]; desiredSubnet = self.args[3]; desiredNet = self.args[2]; tenantName = self.args[1]; if (self.checkDuplicate(routerName,tenantName)==False): netId=None; subnetId=None; routerId=None; neti = self.nova.networks.list() for x in neti: if x.label == desiredNet: netId = x.id; break bodyVal= { "router": { "name": routerName, "external_gateway_info": { "network_id": netId, "enable_snat": "True", }, "admin_state_up": "true" } } subnets = self.neutron.list_subnets(); for each in subnets['subnets']: if each['name'] == desiredSubnet: subnetId = each['id'] subNeti = {"subnet_id": subnetId} self.neutron.create_router(body=bodyVal); time.sleep(1); rtrLists = self.neutron.list_routers(); for each in rtrLists['routers']: if each['name'] == routerName: routerId = each['id'] interfaceArg = {} self.neutron.add_interface_router(routerId,body=subNeti); print "Router Created with name ", routerName else: print "Router Already Exists for this user"; def checkDuplicate(self,myName,myTenant): rtrLists = self.neutron.list_routers(); tenant = self.keystone.tenants.list(); for each in tenant: if (each.name==myTenant): myId = each.id; for each in rtrLists['routers']: if ( (each['tenant_id'] == myId) & (each['name'] == myName) ): return True return False
import argparse import collections import sys reload(sys) sys.setdefaultencoding('utf-8') parser = argparse.ArgumentParser(description='process user given parameters') parser.add_argument("-k", "--apikey", required = True, dest = "apikey", help = "enter api key from your UTS Profile") parser.add_argument("-v", "--version", required = False, dest="version", default = "current", help = "enter version example-2015AA") parser.add_argument("-f", "--outputfile", required = True, dest = "outputfile", help = "enter a name for your output file") args = parser.parse_args() apikey = args.apikey version = args.version outputfile=args.outputfile AuthClient = Authentication(apikey) ################################### #get TGT for our session ################################### tgt = AuthClient.gettgt() base_uri = "https://uts-ws.nlm.nih.gov" #C2711988 is the CUI for the SNOMED CT CORE Problem List content view #Full list of content views is here: https://www.nlm.nih.gov/research/umls/knowledge_sources/metathesaurus/release/content_views.html, #or over web services at https://uts-ws.nlm.nih.gov/rest/content-views/current?ticket=ST... content_view_endpoint = "/rest/content-views/"+version+"/CUI/C2711988/members" tgt = AuthClient.gettgt() pageNumber=1 pageCount=1 f = open(outputfile, 'w')
def getUsername(authToken): return Authentication.getUser(authToken)
# In[ ]: # In[5]: #!/usr/bin/env python from os import environ as env import os from collections import OrderedDict from pprint import pprint from Authentication import * authObj1=Authentication("zaib") nova = authObj1.getComputeClient() neutron = authObj1.getNeutronClient() keystone = authObj1.getKeystoneClient() cclient = authObj1.getCeilometerClient() glance = authObj1.getGlanceClient() class Events:
def updateAccount(authToken, fname, lname, pwd1=False, pwd2=False): if pwd1 and pwd1 == pwd2: Authentication.updateAccount(authToken,fname, lname, pwd1) else: Authentication.updateAccount(authToken, fname, lname)
def getUserInfo(authToken): return Authentication.getUserInfo(authToken)
def getID(uname,pwd): return Authentication.authUser(uname,pwd)
def endSession(authToken): Authentication.endSession(authToken)
def validateID(authToken): return Authentication.validateUser(authToken)
def requestJobHistory(authToken): return Authentication.authViewRequest(authToken)
parser = argparse.ArgumentParser(description='process user given parameters') parser.add_argument("-u", "--username", required = True, dest="username", help = "enter username") parser.add_argument("-p", "--password", required = True, dest="password", help = "enter passowrd") parser.add_argument("-v", "--version", required = False, dest="version", default = "current", help = "enter version example-2015AA") parser.add_argument("-s", "--string", required = True, dest="string", help = "enter a search term, like 'diabetic foot'") args = parser.parse_args() username = args.username password = args.password version = args.version string = args.string uri = "https://uts-ws.nlm.nih.gov" content_endpoint = "/rest/search/"+version ##get at ticket granting ticket for the session AuthClient = Authentication(username,password) tgt = AuthClient.gettgt() pageNumber=0 while True: ##generate a new service ticket for each page if needed ticket = AuthClient.getst(tgt) pageNumber += 1 query = {'string':string,'ticket':ticket, 'pageNumber':pageNumber} #query['includeObsolete'] = 'true' #query['includeSuppressible'] = 'true' #query['returnIdType'] = "sourceConcept" #query['sabs'] = "SNOMEDCT_US" r = requests.get(uri+content_endpoint,params=query) r.encoding = 'utf-8' items = json.loads(r.text)