Merge remote-tracking branch 'origin/32-criar-controller-recuperar-senha' into develop

.env.example

-#Porta para subir o servidor
-PORT=3000
-
-#URL de conexão com o MongoDB
-DB_URL=mongodb+srv://matematicaplataforma7:pm123456@plataforma.mcuxyre.mongodb.net/
-
-#Palavra secreta para geração do token
-SECRET=rdfgdhggfjytfyterutdydfkytfyitfyti
-
-#Tempo de expiração do token
-EXPIREIN=1h
\ No newline at end of file

src/controllers/ConteudoController.js

+// import Conteudo from "../models/Conteudo.js"
+
+//arquivo novo
+import AuthPermissao from "../middleware/AuthPermissao.js"
+
+class ConteudoController {
+
+  static listarConteudos = async (req,res) => {
+      try{
+
+          if(await AuthPermissao.verificarPermissao('conteúdos', 'get', req, res) !== false){
+              return
+          }
+
+          const modulo = req.query.modulo
+          const {page, perPage} = req.query
+
+          const options = {
+              modulo: (modulo),
+              page: parseInt(page) || 1,
+              limit: parseInt(perPage) > 5 ? 5 : parseInt(perPage) || 5
+          }
+
+          if(!modulo){
+              const conteudo = await conteudo.paginate({}, options)
+              let conteudoRetorn = JSON.parse(JSON.stringify(curso))
+    
+              return res.json(conteudoRetorn)
+
+            }else{
+              const conteudo = await conteudo.paginate({modulo: new RegExp(modulo, 'i')}, options)
+              let conteudoRetorn = JSON.parse(JSON.stringify(curso))
+    
+              return res.json(conteudoRetorn)
+            }       
+      }
+      
+      catch(err){
+          //console.error(err)
+          return res.status(500).json({error: true, code: 500, message: "Erro interno do Servidor"})
+      }
+  }
+
+  static listarConteudoPorId = async (req, res) => {
+      try{
+
+          if(await AuthPermissao.verificarPermissao('conteúdo', 'get', req, res) !== false){
+             return
+          }
+
+          const id = req.params.id
+
+          conteudos.findById(id).then(async (curso) =>{
+              //let conteudoRetorn = JSON.parse(JSON.stringify(curso))
+
+              return res.status(200).send(curso)
+          })
+          .catch((err)=> {
+            //console.log(err)
+            return res.status(404).json({ error: true, code: 404, message: "Conteúdo não encontrado!" })
+
+          })
+          
+      }catch(err){
+          //console.error(err);
+          return res.status(500).json({error: true, code: 500, message: "Erro interno do Servidor" })
+      }
+  }
+
+  static cadastrarConteudo = async (req, res) => {
+    try{
+
+        if(await AuthPermissao.verificarPermissao('conteudos', 'post', req, res) !== false){
+            return
+        }
+      
+        let conteudo = new conteudos(req.body);
+
+        let moduloExiste = await conteudos.findOne({modulo:req.body.modulo})
+
+        if(!moduloExiste){
+          
+          conteudo.save().then(() => {
+            res.status(201).send(conteudo.toJSON())
+          })
+          .catch((err) =>{
+              //console.log(err)
+              return res.status(422).json({ error: true, code: 422, message: "Erro nos dados, confira e repita!" })
+          })
+        }else if(moduloExiste){
+          return res.status(422).json({error: true, code: 422, message: "Modulo já cadastrado!" })
+        }
+
+    }catch(err){
+        //console.error(err);
+        return res.status(500).json({ error: true, code: 500, message: "Erro interno do Servidor" })
+    }
+  }
+
+  static atualizarConteudo = async (req,res) => {
+      try{
+
+          if(await AuthPermissao.verificarPermissao('conteudos', 'patch', req, res) !== false){
+            return
+          }
+          
+          var id = req.params.id
+          conteudos.findById(id).then(async ()=>{
+            let moduloExiste = await conteudos.findOne({modulo:req.body.modulo})
+            
+            if(moduloExiste){
+              return res.status(422).json({error: true, code: 422, message: "Modulo já cadastrado!" })
+            }
+            
+            conteudos.findByIdAndUpdate(id,{$set: req.body}).then(()=>{
+              res.status(201).json({ code: 201, message: 'Conteudo atualizado com sucesso!' })
+            })
+            .catch((err) => {
+              //console.log(err)
+              return res.status(422).json({ error: true, code: 422, message: "Erro nos dados, Verifique e tente novamente!" })
+            })
+          })
+          .catch((err)=> {
+            //console.log)(err)
+            return res.status(404).json({ error: true, code: 404, message: "Conteudo não encontrado!" })
+          })
+      }
+
+      catch(err){
+        //console.error(err);
+        return res.status(500).json({error: true, code: 500, message: "Erro interno do Servidor" })
+      }
+  }
+  
+  static excluirConteudo = async (req, res) => {
+      try{
+            
+          if(await AuthPermissao.verificarPermissao('conteúdos', 'delete', req, res) !== false){
+            return
+          }
+          
+          let id = req.params.id
+          
+          await conteudos.findById(id).then(() => {
+              conteudos.findByIdAndDelete(id).then(() => {
+                return res.status(200).json({code: 200, message: "Conteúdo excluído com sucesso!" })
+              }) 
+          })
+          .catch((err)=>{
+            //console.log(err)
+            return res.status(404).json({error: true,code: 404, message:"Conteúdo não Localizado!"})
+          })   
+      }
+        
+      catch(err){
+          //console.error(err);
+          return res.status(500).json({ error: true, code: 500, message: "Erro interno do Servidor" })
+      }
+  }
+}
+
+export default ConteudoController;
\ No newline at end of file

