MyApp.js

require('dotenv').config();
// const MongoClient = require("mongodb").MongoClient;
const mongoose = require('mongoose');
const uri = process.env['MONGO_URI'];
// mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true });
// mongoose.connection.on('open', function (ref) {
//     console.log('Connected to mongo server.');

// mongoose.connection.db.listCollections().toArray(function (err, names) {
//         console.log(names);
//     });
// })
/// create a connection to the DB
mongoose.set('strictQuery', true);
mongoose.connect(uri, {useNewUrlParser: true, useUnifiedTopology: true});
const db = mongoose.connection;

// Check DB Connection
db.once('open', () => {
(async () => {
    const data = await mongoose.connection.db.admin().command({
      listDatabases: 1,
    });
    console.log(data);
})();
console.log('Connected to MongoDB');
});

// Check for DB errors
db.on('error', (err) => {
console.log('DB Connection errors', err);
});
// dbs = mongoose.connection.db.listCollections().toArray()
// console.log(uri, mongoose.connection.readyState, dbs);

// const mongo_username = process.env["MONGO_USERNAME"];
// const mongo_password = process.env["MONGO_PASSWORD"];
// const uri = `mongodb+srv://${mongo_username}:${mongo_password}@cluster0-zrtwi.gcp.mongodb.net/crmdb?retryWrites=true&w=majority`;
// const client = new MongoClient(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });
// collection = client.db("sample_training").collection("people");
// console.log(collection)
// mongooseclient = mongoose.connect(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });

// const client = new MongoClient(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });
// baza = mongooseclient.then((db) => db.db("sample_training"));
// const collections = client.db('sample_training').collection('people');
// const databases = db.listCollections().toArray();
// console.log('current db', baza)

// 2. Create a Model
const Schema = mongoose.Schema;

const personSchema = new Schema({
name: {type: String, required: true},
age: Number,
favoriteFoods: [String]
});

const Person = mongoose.model('Person', personSchema);

// let Person;

const createAndSavePerson = (done) => {
done(null /*, data*/);
};

const createManyPeople = (arrayOfPeople, done) => {
done(null /*, data*/);
};

const findPeopleByName = (personName, done) => {
done(null /*, data*/);
};

const findOneByFood = (food, done) => {
done(null /*, data*/);
};

const findPersonById = (personId, done) => {
done(null /*, data*/);
};

const findEditThenSave = (personId, done) => {
const foodToAdd = "hamburger";

done(null /*, data*/);
};

const findAndUpdate = (personName, done) => {
const ageToSet = 20;

done(null /*, data*/);
};

const removeById = (personId, done) => {
done(null /*, data*/);
};

const removeManyPeople = (done) => {
const nameToRemove = "Mary";

done(null /*, data*/);
};

const queryChain = (done) => {
const foodToSearch = "burrito";

done(null /*, data*/);
};

/** **Well Done !!**
/* You completed these challenges, let's go celebrate !
*/

//----- **DO NOT EDIT BELOW THIS LINE** ----------------------------------

exports.PersonModel = Person;
exports.createAndSavePerson = createAndSavePerson;
exports.findPeopleByName = findPeopleByName;
exports.findOneByFood = findOneByFood;
exports.findPersonById = findPersonById;
exports.findEditThenSave = findEditThenSave;
exports.findAndUpdate = findAndUpdate;
exports.createManyPeople = createManyPeople;
exports.removeById = removeById;
exports.removeManyPeople = removeManyPeople;
exports.queryChain = queryChain;

