KazV2/dockers/apikaz/source/app.py

import os
import re
import requests
import subprocess
import logging
import tempfile
import ldap
import imaplib
import random
import string
import json

from flask import Flask, jsonify, send_from_directory, request, abort, json, Response, render_template
from flask_mail import Mail, Message
from flasgger import Swagger
from flask_restful import Api, Resource
from flask_jwt_extended import JWTManager, create_access_token, jwt_required

from passlib.hash import sha512_crypt
from unidecode import unidecode
from email_validator import validate_email, EmailNotValidError
from time import sleep
from glob import glob
from bs4 import BeautifulSoup
from datetime import datetime

app = Flask(__name__)
jwt = JWTManager(app)
api = Api(app)

app.logger.setLevel(logging.DEBUG)

swagger = Swagger(app, template={
    "swagger": "2.0",
    "info": {
        "title": "L'API Kaz de la mort qui tue",
        "version": "0.2.0",
        "description": "Permettre des opérations de gestion des services kaz avec des écrans Ouaib"
    },
    "tags": [
        {"name": "Authentication", "description": "Auth related operations"},
        {"name": "Test", "description": "pour tester des conneries"},
        {"name": "Password", "description": "Gestion Mdp"},
        {"name": "Paheko", "description": "Gestion Paheko"},
        {"name": "Mattermost", "description": "Gestion Mattermost Authent"},
        {"name": "Mattermost User", "description": "Gestion Mattermost User"},
        {"name": "Mattermost Team", "description": "Gestion Mattermost Team"},
        {"name": "Ldap", "description": "Gestion Ldap"},
        {"name": "Cloud", "description": "Gestion Cloud Général"},
        {"name": "Sympa", "description": "Gestion Sympa"},
        {"name": "Quota", "description": "Gestion Quota"},
        {"name": "Dns", "description": "Gestion Dns"},
        {"name": "Kaz User", "description": "Gestion Kaz User"}        
    ],
    "securityDefinitions": {
          "basicAuth": {
              "type": "basic",
              "description": "Basic Authentication with username and password"
          },
          "Bearer": {
              "type": "apiKey",
              "name": "Authorization",
              "in": "header",
              "description": "JWT Authorization header using the Bearer scheme. Example: 'Bearer {token}'"
          }
      }      
})
        
#TODO:
# check variables
# fail2ban (ou alors sur traefik)
# découper app.py en service
# quels scripts bash garder ?

#*************************************************

# Configuration du logger
# logging.basicConfig(level=logging.INFO)
# logger = logging.getLogger(__name__)  # Création de l'objet logger

#*************************************************
#Filtrer les IP qui peuvent accéder à l'api
#TODO: au lieu d'avoir les IP en dur, prendre le fichier allow_ip'

trusted_ips = [
"82.64.20.246",          
"31.39.14.228",
"51.75.112.172",
"80.11.47.59",
"90.121.138.71",
"109.190.2.75",
"89.234.177.115",
"80.215.140.40",
"80.67.176.91",
"89.234.177.119",
"78.127.1.19",
"80.215.236.243"
]
   
   
#*************************************************
#variables globales
#*************************************************

#le secret pour générer les tokens
#app.config['JWT_SECRET_KEY'] = os.environ.get('JWT_SECRET_KEY')
app.config['JWT_SECRET_KEY'] = os.environ.get('JWT_SECRET_KEY', 'your_jwt_secret_key')

#le paheko de kaz
paheko_ident=os.environ.get('paheko_API_USER')
paheko_pass=os.environ.get('paheko_API_PASSWORD')
paheko_url=os.environ.get('paheko_url')

mattermost_user=os.environ.get('mattermost_user')
mattermost_pass=os.environ.get('mattermost_pass')
mattermost_url=os.environ.get('mattermost_url')

ldap_admin=os.environ.get('ldap_LDAP_ADMIN_USERNAME')
ldap_pass=os.environ.get('ldap_LDAP_ADMIN_PASSWORD')
ldap_root=os.environ.get('ldap_root')
ldap_host="ldapServ.ldapNet"

#cloud général
cloud_ident=os.environ.get('nextcloud_NEXTCLOUD_ADMIN_USER')
cloud_pass=os.environ.get('nextcloud_NEXTCLOUD_ADMIN_PASSWORD')
cloud_url=os.environ.get('cloud_url')

gandi_key=os.environ.get('gandi_GANDI_KEY')
gandi_url_api=os.environ.get('gandi_GANDI_API')

site_url=os.environ.get('site_url')

#pour webmail_url et mdp_url, ça renvoie des tuples et non des str, bizarre, du coup, je mets en dur
#webmail_url=os.environ.get('webmail_url'),
#mdp_url=os.environ.get('mdp_url'),
webmail_url='https://webmail.kaz.bzh',
mdp_url='https://mdp.kazkouil.fr',

#pour le mail
app.config['MAIL_SERVER']= os.environ.get('apikaz_MAIL_SERVER')
app.config['MAIL_PORT'] = 587
app.config['MAIL_USERNAME'] = os.environ.get('apikaz_MAIL_USERNAME')
app.config['MAIL_PASSWORD'] = os.environ.get('apikaz_MAIL_PASSWORD')
app.config['MAIL_REPLY_TO'] = os.environ.get('apikaz_MAIL_REPLY_TO')
app.config['MAIL_USE_TLS'] = True
app.config['MAIL_USE_SSL'] = False
mail = Mail(app)

#sympa
sympa_ident=os.environ.get('sympa_SOAP_USER')
sympa_pass=os.environ.get('sympa_SOAP_PASSWORD')
sympa_url=os.environ.get('sympa_url')
sympa_liste_info=os.environ.get('sympa_liste_info')
MAIL_USERNAME=app.config['MAIL_USERNAME']

#pour QUOTA (à virer ensuite)
serveur_imap = os.environ.get('serveur_imap')
mot_de_passe_mail=os.environ.get('mot_de_passe_mail')

#*************************************************
@app.before_request
def limit_remote_addr():    
    if request.environ['HTTP_X_FORWARDED_FOR'] not in trusted_ips:
        abort(jsonify(message="Et pis quoi encore ?"), 400)

#*************************************************
#authent mdp/pass basique
def check_auth(username, password):
    return username == os.environ.get('apikaz_doc_user') and password == os.environ.get('apikaz_doc_password')

def authenticate():
    return Response('tssssss.\n', 401, {'WWW-Authenticate': 'Basic realm="Login Required"'})

@app.before_request
def require_basic_auth():
    if request.path.startswith('/apidocs') or request.path.startswith('/print_env'):
    #if request.path.startswith('/'):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            return  authenticate()


#*************************************************
#DANGER: ne jamais mettre print_env en PROD
@app.route('/print_env')
def print_environment():
    # Crée une chaîne de caractères pour stocker les variables d'environnement
    env_string = ""
    
    # Itère sur les variables d'environnement et les ajoute à la chaîne de caractères
    for key, value in os.environ.items():
        env_string += f"{key}: {value}\n" + "<br>"
    
    # Retourne la chaîne de caractères contenant les variables d'environnement
    return env_string

#*************************************************
#***** DEBUT Quelques fonctions utiles ***********
#*************************************************

#pour injecter la date dans dans le contexte des template
@app.context_processor
def inject_now():
    return {'now': datetime.now}
  
#*************************************************
#***** FIN Quelques fonctions utiles ***********
#*************************************************


#*************************************************

@app.route('/favicon.ico')
def favicon():
    # return send_from_directory(os.path.join(app.root_path, 'static'),'favicon.ico')
    return '', 204

    
#*************************************************
#la page d'accueil est vide
@app.route('/')
def silence():
  return ""


