def user_level_up():
data = request.get_json()
local_auth = LocalAuth(ca, session)
result = local_auth.user_level_up(
data['annotator']) # TODO not implemented (lost?)
return result
def set_quota():
"""Change quota of a user
Returns
-------
json
users: updated users
error: True if error, else False
errorMessage: the error message of error, else an empty string
"""
data = request.get_json()
try:
local_auth = LocalAuth(current_app, session)
local_auth.set_quota(data['quota'], data['username'])
all_users = local_auth.get_all_users()
except Exception as e:
traceback.print_exc(file=sys.stdout)
return jsonify({
'users': [],
'error': True,
'errorMessage': str(e)
}), 500
return jsonify({'users': all_users, 'error': False, 'errorMessage': ''})
def update_galaxy():
"""Update the user apikey
Returns
-------
json
The user with his new apikey
"""
data = request.get_json()
local_auth = LocalAuth(current_app, session)
if session["user"]["galaxy"]:
updated_user = local_auth.update_galaxy_account(
session["user"], data["gurl"], data["gkey"])
else:
updated_user = local_auth.add_galaxy_account(session["user"],
data["gurl"],
data["gkey"])
session["user"] = updated_user["user"]
current_app.logger.debug(updated_user["user"])
return jsonify({
'error': updated_user['error'],
'errorMessage': updated_user['error_message'],
'user': updated_user['user']
})
def signup():
"""Register a new user
Returns
-------
json
Info about the user
"""
user = {}
data = request.get_json()
local_auth = LocalAuth(current_app, session)
local_auth.check_inputs(data)
if not local_auth.get_error():
user = local_auth.persist_user(data)
local_auth.create_user_directories(user['id'], user['username'])
session['user'] = user
return jsonify({
'error': local_auth.get_error(),
'errorMessage': local_auth.get_error_message(),
'user': user
})
def get_user_amount():
"""get the number of user in the database
Returns
-------
int
Number of user in the Database
"""
dataInstance = LocalAuth(ca, session)
users_amount = dataInstance.get_number_of_users()
result = {'error': False, 'errorMessage': "", 'usersAmount': users_amount}
return result
def update_profile():
"""Update user profile (names and email)
Returns
-------
json
The updated user
"""
data = request.get_json()
online_user = session['user']
local_auth = LocalAuth(ca, session)
result = local_auth.update_profile(data, online_user)
result['user']['_id'] = str(result['user']['_id'])
session['user'] = result['user']
return kill_apollo_session(result)
def update_password():
"""Update user password
Returns
-------
json
The updated user
"""
data = request.get_json()
online_user = session['user']
local_auth = LocalAuth(ca, session)
result = local_auth.update_password(data, online_user)
if '_id' in result['user']:
result['user']['_id'] = str(result['user']['_id'])
session['user'] = result['user']
return result
def login_api_key(key):
"""Log user with his API key
Parameters
----------
key : string
User API key
Returns
-------
json
Information about the logged user
"""
local_auth = LocalAuth(current_app, session)
authentication = local_auth.authenticate_user_with_apikey(key)
if not authentication["error"]:
session["user"] = authentication["user"]
proxy_path = "/"
try:
proxy_path = current_app.iniconfig.get('genocrowd',
'reverse_proxy_path')
except Exception:
pass
title = "Genocrowd"
try:
subtitle = current_app.iniconfig.get('genocrowd', 'subtitle')
title = "Genocrowd | {}".format(subtitle)
except Exception:
pass
return render_template('index.html',
title=title,
proxy_path=proxy_path,
redirect="/")
else:
return jsonify({
'error': authentication['error'],
'errorMessage': authentication['error_messages'],
'user': authentication['user']
})
def update_apikey():
"""Update the user apikey
Returns
-------
json
The user with his new apikey
"""
local_auth = LocalAuth(current_app, session)
updated_user = local_auth.update_apikey(session['user'])
session['user'] = updated_user['user']
return jsonify({
'error': updated_user['error'],
'errorMessage': updated_user['error_message'],
'user': updated_user['user']
})
def update_password():
"""Update the user passord
Returns
-------
json
The user
"""
data = request.get_json()
local_auth = LocalAuth(current_app, session)
updated_user = local_auth.update_password(data, session['user'])
return jsonify({
'error': updated_user['error'],
'errorMessage': updated_user['error_message'],
'user': updated_user['user']
})
def set_blocked():
"""Change blocked status of a user
Returns
-------
json
error: True if error, else False
errorMessage: the error message of error, else an empty string
"""
data = request.get_json()
try:
local_auth = LocalAuth(current_app, session)
local_auth.set_blocked(data['newBlocked'], data['username'])
except Exception as e:
traceback.print_exc(file=sys.stdout)
return jsonify({'error': True, 'errorMessage': str(e)}), 500
return jsonify({'error': False, 'errorMessage': ''})
def update_profile():
"""Update user profile (names and email)
Returns
-------
json
The updated user
"""
data = request.get_json()
local_auth = LocalAuth(current_app, session)
updated_user = local_auth.update_profile(data, session['user'])
session['user'] = updated_user['user']
return jsonify({
'error': updated_user['error'],
'errorMessage': updated_user['error_message'],
'user': updated_user['user']
})
def get_users():
"""Get all users
Returns
-------
json
users: list of all users info
error: True if error, else False
errorMessage: the error message of error, else an empty string
"""
try:
local_auth = LocalAuth(current_app, session)
all_users = local_auth.get_all_users()
except Exception as e:
traceback.print_exc(file=sys.stdout)
return jsonify({
'users': [],
'error': True,
'errorMessage': str(e)
}), 500
return jsonify({'users': all_users, 'error': False, 'errorMessage': ''})
def login():
"""Allows a user to log in on Genocrowd
Returns
-------
user info in json format
"""
data = request.get_json()
local_auth = LocalAuth(ca, session)
result = local_auth.authenticate_user(data)
if result["user"] != {}:
if result["user"]['blocked']:
result = {
'error': True,
'errorMessage': ["Your account is blocked"],
'user': {}
}
else:
session['user'] = result['user']
return kill_apollo_session(result)
def log_user(self, username):
"""Summary
Parameters
----------
username : TYPE
Description
"""
auth = LocalAuth(self.app, self.session)
user = auth.users.find_one({'username': username})
with self.client.session_transaction() as sess:
user['_id'] = str(user['_id'])
sess["user"] = user
self.session = sess
def login():
"""Log a user
Returns
-------
json
Information about the logged user
"""
data = request.get_json()
local_auth = LocalAuth(current_app, session)
authentication = local_auth.authenticate_user(data)
user = {}
if not authentication['error']:
session['user'] = authentication['user']
user = authentication['user']
return jsonify({
'error': authentication['error'],
'errorMessage': authentication['error_messages'],
'user': user
})
def get_top_annotation(self):
"""Get top annotator and top group
Returns
-------
dict
list of top 3 users and groups, error and error message
"""
error = False
error_message = []
top_users = []
top_groups = []
nb = self.get_number_of_groups()
liste_temp = [0] * nb
userList = LocalAuth.get_all_users(self)
for element in userList:
"""We don't want Admin in the ranking"""
if element['group'] is not None:
dico = {}
dico["username"] = element['username']
dico["score"] = element['total_annotation']
top_users.append(dico)
"""sums the annotations for each group"""
index = element['group'] - 1
liste_temp[
index] = liste_temp[index] + element['total_annotation']
"""get the group name"""
groups_names = self.get_groups_names()
for i, element in enumerate(liste_temp):
dico = {}
dico["name"] = groups_names['groups_names'][i]
dico["score"] = element
top_groups.append(dico)
top_groups = sorted(top_groups, key=lambda k: k['score'], reverse=True)
top_users = sorted(top_users, key=lambda k: k['score'], reverse=True)
return {
'top_users': top_users[:3],
'top_groups': top_groups[:3],
'error': error,
'errorMessage': error_message
}
def create_user(self, username):
"""Summary
Parameters
----------
username : TYPE
Description
Returns
-------
TYPE
Description
"""
uinfo = {
"username":
"******" if username == "jdoe" else "jsmith",
"password":
self.app.bcrypt.generate_password_hash("iamjohndoe").decode(
'utf-8') if username == "jdoe" else self.app.bcrypt.
generate_password_hash("iamjanesmith").decode('utf-8'),
"email":
"*****@*****.**"
if username == "jdoe" else "*****@*****.**",
"isAdmin":
True if username == "jdoe" else False,
"isExternal":
False,
"created":
datetime.utcnow(),
"blocked":
False,
"grade":
"ADMIN" if username == "jdoe" else "mygrade",
"group":
None,
"role":
'admin' if username == "jdoe" else "user"
}
auth = LocalAuth(self.app, self.session)
auth.users.insert(uinfo)
user = auth.users.find_one({'username': uinfo['username']})
user['_id'] = str(user['_id'])
return user
def signup():
"""Creates a new user for Genocrowd
"""
new_user = {}
local_auth = LocalAuth(ca, session)
data = request.get_json()
local_auth.check_inputs(data)
if not local_auth.get_error():
# FIXME is it safe to pass role? where does it come from?
new_user = local_auth.add_user_to_database(data['username'],
data['email'],
data['password'],
data['grade'], data['role'])
new_user['_id'] = str(new_user['_id'])
session['user'] = new_user
return kill_apollo_session(
jsonify({
'error': local_auth.get_error(),
'errorMessage': local_auth.get_error_message(),
'user': new_user
}))
def start():
"""Starting route
Returns
-------
json
Information about a eventualy logged user, and the Genocrowd version
and a footer message
"""
try:
starter = Start(current_app, session)
starter.start()
# Get commmit hash
sha = None
if current_app.iniconfig.getboolean('genocrowd',
'display_commit_hash'):
try:
repo = git.Repo(search_parent_directories=True)
sha = repo.head.object.hexsha[:10]
except Exception:
pass
# get proxy path
proxy_path = "/"
try:
proxy_path = current_app.iniconfig.get("genocrowd",
"reverse_proxy_path")
except Exception:
pass
config = {
"footerMessage":
current_app.iniconfig.get('genocrowd', 'footer_message'),
"version":
get_distribution('genocrowd').version,
"commit":
sha,
"gitUrl":
current_app.iniconfig.get('genocrowd', 'github'),
"disableIntegration":
current_app.iniconfig.getboolean('genocrowd',
'disable_integration'),
"prefix":
current_app.iniconfig.get('triplestore', 'prefix'),
"namespace":
current_app.iniconfig.get('triplestore', 'namespace'),
"proxyPath":
proxy_path,
"user": {},
"logged":
False
}
json = {"error": False, "errorMessage": '', "config": config}
if 'user' in session:
current_app.logger.debug(session["user"]["username"])
local_auth = LocalAuth(current_app, session)
user = local_auth.get_user(session['user']['username'])
session['user'] = user
json['config']['user'] = user
json['config']['logged'] = True
return jsonify(json)
except Exception as e:
traceback.print_exc(file=sys.stdout)
return jsonify({
"error": True,
"errorMessage": str(e),
"config": {}
}), 500
def set_group():
local_auth = LocalAuth(current_app, session)
data = request.get_json()
result = local_auth.set_group(data)
return result
def create_app(config='config/genocrowd.ini',
app_name='genocrowd',
blueprints=None):
"""Create the Genocrowd app
Parameters
----------
config : str, optional
Path to the config file
app_name : str, optional
Application name
blueprints : None, optional
Flask blueprints
Returns
-------
Flask
Genocrowd Flask application
"""
conf = configparser.ConfigParser()
conf.read(config)
sentry_dsn = None
try:
sentry_dsn = conf['sentry']['server_dsn']
except Exception:
pass
if sentry_dsn:
version = get_distribution('genocrowd').version
name = get_distribution('genocrowd').project_name
sentry_sdk.init(dsn=sentry_dsn,
release="{}@{}".format(name, version),
integrations=[FlaskIntegration(),
CeleryIntegration()])
app = Flask(app_name, static_folder='static', template_folder='templates')
app.iniconfig = FlaskIni()
with app.app_context():
app.iniconfig.read(config)
proxy_path = None
try:
proxy_path = app.iniconfig.get('genocrowd', 'reverse_proxy_path')
app.config['REVERSE_PROXY_PATH'] = proxy_path
except Exception:
pass
mongo_dbname = app.iniconfig.get('flask', 'mongo_dbname')
app.config['MONGO_DBNAME'] = mongo_dbname
mongo_uri = app.iniconfig.get('flask', 'mongo_uri')
app.config['MONGO_URI'] = mongo_uri
if not mongo_uri:
raise Exception("Missing mongo_uri in config file")
if not mongo_dbname:
raise Exception("Missing mongo_dbname in config file")
app.mongo = PyMongo(app)
app.bcrypt = Bcrypt(app)
users = app.mongo.db.users
app.mongo.db.genes
app.mongo.db.answers
groups = app.mongo.db.groups
app.genocrowd_admin_email = app.iniconfig.get('genocrowd',
'genocrowd_admin_email')
app.genocrowd_admin_password = app.iniconfig.get(
'genocrowd', 'genocrowd_admin_password')
app.apollo_admin_email = app.iniconfig.get('genocrowd',
'apollo_admin_email')
app.apollo_admin_password = app.iniconfig.get('genocrowd',
'apollo_admin_password')
app.apollo_dataset_path = app.iniconfig.get('genocrowd',
'apollo_dataset_path')
app.apollo_org_id = app.iniconfig.get('genocrowd', 'apollo_org_id')
app.apollo_url = app.iniconfig.get('genocrowd', 'apollo_url')
# We don't want ending slash
if app.apollo_url.endswith("/"):
app.apollo_url = app.apollo_url[:-1]
app.apollo_url_ext = app.iniconfig.get('genocrowd', 'apollo_url_ext')
# We don't want ending slash
if app.apollo_url_ext.endswith("/"):
app.apollo_url_ext = app.apollo_url_ext[:-1]
configure_logging(app)
if users.find_one() is None:
# Create default admin user
local_auth = LocalAuth(app, None)
local_auth.add_user_to_database('admin', app.genocrowd_admin_email,
app.genocrowd_admin_password,
'admin', 'admin')
if blueprints is None:
blueprints = BLUEPRINTS
for blueprint in blueprints:
app.register_blueprint(blueprint)
if groups.find_one() is None:
# Initiate the groups database
data = Data(app, None)
data.initiate_groups()
if proxy_path:
ReverseProxyPrefixFix(app)
return app
