Services_ClientService.js

const CrudService = require("./CrudService");
const JsonResponse = require("../Controllers/JsonResponse");
const logger = require("../Logger");

/**
 * @extends Myintranet.Services.CrudService
 * @memberof Myintranet.Services
 * @inheritDoc
 */



class ClientService extends CrudService {
  constructor(db) {
    super(db.Client);
    this.db = db;
  }

  async findByText(request) {
    let { text } = request.body;
    let { db } = this;
    let { user } = request.user;
    return new Promise((resolve, reject) => {
      db.Client.findAll({
        where: {
            [db.Sequelize.Op.or]: {
                denominationSocial: { [db.Sequelize.Op.like]: "%" + text + "%" },  
                contact: { [db.Sequelize.Op.like]: "%" + text + "%" },  
                address: { [db.Sequelize.Op.like]: "%" + text + "%" },  
            }
          
        },
        order: [["createdAt", "DESC"]],
      })
        .then((users) => {
          resolve(users);
        })
        .catch((err) => {
          reject(err);
        });
    });
  }

  async delete(request) {
    let { db } = this;
    let data = request.body;

    const t = await db.sequelize.transaction();
    let connected = request.user;

    try {
      let id = this.__getIdFromRequest(request);
      if (id === null) {
        throw new Error("On ne peut pas supprimer un élément sans son ID");
      } else {
        if (connected.type === "SuperAdmin" || connected.type === "Admin") {
          let clientMissions = await db.Mission.findAll({
            where: { ClientId: id },
          });
          if (clientMissions.length === 0) {
            let connected = request.user;
            await db.Action.create(
              {
                UtilisateurId: connected.id,
                meta: JSON.stringify(data),
                type: "suppression",
                text: `<b>${connected.firstname} ${
                  connected.lastname
                }</b> a supprimé le client <b>${
                  data.denominationSocial
                }</b>  le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
              },
              { transaction: t }
            );
            await db.Client.destroy({ where: { id } }, { transaction: t }); // Suppression du client
            await t.commit();
            return { message: "Client supprimé avec succès." };
          } else {
            throw new Error(
              `${data.denominationSocial} est associé à des missions. Ne peut pas être supprimé.`
            );
          }
        } else {
          throw new Error("Seule un administrateur peut supprimer un client");
        }
      }
    } catch (e) {
      await t.rollback();
     // logger.error(e.message);
      throw e;
    }
  }

  async getAll(request) {
    let connected = request.user;
    // let id = this.__getIdFromRequest(request);
    if (connected.type === "SuperAdmin" || connected.type === "Admin") {
      return this.model.findAll({});
    } else {
      throw new Error(
        "Seule un administrateur peu lire les informations des clients"
      );
    }
  }

  async getOne(request) {
    let connected = request.user;
    if (connected.type === "SuperAdmin" || connected.type === "Admin") {
      let id = this.__getIdFromRequest(request);
      return this.model.findOne({ where: { id } });
    } else {
      throw new Error(
        "Seule un administrateur peu lire les informations d'un client"
      );
    }
  }

  async update(request) {
    let { db } = this;
    const t = await db.sequelize.transaction();
    let connected = request.user;

    try {
      let id = this.__getIdFromRequest(request);
      if (id === null) {
        throw new Error("On ne peut pas mettre à jour un element sans son ID");
      } else {
        if (connected.type === "SuperAdmin" || connected.type === "Admin") {
          let connected = request.user;
          let data = request.body;

          await db.Action.create(
            {
              UtilisateurId: connected.id,
              meta: JSON.stringify(data),
              type: "mise a jour",
              text: `<b>${connected.firstname} ${
                connected.lastname
              }</b> a modifié le client : <b>${
                data.denominationSocial
              }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
            },
            { transaction: t }
          );
          let updateRes = await db.Client.update(
            data,
            { where: { id } },
            { transaction: t }
          );
          await t.commit();
          return updateRes;
        } else {
          throw new Error("Seule un administrateur peu modifier un client");
        }
      }
    } catch (e) {
      await t.rollback();
      logger.error(e.message);
      throw e;
    }
  }

  async add(request) {
    let { db } = this;
    let connected = request.user;
    let data = request.body;
    const t = await db.sequelize.transaction();
    try {
      if (connected.type === "SuperAdmin" || connected.type === "Admin") {
        await db.Action.create(
          {
            UtilisateurId: connected.id,
            meta: JSON.stringify(data),
            type: "creation",
            text: `<b>${connected.firstname} ${
              connected.lastname
            }</b> a créé le client : <b>${
              data.denominationSocial
            }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
          },
          { transaction: t }
        );
        let Client = await db.Client.create(data, { transaction: t });
        await t.commit();
        return Client;
      } else {
        throw new Error("Seule un administrateur peu ajouter un client");
      }
    } catch (e) {
      await t.rollback();
      logger.error(e.message);
      throw e;
    }
  }
}

module.exports = ClientService;