#*************************************************
# obtenir un token
@app.route('/get_token', methods=['GET'])
def get_token():
    """
    Get JWT token with basic auth
    ---
    tags:
      - Authentication
    security:
      - basicAuth: []      
    responses:
      200:
        description: Token generated successfully
        schema:
          type: object
          properties:
            access_token:
              type: string
              description: JWT access token
      401:
        description: Unauthorized
    """
    auth = request.authorization
    if auth and check_auth(auth.username, auth.password):
        # Créez un token JWT après une authentification réussie
        access_token = create_access_token(identity=auth.username)
        return jsonify(access_token=access_token)
    else:
        return authenticate()
    
#*************************************************
#*******MDP***************************************
#*************************************************
class Password_create(Resource):
    @jwt_required()
    def get(self):
        """
        créer un password qui colle avec les appli kaz
        ---
        tags:
          - Password
        security:
          - Bearer: []
        parameters: []
        responses:
          200:
            description: le password
          404:
            description: oops 
        """    
        global new_password

        cmd="apg -n 1 -m 10 -M NCL -d"
        try:
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)        
            new_password="_"+output.decode("utf-8")+"_"
            return new_password,200          
        
        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400 

api.add_resource(Password_create, '/password/create')

#*************************************************
#*******PAHEKO************************************
#*************************************************

class Paheko_categories(Resource):
  
    @jwt_required()
    def get(self):
        """
        Récupérer les catégories Paheko avec le compteur associé
        ---
        tags:
          - Paheko
        security:
          - Bearer: []
        parameters: []
        responses:
          200:
            description: Liste des catégories Paheko
          404:
            description: oops 
        """    
        global paheko_ident, paheko_pass, paheko_url

        auth = (paheko_ident, paheko_pass)
        api_url = paheko_url + '/api/user/categories'
        
        response = requests.get(api_url, auth=auth)

        if response.status_code == 200:
            data = response.json()
            return jsonify(data)
        else:
            return jsonify({'error': 'La requête a échoué'}), response.status_code
    
api.add_resource(Paheko_categories, '/paheko/user/categories')
 
#*************************************************

class Paheko_users(Resource):
  
    @jwt_required()
    def get(self,categorie):
        """
        Afficher les membres d'une catégorie Paheko
        ---
        tags:
          - Paheko
        security:
          - Bearer: []        
        parameters:
          - in: path
            name: categorie
            type: string
            required: true
        responses:
            200:
                description: Liste des membres une catégorie Paheko
            404:
                description: oops
        """    
    
        global paheko_ident, paheko_pass, paheko_url

        auth = (paheko_ident, paheko_pass)
        if not categorie.isdigit():
            return 'Id de category non valide', 400
        
        api_url = paheko_url + '/api/user/category/'+categorie+'.json'
        
        response = requests.get(api_url, auth=auth)

        if response.status_code == 200:
            data = response.json()
            return jsonify(data)
        else:
            return jsonify({'error': 'La requête a échoué'}), response.status_code
    
api.add_resource(Paheko_users, '/paheko/user/category/<categorie>')

#*************************************************

class Paheko_user(Resource):
  
    def __init__(self):
        global paheko_ident, paheko_pass, paheko_url
        self.paheko_ident = paheko_ident
        self.paheko_pass = paheko_pass
        self.paheko_url = paheko_url
        self.auth = (self.paheko_ident, self.paheko_pass)
        
    @jwt_required()
    def get(self,ident):
        """
        Afficher un membre de Paheko par son email kaz ou son numéro ou le non court de l'orga
        ---
        tags:
          - Paheko        
        security:
          - Bearer: []                
        parameters: 
          - in: path
            name: ident
            type: string
            required: true        
            description: possible d'entrer un numéro, un email, le nom court de l'orga
        responses:
            200:
                description: Existe et affiche
            404:
                description: N'existe pas
        """    
        
        emailmatchregexp = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")

        if emailmatchregexp.match(ident):
          data = { "sql": f"select * from users where email='{ident}' or alias = '{ident}'" }
          api_url = self.paheko_url + '/api/sql/'
          response = requests.post(api_url, auth=self.auth,  data=data)
          #TODO: if faut Rechercher count et vérifier que = 1 et supprimer le count=1 dans la réponse
        elif  ident.isdigit():
          api_url = self.paheko_url + '/api/user/'+ident
          response = requests.get(api_url, auth=self.auth)                  
        else:
          nomorga = re.sub(r'\W+', '', ident) # on vire les caractères non alphanumérique
          data = { "sql": f"select * from users where admin_orga=1 and nom_orga='{nomorga}'" }
          api_url = self.paheko_url + '/api/sql/'
          response = requests.post(api_url, auth=self.auth,  data=data)
          #TODO:if faut Rechercher count et vérifier que = 1  et supprimer le count=1 dans la réponse
          
        if response.status_code == 200:
            data = response.json()
            if data["count"] == 1:
                 return jsonify(data["results"][0])
            elif data["count"] == 0:
                 return "pas de résultat", 400
            else: 
                 return "Plusieurs utilisateurs correspondent ?!", 400
        else:
            #return jsonify({'error': 'La requête a échoué'}), response.status_code
            return "pas de résultat", response.status_code
    
#*************************************************

    @jwt_required()
    def put(self,ident,field,new_value):
        """
        Modifie la valeur d'un champ d'un membre paheko (ident= numéro paheko ou email kaz)
        ---
        tags:
          - Paheko        
        security:
          - Bearer: []        
        parameters: 
          - in: path
            name: ident
            type: string
            required: true        
            description: possible d'entrer le numéro paheko, un email kaz 
          - in: path
            name: field
            type: string
            required: true        
            description: un champ de la table users de la base paheko
          - in: path
            name: new_value
            type: string
            required: true        
            description: la nouvelle valeur à remplacer
        
        responses:
            200:
                description: Modification effectuée avec succès
            400:
                description: Oops, ident non trouvé ou incohérent
            404:
                description: Oops, modification du champ KO
        """    
        
        #récupérer le numero paheko si on fournit un email kaz
        emailmatchregexp = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$")
        if emailmatchregexp.match(ident):         
          data = { "sql": f"select id from users where email='{ident}'" }
          api_url = self.paheko_url + '/api/sql/'
          response = requests.post(api_url, auth=self.auth, data=data)
          if response.status_code == 200:
              #on extrait l'id de la réponse              
              data = response.json()
              if data['count'] == 0:
                return "email non trouvé", 400
              elif data['count'] > 1:
                return "trop de résultat", 400
              else:
                #OK 
                ident = data['results'][0]['id']
          else:
              return "pas de résultat", response.status_code          
        elif not ident.isdigit():
           return "Identifiant utilisateur invalide", response.status_code
        
        regexp = re.compile("[^a-zA-Z0-9 \\r\\n\\t" + re.escape(string.punctuation) + "]")
        valeur = regexp.sub('',new_value) # mouais, il faudrait être beaucoup plus précis ici en fonction des champs qu'on accepte...

        champ = re.sub(r'\W+','',field) # pas de caractères non alphanumériques ici, dans l'idéal, c'est à choisir dans une liste plutot
 
        api_url = self.paheko_url + '/api/user/'+str(ident)        
        payload = {champ: valeur}
        response = requests.post(api_url, auth=self.auth, data=payload)
        return response.json(),response.status_code
            
#*************************************************

api.add_resource(Paheko_user, '/paheko/user/<ident>', endpoint='paheko_get_user', methods=['GET'])
api.add_resource(Paheko_user, '/paheko/user/<ident>/<string:field>/<string:new_value>', endpoint='paheko_maj_user', methods=['PUT'])

#*************************************************

