def account_update_password():
"""
This route will be used to update user password
"""
err = True
pwd_old = request.form['password_old']
pwd_clear = request.form['password1']
pwd_clear2 = request.form['password2']
# verification des champs
content = {}
# if pwd_old != ancien mdp
if db.check_user_password(session['user']['id'], _hash_pwd(pwd_old)):
content['password_old'] = "Le mot de passe est incorrect !"
if len(pwd_clear) < 6:
content['password1'] = "Le mot de passe doit faire au minimum 6 caractères !"
if pwd_clear2 != pwd_clear:
content['password2'] = "Les deux mots de passe doivent être identiques !"
# hash password
pwd_hash = _hash_pwd(pwd_clear)
# realisation si pas d'erreur
if len(content.keys()) == 0:
content = "La mise à jour du profil a échouée"
# verification de l'existence de l'utilisateur
if db.update_user(session['user']['id'], pwd=pwd_hash):
# _update_user(session, session['user']['id'])
# mise à jour des variables de réponse
err = False
content = 'ok'
return json_response(Response(err, content).json(), status_code=200)
def location_create():
"""
This route is used to add a new location for a user
"""
# recupération des données du post
uid = session['user']['id']
osm_id = escape(request.form['osm_id'].strip())
osm_type = escape(request.form['osm_type'].strip())
# construction du bloc de metadonnées
metadata = {}
metadata['reason'] = escape(request.form['reason'].strip())
# vérification des champs
content = {}
err = True
if not validator.validate(osm_id, 'int'):
content['osm_id'] = "Le champ osm_id doit être un identifiant numérique !"
if validator.is_empty(osm_type):
content['osm_type'] = "Le champ osm_type ne doit pas être vide !"
if metadata['reason'] not in ['no', 'internship', 'exchange', 'dd', 'job']:
content['meta']['reason'] = "La valeur de la métadonnée raison est invalide."
if len(content.keys()) == 0:
# create user - location mapping record in db
content = "L'ajout de la localisation a échoué. La localisation n'a pas été confirmée par Nominatim."
if db.create_user_location(uid, osm_id, osm_type, metadata):
err = False
content = "La nouvelle localisation a été enregistrée."
return json_response(Response(err, content).json(), status_code=200)
def battery():
result = {"battery_perc": -1, "remaining_seconds": -1, "temperature_c": -1, "adapter_on": None}
p = sarge.run("acpi --everything", stdout=sarge.Capture())
output = p.stdout.text
first_line = output.splitlines()[0].strip()
print(first_line)
batt_perc_raw = re.findall("(\d\d\d?)%", first_line)
print(batt_perc_raw)
result["battery_perc"] = int(batt_perc_raw[0])
try:
batt_remain_time = re.findall("(\d\d):(\d\d):(\d\d)", first_line)
result["remaining_seconds"] = (lambda x: x[0]*3600+x[1]*60+x[2])(list(map(int, batt_remain_time[0])))
except IndexError:
result["remaining_seconds"] = -1
temperature_raw = re.findall("Thermal .+(\d\d\.\d) degrees C", output)
print("temp", temperature_raw)
result["temperature_c"] = float(temperature_raw[0])
adapter_on_raw = re.findall("Adapter \d: (on-line|off-line)", output)[0]
print(adapter_on_raw)
result["adapter_on"] = (adapter_on_raw == "on-line") and True or False
return json_response(result, status_code=200)
def search_users():
"""
This route can be used to search users based on given filters
"""
filters = request.form['filters']
content = db.get_users(filters)
return json_response(Response(False, content).json(), status_code=200)
def togle():
GPIO.setmode(GPIO.BOARD) ## Use board pin numbering
GPIO.setup(7, GPIO.OUT) ## Setup GPIO Pin 7 to OUT
state = not GPIO.input(7)
GPIO.output(7,state) ## Turn on GPIO pin 7
return json_response({“status”: state}, status_code=201)
def account_delete():
"""
This route is used to delete completly a user account and all its data
"""
uid = session['user']['id']
db.delete_user(uid)
session.pop('user', None)
err = False
content = "Le compte a été supprimé avec succès."
return json_response(Response(err, content).json(), status_code=200)
def api_10_equipos():
from app import session
# session = contest.loadSession()
active_contest = contest.get_info_active_contest(session)
user_table = contest.get_user_for_contest(session, active_contest.contestnumber)
response = list()
for user in user_table:
response.append({'usernumber':user.usernumber,
'username': user.username,
'userfullname': user.userfullname})
return json_response({"data": response}, status_code=200)
def ajaxwall(query=None):
q = query
l = Loklak()
tweets = l.search(q)
for tweet in tweets['statuses']:
try:
imageUrl = tweet['user']['profile_image_url_https']
newUrl = imageUrl.split('_bigger')
updatedUrl = newUrl[0]+newUrl[1]
tweet['user']['profile_image_url_https'] = updatedUrl
except:
pass
return json_response(tweets)
def login():
"""
This route is used to authenticate a user in the application
"""
content = "L'utilisateur et/ou le mot de passe est érroné."
email = request.form['email']
pwd_clear = request.form['password']
pwd_hash = _hash_pwd(pwd_clear)
_load_user(session, email, pwd_hash)
err = True
if _check_connected(session):
err = False
content = "Vous êtes maintenant connecté !"
return json_response(Response(err, content).json(), status_code=200)
def locations():
"""
This route is used to retrieve all locations for a given user
"""
err = True
code = 200
uid = request.form['uid']
content = "Une erreur s'est produite, l'identifiant de l'utilisateur passé en paramètre n'est pas valide."
if not validator.validate(uid, 'int'):
uid = int(uid)
locations = db.get_user_locations(uid)
content = "Une erreur s'est produite, aucune localisation n'a été trouvée pour cet utilisateur."
if locations:
err = False
content = locations
return json_response(Response(err, content).json(), status_code=code)
def api_10_problemas():
from app import session
# session = contest.loadSession()
active_contest = contest.get_info_active_contest(session)
problems = contest.get_all_problems(session, active_contest.contestnumber)
response = list()
for p in problems:
response.append({'number':p.problemnumber,
'shortname': p.problemname,
'fullname': p.problemfullname,
'basefilename': p.problembasefilename,
'color': p.problemcolor,
'colorname': p.problemcolorname})
return json_response({"data": response}, status_code=200)
def account_create():
"""
This route is used by the application to add a new user to the application
"""
content = "Captcha invalide. Annulation de l'inscription ! Encore un bot..."
err = True
if validator.check_captcha(request):
# recuperation du contenu de la requete
firstname = escape(request.form['firstname'].strip())
lastname = escape(request.form['lastname'].strip())
email = request.form['email'].strip()
pwd_clear = request.form['password1']
pwd_clear2 = request.form['password2']
promo = request.form['promo'].strip()
# verification des champs
content = {}
if validator.is_empty(firstname):
content['firstname'] = "Le champ prénom ne doit pas être vide !"
if validator.is_empty(lastname):
content['lastname'] = "Le champ nom ne doit pas être vide !"
if not validator.validate(email, 'email'):
content['email'] = "L'email ne respecte pas le format attendu !"
if not validator.validate(promo, 'year'):
content['promo'] = "La promo n'est pas une année correctement formaté !"
if int(promo) < 1969 or int(promo) >= (datetime.datetime.now().year+4):
content['promo'] = "L'année est en dehors de l'intervalle autorisé !"
if len(pwd_clear) < 6:
content['password1'] = "Le mot de passe doit faire au minimum 6 caractères !"
if pwd_clear2 != pwd_clear:
content['password2'] = "Les deux mots de passe doivent être identiques !"
# hash password
pwd_hash = _hash_pwd(pwd_clear)
# realisation si pas d'erreur
if len(content.keys()) == 0:
content = "Cette adresse email est déjà attribuée à un utilisateur."
# verification de l'existence de l'utilisateur
if not db.user_exists(email):
# creation de l'utilisateur
db.create_user(firstname, lastname, email, pwd_hash, promo)
# chargement de l'utilisateur créé dans la session (connexion automatique après inscription)
_load_user(session, email, pwd_hash)
# mise à jour des variables de réponse
err = False
content = 'ok'
return json_response(Response(err, content).json(), status_code=200)
def account_update_promo():
"""
This route will be used to update user promotion
"""
err = True
promo = request.form['promo'].strip()
# verification des champs
content = {}
if not validator.validate(promo, 'year'):
content['promo'] = "La promo n'est pas une année correctement formaté !"
# realisation si pas d'erreur
if len(content.keys()) == 0:
content = "La mise à jour du profil a échouée"
# verification de l'existence de l'utilisateur
if db.update_user(session['user']['id'], promo=promo):
_update_user(session, session['user']['id'])
# mise à jour des variables de réponse
err = False
content = 'ok'
return json_response(Response(err, content).json(), status_code=200)
def location_update():
"""
This route can be used to update a user location
"""
# recupération des données du post
uid = session['user']['id']
osm_id = escape(request.form['osm_id'].strip())
timestamp = escape(request.form['timestamp'].strip())
# vérification des champs
content = {}
err = True
if not validator.validate(osm_id, 'int'):
content['osm_id'] = "L'osm_id transmis ne respecte pas le format attendu: nombre entier."
if not validator.validate(timestamp, 'timestamp'):
content['timestamp'] = "Le timestamp ne respecte pas le format attendu: YYYY-mm-dd"
if len(content.keys()) == 0:
# update timestamp
content = "La mise à jour de la localisation est un échec. Une erreur de persistence s'est produite."
if db.update_user_location(uid, osm_id, timestamp):
err = False
content = "La localisation a été mise à jour."
return json_response(Response(err, content).json(), status_code=200)
def location_delete():
"""
This route can be used to delete a user location
"""
# recupération des données du post
uid = session['user']['id']
osm_id = escape(request.form['osm_id'].strip())
timestamp = escape(request.form['timestamp'].strip())
# vérification des champs
content = {}
err = True
if not validator.validate(osm_id, 'int'):
content['osm_id'] = "L'osm_id transmis ne respecte pas le format attendu: nombre entier."
if not validator.validate(timestamp, 'timestamp'):
content['timestamp'] = "Le timestamp ne respecte pas le format attendu: YYYY-mm-dd"
if len(content.keys()) == 0:
# delete location
content = "La suppression de la localisation n'a pas aboutie !"
if db.delete_user_location(uid, osm_id, timestamp):
err = False
content = "La localisation a été supprimée de votre historique."
return json_response(Response(err, content).json(), status_code=200)
def account_update_names():
"""
This route will be used to update user profile firstname and lastname
"""
err = True
firstname = escape(request.form['firstname'].strip())
lastname = escape(request.form['lastname'].strip())
# verification des champs
content = {}
if validator.is_empty(firstname):
content['firstname'] = "Le champ prénom ne doit pas être vide !"
if validator.is_empty(lastname):
content['lastname'] = "Le champ nom ne doit pas être vide !"
# realisation si pas d'erreur
if len(content.keys()) == 0:
content = "La mise à jour du profil a échouée"
# verification de l'existence de l'utilisateur
if db.update_user(session['user']['id'], firstname=firstname, lastname=lastname):
_update_user(session, session['user']['id'])
# mise à jour des variables de réponse
err = False
content = 'ok'
return json_response(Response(err, content).json(), status_code=200)
def api_10_envios():
last_run = request.args.get('last_run') or 0
from app import session
# session = contest.loadSession()
active_contest = contest.get_info_active_contest(session)
score_site = contest.get_runs_all(session, active_contest.contestnumber, last_run)
response = list()
for r in score_site:
response.append({'usernumber':r.RunTable.usernumber,
'problemname': r.ProblemTable.problemname,
'runproblem': r.RunTable.runproblem,
'problemcolor': r.ProblemTable.problemcolor,
'problemcolorname': r.ProblemTable.problemcolorname,
'problemnumber': r.ProblemTable.problemnumber,
'rundatediff': r.RunTable.rundatediff,
'rundatediffans': r.RunTable.rundatediffans,
'yes': r.AnswerTable.yes,
'runanswer': r.RunTable.runanswer,
'runstatus': r.RunTable.runstatus,
'runnumber': r.RunTable.runnumber})
return json_response({"data": response}, status_code=200)
def account_update_email():
"""
This route will be used to update user email
"""
err = True
email = request.form['email'].strip()
# verification des champs
content = {}
if not validator.validate(email, 'email'):
content['email'] = "L'email ne respecte pas le format attendu !"
# realisation si pas d'erreur
if len(content.keys()) == 0:
content['email'] = "Cette adresse email est déjà attribuée à un utilisateur."
# verification de l'existence de l'utilisateur
if not db.user_exists(email):
content = "La mise à jour du profil a échouée"
# verification de l'existence de l'utilisateur
if db.update_user(session['user']['id'], email=email):
_update_user(session, session['user']['id'])
# mise à jour des variables de réponse
err = False
content = 'ok'
return json_response(Response(err, content).json(), status_code=200)
def home():
'''Document the API so that other services could consume automatically.'''
about = ConfigToDictionary('info.cfg').dict()
return json_response(about)
def space():
result = {"space": (100-psutil.disk_usage("/").percent)}
return json_response(result, status_code=200)
def api_10_remaining_time():
from app import session
# session = contest.loadSession()
response = contest.get_site_clock(session)
return json_response({"data": response}, status_code=200)
def api_10_contest_activo_info():
from app import session
# session = contest.loadSession()
response = contest.get_info_active_contest(session)
return json_response({"data": contest.object_as_dict(response)}, status_code=200)
def show_country_info(country):
data, response = get_country_information(country)
if response.status_code == 200:
return json_response(data[0], status_code=200)
else:
return jsonify(status=404, message="Not Found")
def wrapped_f(*args, **kwargs):
if session.get('user', None):
return json_response(Response(True, "Opération interdite vous n'êtes pas déconnecté !").json(), status_code=403)
else:
return f(*args, **kwargs)
def info(): return json_response(about)
def json_test():
return json_response({'name': 'Alex', 'message': 'hi!'}, status_code=201)
