github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/frontend/directeurs/src/logic/controller.ts

import Vue from "vue";
import Axios, { AxiosResponse } from "axios";
import Cookie from "js-cookie";

import { Directeurs } from "./api";
import { Notifications } from "./notifications";
import {
  AddBonusDocOut,
  AddContactJoomeoIn,
  AddContactJoomeoOut,
  AddDocumentIn,
  AddDocumentOut,
  ChercheSimilaireOut,
  Contrainte,
  CreateEquipierIn,
  DeleteContactOut,
  DeleteContrainteOut,
  DetailsDetailsOutput,
  DetailsEnvoisOut,
  DetailsWritable,
  DocumentsEquipeOut,
  DownloadFicheSanitaireIn,
  Envois,
  EquipierDirecteur,
  Groupe,
  GroupeContraintes,
  InviteFormulaireIn,
  Lettredirecteur,
  LettreDirecteurOut,
  LieDocumentOut,
  ListeVetements,
  ListeVetementsOut,
  LoadContraintesOut,
  LoadEquipiersOut,
  LoadGroupesOut,
  LoadInscritsOut,
  LoadJoomeoOut,
  LogginIn,
  LogginOut,
  OptionnalId,
  PatternsSimilarite,
  Pieces,
  PublicDocument,
  SetContactUploaderIn,
  SetContactUploaderOut,
  UpdateContrainteOut,
  UpdateGroupeOut,
  UpdateInscritIn,
  UpdatePlageIn,
  UpdatePlageOut,
  Groupes,
  Inscrit,
  ContrainteComplete,
  PreviewDocumentsParticipantsOut,
  CampMeta,
  LoadSondagesOut,
  DemandeContraintesIn,
  CampContraintes,
  ResumeMessage,
  Responsable,
  MessageKind,
  LoadGroupeAnimateursOut,
  AddGroupeAnimateursIn,
  DeleteGroupeAnimateurIn,
  UpdateInscritsAnimateurIn,
  UpdateInsritsAnimateurOut,
  Bus,
  UpdateContrainteEquipierIn
} from "./types";
import { NullDate, Formatter } from "./formatter";

export const devMode = process.env.NODE_ENV != "production";
const host = devMode ? "http://localhost:1323" : window.location.origin;
export const BASE_URL = host + "/directeurs/api/";
const UrlDocuments = host + "/document";

const IsSimple = "simple";

function parseContentDisposition(header: string) {
  const startIndex = header.indexOf("filename=") + 9; // Adjust '+ 9' if filename is not the right one.
  const endIndex = header.length; //Check if '- 1' is necessary
  return header.substring(startIndex, endIndex);
}

function saveBlobAsFile(binaryData: Blob, filename: string) {
  const url = window.URL.createObjectURL(new Blob([binaryData]));
  const link = document.createElement("a");
  link.href = url;
  link.setAttribute("download", filename);
  document.body.appendChild(link);
  link.click();
  window.URL.revokeObjectURL(url);
}

/** returns the filename */
function downloadFile(r: AxiosResponse<Blob>) {
  const filename =
    parseContentDisposition(r.headers["content-disposition"]) || "document";
  saveBlobAsFile(r.data, filename);
  return filename;
}

/** Regroupe les messages par dossier */
export interface DossierMessages {
  responsable: Responsable;
  messages: ResumeMessage[];
  participants: Inscrit[];
}

/** Regroupes les requetes à effectuer au serveur (API portail des directeurs) */
export class Controller {
  logs = { id_camp: "", token: "" };
  camp = { nom_camp: "", lien_compta: "", is_simple: false };

  notifications: Notifications;

  inscrits: Inscrit[] = [];
  groupes: NonNullable<Groupes> = {};
  campContraintes: NonNullable<CampContraintes> = [];
  groupeContraintes: NonNullable<GroupeContraintes> = [];
  contraintes: { [key: number]: ContrainteComplete } = {};

  constructor() {
    this.notifications = new Notifications();
  }

  private getAuth() {
    return {
      username: this.logs.id_camp,
      password: this.logs.token
    };
  }