class Paheko_users_action(Resource):
  
    def __init__(self):
        global paheko_ident, paheko_pass, paheko_url
        self.paheko_ident = paheko_ident
        self.paheko_pass = paheko_pass
        self.paheko_url = paheko_url
        
    @jwt_required()
    def get(self, action):
        """
        retourne tous les membres de paheko avec une action à mener (création du compte kaz / modification...)
        ---
        tags:
          - Paheko 
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: action
            type: string
            required: true
            enum: ['A créer','A modifier','En attente','Aucune']
        responses:
            200:
                description: liste des nouveaux kaznautes à créer
            404:
                description: aucun nouveau kaznaute à créer
        """    
        auth = (self.paheko_ident, self.paheko_pass)

        api_url = self.paheko_url + '/api/sql/'
        payload = { "sql": f"select * from users where action_auto='{action}'" }        
        response = requests.post(api_url, auth=auth,  data=payload)
          
        if response.status_code == 200:
            return response.json(),200
        else:
            return "pas de résultat", response.status_code
        
api.add_resource(Paheko_users_action, '/paheko/users/<string:action>')        

#*************************************************
#*******MATTERMOST********************************
#*************************************************

# on utilise mmctl et pas l'apiv4 de MM
# pourquoi ? passe que mmctl déjà utilisé dans les scripts kaz. 

#*************************************************

def Mattermost_authenticate():
     # Authentification sur MM
     global mattermost_url, mattermost_user, mattermost_pass
     cmd = f"/mm/mmctl auth login {mattermost_url} --name local-server --username {mattermost_user} --password {mattermost_pass}"
     subprocess.run(cmd, shell=True, stderr=subprocess.STDOUT, check=True)

#*************************************************

class Mattermost_message(Resource):

    @jwt_required()
    def post(self,message,equipe="kaz",canal="creation-comptes"):
        """
        Envoyer un message dans une Equipe/Canal de MM
        ---
        tags:
          - Mattermost        
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: equipe
            type: string
            required: true
          - in: path
            name: canal
            type: string
            required: true
          - in: path
            name: message
            type: string
            required: true
        
        responses:
            200:
                description: Affiche un message dans un canal d'une équipe
            500:
                description: oops
        """    
        Mattermost_authenticate()
    
        try:
            cmd="/mm/mmctl post create "+equipe+":"+canal+" --message "+ "\"" + message + "\""
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
            return "Message envoyé", 200
        except subprocess.CalledProcessError:
            return "Message non envoyé", 500

api.add_resource(Mattermost_message, '/mattermost/message/<equipe>/<canal>/<message>')

#*************************************************

class Mattermost_user(Resource):
  
    def __init__(self):
      Mattermost_authenticate()
  
#*************************************************  
    @jwt_required()
    def get(self,user):
        """
        Le user existe t-il sur MM ? 
        ---
        tags:
          - Mattermost User
        security:
          - Bearer: []                
        parameters: 
          - in: path
            name: user
            type: string
            required: true        
            description: possible d'entrer un username, un email
        responses:
            200:
                description: Existe
            404:
                description: N'existe pas
        """    
            
        try:
            cmd = f"/mm/mmctl user search {user} --json"
            user_list_output = subprocess.check_output(cmd, shell=True)
            return 200  # Le nom d'utilisateur existe
        except subprocess.CalledProcessError:
            return 404  # Le nom d'utilisateur n'existe pas

#*************************************************
    @jwt_required()
    def post(self,user,email,password):
        """
        Créer un utilisateur sur MM
        ---
        tags:
          - Mattermost User
        security:
          - Bearer: []                
        parameters: 
          - in: path
            name: user
            type: string
            required: true        
          - in: path
            name: email
            type: string
            required: true        
          - in: path
            name: password
            type: string
            required: true        
        responses:
            200:
                description: Utilisateur créé
            400:
                description: oops, Utilisateur non créé
        """        
        
       # Création de l'utilisateur
        try:
            cmd = f"/mm/mmctl user create --email {email} --username {user} --password {password}"
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
            return output.decode("utf-8"), 200

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400

#*************************************************

    @jwt_required()
    def delete(self,email):
        """
        Supprimer un utilisateur sur MM
        ---
        tags:
          - Mattermost User
        security:
          - Bearer: []                
        parameters: 
          - in: path
            name: email
            type: string
            required: true        
        responses:
            200:
                description: Utilisateur supprimé
            400:
                description: oops, Utilisateur non supprimé
        """        
        
        try:
            cmd = f"/mm/mmctl user delete {email} --confirm"
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
            return output.decode("utf-8"), 200

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400

#*************************************************

    @jwt_required()
    def put(self,email,new_password):
        """
        Changer un password pour un utilisateur de MM
        ---
        tags:
          - Mattermost User
        security:
          - Bearer: []                
        parameters: 
          - in: path
            name: email
            type: string
            required: true        
          - in: path
            name: new_password
            type: string
            required: true        
        responses:
            200:
                description: Mot de passe de l'Utilisateur changé
            400:
                description: oops, Mot de passe de l'Utilisateur inchangé
        """        
        try:
            cmd = f"/mm/mmctl user change-password {email} --password {new_password}"
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
            return output.decode("utf-8"), 200 

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400

#*************************************************
        
api.add_resource(Mattermost_user, '/mattermost/user/<string:user>', endpoint='mattermost_get_user', methods=['GET'])
api.add_resource(Mattermost_user, '/mattermost/user/create/<string:user>/<string:email>/<string:password>', endpoint='mattermost_create_user', methods=['POST'])
api.add_resource(Mattermost_user, '/mattermost/user/delete/<string:email>', endpoint='mattermost_delete_user', methods=['DELETE'])
api.add_resource(Mattermost_user, '/mattermost/user/change/password/<string:email>/<string:new_password>', endpoint='mattermost_change_user_password', methods=['PUT'])

#*************************************************

class Mattermost_user_team(Resource):
  
    @jwt_required()
    def post(self,email,equipe):
        """
        Affecte un utilisateur à une équipe MM
        ---
        tags:
          - Mattermost Team       
        security:
          - Bearer: []        
        parameters: 
          - in: path
            name: email
            type: string
            required: true        
          - in: path
            name: equipe
            type: string
            required: true        
        responses:
            200:
                description: l'utilisateur a bien été affecté à l'équipe
            400:
                description: oops, Utilisateur non affecté
        """
        Mattermost_authenticate()
        
        try:
            cmd = f"/mm/mmctl team users add {equipe} {email}"
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
            return output.decode("utf-8"), 200 

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400 

api.add_resource(Mattermost_user_team, '/mattermost/user/team/<string:email>/<string:equipe>')

#*************************************************

class Mattermost_user_channel(Resource):
    @jwt_required()
    def post(self,email,equipe,canal):
        """
        Affecte un utilisateur à un canal MM
        ---
        tags:
          - Mattermost        
        security:
          - Bearer: []                
        parameters: 
          - in: path
            name: email
            type: string
            required: true        
          - in: path
            name: equipe
            type: string
            required: true                
          - in: path
            name: canal
            type: string
            required: true        
        responses:
            200:
                description: l'utilisateur a bien été affecté au canal
            400:
                description: oops, Utilisateur non affecté
        """
        Mattermost_authenticate()
        
        try:
            cmd = f'/mm/mmctl channel users add {equipe}:{canal} {email}'
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
            return output.decode("utf-8"), 200

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400

api.add_resource(Mattermost_user_channel, '/mattermost/user/channel/<string:email>/<string:equipe>/<string:canal>')

#*************************************************

class Mattermost_team(Resource):
  
    def __init__(self):
      Mattermost_authenticate()
      
#*************************************************  

    @jwt_required()
    def get(self):
        """
        Lister les équipes sur MM 
        ---
        tags:
          - Mattermost Team   
        security:
          - Bearer: []                
        parameters: []
        responses:
            200:
                description: liste des équipes
            400:
                description: oops, Equipe non supprimée
        """        
        Mattermost_authenticate()
        
        try:
            cmd = f"/mm/mmctl team list --disable-pager"
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)                                    
            data_list = output.decode("utf-8").strip().split('\n')            
            data_list.pop()
            return data_list, 200
            #return jsonify(data_list),200

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400

