Services_ActionsService.js

const CrudService = require("./CrudService");
const {v4: uuidv4} = require("uuid");

/**
 * @extends Myintranet.Services.CrudService
 * @memberof Myintranet.Services
 * @inheritDoc
 */
const getPagingData = (records, page, limit) => {
    const { count: totalItems, rows: data } = records;
    const currentPage = page ? +page : 0;
    const totalPages = Math.ceil(totalItems / limit);

    return { totalItems, data, totalPages, currentPage };
};
class ActionsService extends CrudService {
    constructor(db) {
        super(db.Action);
        this.db = db;
    }

    /**
     * retreve the list of users with admin role
     * @returns {Promise<Model[]>}
     */
    async getAll(request) {
        let {db} = this;
        let {user} = request.user;
        let {page, limit} = request.query;

        let offset = parseInt(page - 1 || 0) * limit;
        const options = {
            limit: parseInt(limit),
            offset,
            order: [["createdAt", "DESC"]]
        };
        return new Promise((resolve, reject) => {
            db.Action.findAndCountAll(options).then((users) => {
                resolve(  getPagingData(users, page, limit)     );
            }).catch((err) => {
                reject(err);
            });
        });
    }


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

    /**
     * updates a user by id
     * @param {Object} request the data to update
     * @returns {Promise<Model>} update results
     */
    update(request) {
        let id = this.__getIdFromRequest(request);
        let data = request.body;
        let {db} = this;
        return db.Action.update(data, {where: {id}});
    }

    /**
     *
     * @param request
     * @returns {Promise<Model>}
     */
    getOne(request) {
        let id = this.__getIdFromRequest(request);
        let {db} = this;
        let condition = {
            where: {id},
        };
        return db.Action.findOne(condition);

    }

    /**
     *  Add an admin and send an email to this email
     * @param {Request} request
     * @returns Promise<any> update results
     * */
    async add(request) {
        let {db} = this;
        let Action = request.body;
        const t = await db.sequelize.transaction();

        try {
            let createdAction = await db.Action.create(
                Action,
                {transaction: t}
            );
            await t.commit();
            return createdAction;
        } catch (e) {
            await t.rollback();
            throw e;
        }
    }


    /**
     *
     * @param request
     * @returns {Promise<Model[]>}
     */
    //cette route n'est pas utilisé
    async delete(id, user) {
        let {db} = this;
        const t = await db.sequelize.transaction();
        try {
            let userToDelete = await db.User.findOne({
                where: {id},
                include: db.Consultant,
            });
            if (userToDelete.type == "admin") {
                throw new Error("Impossible de supprimer  l'utilisateur admin ");
            } else {
                await userToDelete.Consultant.destroy(
                    {force: true},
                    {transaction: t}
                );
                await userToDelete.destroy({force: true}, {transaction: t});
            }
            return await t.commit();
        } catch (error) {
            await t.rollback();
            throw error;
        }
    }

    async deleteAll(request) {
        let {db} = this;
        let connected = request.user;

        await db.Action.destroy({
            where: {},
            truncate: true,
        });
        await db.Action.create({
            UtilisateurId: connected.id,
            meta: JSON.stringify({}),
            type: "suppression",
            text: `<b>${connected.firstname} ${
                connected.lastname
            }</b> a supprimé tous les logs/actions (PURGE) le : ${new Date(
                Date.now()
            ).toLocaleString("fr-FR")}`,
        });
        return await this.getAll(request);
    }

    async deleteByNb(request) {

        let {db} = this;
        let connected = request.user;
        let nbRows = parseInt(request.params.nb);

        let actionsToDelete = await db.Action.findAll({
            where: {},
            order: [["createdAt", "ASC"]],
            limit: nbRows
        })


        let actionsIds = actionsToDelete.map((action => {
            return action.id;
        }))


        await db.Action.destroy({
            where: {
                id: {
                    [db.Sequelize.Op.in]: actionsIds
                }
            }
        });


        //console.log("-----------------------")

        await db.Action.create({
            UtilisateurId: connected.id,
            meta: JSON.stringify({}),
            type: "suppression",
            text: `<b>${connected.firstname} ${
                connected.lastname
            }</b> a supprimé ${nbRows} logs/actions le : ${new Date(
                Date.now()
            ).toLocaleString("fr-FR")}, les id sont : (${actionsIds.join(", ")})`,
        });
        return await this.getAll(request);
    }

    /**
     *
     * @param request
     * @returns {Promise<Model[]>}
     */
    getPrevActions(request) {
        let id = this.__getIdFromRequest(request);
        let {db} = this;
        return db.Action.findAll({where: {PrevId: id}});

    }

    /**
     *
     * @param request
     * @returns {Promise<Model[]>}
     */
    getCraActions(request) {
        let id = this.__getIdFromRequest(request);
        let {db} = this;
        return db.Action.findAll({where: {CraId: id}});

    }

    /**
     *
     * @param request
     * @returns {Promise<Model[]>}
     */
    async getMissionsActions(request) {
        let id = this.__getIdFromRequest(request);
        let {db} = this;
        return db.Action.findAll({where: {MissionId: id}});
    }
}

module.exports = ActionsService;