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)