#*************************************************  
    @jwt_required()
    def post(self,equipe,email):
        """
        Créer une équipe sur MM et affecter un admin si email est renseigné (set admin marche pô)
        ---
        tags:
          - Mattermost Team        
        security:
          - Bearer: []                
        parameters: 
          - in: path
            name: equipe
            type: string
            required: true        
          - in: path
            name: email
            type: string
            required: true
            description: admin de l'équipe
        responses:
            200:
                description: Equipe créée
            400:
                description: oops, Equipe non créée
        """                
        
        try:
            #DANGER: l'option --email ne rend pas le user admin de l'équipe comme c'est indiqué dans la doc :(
            cmd = f"/mm/mmctl team create --name {equipe} --display-name {equipe} --private --email {email}"
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
            
            #Workaround: on récup l'id du user et de l'équipe pour affecter le rôle "scheme_admin": true, "scheme_user": true avec l'api MM classique.
            #TODO:
            
            return output.decode("utf-8"), 200

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400
          
#*************************************************
    @jwt_required()
    def delete(self,equipe):
        """
        Supprimer une équipe sur MM 
        ---
        tags:
          - Mattermost Team        
        security:
          - Bearer: []        
        parameters: 
          - in: path
            name: equipe
            type: string
            required: true        
        responses:
            200:
                description: Equipe supprimée
            400:
                description: oops, Equipe non supprimée
        """        
        Mattermost_authenticate()
        
        try:
            cmd = f"/mm/mmctl team delete {equipe} --confirm"
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)                        
            return output.decode("utf-8"), 200

        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400
          
#*************************************************
api.add_resource(Mattermost_team, '/mattermost/team/list',endpoint='mattermost_team_list', methods=['GET'])
api.add_resource(Mattermost_team, '/mattermost/team/create/<equipe>/<email>',endpoint='mattermost_team_create', methods=['POST'])
api.add_resource(Mattermost_team, '/mattermost/team/delete/<equipe>',endpoint='mattermost_team_delete', methods=['DELETE'])

#*************************************************
#***** LDAP **************************************
#*************************************************

class Ldap_user(Resource):
  
    def __init__(self):
        global ldap_admin, ldap_pass, ldap_root, ldap_host
        self.ldap_admin = ldap_admin
        self.ldap_pass = ldap_pass
        self.ldap_root = ldap_root
        self.ldap_host = f"ldap://{ldap_host}"

    def _connect_ldap(self):
        ldap_connection = ldap.initialize(self.ldap_host)
        ldap_connection.simple_bind_s("cn={},{}".format(self.ldap_admin, self.ldap_root), self.ldap_pass)
        return ldap_connection
    
    @classmethod
    def is_valid_field(cls, field):
        allowed_fields = ['mailDeSecours', 'mailEnabled', 'nextcloudEnabled', 'mobilizonEnabled', 'agoraEnabled', 'userPassword', 'identifiantKaz', 'mailAlias', 'quota']
        return field in allowed_fields

    @jwt_required()
    def get(self, email):
        """
        Vérifier si un utilisateur avec cet email existe dans le LDAP soit comme mail principal soit comme alias
        ---
        tags:
          - Ldap        
        security:
          - Bearer: []        
        parameters:
          - in: path
            name: email
            type: string
            required: true                
        responses:
            200:
                description: Existe
            400:
                description: N'existe pas
            401:
                description: oops, email invalide
            402:
                description: oops, autre erreur
        
        """               
        try:
          
            if not validate_email(email):
                return "Adresse e-mail non valide", 400
              
            ldap_connection = self._connect_ldap()

            #result = ldap_connection.search_s("ou=users,{}".format(self.ldap_root), ldap.SCOPE_SUBTREE, "(cn={})".format(email))
            
            # Créer une chaîne de filtre pour rechercher dans les champs "cn" et "mailAlias"
            filter_str = "(|(cn={})(mailAlias={}))".format(email, email)
            result = ldap_connection.search_s("ou=users,{}".format(self.ldap_root), ldap.SCOPE_SUBTREE, filter_str)
  
            ldap_connection.unbind_s()

            if result:
                return True, 200
            else:
                return False, 400
              
        except EmailNotValidError as e:
            return str(e), 401

        except ldap.LDAPError as e:
            return str(e), 402


#*************************************************
    @jwt_required()
    def delete(self, email):
        """
        Supprimer un utilisateur du LDAP par son adresse e-mail
        ---
        tags:
          - Ldap        
        security:
          - Bearer: []        
        parameters:
          - in: path
            name: email
            type: string
            required: true                
        responses:
            200:
                description: Utilisateur supprimé avec succès
            404:
                description: Utilisateur non trouvé dans le LDAP
            400:
                description: Erreur lors de la suppression de l'utilisateur
        """
        try:
            if not validate_email(email):
                return "Adresse e-mail non valide", 400
            
            ldap_connection = self._connect_ldap()

            # Recherche de l'utilisateur
            result = ldap_connection.search_s("ou=users,{}".format(self.ldap_root), ldap.SCOPE_SUBTREE, "(cn={})".format(email))
            
            if not result:
                return False, 404  # Utilisateur non trouvé

            # Récupération du DN de l'utilisateur
            dn = result[0][0]
            
            # Suppression de l'utilisateur
            ldap_connection.delete_s(dn)
            ldap_connection.unbind_s()

            return True, 200  # Utilisateur supprimé avec succès
              
        except ldap.NO_SUCH_OBJECT:
            return False, 404  # Utilisateur non trouvé
        except ldap.LDAPError as e:
            return str(e), 400  # Erreur lors de la suppression
        except EmailNotValidError as e:
            return str(e), 400


#*************************************************
    @jwt_required()
    def post(self, email):
        """
        Ajouter, supprimer ou modifier un champ pour l'utilisateur LDAP
        ---
        tags:
          - Ldap   
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: email
            type: string
            required: true
          - in: query
            name: action
            type: string
            required: true
            enum: ['add', 'delete', 'modify']
          - in: body
            name: data
            required: true
            schema:
              type: object
              properties:
                field:
                  type: string
                  enum: ['mailDeSecours', 'mailEnabled', 'nextcloudEnabled', 'mobilizonEnabled', 'agoraEnabled', 'userPassword', 'identifiantKaz', 'mailAlias', 'quota']
                  description: Le champ à ajouter, supprimer ou modifier (par exemple, mailDeSecours, mailAlias, etc.)
                value:
                  type: string        
                  description: La valeur à ajouter, supprimer ou modifier pour le champ spécifié
        responses:
            200:
                description: Opération réussie
            404:
                description: Utilisateur non trouvé dans le LDAP
            400:
                description: Erreur lors de l'opération
        """
        
        try:
            if not validate_email(email):
                return "Adresse e-mail non valide", 400
            
            action = request.args.get('action')
            field = request.json.get('field')
            value = request.json.get('value')
            
            if not action or not field or not value:
                return "Action, champ ou valeur manquant", 400
            
            if not self.is_valid_field(field):
                return "Champ non autorisé", 400
          
            ldap_connection = self._connect_ldap()
            result = ldap_connection.search_s("ou=users,{}".format(self.ldap_root), ldap.SCOPE_SUBTREE, "(cn={})".format(email))
            
            if not result:
                return False, 404
            
            dn = result[0][0]

            if field == 'userPassword' and (action == 'add' or action == 'modify'):
                  password_chiffre = sha512_crypt.hash(value)
                  value = "{{CRYPT}}{}".format(password_chiffre)
                  
            if action == 'add':
                mod_attrs = [(ldap.MOD_ADD, field, value.encode('utf-8'))]
                
            elif action == 'delete':
                mod_attrs = [(ldap.MOD_DELETE, field, value.encode('utf-8'))]
                
            elif action == 'modify':

              if field == 'quota':
                  mail_quota_value = value + 'G'
                  nextcloud_quota_value = value + " GB"
                  mod_attrs = [
                      (ldap.MOD_REPLACE, 'quota', value.encode('utf-8')),                    
                      (ldap.MOD_REPLACE, 'mailQuota', mail_quota_value.encode('utf-8')),
                      (ldap.MOD_REPLACE, 'nextcloudQuota', nextcloud_quota_value.encode('utf-8'))
                  ]
              else:
                  mod_attrs = [(ldap.MOD_REPLACE, field, value.encode('utf-8'))]
                              
            else:
                return "Action non valide", 400
            
            ldap_connection.modify_s(dn, mod_attrs)
            ldap_connection.unbind_s()

            return True, 200
              
        except ldap.NO_SUCH_OBJECT:
            return False, 404
        except ldap.LDAPError as e:
            return str(e), 400
        except EmailNotValidError as e:
            return str(e), 400