src/controllers/RecuperarSenhaController.js

+// PasswordController.js
+import User from "../models/User"; // Importe o modelo de usuário (ou onde você armazena informações de usuário)
+import bcrypt from "bcrypt"; // Para manipular senhas criptografadas
+import crypto from "crypto"; // Para gerar tokens seguros
+import { sendPasswordResetEmail } from "../utils/email"; // Utilitário para enviar e-mails de redefinição de senha
+
+const PasswordController = {
+  // Rota para solicitar redefinição de senha
+  resetPasswordRequest: async (req, res) => {
+    try {
+      const { email } = req.body;
+
+      // Verifique se o e-mail existe no banco de dados
+      const user = await User.findOne({ email });
+
+      if (!user) {
+        return res.status(404).json({ message: "E-mail não encontrado." });
+      }
+
+      // Crie um token seguro para a redefinição de senha
+      const token = crypto.randomBytes(20).toString("hex");
+
+      // Defina o token e a data de expiração no usuário
+      user.resetPasswordToken = token;
+      user.resetPasswordExpires = Date.now() + 3600000; // Token válido por 1 hora
+
+      // Salve as alterações no banco de dados
+      await user.save();
+
+      // Envie um e-mail com o link de redefinição de senha
+      await sendPasswordResetEmail(user.email, token);
+
+      return res.status(200).json({ message: "E-mail de redefinição de senha enviado." });
+    } catch (error) {
+      console.error(error);
+      return res.status(500).json({ message: "Erro interno do servidor." });
+    }
+  },
+
+  // Rota para definir uma nova senha
+  resetPassword: async (req, res) => {
+    try {
+      const { token, password } = req.body;
+
+      // Verifique se o token é válido e não expirou
+      const user = await User.findOne({
+        resetPasswordToken: token,
+        resetPasswordExpires: { $gt: Date.now() },
+      });
+
+      if (!user) {
+        return res.status(400).json({ message: "Token inválido ou expirado." });
+      }
+
+      // Defina a nova senha para o usuário
+      user.password = await bcrypt.hash(password, 10); // Criptografe a senha
+      user.resetPasswordToken = undefined;
+      user.resetPasswordExpires = undefined;
+
+      // Salve as alterações no banco de dados
+      await user.save();
+
+      return res.status(200).json({ message: "Senha redefinida com sucesso." });
+    } catch (error) {
+      console.error(error);
+      return res.status(500).json({ message: "Erro interno do servidor." });
+    }
+  },
+};
+
+export default PasswordController;

src/models/Conteudo.js

+import mongoose from "mongoose";
+import mongoosePaginate from "mongoose-paginate-v2";
+
+const { Schema, model } = mongoose;
+
+const videoSchema = new Schema({
+  nome: {
+    type: String,
+    required: true,
+    trim: true,
+  },
+  descricao: {
+    type: String,
+    required: true,
+  },
+  url: {
+    type: String,
+    required: true,
+    unique: true,
+  },
+  thumbnail: {
+    type: String,
+    required: true,
+  },
+  tema: String,
+  turma: String,
+});
+
+// Adicione o plugin mongoose-paginate-v2 ao schema
+videoSchema.plugin(mongoosePaginate);
+
+// Adicionar um método personalizado para criar um novo vídeo
+videoSchema.statics.criarVideo = async function (videoData) {
+  try {
+    const video = new this(videoData);
+    await video.save();
+    return video;
+  } catch (error) {
+    throw error;
+  }
+};
+
+// Adicionar um método personalizado para consultar vídeos por tema
+videoSchema.statics.obterVideosPorTemaPaginado = async function (tema, pagina, limite) {
+  try {
+    const options = {
+      page: pagina,
+      limit: limite,
+    };
+
+    const result = await this.paginate({ tema }, options);
+    return result;
+  } catch (error) {
+    throw error;
+  }
+};
+
+// Criar o modelo de vídeo
+const Video = model('Video', videoSchema);
+
+export default Video;

src/routes/RecuperarSenhaRoutes,js

+// routes.js
+import express from "express";
+import PasswordController from "./controllers/PasswordController";
+
+const router = express.Router();
+
+// Rota para solicitar redefinição de senha
+router.post("/password/reset-request", PasswordController.resetPasswordRequest);
+
+// Rota para definir uma nova senha
+router.post("/password/reset", PasswordController.resetPassword);
+
+export default router;