  /** Url sécurisé d'upload d'image */
  getUrlUploadImage() {
    return (
      BASE_URL +
      Directeurs.UploadImageLettre(this.logs.id_camp, this.logs.token)
    );
  }

  async getIdentification() {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<CampMeta[]> = await Axios.get(
        BASE_URL + Directeurs.DataLoggin
      );
      this.notifications.progress = false;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async postIdentification(params: LogginIn) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LogginOut> = await Axios.post(
        BASE_URL + Directeurs.Loggin,
        params
      );
      this.logs.token = r.data.token;
      this.notifications.progress = false;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  /** Lit les cookies et setup les informations */
  tryLogginCookie() {
    const id_camp = Cookie.get("id_camp");
    const token = Cookie.get("token");
    const lien_compta = Cookie.get("lien_compta") || "";
    const nom_camp = Cookie.get("nom_camp") || "";
    const is_simple = Cookie.get("is_simple") == IsSimple;
    if (id_camp && token) {
      this.setupLogs(id_camp, {
        camp: { label: nom_camp, is_simple },
        token,
        lien_compta
      });
      return true;
    }
    return false;
  }

  private setupLogs(idCamp: string, data: LogginData) {
    this.logs.id_camp = idCamp;
    this.logs.token = data.token;
    this.camp.nom_camp = data.camp.label;
    this.camp.lien_compta = data.lien_compta;
    this.camp.is_simple = data.camp.is_simple;
  }

  onLogginSuccess(idCamp: string, data: LogginData) {
    this.setupLogs(idCamp, data);

    // mise à jour des cookies
    Cookie.set("id_camp", this.logs.id_camp);
    Cookie.set("token", this.logs.token);
    Cookie.set("nom_camp", this.camp.nom_camp);
    Cookie.set("lien_compta", this.camp.lien_compta);
    Cookie.set("is_simple", this.camp.is_simple ? IsSimple : "");
  }

  onLoggout() {
    Cookie.remove("id_camp");
    Cookie.remove("token");
    Cookie.remove("nom_camp");
    Cookie.remove("lien_compta");
    Cookie.remove("is_simple");
    // vue-router ne permet pas de reset les routes,
    // passer d'un camp simple à un camp complet est donc problématique
    location.reload();
  }

  async getDetails<K extends keyof DetailsTypesOut>(categorie: K) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<DetailsTypesOut[K]> = await Axios.get(
        BASE_URL + Directeurs.GetDetails(categorie),
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async updateDetails<K extends keyof DetailsTypesIn>(
    categorie: K,
    data: DetailsTypesIn[K]
  ) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<DetailsTypesOut[K]> = await Axios.post(
        BASE_URL + Directeurs.UpdateDetails(categorie),
        data,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async addBonusDoc(file: File) {
    const formData = new FormData();
    formData.append("file", file, file.name);
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<AddBonusDocOut> = await Axios.put(
        BASE_URL + Directeurs.AjouteBonusDoc,
        formData,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data.document;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async deleteDocument(idCrypted: string) {
    this.notifications.progress = true;
    try {
      await Axios.delete(UrlDocuments, {
        auth: this.getAuth(),
        params: { "id-crypted": idCrypted }
      });
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async uploadFile(file: File, idDocCrypted: string) {
    this.notifications.progress = true;
    const formData = new FormData();
    formData.append("file", file, file.name);
    formData.append("crypted-id", idDocCrypted);
    try {
      const out: AxiosResponse<PublicDocument> = await Axios.post(
        UrlDocuments,
        formData,
        {
          auth: this.getAuth()
        }
      );
      return out.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  // ---------------------- Inscrits --------------------

  async getInscrits() {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadInscritsOut> = await Axios.get(
        BASE_URL + Directeurs.GetInscrits,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.inscrits = r.data.inscrits || [];
      this.notifications.progress = false;
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  /** Filtre les messages en ne conservant que les messages perso (respo + centre),
   * par dossier
   */
  infosParticulieres() {
    const byFacture: { [key: number]: Inscrit[] } = {};
    this.inscrits.forEach(insc => {
      if (!insc.responsable.valide) return;
      const idDossier = insc.responsable.id;
      const l = byFacture[idDossier] || [];
      byFacture[idDossier] = l.concat(insc);
    });
    return Object.values(byFacture)
      .map(inscrits => {
        const first = inscrits[0]; // toutes les listes ont au moins un inscrits
        const messages = (first.responsable.messages || []).filter(
          m =>
            m.kind == MessageKind.MCentre || m.kind == MessageKind.MResponsable
        );
        const out: DossierMessages = {
          responsable: first.responsable,
          messages: messages,
          participants: inscrits
        };
        return out;
      })
      .filter(info => info.messages.length > 0)
      .sort((a, b) => a.responsable.nom.localeCompare(b.responsable.nom));
  }

  /** Renvoie l'ensemble des mails des inscrits (sans la liste d'attente)
   * Pour un camp complet, il s'agit des mails des responsables.
   * La deuxième liste contient les mails en copies des dossiers (vide pour un camp simple)
   */
  mailsInscrits() {
    const mails: { [key: string]: boolean } = {};
    const mailsCopie: { [key: string]: boolean } = {};
    C.inscrits.forEach(inscrit => {
      if (inscrit.is_attente) return;
      if (inscrit.mail) {
        mails[inscrit.mail] = true;
      }
      if (inscrit.responsable.mail) {
        mails[inscrit.responsable.mail] = true;
      }
      (inscrit.responsable.mails_copies || []).forEach(mail => {
        mailsCopie[mail] = true;
      });
    });
    // tri
    const mailsOut = Object.keys(mails).sort((a, b) => a.localeCompare(b));
    const mailsCopieOut = Object.keys(mailsCopie).sort((a, b) =>
      a.localeCompare(b)
    );
    return { mails: mailsOut, mailsCopie: mailsCopieOut };
  }

  private exportOneDossier(info: DossierMessages) {
    return (
      `------ ${Formatter.nomPrenom(info.responsable)} ------\n` +
      info.messages
        .map(m => {
          return m.contenu
            .split("\n")
            .filter(line => line.trim() != "")
            .join("\n");
        })
        .join("\n\n")
    );
  }

  async exportInfosToClipboard(infos: DossierMessages[]) {
    const data = infos.map(this.exportOneDossier).join("\n\n");
    try {
      await navigator.clipboard.writeText(data);
      this.notifications.success =
        "Situations particulières copiées dans le presse-papier.";
    } catch (err) {
      this.notifications.error = {
        code: 0,
        kind: "Accès au presse-papier",
        messageHtml: String(err)
      };
    }
  }

  async exportMailsToClipboard(mails: string) {
    try {
      await navigator.clipboard.writeText(mails);
      this.notifications.success =
        "Adresses mails copiées dans le presse-papier.";
    } catch (err) {
      this.notifications.error = {
        code: 0,
        kind: "Accès au presse-papier",
        messageHtml: String(err)
      };
    }
  }

  async updateInscrit(params: UpdateInscritIn) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadInscritsOut> = await Axios.post(
        BASE_URL + Directeurs.UpdateInscrit,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.inscrits = r.data.inscrits || [];
      this.notifications.progress = false;
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async getContraintes() {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadContraintesOut> = await Axios.get(
        BASE_URL + Directeurs.LoadContraintes,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.contraintes = r.data.contraintes || {};
      this.notifications.success = "Documents à remplir chargés.";
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async createContrainte(contrainte: Contrainte) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadContraintesOut> = await Axios.put(
        BASE_URL + Directeurs.CreateContrainte,
        contrainte,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.contraintes = r.data.contraintes || {};
      this.notifications.success = "Documents à remplir bien ajouté.";
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async updateContrainte(contrainte: Contrainte) {
    const doc = this.contraintes[contrainte.id].document;
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<UpdateContrainteOut> = await Axios.post(
        BASE_URL + Directeurs.CreateContrainte,
        contrainte,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      const ct: ContrainteComplete = { ...r.data.contrainte, document: doc };
      Vue.set(this.contraintes, r.data.contrainte.id, ct);
      this.notifications.success = "Demande mise à jour.";
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async deleteContrainte(id: number) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<DeleteContrainteOut> = await Axios.delete(
        BASE_URL + Directeurs.DeleteContrainte,
        {
          auth: this.getAuth(),
          params: { id }
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async lieDocumentContrainte(idContrainte: number) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LieDocumentOut> = await Axios.get(
        BASE_URL + Directeurs.LieDocument,
        {
          auth: this.getAuth(),
          params: { id: idContrainte }
        }
      );
      this.logs.token = r.data.token;
      this.contraintes[idContrainte].document = r.data.document;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async getGroupes(notifie: boolean) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadGroupesOut> = await Axios.get(
        BASE_URL + Directeurs.LoadGroupes,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.groupes = r.data.groupes || {};
      this.campContraintes = r.data.camp_contraintes || [];
      this.groupeContraintes = r.data.groupe_contraintes || [];
      if (notifie) {
        this.notifications.success = "Groupes chargés.";
      }
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async createGroupe(nom: string, couleur: string) {
    const params: Groupe = {
      nom,
      id: -1,
      id_camp: -1,
      plage: { to: NullDate, from: NullDate },
      couleur: couleur
    };
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<UpdateGroupeOut> = await Axios.put(
        BASE_URL + Directeurs.CreateGroupe,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      Vue.set(this.groupes, r.data.groupe.id, r.data.groupe); // VRC
      this.notifications.success = "Groupe ajouté.";
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async updateGroupe(groupe: Groupe) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<UpdateGroupeOut> = await Axios.post(
        BASE_URL + Directeurs.UpdateGroupe,
        groupe,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      Vue.set(this.groupes, r.data.groupe.id, r.data.groupe); // VRC
      this.notifications.success = "Groupe modifié";
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async deleteGroupe(idGroupe: number) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadGroupesOut> = await Axios.delete(
        BASE_URL + Directeurs.DeleteGroupe,
        {
          auth: this.getAuth(),
          params: { id: idGroupe }
        }
      );
      this.logs.token = r.data.token;
      this.groupes = r.data.groupes || {};
      this.campContraintes = r.data.camp_contraintes || [];
      this.groupeContraintes = r.data.groupe_contraintes || [];
      this.notifications.success = "Groupe supprimé.";
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async updateGroupesPlages(plages: UpdatePlageIn) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<UpdatePlageOut> = await Axios.post(
        BASE_URL + Directeurs.UpdatePlages,
        plages,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.notifications.progress = false;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async getGroupeAnimateurs(idGroupe: number) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadGroupeAnimateursOut> = await Axios.get(
        BASE_URL + Directeurs.LoadGroupeAnimateurs,
        {
          params: { id: idGroupe },
          auth: this.getAuth()
        }
      );
      this.notifications.progress = false;
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async addGroupeAnimateurs(idGroupe: number, idAnimateurs: number[]) {
    const params: AddGroupeAnimateursIn = {
      id_groupe: idGroupe,
      id_equipiers: idAnimateurs
    };
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadGroupeAnimateursOut> = await Axios.put(
        BASE_URL + Directeurs.AddGroupeAnimateurs,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.notifications.success = "Animateurs bien ajoutés au groupe.";
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async deleteGroupeAnimateur(idGroupe: number, idAnimateur: number) {
    const params: DeleteGroupeAnimateurIn = {
      id_groupe: idGroupe,
      id_equipier: idAnimateur
    };
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadGroupeAnimateursOut> = await Axios.post(
        BASE_URL + Directeurs.DeleteGroupeAnimateur,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.notifications.success = "Animateur bien retiré du groupe.";
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async updateInscritsAnimateur(params: UpdateInscritsAnimateurIn) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<UpdateInsritsAnimateurOut> = await Axios.post(
        BASE_URL + Directeurs.UpdateInscritsAnimateur,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.notifications.success = "Animateur de référence mis à jour";
      return r.data.participant_equipiers;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async autoRepartitInscritAnimateur(idGroupe: number) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<UpdateInsritsAnimateurOut> = await Axios.put(
        BASE_URL + Directeurs.AutoRepartitInscritsAnimateur,
        {},
        { params: { "id-groupe": idGroupe }, auth: this.getAuth() }
      );
      this.logs.token = r.data.token;
      this.notifications.success = "Répartition effectuée.";
      return r.data.participant_equipiers;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async updateGroupesContraintes(contraintes: DemandeContraintesIn) {
    try {
      this.notifications.progress = true;
      const r: AxiosResponse<LoadGroupesOut> = await Axios.post(
        BASE_URL + Directeurs.UpdateGroupesContraintes,
        contraintes,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.groupes = r.data.groupes || {};
      this.campContraintes = r.data.camp_contraintes || [];
      this.groupeContraintes = r.data.groupe_contraintes || [];
      this.notifications.progress = false;
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async previewDocumentsInscrits(idContrainte: number) {
    try {
      const r: AxiosResponse<PreviewDocumentsParticipantsOut> = await Axios.get(
        BASE_URL + Directeurs.PreviewDocumentInscrits,
        {
          params: { "id-contrainte": idContrainte },
          auth: this.getAuth()
        }
      );
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async downloadDocumentInscrits(idContrainte: OptionnalId) {
    this.notifications.setupMonitor();
    try {
      const r: AxiosResponse<Blob> = await Axios.post(
        BASE_URL + Directeurs.DownloadDocumentInscrits,
        idContrainte,
        {
          responseType: "arraybuffer",
          onDownloadProgress: this.notifications.updateMonitor,
          auth: this.getAuth()
        }
      );
      return downloadFile(r);
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async downloadFicheSanitaire(params: DownloadFicheSanitaireIn) {
    this.notifications.setupMonitor();
    try {
      const r: AxiosResponse<Blob> = await Axios.post(
        BASE_URL + Directeurs.DownloadFicheSanitaire,
        params,
        {
          responseType: "arraybuffer",
          auth: this.getAuth(),
          onDownloadProgress: this.notifications.updateMonitor
        }
      );
      return downloadFile(r);
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  // -------------- Equipiers ------------------------
  async getEquipiers() {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LoadEquipiersOut> = await Axios.get(
        BASE_URL + Directeurs.GetEquipe,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async rechercheProfil(params: PatternsSimilarite) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<ChercheSimilaireOut> = await Axios.post(
        BASE_URL + Directeurs.RechercheProfil,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async ajouteEquier(params: CreateEquipierIn) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LoadEquipiersOut> = await Axios.put(
        BASE_URL + Directeurs.AddEquipier,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async updateEquipier(params: EquipierDirecteur) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LoadEquipiersOut> = await Axios.post(
        BASE_URL + Directeurs.ModifieEquipier,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async deleteEquipier(id: number) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LoadEquipiersOut> = await Axios.delete(
        BASE_URL + Directeurs.DeleteEquipier,
        {
          params: { id },
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async getDocumentsEquipe() {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<DocumentsEquipeOut> = await Axios.get(
        BASE_URL + Directeurs.GetDocumentsEquipe,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async updateDocumentEquipier(params: UpdateContrainteEquipierIn) {
    this.notifications.progress = true;
    try {
      await Axios.post(BASE_URL + Directeurs.SetDocumentsEquipe, params, {
        auth: this.getAuth()
      });
      return true;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async addDocumentEquipe(file: File, params: AddDocumentIn) {
    this.notifications.progress = true;
    const formData = new FormData();
    formData.append("file", file, file.name);
    formData.append("meta", JSON.stringify(params));
    try {
      const r: AxiosResponse<AddDocumentOut> = await Axios.put(
        BASE_URL + Directeurs.AddDocumentEquipe,
        formData,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data.document;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async donwloadDocumentsEquipe(onlyRequis: boolean) {
    this.notifications.setupMonitor();
    try {
      const r: AxiosResponse<Blob> = await Axios.get(
        BASE_URL + Directeurs.DownloadDocumentsEquipe,
        {
          params: { "only-requis": onlyRequis ? "true" : "" },
          responseType: "arraybuffer",
          onDownloadProgress: this.notifications.updateMonitor,
          auth: this.getAuth()
        }
      );
      return downloadFile(r);
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  async inviteFormulaireEquipier(
    mode: "all" | "new" | "one",
    idParticipant: number
  ) {
    this.notifications.progress = true;
    const params: InviteFormulaireIn = { id_participant: idParticipant, mode };
    try {
      const r: AxiosResponse<LoadEquipiersOut> = await Axios.post(
        BASE_URL + Directeurs.InviteFormulaireEquipier,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  // -------------- Exports ---------------------------

  async export(
    categorie: "inscrits" | "equipe" | "finances",
    options: OptionsExportInscrit
  ) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<Blob> = await Axios.get(
        BASE_URL + Directeurs.ExportsExcel(categorie),
        {
          params: {
            bus: options.bus || "",
            with_groupe: options.with_groupe ? "ok" : "",
            with_attente: options.with_attente ? "ok" : "",
            show_colors: options.show_colors ? "ok" : "",
            simple: options.simple ? "ok" : ""
          },
          responseType: "arraybuffer",
          auth: this.getAuth()
        }
      );
      return downloadFile(r);
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }

  // --------------Lettre du directeur ----------------

  async getLettreDirecteur() {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LettreDirecteurOut> = await Axios.get(
        BASE_URL + Directeurs.GetLettreDirecteur,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async updateLettreDirecteur(params: Lettredirecteur) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LettreDirecteurOut> = await Axios.post(
        BASE_URL + Directeurs.UpdateLettreDirecteur,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  // ------------ Liste de vêtements ------------------

  async getListeVetements(saison: "ete" | "hiver" | "current") {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<ListeVetementsOut> = await Axios.get(
        BASE_URL + Directeurs.GetListeVetements(saison),
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async updateListeVetements(params: ListeVetements) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<ListeVetementsOut> = await Axios.post(
        BASE_URL + Directeurs.UpdateListeVetements,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async previewListeVetements() {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<ArrayBuffer> = await Axios.get(
        BASE_URL + Directeurs.PreviewListeVetements,
        {
          responseType: "arraybuffer",
          auth: this.getAuth()
        }
      );
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  // ------------ JOOMEO ------------------------------

  async getPhotos() {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LoadJoomeoOut> = await Axios.get(
        BASE_URL + Directeurs.GetJoomeo,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async setUploader(contactid: string) {
    this.notifications.progress = true;
    try {
      const params: SetContactUploaderIn = { contactid };
      const r: AxiosResponse<SetContactUploaderOut> = await Axios.post(
        BASE_URL + Directeurs.SetContactUploader,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async addContacts(params: AddContactJoomeoIn) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<AddContactJoomeoOut> = await Axios.put(
        BASE_URL + Directeurs.AddContactsJoomeo,
        params,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async deleteContact(contactid: string) {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<DeleteContactOut> = await Axios.delete(
        BASE_URL + Directeurs.DeleteContact,
        {
          params: { contactid },
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      return r.data;
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
    this.notifications.progress = false;
  }

  async loadSondages() {
    this.notifications.progress = true;
    try {
      const r: AxiosResponse<LoadSondagesOut> = await Axios.get(
        BASE_URL + Directeurs.LoadSondages,
        {
          auth: this.getAuth()
        }
      );
      this.logs.token = r.data.token;
      this.notifications.progress = false;
      return r.data.sondages || [];
    } catch (error) {
      this.notifications.onAxiosError(error);
    }
  }
}

export const C = new Controller();

// additionnal typing
interface DetailsTypesIn {
  details: DetailsWritable;
  envois: Envois;
}

interface DetailsTypesOut {
  details: DetailsDetailsOutput;
  envois: DetailsEnvoisOut;
}

export type LogginData = Omit<LogginOut, "camp" | "valide"> & {
  camp: { label: string; is_simple: boolean };
};

export interface OptionsExportInscrit {
  simple?: boolean;
  bus?: Bus;
  with_groupe?: boolean;
  with_attente?: boolean;
  show_colors?: boolean;
}