github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/frontend/bv/src/pages/espace_perso/logic/data.ts

// Ce module définit l'objet de stockage général,
// qui effectue toutes les requêtes avec le serveur
import { UrlServerBase, fileMeta } from "@/shared/logic/controller";
import axios, { AxiosResponse } from "axios";
import Vue from "vue";
import {
  Aide,
  ChampsAideEditables,
  ContentEspacePerso,
  OutFicheSanitaire,
  InFicheSanitaire,
  JoomeoOutput,
  LockableFicheSanitaire,
  Participant,
  PublicDocument,
  InCreateDocument,
  MetaEspacePerso,
  Finances,
  PublicSondage,
  EditMessage,
  PseudoMessage,
  MessageKind
} from "@/shared/logic/types";
import { ControllerEspacePerso } from "./controller";
import { EspacePerso } from "@/shared/logic/api";

export class Data {
  controller: ControllerEspacePerso;

  // numero de l'espace perso, à setup au chargement initial
  key: string = "";

  metas: MetaEspacePerso | null = null;

  responsable: ContentEspacePerso["responsable"] | null = null;
  personnes: NonNullable<ContentEspacePerso["personnes"]> = {};
  participants: NonNullable<ContentEspacePerso["participants"]> = [];
  camps: NonNullable<ContentEspacePerso["camps"]> = {};
  messages: NonNullable<ContentEspacePerso["messages"]> = [];
  sondages: NonNullable<ContentEspacePerso["sondages"]> = {};

  finances: Finances | null = null;

  joomeoData: JoomeoOutput | null = null;

  get urlFacture() {
    return UrlServerBase + EspacePerso.DownloadFacture(this.key);
  }
  get urlAttestationPresence() {
    return UrlServerBase + EspacePerso.DownloadAttestationPresence(this.key);
  }

  constructor(controller: ControllerEspacePerso) {
    this.controller = controller;
  }