#*************************************************
    @jwt_required()
    def put(self, email, **kwargs):
        """
        Créer une nouvelle entrée dans le LDAP pour un nouvel utilisateur. QUESTION: A QUOI SERVENT PRENOM/NOM/IDENT_KAZ DANS LE LDAP ? POURQUOI 3 QUOTA ?
        ---
        tags:
          - Ldap    
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: email
            type: string
            required: true
          - in: body
            name: data
            required: true
            schema:
              type: object
              properties:
                prenom:
                  type: string
                  description: Prénom de l'utilisateur
                nom:
                  type: string
                  description: Nom de l'utilisateur
                password:
                  type: string
                  description: Mot de passe de l'utilisateur
                email_secours:
                  type: string
                  description: Adresse e-mail de secours
                quota:
                  type: string
                  description: Quota de l'utilisateur
        responses:
            200:
                description: Utilisateur ajouté avec succès
            400:
                description: Erreur lors de l'ajout de l'utilisateur
            406:
                description: Erreur utilisateur déjà existant
        
        """
        try:
                     
            if kwargs: # appel depuis une autre api
              email_secours = kwargs.get('email_secours')
              prenom = kwargs.get('prenom')
              nom = kwargs.get('nom')
              password = kwargs.get('password')
              quota = kwargs.get('quota')
              
            else: # appel depuis swagger 
              email_secours = request.json.get('email_secours')
              nom = request.json.get('nom')
              prenom = request.json.get('prenom')
              password = request.json.get('password')
              quota = request.json.get('quota')

            password_chiffre = sha512_crypt.hash(password)

            if not validate_email(email) or not validate_email(email_secours):
                return "Adresse e-mail ou secours non valide", 400
            
            #le user existe t-il déjà ?
            ldap_connection = self._connect_ldap()
            result = ldap_connection.search_s("ou=users,{}".format(self.ldap_root), ldap.SCOPE_SUBTREE, "(cn={})".format(email))
            
            if result:
                return "User déjà existant", 406

            # Construire le DN
            dn = f"cn={email},ou=users,{ldap_root}"
            
            mod_attrs = [
              ('objectClass', [b'inetOrgPerson', b'PostfixBookMailAccount', b'nextcloudAccount', b'kaznaute']),
              ('sn', f'{prenom} {nom}'.encode('utf-8')),
              ('mail', email.encode('utf-8')),
              ('mailEnabled', b'TRUE'),
              ('mailGidNumber', b'5000'),
              ('mailHomeDirectory', f"/var/mail/{email.split('@')[1]}/{email.split('@')[0]}/".encode('utf-8')),
              ('mailQuota', f'{quota}G'.encode('utf-8')),
              ('mailStorageDirectory', f"maildir:/var/mail/{email.split('@')[1]}/{email.split('@')[0]}/".encode('utf-8')),
              ('mailUidNumber', b'5000'),
              ('mailDeSecours', email_secours.encode('utf-8')),
              ('identifiantKaz', f'{prenom.lower()}.{nom.lower()}'.encode('utf-8')),
              ('quota', str(quota).encode('utf-8')),
              ('nextcloudEnabled', b'TRUE'),
              ('nextcloudQuota', f'{quota} GB'.encode('utf-8')),
              ('mobilizonEnabled', b'TRUE'),
              ('agoraEnabled', b'TRUE'),
              ('userPassword', f'{{CRYPT}}{password_chiffre}'.encode('utf-8')),
              ('cn', email.encode('utf-8'))            
            ]
            
            ldap_connection.add_s(dn, mod_attrs)
            ldap_connection.unbind_s()
            
            return "Utilisateur créé dand le ldap", 200
          
        except ldap.LDAPError as e:
            return str(e), 400
        except EmailNotValidError as e:
            return str(e), 400

#*************************************************
          
# Définition des routes avec les méthodes correspondantes
api.add_resource(Ldap_user, '/ldap/user/<string:email>', endpoint='ldap_user_get', methods=['GET'])
api.add_resource(Ldap_user, '/ldap/user/delete/<string:email>', endpoint='ldap_user_delete', methods=['DELETE'])
api.add_resource(Ldap_user, '/ldap/user/change/<string:email>', endpoint='ldap_user_change', methods=['POST'])
api.add_resource(Ldap_user, '/ldap/user/add/<string:email>', endpoint='ldap_user_add', methods=['PUT'])


#*************************************************
#***** CLOUD **************************************
#*************************************************
#TODO: pas réussi à faire une seule classe Cloud_user avec 2 méthodes get/delete

class Cloud_user(Resource):
  
    @jwt_required()
    def get(self, email):
        """
        Existe dans le cloud général ?
        ---
        tags:
          - Cloud
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: email
            type: string
            required: true
        responses:
            200:
                description: Succès
            404:
                description: L'utilisateur n'existe pas
            500:
                description: Erreur interne du serveur
        """    

        global cloud_ident, cloud_pass, cloud_url

        try:
            auth = (cloud_ident, cloud_pass)
            api_url = f"{cloud_url}/ocs/v1.php/cloud/users?search={email}"
            headers = {"OCS-APIRequest": "true"}
            response = requests.get(api_url, auth=auth, headers=headers)

            if response.status_code == 200:
              if re.search(r'<element>.*</element>', response.text):
                return 200
              else:
                return 404

        except Exception as e:
            return jsonify({'error': str(e)}), 500
          
api.add_resource(Cloud_user, '/cloud/user/<string:email>')
    
#*************************************************
class Cloud_user_delete(Resource):
  
    @jwt_required()
    def delete(self, email):
        """
        Supprime le compte dans le cloud général
        QUESTION: A PRIORI INUTILE CAR LIE AU LDAP
        ---
        tags:
          - Cloud
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: email
            type: string
            required: true
        responses:
            200:
                description: Succès, l'utilisateur a été supprimé du cloud général
            404:
                description: Oops, l'utilisateur n'a pas été supprimé du cloud général
            500:
                description: Erreur interne du serveur
        """    

        global cloud_ident, cloud_pass, cloud_url

        try:
            auth = (cloud_ident, cloud_pass)
            api_url = f"{cloud_url}/ocs/v1.php/cloud/users?search={email}"
            headers = {"OCS-APIRequest": "true"}
            response = requests.delete(api_url, auth=auth, headers=headers)

            if response.status_code == 200:
              if re.search(r'<element>.*</element>', response.text):
                return 200
              else:
                return 404

        except Exception as e:
            return jsonify({'error': str(e)}), 500
          
api.add_resource(Cloud_user_delete, '/cloud/user/delete/<string:email>')

