Produccion

README.md

@@ -45,3 +45,4 @@ Any issues or feature requests can be raised on the [Issues page](https://github
 ## License
 
 This template repository is [MIT licensed](LICENSE).
+

app.js

@@ -1,7 +1,5 @@
-const express = require('express');
-const app = express();
-const port = process.env.PORT ?? 3000;
 
+/*
 app.use(express.static('public'))
 
 app.get('*', (req, res) => {
@@ -10,4 +8,32 @@ app.get('*', (req, res) => {
 
 app.listen(port, () => {
     console.log(`App listening on port ${port}`);
-})
+})
+
+
+*/
+
+import express from "express";
+import cors from "cors";
+import cookieParser from "cookie-parser";
+import createConnection from './config/ConnectMongodb.js';
+import * as personaRouter from './router/RouterPersona.js';
+import * as userRouter from './router/RouterUser.js';
+
+const app = express();
+const port = process.env.PORT ?? 3000;;
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.use(cookieParser());
+app.use(cors({ credentials: true }));
+
+createConnection();
+
+app.use(personaRouter.router);
+app.use(userRouter.router);
+
+app.listen(port, () => {
+    console.log('server is runing on port ', port)
+});

compose-dev.yaml

@@ -0,0 +1,13 @@
+services:
+  app:
+    build:
+      context: .  # Asegúrate de que el Dockerfile esté en el mismo directorio que el docker-compose
+      dockerfile: Dockerfile  # Puedes especificar un nombre diferente si tu Dockerfile tiene un nombre distinto
+    entrypoint:
+      - sleep
+      - infinity
+    init: true
+    volumes:
+      - type: bind
+        source: /var/run/docker.sock
+        target: /var/run/docker.sock

config/ConnectMongodb.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+//{ useNewUrlParser: true, useUnifiedTopology: true }
+const createConnection = () => {
+    mongoose
+        .connect("mongodb+srv://lguerrero:aR2dde7ea0UZYGXN@atlasmongofullstackmern.nglsbuq.mongodb.net/Persona")
+        .then(() => {
+            console.log("conectado a la BD correctamente");
+        })
+        .catch((e) => {
+            console.log(e);
+        });
+};
+
+export default createConnection;

config/jwt.config.js

@@ -0,0 +1,30 @@
+import jwt from 'jsonwebtoken';
+
+const secret = "mysecret";
+
+const authenticate = (req, res, next) => {
+    // Verifica si existe la cookie del token
+    const cookies = req;
+    const token = req;
+    console.log(cookies);
+    console.log(token);
+
+    if (!token) {
+        // Si no hay token, retorna un error no autorizado (401)
+        return res.status(401).json({ verified: false, message: 'Unauthorized' });
+    }
+
+    // Verifica el token
+    jwt.verify(token, secret, (err, payload) => {
+        if (err) {
+            // Si hay un error en la verificación, retorna un error no autorizado (401)
+            return res.status(401).json({ verified: false, message: 'Unauthorized' });
+        } else {
+            // Si la verificación es exitosa, establece el usuario en la sesión
+            req.user = payload;
+            next();
+        }
+    });
+};
+
+export { authenticate };

controllers/ContrPersona.js

@@ -0,0 +1,75 @@
+import Persona from "../models/ModelPersona.js";
+
+
+const createPersona = async (req, res) => {
+    try {
+        console.log(req.body);
+        let personData = req.body;
+        let newPersona = await Persona.create(personData)
+        res.status(200).json(newPersona);
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const getPersona = async (req, res) => {
+    try {
+        let personaList = await Persona.find();
+        res.status(200).json(personaList);
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const getOnePersona = async (req, res) => {
+    try {
+
+        let id = req.params.id;
+        let personaList = await Persona.find(id);
+        res.status(200).json(personaList);
+
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const updatePersona = async (req, res) => {
+    try {
+        let id = req.params.id;
+        let updatePersona = await Persona.findByIdAndUpdate(id, req.body, { new: true })
+        res.status(200).json(updatePersona);
+
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const deletePersona = async (req, res) => {
+    try {
+
+        let persona = await Persona.findById(id);
+        if (!persona) {
+
+            res.status(400).json({ message: "Persona not found", });
+
+        }
+        await Persona.findByIdAndDelete(id)
+
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+
+export {
+    createPersona,
+    getPersona,
+    getOnePersona,
+    updatePersona,
+    deletePersona
+};

controllers/ContrUser.js

@@ -0,0 +1,146 @@
+import User from "../models/ModelUser.js";
+import bcrypt from "bcrypt"
+import jwt from "jsonwebtoken"
+
+
+const loginUser = async (req, res) => {
+    const { email, password } = req.body;
+    console.log(req.body)
+    try {
+        const user = await User.findOne({ email });
+        if (user) {
+            const passwordIsValid = await bcrypt.compare(password, user.password);
+
+            if (passwordIsValid) {
+                const newJWT = jwt.sign({ _id: user._id }, "mysecret");
+                console.log(newJWT);
+                res.cookie("usertoken", newJWT, { httpOnly: true }).json({ success: true, user: user });
+            } else {
+                res.status(500).json({ success: false });
+            }
+        } else {
+            res.status(500).json({ success: false });
+        }
+    } catch (error) {
+        console.error('Error en la autenticación:', error);
+        res.status(500).json({ success: false, error: 'Error en la autenticación' });
+    }
+};
+
+const registerUser = async (req, res) => {
+    try {
+        // Extraer datos del cuerpo de la solicitud
+        const { firstName, lastName, email, password, confirmPassword } = req.body;
+        // Verificar si la contraseña y la confirmación coinciden
+        if (password !== confirmPassword) {
+            return res.status(400).json({ success: false, message: 'Password and confirmPassword do not match' });
+        }
+        // Hash de la contraseña
+        const hashedPassword = await bcrypt.hash(password, 10);
+        // Crear una instancia del modelo User
+        const user = new User({ firstName, lastName, email, password: hashedPassword, confirmPassword: hashedPassword });
+        // Guardar el usuario en la base de datos
+        await user.save();
+        // Devolver una respuesta exitosa
+        res.status(201).json({ success: true, message: 'User registered successfully' });
+    } catch (error) {
+        // Manejar errores durante el registro
+        console.error(error);
+        // Verificar si el error es de validación (por ejemplo, contraseña no coincidente)
+        if (error.errors) {
+            const validationErrors = Object.values(error.errors).map(err => err.message);
+            return res.status(400).json({ success: false, errors: validationErrors });
+        }
+        // Otros errores, devolver un mensaje genérico de error
+        res.status(500).json({ success: false, message: 'Error registering user' });
+    }
+};
+
+const logoutUser = (req, res) => {
+    try {
+        // Eliminar la cookie del token de usuario
+        res.clearCookie('usertoken', { httpOnly: true });
+        // Respondemos con un código 200 (OK) para indicar que el cierre de sesión fue exitoso
+        res.status(200).json({ success: true, message: 'Logout successful' });
+    } catch (error) {
+        console.error('Error during logout:', error);
+        res.status(500).json({ success: false, error: 'Error during logout' });
+    }
+};
+
+
+const createUser = async (req, res) => {
+    try {
+        console.log(req.body);
+        let personData = req.body;
+        let newUser = await User.create(personData)
+        res.status(200).json(newUser);
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const getUser = async (req, res) => {
+    try {
+        let userList = await User.find();
+        res.status(200).json(userList);
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const getOneUser = async (req, res) => {
+    try {
+
+        let id = req.params.id;
+        let userList = await User.find(id);
+        res.status(200).json(userList);
+
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const updateUser = async (req, res) => {
+    try {
+        let id = req.params.id;
+        let updateUser = await User.findByIdAndUpdate(id, req.body, { new: true })
+        res.status(200).json(updateUser);
+
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+const deleteUser = async (req, res) => {
+    try {
+
+        let user = await User.findById(id);
+        if (!user) {
+
+            res.status(400).json({ message: "User not found", });
+
+        }
+        await User.findByIdAndDelete(id)
+
+    } catch (e) {
+        console.log("Error", + e)
+        res.status(400).json({ message: e.message, });
+    }
+};
+
+
+export {
+    createUser,
+    getUser,
+    getOneUser,
+    updateUser,
+    deleteUser,
+    registerUser,
+    loginUser,
+    logoutUser
+};

models/ModelPersona.js

@@ -0,0 +1,32 @@
+import mongoose from "mongoose"
+
+const PersonaSchema = new mongoose.Schema(
+    {
+        firstName: {
+            type: String,
+            required: [true, "First name is required"]
+        },
+        lastName: {
+            type: String,
+            required: [true, "Last name is required"]
+        },
+        email: {
+            type: String,
+            required: [true, "Email is required"],
+            unique: true,
+        },
+        password: {
+            type: String,
+            required: [true, "Password is required"],
+            minlength: [8, "Password must be 8 characters or longer"]
+        },
+        confirmPassword: {
+            type: String,
+            required: [true, "Password is required"]
+        }
+    },
+    { timesstamps: true }
+)
+const Persona = mongoose.model('Persona', PersonaSchema);
+export default Persona;
+