def get(self):
"""
Get recommendation for the given product id
:return: dict: status, message, data -> list of recommended products
"""
product_id = request.args.get('productid')
if product_id is None or product_id == "":
response_d = self.__get_error_resposne()
return jsonify(response_d)
try:
key = self.__get_key(product_id)
recommendation_dict = db.hgetall(key)
if recommendation_dict is None or len(recommendation_dict) == 0:
response_d = {"status": 404, "message": "Error", "data": []}
else:
recommended_ids = [int(k) for k in recommendation_dict.keys()]
message = "recommendations for PID : %s" % product_id
response_d = {
"status": 200,
"message": message,
"data": recommended_ids
}
except Exception as e:
print(e)
response_d = self.__get_error_resposne()
return response_d
def get_file_fromdb(filetype, taskid):
"""Download a file."""
task = db.hgetall("%s:cols" % taskid)
cols = ast.literal_eval(task['cols'])
sep = "\t" if filetype == "tsv" else ","
csv = "%s\n" % sep.join(cols)
client = redisearch.Client(taskid)
num_docs = int(client.info()['num_docs'])
for i in range(0, num_docs):
doc = client.load_document("%s_%d" % (taskid, i))
listparam = []
for col in cols:
if col == "TF_gene":
listparam.append("\"%s\"" % eval("doc.%s" % col))
else:
listparam.append(eval("doc.%s" % col))
csv += sep.join(listparam)
if i != num_docs - 1:
csv += "\n"
''' return the csv/tsv file without having to save it '''
return Response(csv,
mimetype="text/csv",
headers={
"Content-disposition":
"attachment; filename=prediction_result-%s.%s" %
(taskid, filetype)
})
def get_file_fromtbl(filetype, task_id, filters): #taskid,filters
#filtered_db = filter_fromdb(task_id,searchFilter,start,length,cols[order_col],order_asc)
search_filter = ast.literal_eval(filters)
# [{"searchOpt":"in sequence","searchKey":"AAT","searchCol":"sequence"}
filtered = filter_fromdb(task_id, search_filter, start=0, length=-1)
ftype = filetype.lower()
if ftype == "tsv":
sep = "\t"
else:
sep = ","
cols = ast.literal_eval(db.hgetall("%s:cols" % task_id)['cols'])
tblret = sep.join(cols) + "\n"
for doc in filtered['data']:
try: # TODO: handle this
row = []
for col in cols: # need to do this because we can have multiple TF_genes
if col == "TF_gene":
row.append("\"%s\"" % getattr(doc, col))
else:
row.append(getattr(doc, col))
tblret += sep.join(row) + "\n"
except: #now: if not found, just return 404
abort(404)
return Response(tblret[:-1],
mimetype="text/csv",
headers={
"Content-disposition":
"attachment; filename=prediction_result-%s.%s" %
(task_id, ftype)
})
def _get_story(id, created=None):
"""
get all necessary data for a story from db
"""
story = db.hgetall("z:stories:{id}".format(id=id))
if not story:
return None
if not created:
createdvalue = db.zscore("z:stories:index:created", id)
created = str(round(createdvalue)) if createdvalue else None
story["id"] = id
story["created"] = created
story["created_human"] = dt.utcfromtimestamp(int(
story["created"])).strftime('%Y-%m-%d %H:%M:%S')
story["content_url"] = ApiStories._get_content_url(id)
story["detail_url"] = ApiStories._get_detail_url(id)
edit_url = ApiStories._get_edit_url(id)
if edit_url:
story["edit_url"] = edit_url
location = db.geopos("z:stories:position", id)[0]
if location:
story["lon"] = str(round(location[0], 4))
story["lat"] = str(round(location[1], 4))
return story
def get_userdata(self, uid):
"""
get all user data from <uid>
populates also uid in data even not stored in db
"""
if not uid:
uid = get_jwt_identity()
return merge_dict(db.hgetall("z:users:{uid}".format(uid=uid)),
{"uid": uid})
def process_request(job_id):
# get the task data from redis
taskdata = db.hgetall(job_id)
if "parent_id" not in taskdata:
abort(404)
p0 = taskdata["parent_id"]
p1 = taskdata["task_id"]
parents = json.dumps({'parent-0': p0, 'parent-1': p1})
#session.clear() # clear the session given from index
return render_template("result.html",
stats_url=url_for('task_status', task_id=job_id),
parents=parents)
def post(self):
"""
http -F POST :5000/api/v01/login [email protected] password="******"
http -F POST :5000/api/v01/register [email protected] password="******"
"""
data = request.json or {}
# mandatory fields
errs = check_mandatory_fields(data, ["email", "password"])
if errs:
return make_response(jsonify(errs), 422)
endpointUsed = re.sub("^.*?([^/]*)$", r"\1", request.path)
# login
if (endpointUsed == "login"):
# verify if email exists in db
uid = db.get("z:usersByEmail:{email}".format(email=data["email"]))
user = db.hgetall("z:users:{uid}".format(uid=uid)) if uid else {}
# verify email/password
if user and sha256.verify(data["password"], user["password"]):
return self.login(uid, user)
else:
return self.response("wrong creds")
# register
else:
# verify email by simple validation for now
# https://www.scottbrady91.com/Email-Verification/Python-Email-Verification-Script
match = re.match(
"^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$",
data["email"])
if match == None:
return self.response("wrong format", "email")
dataFiltered = filter_dict(data, self.exposedFields)
dataFiltered["password"] = sha256.hash(data["password"])
dataFiltered["uid"] = uuid.uuid4()
ret = db.replaceOrInsertUser(args=dict2list(dataFiltered)).lower()
if ret == "ok":
return self.login(dataFiltered["uid"])
else:
return self.response(*ret.split(":"))
def login(self, uid, user=None):
access_token = create_access_token(identity=uid, fresh=True)
refresh_token = create_refresh_token(identity=uid)
user = db.hgetall("z:users:{uid}".format(
uid=uid)) if user == None else user
# store tokens in db for security and logout blacklisting
access_jti = get_jti(encoded_token=access_token)
refresh_jti = get_jti(encoded_token=refresh_token)
db.set("z:tokens:{jti}".format(jti=access_jti), "false",
current_app.config.get("ACCESS_EXPIRES") * 1.2)
db.set("z:tokens:{jti}".format(jti=refresh_jti), "false",
current_app.config.get("REFRESH_EXPIRES") * 1.2)
return jsonify(
merge_dict(
filter_dict(user, self.exposedFields), {
"msg": "ok",
"access_token": access_token,
"refresh_token": refresh_token,
"uid": uid
}))
def get_res_col(task_id):
cols = []
col_id = "%s:cols" % task_id
colmap = { # hardcoded, need to fix this
"row": "Index",
"wild": "Ref",
"mutant": "Alt",
"diff": "Difference",
"p_value": "p value",
"z_score": "z score",
"TF_gene": "TF gene",
"binding_status": "Binding status",
#"gapmodel":"Gap model", #vmartin: comment this
"pbmname": "PBM filename"
}
if db.exists(col_id):
cols_fromdb = ast.literal_eval(db.hgetall(col_id)['cols'])
# add conditional to ignore if there is any undefined column
cols = [{
"title": colmap[title]
} for title in cols_fromdb
if title in colmap] #vmartin: hide gap model
# else just return an empty list
return jsonify(cols)
def get_input_param(job_id):
# key: filename,pbmselected,filteropt,filterval,chrver
indict = db.hgetall(job_id)
indict["genes_selected"] = ast.literal_eval(indict["genes_selected"])
return json.dumps(indict) # must return a json
def get_res_tbl(task_id):
# Get all mandatory informations we need
# Info about params: https://datatables.net/manual/server-side#DataTables_Table_1
draw = int(request.args['draw']) # not secure # TODO: make it secure?
start = int(request.args['start'])
length = int(request.args['length'])
# cs is custom search
searchFilter = ast.literal_eval(request.args['searchFilter'])
# check orderable -- orderMulti is disabled in result.js so we can assume
# one column ordering.
order_col = int(request.args["order[0][column]"])
order_asc = True if request.args["order[0][dir]"] == "asc" else False
retlist = []
#res_csv = pd.read_csv("%s%s.csv"%(app.config['UPLOAD_FOLDER'],task_id)).values.tolist()
cols = ast.literal_eval(db.hgetall("%s:cols" % task_id)['cols'])
filtered_db = filter_fromdb(task_id, searchFilter, start, length,
cols[order_col], order_asc)
retlist = []
# for now, if nothing found then return an empty table
if filtered_db['data'] and not hasattr(filtered_db['data'][0], 'row'):
return jsonify({
"draw": 0,
"recordsTotal": 0,
"recordsFiltered": 0,
"data": [],
"status": "false"
})
for doc in filtered_db['data']:
#if not filter_search(row,csKey,csField):
# continue
#try: # TODO: handle this
# rowdict = {col:getattr(doc,col) for col in cols}
#except: #now: if not found, just return 404
# abort(404)
rowdict = {}
rowdict['row'] = doc.row
rowdict[
'wild'] = doc.wild[:5] + '<span class="bolded-red">' + doc.wild[
5] + '</span>' + doc.wild[6:]
rowdict[
'mutant'] = doc.mutant[:
5] + '<span class="bolded-red">' + doc.mutant[
5] + '</span>' + doc.mutant[6:]
rowdict['diff'] = doc.diff
rowdict['z_score'] = customround(doc.z_score)
rowdict['p_value'] = customround(doc.p_value)
rowdict['binding_status'] = htmlformat(
doc.binding_status, "filter",
"binding_status") #vmartin: binding-flag
#rowdict['gapmodel'] = htmlformat(doc.gapmodel,"filter","gapmodel")
rowdict['TF_gene'] = htmlformat(doc.TF_gene, "filter", "TF_gene")
rowdict['pbmname'] = htmlformat(doc.pbmname, "filter", "pbmname")
retlist.append([rowdict[col] for col in cols])
return jsonify({
"draw": draw,
"recordsTotal": filtered_db['recordsTotal'],
"recordsFiltered": filtered_db['recordsFiltered'],
"data": retlist,
"status": "success"
})