#*************************************************
# class Cloud_user_change(Resource):
#     @jwt_required()
#     def put(self, email, new_password):
#         """
#         Modifie le mot de passe d'un Utilisateur dans le cloud général: QUESTION: A PRIORI INUTILE CAR LIE AU LDAP
#         ---
#         tags:
#           - Cloud
#        security:
#          - Bearer: []        
#         parameters:
#           - in: path
#             name: email
#             type: string
#             required: true
#           - in: path
#             name: new_password
#             type: string
#             required: true
#         responses:
#             200:
#                 description: Succès, mot de passe changé
#             404:
#                 description: Oops, mot de passe NON changé
#             500:
#                 description: Erreur interne du serveur
#         """    
# 
#         global cloud_ident, cloud_pass, cloud_url
# 
#         try:
#             auth = (cloud_ident, cloud_pass)
#             api_url = f"{cloud_url}/ocs/v1.php/cloud/users?search={email}"
#             headers = {"OCS-APIRequest": "true"}
#             data = {
#               "key": "password",
#               "value": new_password
#             }
#             response = requests.put(api_url, auth=auth, headers=headers)
# 
#             if response.status_code == 200:
#               if re.search(r'<element>.*</element>', response.text):
#                 return 200
#               else:
#                 return 404
# 
#         except Exception as e:
#             return jsonify({'error': str(e)}), 500
#           
# api.add_resource(Cloud_user_change, '/cloud/user/change/<string:email>/<string:new_password>')

#*************************************************
#***** SYMPA **************************************
#*************************************************

class Sympa_user(Resource):
    def __init__(self):
        global sympa_ident, sympa_pass, sympa_url,MAIL_USERNAME
        self.sympa_ident = sympa_ident
        self.sympa_pass = sympa_pass
        self.sympa_url = sympa_url

    def _execute_sympa_command(self, email, liste, service):
        try:
            if validate_email(email) and validate_email(liste):
                cmd = f'export PERL5LIB=/usr/src/app/:$PERL5LIB && /usr/src/app/Sympa/sympa_soap_client.pl --soap_url={self.sympa_url}/sympasoap --trusted_application={self.sympa_ident} --trusted_application_password={self.sympa_pass} --proxy_vars=USER_EMAIL={MAIL_USERNAME} --service={service} --service_parameters="{liste},{email}" && echo $?'
                output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)
                return output.decode("utf-8"), 200  # Retourne la sortie et un code de succès
        except EmailNotValidError as e:
            return str(e), 400  # Retourne le message d'erreur et un code d'erreur 400
        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400  # Retourne la sortie de la commande et un code d'erreur 400

    @jwt_required()
    def post(self, email, liste):
        """
        Ajouter un email dans une liste sympa
        ---
        tags:
          - Sympa
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: email
            type: string
            required: true
          - in: path
            name: liste
            type: string
            required: true
        responses:
            200:
                description: Succès, email ajouté dans la liste
            400:
                description: Oops, email non ajouté dans la liste
        """
        output, status_code = self._execute_sympa_command(email, liste, 'add')
        return output, status_code

    @jwt_required()
    def delete(self, email, liste):
        """
        Supprimer un email dans une liste sympa
        ---
        tags:
          - Sympa
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: email
            type: string
            required: true
          - in: path
            name: liste
            type: string
            required: true
        responses:
            200:
                description: Succès, email supprimé dans la liste
            400:
                description: Oops, email non supprimé dans la liste
        """
        output, status_code = self._execute_sympa_command(email, liste, 'del')
        return output, status_code

api.add_resource(Sympa_user, '/sympa/user/<string:email>/<string:liste>')   

#*************************************************
#***** QUOTA **************************************
#*************************************************

class Quota(Resource):
  
#https://doc.dovecot.org/configuration_manual/authentication/master_users/

#https://blog.debugo.fr/serveur-messagerie-dovecot/
# sur kazkouil.fr, j'ai modifié /etc/dovecot/conf.d/20-lmtp.conf
#mail_plugins = $mail_plugins sieve quota

    @jwt_required()
    def get(self, email):
        """
        Récupérer la place prise par une BAL (EN COURS)
        ---
        tags:
          - Quota
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: email
            type: string
            required: true
        responses:
            200:
                description: Succès, taille d'une BAL'
            400:
                description: Oops, échec dans l'affichage de la taille d'une BAL
        """
        global serveur_imap, mot_de_passe_mail
                
        try:
            if validate_email(email):
                # Connexion au serveur IMAP
                mail = imaplib.IMAP4_SSL(serveur_imap)
                mail.login(email, mot_de_passe_mail)
                
                #res, data = mail.select("INBOX")
                #return data[0].decode("utf-8"), 200

                # Requête pour obtenir le quota de la boîte aux lettres
                # res, data = mail.getquota("INBOX")
                # return str(data[0]).split()
                
                res, data = mail.getquotaroot("INBOX")
                return str(data[1]).split()[3]+" KB"
              
                # Fermeture de la connexion
                mail.close()
                mail.logout()
                                          
            else:
                return "Email non valide", 400

        except imaplib.IMAP4.error as e:
            return str(e), 400  # Retourne le message d'erreur et un code d'erreur 400
        except EmailNotValidError as e:
            return str(e), 400  # Retourne le message d'erreur et un code d'erreur 400
                
api.add_resource(Quota, '/quota/<string:email>')


#*************************************************
#***** DNS **************************************
#*************************************************

class Dns_serveurs(Resource):

    def __init__(self):
        global gandi_key, gandi_url_api
        self.gandi_key = gandi_key
        self.gandi_url_api = gandi_url_api

    @jwt_required()
    def get(self):
        """
        Renvoie tous les serveurs kaz de la zone dns
        ---
        tags:
          - Dns
        security:
          - Bearer: []                
        responses:
            200:
                description: Succès, liste des serveurs
            404:
                description: Oops, soucis...
        """  
        url = f"{self.gandi_url_api}/records/srv/TXT"
        headers = { "Authorization": f"Apikey {self.gandi_key}" }
        response = requests.get(url, headers=headers)           
        
        if response.status_code != 200:
          return response.json(),response.status_code

        # Extraire la liste des serveurs de la réponse JSON
        rrset_values = response.json()["rrset_values"]
        # Nettoyer la liste
        serveurs = [serveur.strip('"') for serveur in rrset_values[0].split(";")]
        return serveurs, 200
                              
api.add_resource(Dns_serveurs, '/dns/')

#*************************************************

class Dns(Resource):

    def __init__(self):
        global gandi_key, gandi_url_api
        self.gandi_key = gandi_key
        self.gandi_url_api = gandi_url_api
        self.dns_serveurs_resource = Dns_serveurs()

#*************************************************
    @jwt_required()
    def get(self,sdomaine):
        """
        Le sous-domaine existe t-il dans la zone dns avec un enreg CNAME ?
        ---
        tags:
          - Dns
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: sdomaine
            type: string
            required: true
        responses:
            200:
                description: Succès, sdomaine existe déjà avec un CNAME
            404:
                description: Oops, sdomaine non trouvé
        """        
        url = f"{self.gandi_url_api}/records/{sdomaine}/CNAME"
        headers = { "Authorization": f"Apikey {self.gandi_key}" }
        response = requests.get(url, headers=headers)           
        return response.json(),response.status_code


#*************************************************

    @jwt_required() 
    def delete(self,sdomaine):
        """
        suppression du sdomaine 
        ---
        tags:
          - Dns
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: sdomaine
            type: string
            required: true
        responses:
            204:
                description: Succès, sdomaine supprimé
            404:
                description: Oops,
        """       
        url = f"{self.gandi_url_api}/records/{sdomaine}"
        headers = { "Authorization": f"Apikey {self.gandi_key}" }
        response = requests.delete(url, headers=headers)
        return response.text,response.status_code
                                
