Services_AdminsService.js

const CrudService = require("./CrudService");
const WelcomeMail = require("../sms-mail/WelcomeMail");
const AdminWelcomeMail = require("../sms-mail/AdminWelcomeMail");
const { v4: uuidv4 } = require("uuid");

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

  /**
   * retreve the list of users with admin role
   */
  async getAll(request) {
    let { db } = this;
    let condition = {
      where: { type: { [db.Sequelize.Op.eq]: "Admin" } },

      include: [db.Employeur],
    };
    let { user } = request;
    if (user.type === "SuperAdmin") {
      return await db.User.findAll(condition);
    } else {
      throw new Error(
        "Seule le super administrateur a le droit de voir les Administrateurs"
      );
    }
  }

  async findByText(request) {
    let { text } = request.body;
    let { db } = this;
    let condition = {
        include: [db.Employeur],
      where: {
        [db.Sequelize.Op.and]: {
            type: { [db.Sequelize.Op.eq]: "Admin" },
        },
        [db.Sequelize.Op.or]: {
          firstname: { [db.Sequelize.Op.like]: "%" + text + "%" },
          login: { [db.Sequelize.Op.like]: "%" + text + "%" },
        }
      },
    };
    let { user } = request;
    if (user.type === "SuperAdmin") {
      return await db.User.findAll(condition);
    } else {
      throw new Error(
        "Seule le super administrateur a le droit de voir les Administrateurs"
      );
    }
  }

  /**
   *
   * @param request
   * @returns {Promise<*>}
   */
  async update(request) {
    let data = request.body,
      connected = request.user;
    let { db } = this;
    const t = await db.sequelize.transaction();
    let id = this.__getIdFromRequest(request);
    try {
      if (id) {
        if (connected.type === "SuperAdmin") {
          await db.Action.create(
            {
              UtilisateurId: connected.id,
              meta: JSON.stringify(data),
              type: "mise a jour",
              text: `<b>${connected.firstname} ${
                connected.lastname
              }</b> a  modifié l'administrateur : <b>${data.firstname}-${
                data.lastname
              }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
            },
            { transaction: t }
          );
           await db.User.update(data, {
            where: { id },
            include: [db.Employeur],
          });
          await t.commit();
          return this.getOne(request);
        } else {
          throw new Error(
            "Seule ee super administrateur a le droit de voir Administrateur" +
              id
          );
        }
      } else {
        throw new Error("cant update with no id");
      }
    } catch (e) {
      await t.rollback();
      throw e;
    }
  }

  async updateAttributions(request) {
    let data = request.body,
      connected = request.user;
    let { db } = this;
    const t = await db.sequelize.transaction();
    let id = this.__getIdFromRequest(request);
    try {
      if (!id) {
        throw new Error("cant update with no id");
      } else {
        if (connected.type === "SuperAdmin") {
          await db.Action.create(
            {
              UtilisateurId: connected.id,
              meta: JSON.stringify(data),
              type: "mise a jour",
              text: `<b>${connected.firstname} ${
                connected.lastname
              }</b> a  modifié l'administrateur : <b>${data.firstname}-${
                data.lastname
              }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
            },
            { transaction: t }
          );

          let inDbAdmin = await this.getOne(request);
          let indbIds = inDbAdmin.Employeurs.map((employeur) => {
            return employeur.id;
          });
          let frontIds = data.Employeurs.map((employeur) => {
            return employeur.id;
          });

          // delete association of removed
          for (let i = 0; i < indbIds.length; i++) {
            if (!frontIds.includes(indbIds[i])) {
              /// supression de l'association
              console.log("Supression ", indbIds[i]);
              let e = await db.Employeur.findOne({ where: { id: indbIds[i] } });
             await inDbAdmin.removeEmployeurs(e);
            }
          }

          for (let i = 0; i < frontIds.length; i++) {
            if (!indbIds.includes(frontIds[i])) {
              /// creqtion de l'association
              console.log("Creation ", frontIds[i]);
              let e = await db.Employeur.findOne({
                where: { id: frontIds[i] },
              });
              await inDbAdmin.addEmployeurs(e);
            }
          }
          //todo: manage associations directy
          // await PlayerGameTeam.bulkCreate([
          //     // In 'Winter Showdown' (i.e. GameTeamIds 3 and 4):
          //     { PlayerId: 1, GameTeamId: 3 },   // s0me0ne played for The Martians
          //     { PlayerId: 3, GameTeamId: 3 },   // greenhead played for The Martians
          //     { PlayerId: 4, GameTeamId: 4 },   // not_spock played for The Plutonians
          //     { PlayerId: 5, GameTeamId: 4 }    // bowl_of_petunias played for The Plutonians
          // ]);

          await inDbAdmin.save({ transaction: t });
          await t.commit();
          return await this.getOne(request);
        } else {
          throw new Error(
            "Seule ee super administrateur a le droit de voir Administrateur" +
              id
          );
        }
      }
    } catch (e) {
      await t.rollback();
      throw e;
    }
  }

  /**
   * retreve an admin by id
   */
  async getOne(request) {
    let { user } = request;
    let id = this.__getIdFromRequest(request);
    let { db } = this;
    let condition = {
      where: { id },
      include: [db.Employeur],
    };
    if (user.type === "SuperAdmin") {
      return db.User.findOne(condition);
    } else {
      throw new Error(
        "Seule ee super administrateur a le droit de voir Administrateur "
      );
    }
  }

  async add(request) {
    let { db } = this;
    let { user, id } = request;
    const t = await db.sequelize.transaction();
    try {
      let User = request.body;
      let connected = request.user;
      User.type = "Admin";

      if (user.type === "SuperAdmin") {
        await db.Action.create(
          {
            UtilisateurId: connected.id,
            meta: JSON.stringify(User),
            type: "creation",
            text: `<b>${connected.firstname} ${
              connected.lastname
            }</b> a créé l'administrateur : <b>${User.firstname} ${
              User.lastname
            }</b>, Un mail de bienvenu a été envoyé à l address : <b>${
              User.login
            }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
          },
          { transaction: t }
        );
        let admin = await db.User.create(User, { transaction: t });
        admin.link =  await db.SecuredLink.create(
          {
            token: uuidv4(),
            UtilisateurId: admin.id,
            reason: "admin creation",
          },
          { transaction: t }
        );

        let admW = new AdminWelcomeMail(
          admin,
          "Confirmer votre inscription - My Intranet"
        );
        let infos = await admW.send();
        //console.log(infos, "email sent");
        await t.commit();
        return admin;
      } else {
        throw new Error(
          "Seule ee super administrateur a le droit d'ajouter Administrateur "
        );
      }
    } catch (e) {
      await t.rollback();
      throw e;
    }
  }

  sendWelcomeNail(user, cb) {
    let welcomeMail = new WelcomeMail(user);
    return welcomeMail.send(cb);
  }

  async delete(request) {
    let { db } = this;
    let connected = request.user;
    const t = await db.sequelize.transaction();
    let id = this.__getIdFromRequest(request);
    try {
      if (!id) {
        throw new Error("cant delete with no id");
      } else {
        let empDelete = await db.User.findOne({ where: { id } });
        if (!empDelete) {
          throw new Error("cant find Admin with id : " + id);
        } else {
          if (connected.type === "SuperAdmin") {
            await db.Action.create(
              {
                UtilisateurId: connected.id,
                meta: JSON.stringify(empDelete),
                type: "suppression",
                text: `<b>${connected.firstname} ${
                  connected.lastname
                }</b> a supprimé l'administrateur : <b>${empDelete.firstname}-${
                  empDelete.lastname
                }</b> le : ${new Date(Date.now()).toLocaleString("fr-FR")}`,
              },
              { transaction: t }
            );
            await empDelete.destroy({ transaction: t });
            // await empDelete.Consultant.destroy({force: true}, {transaction: t})
            return await t.commit();
          } else {
            throw new Error(
              "Le super administrateur est le seule a avoir le droit de supprimer un Administrateur"
            );
          }
        }
      }
    } catch (error) {
      await t.rollback();
      throw error;
    }
  }
}

module.exports = AdminsService;