nodaje js

Cómo conectar mongodb y nodejs

Si vamos a usar un webservices vamos a necesitar conectar mongodb y nodejs para guardar información.

Recuerden ver nuestros otros post sobre este tema:

Mongoose para nodejs

vamos a instalar lo siguiente:

npm i mongoose –save

Este será nuestro conector para mongodb , tiene las funciones suficiente para hacer todo lo que necesitas en mongo.

Vamos a crear un documento nuevo llamado mongooseeconections.js

var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/ubikt', {
        useCreateIndex: true,
        useFindAndModify: false,
        useNewUrlParser: true
    }).then(db => console.log('conexion exitosa'))
    .catch(err => console.log('error: ', err))

si ejecutamos este código vamos a ver que se conecta a nuestra base de datos y nos dice conexion exitosa, no necesitamos crear nada ya que lo hace de forma automática.

Modelos para trabajar con mongodb y nodejs

Cada colección que tengamos en nuestro mongo debemos crear un modelo, esto ayuda para que siempre tengamos la misma estructura en todo nuestro código, llenemos información más fácil o podamos hacer validaciones.

const mongoose = require('mongoose');
const {
    Schema
} = mongoose;

const loginInfo = new Schema({
    userId: {
        type: String,
        unique: true,
        required: true
    },
    password: {
        type: String,
        required: true
    },
    date: {
        type: Date,
        default: Date.now
    },
    access: {
        type: Boolean,
        default: false
    },
    code: {
        type: String,
        required: true
    }
});

module.exports = mongoose.model('login', loginInfo);

Como podemos ver, de manera muy fácil colocamos qué valor son requeridos y cuáles no, si lo llenamos mal nos regresará un error diciendo que es requerido cierto valor.

Usando nuestros modelos

const express = require('express');
const router = express.Router();
const modelLogin = require('../model/Login');
'use strict';


router.post('/signup', async(req, res) => {
  
    var { user, pass } = req.body;
    // logica de login
    clave = 2212;
    let xlogin = new modelLogin({ user: user, pass: pass, code: clave })
    await xlogin.save((error, signup) => {
        if (error) {
            if (error.code == 11000) {
                responseb.error = true;
                responseb.codigo = 401;
                responseb.mensaje = 'Ya Existe este usuario';
                res.status(401).send({
                    responseb
                });

            } else {
                responseb.error = true;
                responseb.codigo = 304;
                responseb.mensaje = error.code;
                res.status(304).send({
                    responseb
                });

            }

        } else {
           responseb.error = true;
            responseb.codigo = 200;
            responseb.mensaje = {
                id: signup._id,
                tk: token

            };
            res.send({
                responseb
            });

        }

Si ponemos console.log a xlogin, vamos a ver que nos da la estructura de mongodb, pero no lo hemos guardado aún, para esto debemos usar nuestro método .save(), y await para que esperemos hasta que se guarde la información.

Cada que vamos a hacer un insert podemos hacerlo de esa manera, llenamos nuestro modelo y luego invocamos a .save().

otro ejemplo cree un modelo para perfil de usuario:

usri = new userinfo({
        email: req.body.email,
        name: req.body.name,
        lastName: req.body.lastName,
        lastName2: req.body.lastName2,
        idLocation: [],
        idFav: []
    })
usri.save((error, tok) => {
        if (error) {
            responseb.error = false;
            responseb.codigo = 400;
            responseb.mensaje = error;
            res.status(400).send(responseb)

        } else {
            responseb.error = false;
            responseb.codigo = 200;
            responseb.mensaje = tok._id;
            res.status(201).send(responseb)
        }
    })

Buscar en mongodb con mongoosee (fing y fingOne)

Para buscar información vamos a usar lo siguiente, vamos a usar nuestro modelo por ejemplo modelLogin ya que tenemos la estructura y el llamado de la colección.

Si vemos la documentación de mongo, para buscar un archivo, usamos el método fing()

para mongoosee usaremos el mismo método fing de la siguiente forma:

router.post('/login', (req, res) => {
    // logica de login
    modelLogin.find({ user: req.body.user, pass: req.body.pass }, (error, sok) => {
        if (error) {
            responseb.error = true;
            responseb.codigo = 304;
            responseb.mensaje = error;
            res.status(304).send({
                responseb
            });
        } else {
            if (sok.length == 0) {
                responseb.error = true;
                responseb.codigo = 404;
                responseb.mensaje = 'no se encontro ningun registro, comprueba contraseña sea correcta o el correo esta bien escrito';
                res.status(404).send({
                    responseb
                });
            } else {
                if (sok[0].access) {
                    
                    responseb.error = false;
                    responseb.codigo = 200;
                    responseb.mensaje = token;
                    res.send({
                        responseb
                    })
                } else {
                    responseb.error = true;
                    responseb.codigo = 403;
                    responseb.mensaje = 'no ha confirmado su correo, verifique su bandeja de entrada';
                    res.status(403).send({
                        responseb
                    })
                }

            }

        }

    });
});

Si queremos usar una busqueda mas especifica podemos usar findOne, traeremos solo un valor a comparación de find, que trae todos los valores que coinciden.

Update y delete con mongoosee y node js

Otros de los métodos que vamos a usar muy seguidos es el método update y delete para actualizar y borrar un registro.

Para borrar vamos a usar el metodo findOneAndDelete:

await modelLogin.findOneAndDelete({ _id: req.params.id }, (error, modify) => {
            if (error) {
                responseb.mensaje = error;
                responseb.error = true;
                responseb.codigo = 400;
                res.status(400).send(responseb);
            } else {
                responseb.mensaje = error;
                responseb.error = false;
                responseb.codigo = 201;
                res.status(201).send(responseb);
            }
        });

findOneAndXXXXXX, el primer parametro es una búsqueda especifica (como un where) enseguida, ese resultado no los regresa en un objeto y es el que vamos a modificar o borrar.

Si queremos actualizar usaremos el siguiente método findOneAndUpdate que es muy parecido al método anterior o podemos usar lo siguiente:

await userprop.findOne({ _id: req.params.id }, (error, modify) => {
            if (error) {
                responseb.mensaje = error;
                responseb.error = true;
                responseb.codigo = 400;
                res.status(400).send(responseb);
            } else {
                
                if (req.body.properties.user != undefined) {
                    modify.properties.user = req.body.properties.user;
                }
                
                console.log(modify)
                modify.save((error, tok) => {
                    if (error) {
                        responseb.mensaje = error;
                        responseb.error = true;
                        responseb.codigo = 400;
                        res.status(500).send(responseb);

                    } else {
                        responseb.mensaje = 'todo bien';
                        responseb.error = true;
                        responseb.codigo = 204;
                        res.status(204).send(responseb);

                    }
                })

            }
        });

Con este es un funcionamiento básico de esta gran herramienta.

recuerden seguirnos en telegram.

Deja un comentario

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.