/*
require('dotenv').config();

// 1. Install and Set Up Mongoose
const mongoose = require('mongoose');

const uri = process.env['MONGO_URI'];

mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true });

// 2. Create a Model
const Schema = mongoose.Schema;

const personSchema = new Schema({
name: {type: String, required: true},
age: Number,
favoriteFoods: [String]
});

const Person = mongoose.model('Person', personSchema);

// 3. Create and Save a Record of a Model
const createAndSavePerson = (done) => {
var janeFonda = new Person({
    name: "Jane Fonda",
    age: 84,
    favoriteFoods: ["eggs", "fish", "fresh fruit"]
});

janeFonda.save(function(err, data) {
    if (err) return console.error(err);
    done(null, data)
});
};

// 4. Create Many Records with model.create()
var arrayOfPeople = [
{name: "Frankie", age: 74, favoriteFoods: ["Del Taco"]},
{name: "Sol", age: 76, favoriteFoods: ["roast chicken"]},
{name: "Robert", age: 78, favoriteFoods: ["wine"]}
];

const createManyPeople = (arrayOfPeople, done) => {
Person.create(arrayOfPeople, function (err, people) {
    if (err) return console.log(err);
    done(null, people);
});
};

// 5. Use model.find() to Search Your Database
const findPeopleByName = (personName, done) => {
Person.find({name: personName}, function (err, personFound) {
    if (err) return console.log(err);
    done(null, personFound);
});
};

// 6. Use model.findOne() to Return a Single Matching Document from Your Database
const findOneByFood = (food, done) => {
Person.findOne({favoriteFoods: food}, function (err, data) {
    if (err) return console.log(err);
    done(null, data);
});
};

// 7. Use model.findById() to Search Your Database By _id
const findPersonById = (personId, done) => {
Person.findById(personId, function (err, data) {
    if (err) return console.log(err);
    done(null, data);
});
};

// 8. Perform Classic Updates by Running Find, Edit, then Save
const findEditThenSave = (personId, done) => {
const foodToAdd = 'hamburger';

// .findById() method to find a person by _id with the parameter personId as search key.
Person.findById(personId, (err, person) => {
    if(err) return console.log(err);

    // Array.push() method to add "hamburger" to the list of the person's favoriteFoods
    person.favoriteFoods.push(foodToAdd);

    // and inside the find callback - save() the updated Person.
    person.save((err, updatedPerson) => {
      if(err) return console.log(err);
      done(null, updatedPerson)
    })
})
};

// 9. Perform New Updates on a Document Using model.findOneAndUpdate()
const findAndUpdate = (personName, done) => {
const ageToSet = 20;

Person.findOneAndUpdate({name: personName}, {age: ageToSet}, {new: true}, (err, updatedDoc) => {
    if(err) return console.log(err);
    done(null, updatedDoc);
})
};

// 10. Delete One Document Using model.findByIdAndRemove
const removeById = (personId, done) => {
Person.findByIdAndRemove(
    personId,
    (err, removedDoc) => {
      if(err) return console.log(err);
      done(null, removedDoc);
    }
);
};

// 11. Delete Many Documents with model.remove()
const removeManyPeople = (done) => {
const nameToRemove = "Mary";
Person.remove({name: nameToRemove}, (err, response) => {
    if(err) return console.log(err);
    done(null, response);
})
};

// 12. Chain Search Query Helpers to Narrow Search Results
const queryChain = (done) => {
const foodToSearch = "burrito";

Person.find({ favoriteFoods: foodToSearch })
.sort({ name: 1 })
.limit(2)
.select({ age: 0 })
.exec(function(err, data) {
    if(err) return console.log(err);
    done(null, data);
});

};

/** **Well Done !!**
/* You completed these challenges, let's go celebrate !
*/

//----- **DO NOT EDIT BELOW THIS LINE** ----------------------------------

exports.PersonModel = Person;
exports.createAndSavePerson = createAndSavePerson;
exports.findPeopleByName = findPeopleByName;
exports.findOneByFood = findOneByFood;
exports.findPersonById = findPersonById;
exports.findEditThenSave = findEditThenSave;
exports.findAndUpdate = findAndUpdate;
exports.createManyPeople = createManyPeople;
exports.removeById = removeById;
exports.removeManyPeople = removeManyPeople;
exports.queryChain = queryChain;

*/

server.js

/********************************************
* DO NOT EDIT THIS FILE
* the verification process may break
*******************************************/

const express = require("express");
const app = express();
let mongoose;
try {
mongoose = require("mongoose");
} catch (e) {
console.log(e);
}
const fs = require("fs");
const path = require("path");
const bodyParser = require("body-parser");
const router = express.Router();

