Projet IoT I4 Secura

from flask import Flask, session, jsonify, render_template, redirect, url_for, request, flash
from flask_socketio import SocketIO, emit
import logging
import requests
from functools import wraps
from appwrite.client import Client
from appwrite.services.account import Account
from appwrite.services.users import Users
from appwrite.services.databases import Databases
from appwrite.id import ID
from appwrite.exception import AppwriteException
from appwrite.query import Query
from functools import wraps
import os
from dotenv import load_dotenv
from appwrite.services.databases import Databases
import json
import threading
import lora
import time
import base64
import binascii
import random
from datetime import datetime
from time import strftime

load_dotenv()

app = Flask(__name__)
socketio = SocketIO(app, cors_allowed_origins="*")
app.secret_key = os.getenv("FLASK_SECRET_KEY")

# Configuration de Appwrite
client = Client()
client.set_endpoint(os.getenv("APPWRITE_ENDPOINT"))
client.set_project(os.getenv("APPWRITE_PROJECT_ID"))
client.set_key(os.getenv("APPWRITE_API_KEY"))

databases = Databases(client)
USERS_COLLECTION_ID = os.getenv("USERS_COLLECTION_ID")
ADMINS_COLLECTION_ID = os.getenv("ADMINS_COLLECTION_ID")
DATABASE_ID = os.getenv("DATABASE_ID")

code_secret = os.getenv("CODE_SECRET")
code_secret = int(code_secret)

app_id = os.getenv("TTN_APP_ID").lower()
dev_id = os.getenv("TTN_DEV_ID")
api_key = os.getenv("TTN_API_KEY")
url = f"https://eu1.cloud.thethings.network/api/v3/as/applications/{app_id}/devices/{dev_id}/down/replace"

logging.basicConfig(level=logging.INFO)

uid_badge = None
generated_code = None

def promote_to_admin(user_id, user_email, user_password, isAdmin):
    try:
        databases.create_document(
            database_id=os.getenv("DATABASE_ID"),
            admins_collection_id=os.getenv("ADMINS_COLLECTION_ID"),
            document_id=ID.unique(),
            data={
                'userID': user_id,
                'email': user_email,
                'password': user_password,
                'isAdmin': isAdmin
            }
        )
        print(f"Utilisateur {user_email} promu admin")
    except AppwriteException as e:
        print(f"Erreur: {e.message}")


def add_user(user_email, user_password, badgeUID, nom, prenom):
    try:
        databases.create_document(
            database_id=os.getenv("DATABASE_ID"),
            collection_id=os.getenv("USERS_COLLECTION_USER_ID"),
            document_id=ID.unique(),
            data={
                'nom': nom,
                'prenom': prenom,
                'email': user_email,
                'password': user_password,
                'Badge_UID': badgeUID
            }
        )
        print(f"Utilisateur {user_email} ajout")
    except AppwriteException as e:
        print(f"Erreur: {e.message}")
    
    
def login_required(f):
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not session.get('admin_logged_in'):
            return redirect(url_for('login', next=request.url))
        return f(*args, **kwargs)
    return decorated_function

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        email = request.form['email']
        password = request.form['password']

        try:
            admins = databases.list_documents(
                DATABASE_ID,
                ADMINS_COLLECTION_ID,
                queries=[Query.equal('email', email)]
            )

            if admins['total'] == 0:
                flash('Identifiants invalides', 'error')
                return redirect(url_for('login'))

            admin = admins['documents'][0]

            if admin['password'] != password:
                flash('Identifiants invalides', 'error')
                return redirect(url_for('login'))
            
            if admin['isAdmin'] == False:
                flash('Identifiants invalides', 'error')
                return redirect(url_for('login'))
            
            
            session['admin_logged_in'] = True
            session['admin_email'] = email
            
            return redirect(url_for('menu'))

        except AppwriteException as e:
            flash(f"Erreur systme: {e.message}", 'error')
            return redirect(url_for('login'))

    return render_template('login.html')

@app.route('/menu', methods=['GET', 'POST'])
@login_required
def menu():
    if request.method == 'POST':
        if 'add' in request.form:
            return redirect(url_for('add'))
        elif 'act' in request.form:
            return redirect(url_for('uid'))
        elif 'dash' in request.form:
            return redirect(url_for('dashboard'))
    return render_template('menu.html', admin_email=session.get('admin_email'))
    
    