#*************************************************

    @jwt_required()
    def post(self,sdomaine,serveur):
        """
        Créé le sous-domaine de type CNAME qui pointe sur serveur
        ---
        tags:
          - Dns
        security:
          - Bearer: []                
        parameters:
          - in: path
            name: sdomaine
            type: string
            required: true
          - in: path
            name: serveur
            type: string
            required: true
            description: Le serveur doit être l'un des serveurs disponibles dans la zone DNS
        responses:
            201:
                description: Succès, sdomaine créé comme CNAME
            400:
                description: Oops, serveur inconnu, sdomaine non créé
            404:
                description: Oops, sdomaine non créé
            200,409:
                description: Oops, sdomaine déjà créé
        """

        
        # Récupérer la liste des serveurs disponibles
        serveurs_disponibles, status_code = self.dns_serveurs_resource.get()
      
        if status_code != 200:
            return serveurs_disponibles, status_code
        
        if serveur not in serveurs_disponibles:
            return f"Erreur: Le serveur {serveur} n'est pas disponible", 400
                  
        url = f"{self.gandi_url_api}/records/{sdomaine}/CNAME"
        headers = { "Authorization": f"Apikey {self.gandi_key}" }
        payload = f'{{"rrset_values":["{serveur}"]}}'
        
        response = requests.post(url, data=payload, headers=headers)
        return response.json(),response.status_code
                                
#*************************************************

api.add_resource(Dns, '/dns/<string:sdomaine>', endpoint='dns_get', methods=['GET'])
api.add_resource(Dns, '/dns/<string:sdomaine>', endpoint='dns_delete', methods=['DELETE'])
api.add_resource(Dns, '/dns/<string:sdomaine>/<string:serveur>', endpoint='dns_post', methods=['POST'])

#*************************************************

#*************************************************
#***** KAZ **************************************
#*************************************************

class Kaz_user(Resource):

    def __init__(self):
        global sympa_liste_info
        
        self.paheko_users_action_resource = Paheko_users_action()
        self.paheko_user_resource=Paheko_user()
        self.ldap_user_resource = Ldap_user()
        self.password_create_resource = Password_create()        
        self.mattermost_message_resource=Mattermost_message()
        self.mattermost_user_resource=Mattermost_user()
        self.mattermost_user_team_resource=Mattermost_user_team()
        self.mattermost_user_channel_resource=Mattermost_user_channel()
        self.mattermost_team_resource=Mattermost_team()                
        self.sympa_user_resource=Sympa_user()
        

#********************************************************************************************
    @jwt_required()
    def delete(self):
        """
        Utile pour les tests de createUser. Avant le POST de /kaz/create/users. Ça permet de supprimer/maj les comptes.
        ---
        tags:
          - Kaz User
        security:
          - Bearer: []                
        parameters: []
        responses:
            201:
                description: Succès        
            401: 
                description: Oops, un soucis quelconque
        """      
        #verrou pour empêcher de lancer en même temps la même api          
        try:
          prefixe="del_user_lock_"
          if glob(f"{tempfile.gettempdir()}/{prefixe}*"): raise ValueError("ERREUR 0 : api déjà en cours d'utilisation !")
          lock_file = tempfile.NamedTemporaryFile(prefix=prefixe,delete=True)
        
          #TODO à remplir à la main
          liste_emails=["",""]
          email_secours=""
          liste_sympa=""
          
          for email in liste_emails:
            res, status_code = self.ldap_user_resource.delete(email)
            res, status_code = self.mattermost_user_resource.delete(email)
            nom_orga=''.join(random.choice(string.ascii_lowercase) for _ in range(8))                        
            res, status_code = self.paheko_user_resource.put(email,"nom_orga",nom_orga)
            res, status_code = self.paheko_user_resource.put(email,"action_auto","A créer")
            res, status_code = self.paheko_user_resource.put(email,"email_secours",email_secours)
            res, status_code = self.sympa_user_resource.delete(email,liste_sympa)
            res, status_code = self.sympa_user_resource.delete(email_secours,liste_sympa)
            msg=f"**POST AUTO** suppression de {email} ok"
            self.mattermost_message_resource.post(message=msg)          
          return "OK", 200

        except ValueError as e:
          msg=f"(classe: {__class__.__name__} : {e}"
          self.mattermost_message_resource.post(message=msg)
          return str(msg), 401
        
