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)