redefine/add few stuff

Author: osamaakb

module3-crud-and-data-models/r1-schema-and-data-models/README.md

@@ -2,20 +2,7 @@
 
 A database schema is a blueprint or architecture of how our data will look. It doesn’t hold data itself, but instead describes the shape of the data and how it might relate to other tables or models.
 
-<<<<<<< HEAD
 For example, this is a `customer` schema in MongoDB using mongoose.
-=======
-A database model is a type of data model that determines the logical structure of a database. It is the high level design which defines the kind of tables, the `fields` in those tables and the `relations` between different tables.
-
-The most popular example of a database model is the relational model, which uses a table-based format, which is the one we use in most SQL databases.
-
-### What are database schemas?
-
-A database schema is a `blueprint` or `architecture` of how our data will look. It doesn’t hold data itself, but instead describes the shape of the data and how it might relate to other tables or models.
-
-For example, This is a `Customer` schema in mongoDB using mongoose.
-
-> > > > > > > c7eff66f097a2a47f25f1ab1b06941e77c329eb9
 
 ```js
 const mongoose = require("mongoose");
@@ -111,15 +98,3 @@ Request:
 - [What is REST](https://restfulapi.net/)
 - [See this](https://www.educative.io/blog/crud-operations#what) for more information on how CRUD operations are performed directly on `SQL` database.
 - [database schemas](https://www.educative.io/blog/what-are-database-schemas-examples#types)
-
-```
-
-```
-
-```
-
-```
-
-```
-
-```

module3-crud-and-data-models/r3-model-view-controller/README.md

@@ -2,8 +2,8 @@
 
 ## Introduction to MVC projects
 
-When beginning a new project, there are several different methods that can be used to set up the overall file structure and flow. One of the most commonly used architectural patterns is called MVC. This is an acronym for `Model`, `View`, `Controller`.
-This pattern is favored because of its alignment with the computer science design principle, Separation of Concerns. By dividing up responsibilities within our file structure, we can encapsulate information to be referred to via abstraction and maintain cleaner codebases.
+When beginning a new project (especially, when using express), there are several different methods that can be used to set up the overall file structure and flow. One of the most commonly used architectural patterns is called MVC. this acronym stands for "Model, View, Controller".
+This pattern is favored because of its alignment with the computer science design principle, [**separation of concerns**](https://en.wikipedia.org/wiki/Separation_of_concerns). By dividing up responsibilities within our file structure, for example, we can have our db connection work in one file and api routes in another file, ...etc.
 
 ```
 app-name-here
@@ -17,9 +17,17 @@ package.json
 package-lock.json
 ```
 
+### Components Of MVC
+
+**Model:** This consists of the structure of our data and handle the database.
+
+**View:** The part of our application which is shown to the user.
+
+**Controller:** Controller has all the logic to control and respond to the action, the user performs using the views.
+
 ### Models
 
-In the models folder, the files will contain our schema definition and expected fields for the model.
+In this folder, you can write the functionality & logics related to the Database (if you aren't using ORM) like insert, fetch, update, delete queries. It takes the query request from the controller & sends the response back to the controller.
 The naming convention for the model files is: `name-here-model.js`.
 
 Here’s an example model using JavaScript and mongoose.
@@ -53,6 +61,7 @@ module.exports = mongoose.model("Post", post);
 ### Controllers
 
 Controllers are the layer between the Model and the View. the views can use the controllers to `add`, `read`, `delete`, ...etc data.
+In controllers, you can write the functionality & logic to develop dynamic web applications. It takes the data request from the views & sends it to the model and sends the response back to the views.
 The naming convention for the model files is: `name-here-controller.js`.
 
 Here is an example:
@@ -76,8 +85,10 @@ router.get('/posts', (req, res) => {
 
 ### Views
 
-In a back-end application, views are usually not implemented and rather we create a front-end app using maybe `React` to call our `api` end-points to manipulate the data in the back-end.
+In this folder, you can write HTML code for displaying a web page on the web browser. You can send the data from the controller to view for displaying data dynamically.
+In a back-end application, views are usually not implemented and rather we create a front-end app using maybe `React` to call our `api` end-points to manipulate and dispaly the data in the back-end.
 
 ## Resources
 
 - [MVC Architecture with NodeJS and mongoose](https://medium.com/geekculture/mvc-architecture-with-express-server-e35aedfe7889)
+- [express MVC structure](https://codingstatus.com/express-mvc-structure/)

module3-crud-and-data-models/r3.2-models-and-controllers-in-mongoose/README.md

@@ -31,7 +31,7 @@ module.exports = Food;
 And we are required to do the CRUD operation on this model, how can we acheive that with mongoose?
 we will first create a `food-conroller` for all the food requests and place all requests in there.
 
-#### Read
+- #### Read
 
 To get all the foods from our MongoDB using mongoose we can simply use the `find({})` function.
 
@@ -54,7 +54,7 @@ app.get("/foods", async (request, response) => {
 module.exports = app;
 ```
 
-#### Create
+- #### Create
 
 Create or add a new `food` item to our foods.
 
@@ -72,7 +72,7 @@ app.post("/food", async (request, response) => {
 // ...
 ```
 
-#### Update
+- #### Update
 
 To update an item, we need to first make sure it exist by using the id to find it and then updating it, using the`findByIdAndUpdate()`, and then save the new item in the database.
 
@@ -91,7 +91,7 @@ app.patch("/food/:id", async (request, response) => {
 // ...
 ```
 
-#### Delete
+- #### Delete
 
 To delete, we need to check if the item exist by using the id to find it and then delete it, we us `findByIdAndDelete()`.