#********************************************************************************************

    @jwt_required()
    def post(self):
        """
        Créé un nouveau kaznaute: inscription sur MM / Cloud / email + msg sur MM + email à partir de action="a créer" sur paheko
        ---
        tags:
          - Kaz User
        security:
          - Bearer: []                
        parameters: []
        responses:
            201:
                description: Succès, kaznaute créé        
            400: 
                description: Oops, rien à créer
            401: 
                description: Oops, un soucis quelconque
        """
        
        try:

          #verrou pour empêcher de lancer en même temps la même api          
          prefixe="create_user_lock_"
          if glob(f"{tempfile.gettempdir()}/{prefixe}*"): raise ValueError("ERREUR 0 : api déjà en cours d'utilisation !")
          lock_file = tempfile.NamedTemporaryFile(prefix=prefixe,delete=True)
         
          #qui sont les kaznautes à créer ?   
          liste_kaznautes, status_code = self.paheko_users_action_resource.get("A créer")
          
          if liste_kaznautes=="pas de résultat": return "ERREUR: paheko non joignable",401
          
          count=liste_kaznautes['count']
          if count==0: return "aucun nouveau kaznaute à créer",400
          
          #au moins un kaznaute à créer
          for tab in liste_kaznautes['results']:          
            email = tab['email'].lower() 
                     
            # est-il déjà dans le ldap ? (mail ou alias)          
            res, status_code = self.ldap_user_resource.get(email)         
            if status_code != 400: raise ValueError(f"ERREUR 1: {email} déjà existant dans ldap. {res}, on arrête tout")
            
            #test nom orga
            if tab['admin_orga'] == 1:
              if tab['nom_orga'] is None: 
                raise ValueError(f"ERREUR 0 sur paheko: {email} : nom_orga vide, on arrête tout")
              if not bool(re.match(r'^[a-z0-9-]+$', tab['nom_orga'])):
                raise ValueError(f"ERREUR 0 sur paheko: {email} : nom_orga ({tab['nom_orga']}) incohérent (minuscule/chiffre/-), on arrête tout")
                      
            #test email_secours
            email_secours = tab['email_secours'].lower()
            if not validate_email(email_secours): raise EmailNotValidError()

            #test quota
            quota = tab['quota_disque']
            if not quota.isdigit(): raise ValueError(f"ERREUR 2: quota non numérique : {quota}, on arrête tout")
          
            #quel type de test ?
            #"nom": "ROUSSEAU Mickael",
            nom, prenom = tab['nom'].split(maxsplit=1)
            
            #on génère un password
            password,status_code = self.password_create_resource.get()
          
            #on créé dans le ldap
            #à quoi servent prenom/nom dans le ldap ?
            data = {
              "prenom": prenom,
              "nom": nom,
              "password": password,
              "email_secours": email_secours,
              "quota": quota
            }            
            res, status_code = self.ldap_user_resource.put(email, **data)
            if status_code != 200: raise ValueError(f"ERREUR 3 sur ldap: {email} : {res}, on arrête tout ")
            
            #on créé dans MM 
            user = email.split('@')[0]
            res, status_code = self.mattermost_user_resource.post(user,email,password)
            if status_code != 200: raise ValueError(f"ERREUR 4 sur MM: {email} : {res}, on arrête tout ")
                      
            # et on affecte à l'équipe kaz
            res, status_code = self.mattermost_user_team_resource.post(email,"kaz")
            if status_code != 200: raise ValueError(f"ERREUR 5 sur MM: {email} : {res}, on arrête tout ")
          
            #et aux 2 canaux de base
            res, status_code = self.mattermost_user_channel_resource.post(email,"kaz","une-question--un-soucis")
            if status_code != 200: raise ValueError(f"ERREUR 6 sur MM: {email} : {res}, on arrête tout ")
            res, status_code = self.mattermost_user_channel_resource.post(email,"kaz","cafe-du-commerce--ouvert-2424h")
            if status_code != 200: raise ValueError(f"ERREUR 7 sur MM: {email} : {res}, on arrête tout ")
                        
            #on créé une nouvelle équipe ds MM si besoin
            if tab['admin_orga'] == 1:
              res, status_code = self.mattermost_team_resource.post(tab['nom_orga'],email)
              if status_code != 200: raise ValueError(f"ERREUR 8 sur MM: {email} : {res}, on arrête tout ")            
              #BUG: créer la nouvelle équipe n'a pas rendu l'email admin, on le rajoute comme membre simple
              res, status_code = self.mattermost_user_team_resource.post(email,tab['nom_orga'])
              if status_code != 200: raise ValueError(f"ERREUR 8.1 sur MM: {email} : {res}, on arrête tout ")
            
            #on créé dans le cloud genéral
            #inutile car tous les user du ldap sont user du cloud général.
            
            #on inscrit email et email_secours à la nl sympa_liste_info
            res, status_code = self.sympa_user_resource.post(email,sympa_liste_info)
            if status_code != 200: raise ValueError(f"ERREUR 9 sur Sympa: {email} : {res}, on arrête tout ")          
            res, status_code = self.sympa_user_resource.post(email_secours,sympa_liste_info)
            if status_code != 200: raise ValueError(f"ERREUR 10 sur Sympa: {email_secours} : {res}, on arrête tout ")
          
            #on construit/envoie le mail
            context = {
            'ADMIN_ORGA': tab['admin_orga'], 
            'NOM': tab['nom'],
            'EMAIL_SOUHAITE': email,
            'PASSWORD': password,
            'QUOTA': tab['quota_disque'],
            'URL_WEBMAIL': webmail_url,
            'URL_AGORA': mattermost_url,
            'URL_MDP': mdp_url,
            'URL_LISTE': sympa_url,
            'URL_SITE': site_url,
            'URL_CLOUD': cloud_url
            }                  
            subject="KAZ: confirmation d'inscription !"
            sender=app.config['MAIL_USERNAME']
            reply_to = app.config['MAIL_REPLY_TO']
            msg = Message(subject=subject, sender=sender, reply_to=reply_to, recipients=[email,email_secours])
            msg.html = render_template('email_inscription.html', **context)        
            mail.send(msg)
            
            #on met le flag paheko action à Aucune
            res, status_code = self.paheko_user_resource.put(email,"action_auto","Aucune")
            if status_code != 200: raise ValueError(f"ERREUR 12 sur paheko: {email} : {res}, on arrête tout ")            
          
            #on post sur MM pour dire ok
            msg=f"**POST AUTO** Inscription réussie pour {email} avec le secours {email_secours} Bisou!"
            self.mattermost_message_resource.post(message=msg)
                                    
          return "fin des inscriptions", 201
        
        except EmailNotValidError as e:
          msg=f"classe: {__class__.__name__} : ERREUR 13 : email_secours : {email_secours} " + str(e) +", on arrête tout"
          self.mattermost_message_resource.post(message=msg)             
          return msg, 401
        except ValueError as e:
          msg=f"(classe: {__class__.__name__} : {e}"
          self.mattermost_message_resource.post(message=msg)
          return str(msg), 401
        

#*************************************************

api.add_resource(Kaz_user, '/kaz/create/users', endpoint='kaz_create_user', methods=['POST'])
api.add_resource(Kaz_user, '/kaz/delete/user', endpoint='kaz_delete_user', methods=['DELETE'])

#*************************************************
#**********TEST***********************************
#*************************************************
class Test(Resource):

    def __init__(self):
      toto="toto"
      #self.mattermost_team_resource=Mattermost_team()
      #global mattermost_url, sympa_url, webmail_url, mdp_url, site_url, nc_url

#********************************************************************************************
    @jwt_required()
    def get(self):
        """
        Pour tester des conneries: # test lançement de cmde ssh sur des serveurs distants:
        ---
        tags:
          - Test
        security:
          - Bearer: []                
        parameters: []
        responses:
            201:
                description: OK
            401: 
                description: KO
        """     
#********************************************************************************************       


# test lançcement de cmde ssh sur des serveurs distants:
# il faut au préalable que la clé publique de root du conteneur apikaz soit dans authorized key du user fabricer de la machine 163.172.94.54
# clé à créer dans le Dockerfile
# risque sécu ?        
        
        
        cmd="ssh -p 2201 fabricer@163.172.94.54 mkdir -p /tmp/toto"
        try:
            output = subprocess.check_output(cmd, shell=True, stderr=subprocess.STDOUT)        
            return "ok",200
        
        except subprocess.CalledProcessError as e:
            return e.output.decode("utf-8"), 400 
        
#********************************************************************************************       
# #***** test suppression de toutes les équipes de MM sauf KAZ
#         res,status=self.mattermost_team_resource=Mattermost_team().get()        
#         for equipe in res:
#           if equipe!="kaz": res,status=self.mattermost_team_resource=Mattermost_team().delete(equipe)                    
#         return "fin"

#********************************************************************************************
       
#**** test messagerie  
                  
#         NOM="toto"
#         EMAIL_SOUHAITE='f@kaz.bzh'
#         PASSWORD="toto"
#         QUOTA="1"        
#         ADMIN_ORGA="0"
#         
#         context = {
#         'ADMIN_ORGA': ADMIN_ORGA, 
#         'NOM': NOM,
#         'EMAIL_SOUHAITE': EMAIL_SOUHAITE,
#         'PASSWORD': PASSWORD,
#         'QUOTA': QUOTA,
#         'URL_WEBMAIL': webmail_url,
#         'URL_AGORA': mattermost_url,
#         'URL_MDP': mdp_url,
#         'URL_LISTE': sympa_url,
#         'URL_SITE': site_url,
#         'URL_CLOUD': cloud_url
#         }
#               
#         subject = "KAZ: confirmation d'inscription !"
#         sender=app.config['MAIL_USERNAME']
#         reply_to = app.config['MAIL_REPLY_TO']
# 
#         msg = Message(subject=subject, sender=sender, reply_to=reply_to, recipients=[EMAIL_SOUHAITE])
#         msg.html = render_template('email_inscription.html', **context)        
#         
#         # Parsez le contenu HTML avec BeautifulSoup
#         soup = BeautifulSoup(msg.html, 'html.parser')
#         msg.body = soup.get_text()
# 
#         mail.send(msg)
#         return "Message envoyé!"
      
#********************************************************************************************
# #**** test ms erreur
#         email_secours="toto"
#         
#         msg=f"classe: {__class__.__name__} : ERREUR 8 : email_secours : {email_secours} "  +", on arrête tout"
#         #return __class__.__name__
#         return msg
        
#********************************************************************************************
#**** test vérou        
#         prefixe="toto_"   
#         if glob(f"{tempfile.gettempdir()}/{prefixe}*"):          
#           return "ERREUR : api déjà en cours d'utilisation !", 400
#         else:                  
#           lock_file = tempfile.NamedTemporaryFile(prefix=prefixe,delete=True)
#           
#         sleep(20)
#         return str(lock_file), 201

api.add_resource(Test, '/test', endpoint='test', methods=['GET'])

#*************************************************
#*************************************************
#*************************************************

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=os.getenv('PORT'))