const enableCORS = function (req, res, next) {
if (!process.env.DISABLE_XORIGIN) {
    const allowedOrigins = ["https://www.freecodecamp.org"];
    const origin = req.headers.origin;
    if (!process.env.XORIGIN_RESTRICT || allowedOrigins.indexOf(origin) > -1) {
      console.log(req.method);
      res.set({
        "Access-Control-Allow-Origin": origin,
        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
        "Access-Control-Allow-Headers":
          "Origin, X-Requested-With, Content-Type, Accept",
      });
    }
}
next();
};

// global setting for safety timeouts to handle possible
// wrong callbacks that will never be called
const TIMEOUT = 10000;

app.use(bodyParser.urlencoded({ extended: "false" }));
app.use(bodyParser.json());

app.get("/", function (req, res) {
res.sendFile(path.join(__dirname, "views", "index.html"));
});

router.get("/file/*?", function (req, res, next) {
if (req.params[0] === ".env") {
    return next({ status: 401, message: "ACCESS DENIED" });
}
fs.readFile(path.join(__dirname, req.params[0]), function (err, data) {
    if (err) {
      return next(err);
    }
    res.type("txt").send(data.toString());
});
});

router.get("/is-mongoose-ok", function (req, res) {
if (mongoose) {
    res.json({ isMongooseOk: !!mongoose.connection.readyState });
} else {
    res.json({ isMongooseOk: false });
}
});

const Person = require("./myApp.js").PersonModel;

router.use(function (req, res, next) {
if (req.method !== "OPTIONS" && Person.modelName !== "Person") {
    return next({ message: "Person Model is not correct" });
}
next();
});

router.post("/mongoose-model", function (req, res, next) {
// try to create a new instance based on their model
// verify it's correctly defined in some way
let p;
p = new Person(req.body);
res.json(p);
});

const createPerson = require("./myApp.js").createAndSavePerson;
router.get("/create-and-save-person", function (req, res, next) {
// in case of incorrect function use wait timeout then respond
let t = setTimeout(() => {
    next({ message: "timeout" });
}, TIMEOUT);
createPerson(function (err, data) {
    clearTimeout(t);
    if (err) {
      return next(err);
    }
    if (!data) {
      console.log("Missing `done()` argument");
      return next({ message: "Missing callback argument" });
    }
    Person.findById(data._id, function (err, pers) {
      if (err) {
        return next(err);
      }
      res.json(pers);
      pers.remove();
    });
});
});

const createPeople = require("./myApp.js").createManyPeople;
router.post("/create-many-people", function (req, res, next) {
Person.remove({}, function (err) {
    if (err) {
      return next(err);
    }
    // in case of incorrect function use wait timeout then respond
    let t = setTimeout(() => {
      next({ message: "timeout" });
    }, TIMEOUT);
    createPeople(req.body, function (err, data) {
      clearTimeout(t);
      if (err) {
        return next(err);
      }
      if (!data) {
        console.log("Missing `done()` argument");
        return next({ message: "Missing callback argument" });
      }
      Person.find({}, function (err, pers) {
        if (err) {
          return next(err);
        }
        res.json(pers);
        Person.remove().exec();
      });
    });
});
});

const findByName = require("./myApp.js").findPeopleByName;
router.post("/find-all-by-name", function (req, res, next) {
let t = setTimeout(() => {
    next({ message: "timeout" });
}, TIMEOUT);
Person.create(req.body, function (err, pers) {
    if (err) {
      return next(err);
    }
    findByName(pers.name, function (err, data) {
      clearTimeout(t);
      if (err) {
        return next(err);
      }
      if (!data) {
        console.log("Missing `done()` argument");
        return next({ message: "Missing callback argument" });
      }
      res.json(data);
      Person.remove().exec();
    });
});
});

