Restringir acesso de usuario que não possui permissão

[Everton Luis de Siqueira]

Bom dia pessoal, sou iniciante em programação estou me deparando com um problema que talvez vocês possam me ajudar! Comecei administrar um sistema de currículos que funciona da seguinte forma!

O sistema funciona da seguinte forma, existem grupos de usuários diferentes, usuários comuns, que só podem ver o seu currículo, coordenadores que podem ver os processos seletivos designados pelos usuários administradores, que são os administradores e o Rh. Somente o rh e os usuários administradores podem criar processos seletivos. Todo usuário seja ele administrador, coordenador, usuário comum, recebem um id quando são cadastrados no sistema, só que as permissões, são definidas pelo adm, de acordo com as necessidades.

Quando o adm cria um processo, há opção no sistema de designar para qual usuário esse processo seletivo será atribuído, mas somente coordenadores possuem a permissão para receber esses processos seletivos. Quando é criado um processo seletivo, também é gerado o id desse processo. Na pagina meus processos é possível ver quais os processos o usuário possui, que é gerado visualmente um card, quando é clicado nesse card a rota leva para a etapa de processos seletivos, na url dessa pagina, aparece o id desse processo. Eu quero bloquear o usuário de que caso ele acerte o id de outro processo seletivo ele veja o processo.

Vou deixar aqui, os código do etapaProcessoSeletivoController do backend e Front, e também as rotas. Eu mascarei o id do processo seletivo criando uma função Math.Radom(). Eu quero evitar que os usuários que não sejam administradores consigam ver a etapa dos processos de outros. Abaixo vou mandar os códigos: 

import { Op } from 'sequelize';
import EtapaProcessoSeletivo from '../models/EtapaProcessoSeletivo';
import Etapa from '../models/Etapa';
import { Usuarios } from '../models';

class EtapaProcessoSeletivoController {
  async add(req, res) {
    try {
      const item = await EtapaProcessoSeletivo.create(req.body).catch(err => res.json({ status: false, message: err.message }));
      req.io.sockets.in('etapaProcessoSeletivo').emit('file', item);

      return res.json({ data: item, status: true, message: 'Etapa Processo Seletivo cadastrada com sucesso!' });
    } catch (err) {
      return res.json({ status: false, message: err.message });
    }
  }

  async getAll(req, res) {
    try {
      return await EtapaProcessoSeletivo.findAll({
        where: { dataExclusao: null },
        order: [['nome', 'asc']],
      }).then(rs => res.json(rs));
    } catch (err) {
      return res.json({ status: false, message: err.message });
    }
  }

  async getAllWithPagination(req, res) {
    try {
      const item = await EtapaProcessoSeletivo.findAll({
        where: { dataExclusao: null },
        order: [['nome', 'asc']],
        limit: parseInt(req.params.limit),
        offset: parseInt(req.params.offset),
      });

      const total = await EtapaProcessoSeletivo.count({
        where: { dataExclusao: null },
        distinct: true,
        col: 'id',
      });

      return res.json({ data: item, total });
    } catch (err) {
      return res.json({ status: false, message: err.message });
    }
  }

  async getSearchWithPagination(req, res) {
    try {
      const item = await EtapaProcessoSeletivo.findAll({
        where: {
          dataExclusao: null,
          nome: { [Op.like]: `%${req.params.search}%` },
        },
        order: [['nome', 'asc']],
        limit: parseInt(req.params.limit),
        offset: parseInt(req.params.offset),
      });

      const total = await EtapaProcessoSeletivo.count({
        where: {
          dataExclusao: null,
          nome: { [Op.like]: `%${req.params.search}%` },
        },
        distinct: true,
        col: 'id',
      });

      return res.json({ data: item, total });
    } catch (err) {
      return res.json({ status: false, message: err.message });
    }
  }

  async getById(req, res) {
    try {
      return await EtapaProcessoSeletivo.findAll({
        where: { id: req.params.id },
      }).then(rs => res.json({ data: rs }));
    } catch (err) {
      return res.json({ status: false, message: err.message });
    }
  }
//--------------Metodo Correto-----------------------------------------------*/
/*
  async getByProcessoSeletivoId(req, res) {
    try {
      return await EtapaProcessoSeletivo.findAll({
        where: { processoSeletivoId: req.params.id },
        include: [{ model: Etapa, required: false, where: { dataExclusao: null } }],
        order: [['sequencia', 'asc']],
      }).then(rs => res.json({ data: rs }));
    } catch (error) {
      return res.json({ status: false, message: error.message });
    }
  }
  */
  //-------------- FIM --- DO---Metodo Correto-----------------------------------------------

  async  getByProcessoSeletivoId(req, res) {
    try {
      const userId = req.Usuarios.id; // Captura o ID do usuário atual
     
      const processoSeletivoId = req.params.processoSeletivoId; // Captura o ID do processo seletivo

      // Verifica se o usuário é o proprietário do processo seletivo
      const processoSeletivo = await ProcessoSeletivo.findOne({
        where: { id: processoSeletivoId, id: userId }
      });

      if (!processoSeletivo) {
        // Se o usuário não for o proprietário do processo seletivo, retorna acesso negado
        return res.status(403).json({ status: false, message: "Acesso não autorizado." });
      }

      // Se o usuário for o proprietário, recupera as etapas do processo seletivo
      const etapas = await EtapaProcessoSeletivo.findAll({
        where: { processoSeletivoId: req.params.id},
        include: [{ model: Etapa, required: false, where: { dataExclusao: null } }],
        order: [['sequencia', 'asc']]
      });

      // Retorna as etapas do processo seletivo
      return res.json({ status: true, etapas: etapas });
    } catch (error) {
      // Se ocorrer um erro, retorna uma mensagem de erro

      return res.status(500).json({ status: false, message: "Erro interno do servidor." });
    }
  }


  async update(req, res) {
    try {
      return await EtapaProcessoSeletivo.update(req.body, {
        where: { id: req.body.id },
      })
        .then(count => {
          res.json({ status: count > 0, message: 'Etapa Processo Seletivo atualizada com sucesso!' });
        })
        .catch(err => res.json({ status: false, message: err.message }));
    } catch (err) {
      return res.json({ status: false, message: err.message });
    }
  }

  async delete(req, res) {
    try {
      return await EtapaProcessoSeletivo.update(
        {
          dataExclusao: req.body.dataExclusao,
          usuarioExclusao: req.body.usuarioExclusao,
        },
        {
          where: { id: req.body.id },
        }
      )
        .then(count => res.json({ status: count > 0, message: 'Etapa Processo Seletivo excluída com sucesso!' }))
        .catch(err => res.json({ status: false, message: err.message }));
    } catch (err) {
      return res.json({ status: false, message: err.message });
    }
  }
}

export default new EtapaProcessoSeletivoController();

se for precisso envio as rotas tanto do backend e front!