def __init__(self, toaddr):
from email.MIMEMultipart import MIMEMultipart
from email.MIMEText import MIMEText
verification_code = str(uuid.uuid4())
key = self.key_prefix + ":" + verification_code
data = {
"verification_code": verification_code,
"email_address": toaddr,
"timestamp": timestamp()
}
es = get_elasticsearch_connection()
es_save_data(es, self.key_prefix, "local", data, verification_code)
subject = self.subject
body = render_template(self.template_name,
verification_code=verification_code)
msg = MIMEMultipart()
msg["To"] = toaddr
msg["Subject"] = self.subject
msg["From"] = self.fromaddr
msg.attach(MIMEText(body, "plain"))
send_email(toaddr, msg.as_string())
def num_collections(self):
"""Number of user's collections"""
es = get_elasticsearch_connection()
user_email = self.record['user_email_address']
#ZS: Get user's collections if they exist
response = es.search(
index="users",
doc_type="local",
body={"query": {
"match": {
"email_address": user_email
}
}})
user_info = response['hits']['hits'][0]['_source']
logger.debug("USER NUM COLL:", user_info)
if 'collections' in user_info.keys():
if user_info['collections'] != "[]" and len(
user_info['collections']) > 0:
collections_json = json.loads(user_info['collections'])
return len(collections_json)
else:
return 0
else:
return 0
def password_reset():
"""Entry point after user clicks link in E-mail"""
logger.debug("in password_reset request.url is:", request.url)
# We do this mainly just to assert that it's in proper form for displaying next page
# Really not necessary but doesn't hurt
# user_encode = DecodeUser(ForgotPasswordEmail.key_prefix).reencode_standalone()
verification_code = request.args.get('code')
hmac = request.args.get('hm')
es = get_elasticsearch_connection()
if verification_code:
code_details = get_item_by_unique_column(
es, "verification_code", verification_code,
ForgotPasswordEmail.key_prefix, "local")
if code_details:
user_details = get_user_by_unique_column(
es, "email_address", code_details["email_address"])
if user_details:
return render_template("new_security/password_reset.html",
user_encode=user_details["user_id"])
else:
flash("Invalid code: User no longer exists!", "error")
else:
flash(
"Invalid code: Password reset code does not exist or might have expired!",
"error")
return redirect(
url_for("login")
) #render_template("new_security/login_user.html", error=error)
def password_reset_step2():
"""Handle confirmation E-mail for password reset"""
logger.debug("in password_reset request.url is:", request.url)
errors = []
user_id = request.form['user_encode']
logger.debug("locals are:", locals())
user = Bunch()
password = request.form['password']
set_password(password, user)
es = get_elasticsearch_connection()
es.update(index="users",
doc_type="local",
id=user_id,
body={"doc": {
"password": user.__dict__.get("password")
}})
flash("Password changed successfully. You can now sign in.", "alert-info")
response = make_response(redirect(url_for('login')))
return response
def setUp(self):
self.es = get_elasticsearch_connection()
self.es_cleanup = []
es_logger = logging.getLogger("elasticsearch")
es_logger.setLevel(app.config.get("LOG_LEVEL"))
es_logger.addHandler(
logging.FileHandler("/tmp/es_TestRegistrationInfo.log"))
es_trace_logger = logging.getLogger("elasticsearch.trace")
es_trace_logger.addHandler(
logging.FileHandler("/tmp/es_TestRegistrationTrace.log"))
def setUp(self):
self.es = get_elasticsearch_connection()
self.es_cleanup = []
es_logger = logging.getLogger("elasticsearch")
es_logger.setLevel(app.config.get("LOG_LEVEL"))
es_logger.addHandler(
logging.FileHandler("/tmp/es_TestRegistrationInfo.log"))
es_trace_logger = logging.getLogger("elasticsearch.trace")
es_trace_logger.addHandler(
logging.FileHandler("/tmp/es_TestRegistrationTrace.log"))
def update_collections(self, updated_collections):
es = get_elasticsearch_connection()
collection_body = {
'doc': {
'collections': json.dumps(updated_collections)
}
}
es.update(index='users',
doc_type='local',
id=self.es_user_id,
refresh='wait_for',
body=collection_body)
def oauth2_login(self, login_type, user_id):
"""Login via an OAuth2 provider"""
es = get_elasticsearch_connection()
user_details = get_user_by_unique_column(es, "user_id", user_id)
if user_details:
user = model.User()
user.id = user_details["user_id"]
user.full_name = user_details["name"]
user.login_type = user_details["login_type"]
return self.actual_login(user)
else:
flash("Error logging in via OAuth2")
return make_response(redirect(url_for('login')))
def add_collection(self, collection_name, traits):
"""Add collection into ElasticSearch"""
collection_dict = {
'id':
unicode(uuid.uuid4()),
'name':
collection_name,
'created_timestamp':
datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
'changed_timestamp':
datetime.datetime.utcnow().strftime('%b %d %Y %I:%M%p'),
'num_members':
len(traits),
'members':
list(traits)
}
es = get_elasticsearch_connection()
user_email = self.record['user_email_address']
response = es.search(
index="users",
doc_type="local",
body={"query": {
"match": {
"email_address": user_email
}
}})
user_id = response['hits']['hits'][0]['_id']
user_info = response['hits']['hits'][0]['_source']
if 'collections' in user_info.keys():
if user_info['collections'] != [] and user_info[
'collections'] != "[]":
current_collections = json.loads(user_info['collections'])
current_collections.append(collection_dict)
self.update_collections(current_collections)
#collections_json = json.dumps(current_collections)
else:
self.update_collections([collection_dict])
#collections_json = json.dumps([collection_dict])
else:
self.update_collections([collection_dict])
#collections_json = json.dumps([collection_dict])
return collection_dict['id']
def es_user_id(self):
"""User id from ElasticSearch (need to check if this is the same as the id stored in self.records)"""
es = get_elasticsearch_connection()
user_email = self.record['user_email_address']
#ZS: Get user's collections if they exist
response = es.search(
index="users",
doc_type="local",
body={"query": {
"match": {
"email_address": user_email
}
}})
user_id = response['hits']['hits'][0]['_id']
return user_id
def orcid_oauth2():
from uuid import uuid4
from utility.tools import ORCID_CLIENT_ID, ORCID_CLIENT_SECRET, ORCID_TOKEN_URL, ORCID_AUTH_URL
code = request.args.get("code")
error = request.args.get("error")
url = "/n/login"
if code:
data = {
"client_id": ORCID_CLIENT_ID,
"client_secret": ORCID_CLIENT_SECRET,
"grant_type": "authorization_code",
"code": code
}
result = requests.post(ORCID_TOKEN_URL, data=data)
result_dict = json.loads(result.text.encode("utf-8"))
es = get_elasticsearch_connection()
user_details = get_user_by_unique_column(es, "orcid",
result_dict["orcid"])
if user_details == None:
user_details = {
"user_id":
str(uuid4()),
"name":
result_dict["name"],
"orcid":
result_dict["orcid"],
"user_url":
"%s/%s" % ("/".join(
ORCID_AUTH_URL.split("/")[:-2]), result_dict["orcid"]),
"login_type":
"orcid",
"organization":
"",
"active":
1,
"confirmed":
1
}
save_user(es, user_details, user_details["user_id"])
url = "/n/login?type=orcid&uid=" + user_details["user_id"]
else:
flash("There was an error getting code from ORCID")
return redirect(url)
def forgot_password_submit():
"""When a forgotten password form is submitted we get here"""
params = request.form
email_address = params['email_address']
next_page = None
if email_address != "":
logger.debug("Wants to send password E-mail to ", email_address)
es = get_elasticsearch_connection()
user_details = get_user_by_unique_column(es, "email_address",
email_address)
if user_details:
ForgotPasswordEmail(user_details["email_address"])
return render_template("new_security/forgot_password_step2.html",
subject=ForgotPasswordEmail.subject)
else:
flash("You MUST provide an email", "alert-danger")
return redirect(url_for("forgot_password"))
def get_transform_vals(dataset, trait):
es = get_elasticsearch_connection(for_user=False)
logger.info("DATASET NAME:", dataset.name)
query = '{"bool": {"must": [{"match": {"name": "%s"}}, {"match": {"dataset": "%s"}}]}}' % (trait.name, dataset.name)
es_body = {
"query": {
"bool": {
"must": [
{
"match": {
"name": "%s" % (trait.name)
}
},
{
"match": {
"dataset": "%s" % (dataset.name)
}
}
]
}
}
}
response = es.search( index = "traits", doc_type = "trait", body = es_body )
logger.info("THE RESPONSE:", response)
results = response['hits']['hits']
if len(results) > 0:
samples = results[0]['_source']['samples']
sample_dict = {}
for sample in samples:
sample_dict[sample['name']] = sample['qnorm']
logger.info("SAMPLE DICT:", sample_dict)
return sample_dict
else:
return None
def get_transform_vals(dataset, trait):
es = get_elasticsearch_connection(for_user=False)
logger.info("DATASET NAME:", dataset.name)
query = '{"bool": {"must": [{"match": {"name": "%s"}}, {"match": {"dataset": "%s"}}]}}' % (
trait.name, dataset.name)
es_body = {
"query": {
"bool": {
"must": [{
"match": {
"name": "%s" % (trait.name)
}
}, {
"match": {
"dataset": "%s" % (dataset.name)
}
}]
}
}
}
response = es.search(index="traits", doc_type="trait", body=es_body)
logger.info("THE RESPONSE:", response)
results = response['hits']['hits']
if len(results) > 0:
samples = results[0]['_source']['samples']
sample_dict = {}
for sample in samples:
sample_dict[sample['name']] = sample['qnorm']
logger.info("SAMPLE DICT:", sample_dict)
return sample_dict
else:
return None
def register():
params = None
errors = None
params = request.form if request.form else request.args
params = params.to_dict(flat=True)
es = get_elasticsearch_connection()
params["es_connection"] = es
if params:
logger.debug("Attempting to register the user...")
result = RegisterUser(params)
errors = result.errors
if len(errors) == 0:
flash(
"Registration successful. You may login with your new account",
"alert-info")
return redirect(url_for("login"))
return render_template("new_security/register_user.html",
values=params,
errors=errors)
def github_oauth2():
from utility.tools import GITHUB_CLIENT_ID, GITHUB_CLIENT_SECRET
code = request.args.get("code")
data = {
"client_id": GITHUB_CLIENT_ID,
"client_secret": GITHUB_CLIENT_SECRET,
"code": code
}
result = requests.post("https://github.com/login/oauth/access_token",
json=data)
result_dict = {
arr[0]: arr[1]
for arr in [
tok.split("=") for tok in
[token.encode("utf-8") for token in result.text.split("&")]
]
}
github_user = get_github_user_details(result_dict["access_token"])
es = get_elasticsearch_connection()
user_details = get_user_by_unique_column(es, "github_id",
github_user["id"])
if user_details == None:
user_details = {
"user_id": str(uuid.uuid4()),
"name": github_user["name"].encode("utf-8"),
"github_id": github_user["id"],
"user_url": github_user["html_url"].encode("utf-8"),
"login_type": "github",
"organization": "",
"active": 1,
"confirmed": 1
}
save_user(es, user_details, user_details["user_id"])
url = "/n/login?type=github&uid=" + user_details["user_id"]
return redirect(url)
def user_collections(self):
"""List of user's collections"""
es = get_elasticsearch_connection()
user_email = self.record['user_email_address']
#ZS: Get user's collections if they exist
response = es.search(
index="users",
doc_type="local",
body={"query": {
"match": {
"email_address": user_email
}
}})
user_info = response['hits']['hits'][0]['_source']
if 'collections' in user_info.keys():
if len(user_info['collections']) > 0:
return json.loads(user_info['collections'])
else:
return []
else:
return []
"dataset_fullname": result_info[2],
"samples": sample_list,
"transform_types": "qnorm"
}
}
if __name__ == '__main__':
Conn = MySQLdb.Connect(**parse_db_uri())
Cursor = Conn.cursor()
#es = Elasticsearch([{
# "host": ELASTICSEARCH_HOST, "port": ELASTICSEARCH_PORT
#}], timeout=60) if (ELASTICSEARCH_HOST and ELASTICSEARCH_PORT) else None
es = get_elasticsearch_connection(for_user=False)
#input_filename = "/home/zas1024/cfw_data/" + sys.argv[1] + ".txt"
#input_df = create_dataframe(input_filename)
#output_df = quantileNormalize(input_df)
#output_df.to_csv('quant_norm.csv', sep='\t')
#out_filename = sys.argv[1][:-4] + '_quantnorm.txt'
success, _ = bulk(es, set_data(sys.argv[1]))
response = es.search(
index="traits",
doc_type="trait",
body={"query": {
"dataset": dataset_name,
"dataset_fullname": result_info[2],
"samples": sample_list,
"transform_types": "qnorm"
}
}
if __name__ == '__main__':
Conn = MySQLdb.Connect(**parse_db_uri())
Cursor = Conn.cursor()
#es = Elasticsearch([{
# "host": ELASTICSEARCH_HOST, "port": ELASTICSEARCH_PORT
#}], timeout=60) if (ELASTICSEARCH_HOST and ELASTICSEARCH_PORT) else None
es = get_elasticsearch_connection(for_user=False)
#input_filename = "/home/zas1024/cfw_data/" + sys.argv[1] + ".txt"
#input_df = create_dataframe(input_filename)
#output_df = quantileNormalize(input_df)
#output_df.to_csv('quant_norm.csv', sep='\t')
#out_filename = sys.argv[1][:-4] + '_quantnorm.txt'
success, _ = bulk(es, set_data(sys.argv[1]))
response = es.search(
index = "traits", doc_type = "trait", body = {
"query": { "match": { "name": "ENSMUSG00000028982" } }
}
def standard_login(self):
"""Login through the normal form"""
params = request.form if request.form else request.args
logger.debug("in login params are:", params)
es = get_elasticsearch_connection()
if not params:
from utility.tools import GITHUB_AUTH_URL, GITHUB_CLIENT_ID, ORCID_AUTH_URL, ORCID_CLIENT_ID
external_login = {}
if GITHUB_AUTH_URL and GITHUB_CLIENT_ID != 'UNKNOWN':
external_login["github"] = GITHUB_AUTH_URL
if ORCID_AUTH_URL and ORCID_CLIENT_ID != 'UNKNOWN':
external_login["orcid"] = ORCID_AUTH_URL
assert (es is not None)
return render_template("new_security/login_user.html",
external_login=external_login,
es_server=es.ping())
else:
user_details = get_user_by_unique_column(es, "email_address",
params["email_address"])
user = None
valid = None
if user_details:
user = model.User()
for key in user_details:
user.__dict__[key] = user_details[key]
valid = False
submitted_password = params['password']
pwfields = Struct(json.loads(user.password))
encrypted = Password(submitted_password, pwfields.salt,
pwfields.iterations, pwfields.keylength,
pwfields.hashfunc)
logger.debug("\n\nComparing:\n{}\n{}\n".format(
encrypted.password, pwfields.password))
valid = pbkdf2.safe_str_cmp(encrypted.password,
pwfields.password)
logger.debug("valid is:", valid)
if valid and not user.confirmed:
VerificationEmail(user)
return render_template(
"new_security/verification_still_needed.html",
subject=VerificationEmail.subject)
if valid:
if params.get('remember'):
logger.debug("I will remember you")
self.remember_me = True
if 'import_collections' in params:
import_col = "true"
else:
import_col = "false"
#g.cookie_session.import_traits_to_user()
self.logged_in = True
return self.actual_login(user, import_collections=import_col)
else:
if user:
self.unsuccessful_login(user)
flash("Invalid email-address or password. Please try again.",
"alert-danger")
response = make_response(redirect(url_for('login')))
return response