const findByFood = require("./myApp.js").findOneByFood;
router.post("/find-one-by-food", function (req, res, next) {
let t = setTimeout(() => {
    next({ message: "timeout" });
}, TIMEOUT);
let p = new Person(req.body);
p.save(function (err, pers) {
    if (err) {
      return next(err);
    }
    findByFood(pers.favoriteFoods[0], function (err, data) {
      clearTimeout(t);
      if (err) {
        return next(err);
      }
      if (!data) {
        console.log("Missing `done()` argument");
        return next({ message: "Missing callback argument" });
      }
      res.json(data);
      p.remove();
    });
});
});

const findById = require("./myApp.js").findPersonById;
router.get("/find-by-id", function (req, res, next) {
let t = setTimeout(() => {
    next({ message: "timeout" });
}, TIMEOUT);
let p = new Person({ name: "test", age: 0, favoriteFoods: ["none"] });
p.save(function (err, pers) {
    if (err) {
      return next(err);
    }
    findById(pers._id, function (err, data) {
      clearTimeout(t);
      if (err) {
        return next(err);
      }
      if (!data) {
        console.log("Missing `done()` argument");
        return next({ message: "Missing callback argument" });
      }
      res.json(data);
      p.remove();
    });
});
});

const findEdit = require("./myApp.js").findEditThenSave;
router.post("/find-edit-save", function (req, res, next) {
let t = setTimeout(() => {
    next({ message: "timeout" });
}, TIMEOUT);
let p = new Person(req.body);
p.save(function (err, pers) {
    if (err) {
      return next(err);
    }
    try {
      findEdit(pers._id, function (err, data) {
        clearTimeout(t);
        if (err) {
          return next(err);
        }
        if (!data) {
          console.log("Missing `done()` argument");
          return next({ message: "Missing callback argument" });
        }
        res.json(data);
        p.remove();
      });
    } catch (e) {
      console.log(e);
      return next(e);
    }
});
});

const update = require("./myApp.js").findAndUpdate;
router.post("/find-one-update", function (req, res, next) {
let t = setTimeout(() => {
    next({ message: "timeout" });
}, TIMEOUT);
let p = new Person(req.body);
p.save(function (err, pers) {
    if (err) {
      return next(err);
    }
    try {
      update(pers.name, function (err, data) {
        clearTimeout(t);
        if (err) {
          return next(err);
        }
        if (!data) {
          console.log("Missing `done()` argument");
          return next({ message: "Missing callback argument" });
        }
        res.json(data);
        p.remove();
      });
    } catch (e) {
      console.log(e);
      return next(e);
    }
});
});

const removeOne = require("./myApp.js").removeById;
router.post("/remove-one-person", function (req, res, next) {
Person.remove({}, function (err) {
    if (err) {
      return next(err);
    }
    let t = setTimeout(() => {
      next({ message: "timeout" });
    }, TIMEOUT);
    let p = new Person(req.body);
    p.save(function (err, pers) {
      if (err) {
        return next(err);
      }
      try {
        removeOne(pers._id, function (err, data) {
          clearTimeout(t);
          if (err) {
            return next(err);
          }
          if (!data) {
            console.log("Missing `done()` argument");
            return next({ message: "Missing callback argument" });
          }
          console.log(data);
          Person.count(function (err, cnt) {
            if (err) {
              return next(err);
            }
            data = data.toObject();
            data.count = cnt;
            console.log(data);
            res.json(data);
          });
        });
      } catch (e) {
        console.log(e);
        return next(e);
      }
    });
});
});

const removeMany = require("./myApp.js").removeManyPeople;
router.post("/remove-many-people", function (req, res, next) {
Person.remove({}, function (err) {
    if (err) {
      return next(err);
    }
    let t = setTimeout(() => {
      next({ message: "timeout" });
    }, TIMEOUT);
    Person.create(req.body, function (err, pers) {
      if (err) {
        return next(err);
      }
      try {
        removeMany(function (err, data) {
          clearTimeout(t);
          if (err) {
            return next(err);
          }
          if (!data) {
            console.log("Missing `done()` argument");
            return next({ message: "Missing callback argument" });
          }
          Person.count(function (err, cnt) {
            if (err) {
              return next(err);
            }
            if (data.ok === undefined) {
              // for mongoose v4
              try {
                data = JSON.parse(data);
              } catch (e) {
                console.log(e);
                return next(e);
              }
            }
            res.json({
              n: data.n,
              count: cnt,
              ok: data.ok,
            });
          });
        });
      } catch (e) {
        console.log(e);
        return next(e);
      }
    });
});
});