@app.route('/add', methods=['GET', 'POST'])
@login_required
def add():
    if request.method == 'POST':
        nom = request.form['nom']
        prenom = request.form['prenom']
        email = request.form['email']
        password = request.form['password']
        confirm_password = request.form['confirm-password']
        BadgeUID = request.form['BadgeUID']

        if password != confirm_password:
            flash('Les mots de passe ne correspondent pas', 'error')
            return render_template('add.html')

        try:
            email_query = Query.equal('email', email)
            badge_query = Query.equal('Badge_UID', BadgeUID)

            email_response = databases.list_documents(
                database_id=os.getenv("DATABASE_ID"),
                collection_id=os.getenv("USERS_COLLECTION_USER_ID"),
                queries=[email_query]
            )
            if email_response['documents']:
                flash('Un utilisateur avec cet email existe dj', 'error')
                return render_template('add.html')

            badge_response = databases.list_documents(
                database_id=os.getenv("DATABASE_ID"),
                collection_id=os.getenv("USERS_COLLECTION_USER_ID"),
                queries=[badge_query]
            )
            if badge_response['documents']:
                flash('Un utilisateur avec ce badge UID existe dj', 'error')
                return render_template('add.html')

        except AppwriteException as e:
            print(f"Erreur lors de la vrification de l'utilisateur: {e.message}")
            flash('Erreur lors de la vrification de l\'utilisateur', 'error')
            return render_template('add.html')

        add_user(email, password, BadgeUID, nom, prenom)

        flash("Ajout russi", 'success')
        return redirect(url_for('menu'))

    return render_template('add.html')
        
        
@app.route('/uid')
@login_required
def uid():
    return render_template('uid.html', uid = uid_badge)


@app.route('/dashboard')
@login_required
def dashboard():
    return render_template('dashboard.html', uid = uid_badge)

@app.route('/logout', methods=['GET', 'POST'])
def logout():
    session.pop('admin_logged_in', None)
    session.pop('admin_email', None)
    return redirect(url_for('login'))

badges_list = []

@app.route('/ttn-webhook', methods=['GET', 'POST'])
def ttn_webhook():
    global badges_list, uid_badge
    try:
        data = request.get_json()
        if not data:
            return jsonify({"error": "Aucune donne reue"}), 400

        frm_payload = data.get("uplink_message", {}).get("frm_payload")
        if not frm_payload:
            return jsonify({"error": "frm_payload manquant"}), 400

        missing_padding = len(frm_payload) % 4
        if missing_padding:
            frm_payload += '=' * (4 - missing_padding)

        decoded_bytes = base64.b64decode(frm_payload)
        hex_payload = decoded_bytes.hex()
        uid_badge = hex_payload[2:10].upper()

        current_datetime = datetime.now()
        formatted_date = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
        date = str(formatted_date)   

        try:
            user_response = databases.list_documents(
                DATABASE_ID,
                USERS_COLLECTION_ID,
                queries=[Query.equal('Badge_UID', uid_badge)]
            )
            if user_response['total'] > 0:
                user = user_response['documents'][0]
                badge_data = {
                    'uid': uid_badge,
                    'email': user.get('email', 'N/A'),
                    'nom': user.get('nom', 'N/A'),
                    'prenom': user.get('prenom', 'N/A'),
                    'porte': user.get('porte', '1'),
                    'date': date
                }
                badges_list.append(badge_data)

                socketio.emit('new_badge', badge_data)
                sendCode()

        except AppwriteException as e:
            print(f"Erreur Appwrite: {e.message}")

        return jsonify({"status": "success"}), 200

    except Exception as e:
        import traceback
        traceback.print_exc()
        return jsonify({"error": str(e)}), 500

@app.route('/get_badges', methods=['GET'])
def get_badges():
    return jsonify(badges_list)
    
def code():
    random_number = random.randint(10000000, 99999999)
    operate = random_number % code_secret
    operate = str(operate)
    liste = list(operate)
    random.shuffle(liste)
    code = liste[:6]
    chaine = ''.join(map(str, code))
    code = int(chaine)
    print("Code gnr :", code)
    code = str(code)
    return code

def sendCode():
    global generated_code
    if generated_code is None:  # Gnrer un code uniquement s'il n'existe pas encore
        generated_code = code()

    print(f"Envoi du code {generated_code}")
    socketio.emit("code", {"number": generated_code})
    print("Code envoy  l'application mobile")

    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }

    code_bytes = generated_code.encode('utf-8')
    encoded_payload = base64.b64encode(code_bytes).decode('utf-8')

    data = {
        "downlinks": [{
            "f_port": 1,
            "frm_payload": encoded_payload,
            "priority": "NORMAL",
            "confirmed": False
        }],
        "end_device_ids": { 
            "device_id": dev_id,
            "application_ids": {
                "application_id": app_id
            }
        }
    }

    print("Donnes envoyes  TTN :", data)

    response = requests.post(url, headers=headers, json=data)

    if response.status_code == 200:
        print("Code envoy  TTN avec succs")
    else:
        print("Erreur lors de l'envoi du code  TTN")
        print("Code de statut :", response.status_code)
        print("Rponse :", response.text)
    
    generated_code = None  # Rinitialiser le code aprs l'envoi


if __name__ == '__main__':
    socketio.run(app, debug=True, host='0.0.0.0', port=5000)