  async loadMetas() {
    try {
      const resp: AxiosResponse<MetaEspacePerso> = await axios.get(
        UrlServerBase + EspacePerso.GetMetas(this.key)
      );
      this.metas = resp.data;
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  private setupData(data: ContentEspacePerso) {
    this.responsable = data.responsable;
    this.personnes = data.personnes || {};
    this.participants = data.participants || [];
    this.camps = data.camps || {};
    this.messages = data.messages || [];
    this.sondages = data.sondages || {};
  }

  // charge depuis le serveur les données initiales de la page
  async loadData() {
    try {
      const resp: AxiosResponse<ContentEspacePerso> = await axios.get(
        UrlServerBase + EspacePerso.GetData(this.key)
      );
      this.setupData(resp.data);
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async loadFinances() {
    try {
      const resp: AxiosResponse<Finances> = await axios.get(
        UrlServerBase + EspacePerso.GetFinances(this.key)
      );
      this.finances = resp.data;
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async loadJoomeoInfos() {
    try {
      const resp: AxiosResponse<JoomeoOutput> = await axios.get(
        UrlServerBase + EspacePerso.LoadJoomeo(this.key)
      );
      this.joomeoData = resp.data;
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async transfertFicheSanitaire(idCryptedPersonne: string) {
    try {
      const resp: AxiosResponse<string[] | null> = await axios.get(
        UrlServerBase + EspacePerso.TransfertFicheSanitaire(this.key),
        {
          params: {
            "id-crypted": idCryptedPersonne
          }
        }
      );
      const errors = resp.data || [];
      if (errors.length == 0) {
        this.controller.notifications.success = {
          title: "Partage de la fiche sanitaire",
          message: "Tous les mails ont bien été envoyés."
        };
      } else {
        this.controller.notifications.notification = {
          title: "Erreurs",
          message: `Certains mails n'ont pu être envoyés :
                                <ul>${errors
                                  .map(s => "<li>" + s + "</li>")
                                  .join("")}</ul>`
        };
      }
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async creeDocument(params: InCreateDocument, file: File) {
    const formData = fileMeta(file, params);
    try {
      let resp: AxiosResponse<PublicDocument> = await axios.put(
        UrlServerBase + EspacePerso.CreateDocument(this.key),
        formData
      );
      return resp.data;
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async creeVaccin(file: File, idPersonneCrypted: string) {
    if (this.metas == null) return;
    const params: InCreateDocument = {
      id_personne: idPersonneCrypted,
      id_contrainte: this.metas.contrainte_vaccin.id_crypted
    };
    const uploadedDoc = await this.creeDocument(params, file);
    if (uploadedDoc === undefined) return;
    const pers = this.personnes[idPersonneCrypted];
    return (pers.vaccins || []).concat(uploadedDoc);
  }

  async updateFicheSanitaire(
    idPersonneCrypted: string,
    ficheSanitaire: LockableFicheSanitaire,
    securiteSociale: string
  ) {
    try {
      const params: InFicheSanitaire = {
        id_crypted: idPersonneCrypted,
        fiche_sanitaire: ficheSanitaire,
        securite_sociale: securiteSociale
      };
      const resp: AxiosResponse<OutFicheSanitaire> = await axios.post(
        UrlServerBase + EspacePerso.UpdateFicheSanitaire(this.key),
        params
      );
      const newFs = resp.data;
      this.personnes[idPersonneCrypted].fiche_sanitaire = newFs.fiche_sanitaire;
      this.participants.forEach(p => {
        p.is_fiche_sanitaire_up_to_date = true;
      });
      if (this.responsable) {
        this.responsable.securite_sociale = newFs.securite_sociale;
      }
      this.controller.notifications.success = {
        title: "Fiche sanitaire",
        message: "Votre fiche sanitaire a bien été <b>enregistrée</b>. Merci !"
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async updateParticipants(modifs: Participant[]) {
    try {
      await axios.post(
        UrlServerBase + EspacePerso.UpdateOptionsParticipants(this.key),
        {
          participants: modifs
        }
      );
      modifs.forEach(newPart => {
        const index = this.participants.findIndex(
          part => part.id_crypted == newPart.id_crypted
        );
        Vue.set(this.participants, index, newPart); // VRC
      });
      this.controller.notifications.success = {
        title: "Options",
        message: "Les options ont bien été mises à jour."
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async updateAide(aide: ChampsAideEditables) {
    if (this.finances == null) return;
    try {
      const resp: AxiosResponse<Aide> = await axios.post(
        UrlServerBase + EspacePerso.UpdateAide(this.key),
        aide
      );
      const modifiedAide = resp.data;
      const index = (this.finances.aides || []).findIndex(
        a => a.id_crypted == aide.id_crypted
      );
      Vue.set(this.finances.aides || [], index, modifiedAide); //VRC
      this.controller.notifications.success = {
        title: "Aide",
        message: "L'aide a bien été modifiée."
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async deleteAide(aide: ChampsAideEditables) {
    if (this.finances == null) return;
    try {
      await axios.delete(UrlServerBase + EspacePerso.DeleteAide(this.key), {
        params: { "id-crypted": aide.id_crypted }
      });
      this.finances.aides = (this.finances.aides || []).filter(
        a => a.id_crypted != aide.id_crypted
      );
      this.controller.notifications.success = {
        title: "Suppression",
        message: "L'aide a bien été supprimée."
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async ajouteAide(aide: ChampsAideEditables, file: File) {
    if (this.finances == null) return;
    const formData = fileMeta(file, aide);
    try {
      const resp: AxiosResponse<Aide> = await axios.put(
        UrlServerBase + EspacePerso.CreateAide(this.key),
        formData
      );
      const newAide = resp.data;
      const docAide = resp.data.document;
      newAide.document = docAide;
      if (this.finances.aides == null) {
        this.finances.aides = [];
      }
      this.finances.aides.push(newAide);
      this.controller.notifications.success = {
        title: "Aide",
        message:
          "L'aide a bien été ajoutée. <i>Elle sera validée par le centre dès que possible.</i>"
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async markConnection() {
    try {
      await axios.get(UrlServerBase + EspacePerso.MarkConnection(this.key));
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async saveSondage(sondage: PublicSondage) {
    try {
      const resp: AxiosResponse<PublicSondage> = await axios.post(
        UrlServerBase + EspacePerso.SaveSondage(this.key),
        sondage
      );
      Vue.set(this.sondages, resp.data.id_camp, resp.data); //VRC
      this.controller.notifications.success = {
        title: "Enquête",
        message: "Votre avis a bien été enregistré. Merci !"
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async createMessage(contenu: string) {
    const params: EditMessage = { id: -1, contenu };
    try {
      const resp: AxiosResponse<PseudoMessage> = await axios.put(
        UrlServerBase + EspacePerso.CreeMessage(this.key),
        params
      );
      this.messages = [resp.data].concat(this.messages);
      this.controller.notifications.success = {
        title: "Nouveau message",
        message: "Votre message a bien été envoyé."
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async editMessage(params: EditMessage) {
    try {
      const resp: AxiosResponse<PseudoMessage> = await axios.post(
        UrlServerBase + EspacePerso.EditMessage(this.key),
        params
      );
      // l'id d'un pseudo message ne suffit pas, car il peut s'agir d'un paiement
      const index = this.messages.findIndex(
        mess => mess.id == params.id && mess.kind == MessageKind.MResponsable
      );
      if (index == -1) return;
      Vue.set(this.messages, index, resp.data); // VRC
      this.controller.notifications.success = {
        title: "Message",
        message: "Votre message a bien été modifié."
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async deleteMessage(idMessage: number) {
    try {
      const resp = await axios.delete(
        UrlServerBase + EspacePerso.DeleteMessage(this.key),
        {
          params: { "id-message": idMessage }
        }
      );
      // l'id d'un pseudo message ne suffit pas, car il peut s'agir d'un paiement
      const index = this.messages.findIndex(
        mess => mess.id == idMessage && mess.kind == MessageKind.MResponsable
      );
      if (index == -1) return;
      Vue.set(this.messages, index, resp.data); // VRC
      this.controller.notifications.success = {
        title: "Suppression",
        message: "Votre message a bien été supprimé."
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }

  async confirmePlaceliberee(idMessage: number) {
    try {
      const resp: AxiosResponse<ContentEspacePerso> = await axios.post(
        UrlServerBase + EspacePerso.ConfirmePlaceliberee(this.key),
        {},
        {
          params: { "id-message": idMessage }
        }
      );
      this.setupData(resp.data);
      this.controller.notifications.success = {
        title: "Place confirmée",
        message: "La participation au séjour a bien été confirmée. Merci !"
      };
    } catch (error) {
      this.controller.notifications.onAxiosError(error);
    }
  }
}