Services_EmployeurService.js

const CrudService = require("./CrudService");
const crypto = require("crypto");
function slugify (str) {
  str = str.replace(/^\s+|\s+$/g, ''); // trim
  str = str.toLowerCase();

  // remove accents, swap ñ for n, etc
  let from = "àáäâèéëêìíïîòóöôùúüûñç·/_,:;";
  let to   = "aaaaeeeeiiiioooouuuunc------";
  for (let i=0, l=from.length ; i<l ; i++) {
      str = str.replace(new RegExp(from.charAt(i), 'g'), to.charAt(i));
  }

  str = str.replace(/[^a-z0-9 -]/g, '') // remove invalid chars
      .replace(/\s+/g, '-') // collapse whitespace and replace by -
      .replace(/-+/g, '-'); // collapse dashes

  return str;
}


/**
 * @extends Myintranet.Services.CrudService
 * @memberof Myintranet.Services
 * @inheritDoc
 */
class EmployeurService extends CrudService {
  constructor(db) {
    super(db.Employeur);
    this.db = db;
  }

  async getAll(request) {
    let { db } = this;
    let connectedUser = request.user;
    if (connectedUser.type === "SuperAdmin") {
      return db.Employeur.findAll({});
    } else if (connectedUser.type === "Admin") {
      let admin = await db.User.findOne({
        where: { id: connectedUser.id },
        include: { model: db.Employeur },
      });
      let employeursIds = admin.Employeurs.map((emp) => {
        return emp.id;
      });
      return db.Employeur.findAll({
        where: { id: { [db.Sequelize.Op.in]: employeursIds } },
      });
    } else {
      //Consultant
      throw new Error(
        "Un consultant ne peu pas consulter la liste des Employeurs, seul un admin ou un super admin le peuvent!"
      );
    }
  }

  async findByText(request) {
    let { text } = request.body;
    let { db } = this;
    let { user } = request.user;
    return new Promise((resolve, reject) => {
      db.Employeur.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 add(request) {
    let { db } = this;
    let connected = request.user;
    let data = request.body;
    data.slug = slugify(data.denominationSocial)



    //console.log(connected)
    const t = await db.sequelize.transaction();
    try {
      await db.Action.create(
        {
          UtilisateurId: connected.id,
          meta: JSON.stringify(data),
          type: "creation",
          text: `<b>${connected.firstname} ${
            connected.firstname
          }</b> a créé  l'employeur : <b>${
            data.denominationSocial
          }</b>. le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
        },
        { transaction: t }
      );
      let Client = await db.Employeur.create(data, { transaction: t });
      await t.commit();
      return Client;
    } catch (e) {
      await t.rollback();
      throw e;
    }
  }

  async update(request) {
    let data = request.body,
      connected = request.user;
      data.slug = slugify(data.denominationSocial)

    let { db } = this;
    const t = await db.sequelize.transaction();
    let id = null;
    if (request.body.id) {
      id = request.body.id;
    } else if (request.params.id) {
      id = request.params.id;
    } else if (request.query.id) {
      id = request.query.id;
    }
    try {
      if (!id) {
        throw new Error("cant update with no id");
      } else {
        await db.Action.create(
          {
            UtilisateurId: connected.id,
            meta: JSON.stringify(data),
            type: "mise a jour",
            text: `<b>${connected.firstname} ${
              connected.firstname
            }</b> a  modifié l'employeur : <b>${
              data.denominationSocial
            }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
          },
          { transaction: t }
        );
        let updateRes = await db.Employeur.update(data, { where: { id } });
        await t.commit();
        return updateRes;
      }
    } catch (e) {
      await t.rollback();
      throw e;
    }
  }

  async delete(request) {
    let { db } = this;
    let connected = request.user;
    let id = this.__getIdFromRequest(request);
    const t = await db.sequelize.transaction();
    try {
      if (!id) {
        throw new Error("On ne peut pas supprimer un élément sans son ID");
      } else {
        let empDelete = await db.Employeur.findOne({
          where: { id },
          include: db.Consultant,
        });
        // let empMissions = await db.Mission.findAll({where: {EmployeurId: id}});
        if (empDelete.Consultants.length === 0) {
          // let empConsultants = await db.Consultant.findAll({where: {EmployeurId: id}});
          await db.Action.create(
            {
              UtilisateurId: connected.id,
              meta: JSON.stringify(empDelete.toJSON()),
              type: "suppression",
              text: `<b>${connected.firstname} ${
                connected.firstname
              }</b> a supprimé l'employeur : <b>${
                empDelete.denominationSocial
              }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
            },
            { transaction: t }
          );
          await empDelete.destroy({ force: false }, { transaction: t });
          return await t.commit();
        } else {

          
          throw new Error(
            `${empDelete.denominationSocial} est associé à des consultants. Impossible de le supprimer.`
          );

          // throw new Error(`${empDelete.denominationSocial} est associé à des missions. Impossible de le supprimer.`);
        }
      }
    } catch (error) {
      await t.rollback();
      throw error;
    }
  }
}

module.exports = EmployeurService;