const chain = require("./myApp.js").queryChain;
router.post("/query-tools", function (req, res, next) {
let t = setTimeout(() => {
    next({ message: "timeout" });
}, TIMEOUT);
Person.remove({}, function (err) {
    if (err) {
      return next(err);
    }
    Person.create(req.body, function (err, pers) {
      if (err) {
        return next(err);
      }
      try {
        chain(function (err, data) {
          clearTimeout(t);
          if (err) {
            return next(err);
          }
          if (!data) {
            console.log("Missing `done()` argument");
            return next({ message: "Missing callback argument" });
          }
          res.json(data);
        });
      } catch (e) {
        console.log(e);
        return next(e);
      }
    });
});
});

app.use("/_api", enableCORS, router);

// Error handler
app.use(function (err, req, res, next) {
if (err) {
    res
      .status(err.status || 500)
      .type("txt")
      .send(err.message || "SERVER ERROR");
}
});

// Unmatched routes handler
app.use(function (req, res) {
if (req.method.toLowerCase() === "options") {
    res.end();
} else {
    res.status(404).type("txt").send("Not Found");
}
});

const listener = app.listen(process.env.PORT || 3000, function () {
console.log("Your app is listening on port " + listener.address().port);
});

/********************************************
* DO NOT EDIT THIS FILE
* the verification process may break
*******************************************/

MongoDB and Mongoose Challenges

This is the boilerplate for the MongoDB and Mongoose lessons. Instructions for completing these lessons start at https://www.freecodecamp.org/learn/apis-and-microservices/mongodb-and-mongoose/

package.json

{
"name": "fcc-mongo-mongoose-challenges",
"version": "0.0.1",
"description": "A boilerplate project",
"main": "server.js",
"scripts": {
    "start": "node server.js"
},
"dependencies": {
    "body-parser": "^1.15.2",
    "dotenv": "^8.2.0",
    "express": "^4.12.4",
    "mongodb": "^6.1.0",
    "mongoose": "^5.11.15"
},
"repository": {
    "type": "git",
    "url": "https://github.com/freeCodeCamp/boilerplate-mongomongoose.git"
},
"keywords": [
    "node",
    "mongoose",
    "express"
],
"license": "MIT"
}
sample.env

MONGO_URI=

views/index.html

<!DOCTYPE html>
<html>
<head>
    <title>MongoDB & Mongoose | freeCodeCamp.org</title>
    <link
      rel="shortcut icon"
      href="https://cdn.freecodecamp.org/universal/favicons/favicon-32x32.png"
      type="image/x-icon"
    />
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <style>
      body {
        background-color: #ddd;
        color: #333;
        font-family: sans-serif;
        text-align: center;
      }
    </style>
</head>

<body>
    <h1>MongoDB & Mongoose</h1>
</body>
</html>

Compiled blog

Pages

Wednesday, September 4, 2024

Boilerplate Mongoose MongoDB

MongoDB and Mongoose Challenges

Show IP and Country

Search This Blog

LinkedIn Profile

About Me

Useful Links

Blog Archive

Tags

2Performant

ProZ.com Jobs

TranslatorsCafe.com: Recent Translation Jobs

TranslatorsTown.com

Total Pageviews

Popular Posts

SmartCAT

Wikipedia

Google Translate

2performant

Compiled blog

Pages

Wednesday, September 4, 2024

Boilerplate Mongoose MongoDB

MongoDB and Mongoose Challenges

Show IP and Country

Search This Blog

LinkedIn Profile

About Me

Useful Links

Blog Archive

Tags

2Performant

ProZ.com Jobs

TranslatorsCafe.com: Recent Translation Jobs

TranslatorsTown.com

Total Pageviews

Popular Posts

Subscribe To

SmartCAT

Wikipedia

Google Translate

2performant