Merge remote-tracking branch 'origin/master'

# Conflicts:
#	shared/middleware/advanced-result.js

feature/carburant/controller/carburant.controller.js

@@ -0,0 +1,53 @@
+const CarburantModel = require("../model/carburant.model")
+
+
+//getAll
+module.exports.getAll = (async (req, res)=>{
+
+
+    //res.status(200).json({success: true, data : carburant});
+    res.status(200).json(res.advancedResults);
+})
+
+//getById
+module.exports.getById = (async (req, res)=>{
+    //req.params.id
+    const carburant = await CarburantModel.findById(req.params.id);
+    if(!carburant){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+    res.status(200).json({success: true, data :carburant });
+})
+
+//create
+module.exports.create = (async (req, res)=>{
+    let carburant = req.body;
+    carburant = await CarburantModel.create(carburant);
+    res.status(200).json({success: true, data :carburant });
+})
+
+//update
+module.exports.update = (async (req, res)=>{
+    let carburant = await CarburantModel.findById(req.params.id);
+    if(!carburant){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await CarburantModel.updateOne({_id:req.params.id}, req.body);
+    carburant = await CarburantModel.findById(req.params.id);
+    res.status(200).json({success: true, data :carburant });
+})
+
+//delete
+module.exports.delete = (async (req, res)=>{
+    let carburant = await CarburantModel.findById(req.params.id);
+    if(!carburant){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await CarburantModel.deleteOne({_id:req.params.id});
+    res.status(200).json({success: true, data :{} });
+})

feature/carburant/model/carburant.model.js

@@ -0,0 +1,20 @@
+const mongoose = require("mongoose");
+
+const  schema=  mongoose.Schema({
+    //String, Number, Boolean, MongoObject, Object
+    type: {
+        type: String,
+        default: ""
+    },
+    prix: {
+        type: String,
+        default: ""
+    }
+}, { timestamps : true});
+
+
+
+
+module.exports = mongoose.model('carburant', schema, 'carburants');
+
+

feature/carburant/route/carburant.route.js

@@ -0,0 +1,27 @@
+const express = require("express");
+const router = express.Router();
+const carburantController = require("../controller/carburant.controller");
+const carburantModel = require("../model/carburant.model");
+const advancedResults = require("../../../shared/middleware/advanced-result")
+
+//get All
+//router.route('/').get(carburantController.getAll);
+
+router
+    .route('/')
+    .get(advancedResults(carburantModel), carburantController.getAll) // path , ref et nom de l'entité
+
+
+//getById
+router.route('/:id').get(carburantController.getById);
+
+//create
+router.route('/').post(carburantController.create);
+
+//update
+router.route('/:id').put(carburantController.update);
+
+//delete
+router.route('/:id').delete(carburantController.delete);
+
+module.exports = router

feature/contact/controller/contact.controller.js

@@ -0,0 +1,69 @@
+const ContactModel= require('../model/contact.model')
+
+//getAll :
+
+module.exports.getAll =(async(req,res)=>{
+    // const contacts= await ContactModel.find({})
+    res.status(200).json(res.advancedResults);
+})
+
+
+//getById :
+
+module.exports.getById= (async(req,res)=>{
+     const contact= await ContactModel.findById(req.params.id)
+    if(!contact){
+        res.status(200).json({success: false,data: "NoData"});
+        return;
+    }
+    res.status(200).json({success: true, data: contact})
+})
+
+
+//getOne :
+
+module.exports.getOne= (async(req,res)=>{
+    const contact= await ContactModel.findOne({lastname: req.params.lastname});
+    if(!contact){
+        res.status(200).json({success: false,data: "NoData"});
+        return;
+    }
+    res.status(200).json({success: true,data: contact});
+})
+
+
+//create :
+
+module.exports.create= (async(req,res)=>{
+    let contact= req.body
+    contact= await ContactModel.create(contact);
+    res.status(200).json({success: true,data: contact})
+})
+
+
+//update :
+
+module.exports.update= async(req,res)=>{
+    let contact= await ContactModel.findById(req.params.id);
+    if(!contact){
+        res.status(200).json({success:false,data: "NoData"})
+        return
+    }
+    await ContactModel.updateOne({_id: req.params.id},req.body)
+    contact= await ContactModel.findById(req.params.id)
+    res.status(200).json({success: true,data: contact})
+}
+
+
+//delete :
+
+module.exports.delete= (async(req,res)=>{
+    let contact= await ContactModel.find({})
+    if(!contact){
+        res.status(200).json({sucess: false,data: "NoData"})
+        return
+    }
+    await ContactModel.deleteOne({_id: req.params.id})
+    res.status(200).json({success: true, data: {}})
+})
+

feature/contact/model/contact.model.js

@@ -0,0 +1,42 @@
+const mongoose = require('mongoose');
+const schema = new mongoose.Schema({
+    codeObject: String,
+    lastname: {
+        type: String,
+        require: true,
+        maxLength: 70,
+        minLength: 2,
+        default: ''
+    },
+    firstname: {
+        type: String,
+        require: true,
+        maxLength: 70,
+        default: ""
+    },
+    phone: {
+        type: String,
+        require: true,
+        maxLength: 20,
+        default: ""
+    },
+    mail: {
+        type: String,
+        require: true,
+        default: ""
+    },
+    vehicle: {
+        type: mongoose.Schema.ObjectId,
+        ref: 'vehicle'
+    },
+    status: String,
+    // createdBy: {
+    //     type: String,
+    //     ref: 'user'
+    // }
+},
+    {
+        timestamps:true
+    })
+
+module.exports= mongoose.model('contact',schema)

feature/contact/route/contact.route.js

@@ -0,0 +1,32 @@
+const contactController= require('../controller/contact.controller')
+const advancedResults = require('../../../shared/middleware/advanced-result')
+const ContactModel= require('../model/contact.model')
+
+const router= require('express').Router()
+
+//getAll :
+
+router.route('/').get(advancedResults(ContactModel),contactController.getAll)
+
+//getById :
+
+router.route('/:id').get(contactController.getById)
+
+
+//getOne :
+
+router.route('/lastname/:lastname').get(contactController.getOne)
+
+
+//create :
+
+router.route('/').post(contactController.create)
+
+//update :
+router.route('/:id').put(contactController.update)
+
+//delete :
+
+router.route('/:id').delete(contactController.delete)
+
+module.exports=router;

feature/place/controller/place.controller.js

@@ -0,0 +1,52 @@
+const PlaceModel = require("../model/place.model")
+
+
+
+module.exports.getAll = (async (req, res)=>{
+
+
+    res.status(200).json(res.advancedResults);
+})
+
+//getById
+module.exports.getById = (async (req, res)=>{
+    //req.params.id
+    const place = await PlaceModel.findById(req.params.id);
+    if(!place){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+    res.status(200).json({success: true, data :place });
+})
+
+//create
+module.exports.create = (async (req, res)=>{
+    let place = req.body;
+    place = await PlaceModel.create(place);
+    res.status(200).json({success: true, data :place });
+})
+
+//update
+module.exports.update = (async (req, res)=>{
+    let place = await PlaceModel.findById(req.params.id);
+    if(!place){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await PlaceModel.updateOne({_id:req.params.id}, req.body);
+    place = await PlaceModel.findById(req.params.id);
+    res.status(200).json({success: true, data :place });
+})
+
+//delete
+module.exports.delete = (async (req, res)=>{
+    let place = await PlaceModel.findById(req.params.id);
+    if(!place){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await PlaceModel.deleteOne({_id:req.params.id});
+    res.status(200).json({success: true, data :{} });
+})

feature/place/model/place.model.js

@@ -0,0 +1,40 @@
+const mongoose = require("mongoose");
+
+const schema = new mongoose.Schema({
+    //String, Number, Boolean, MongoObject, Object
+    etage: {
+        type:String,
+        default: ""
+    },
+    taille: {
+        type:String,
+        default: ""
+    },
+    disponibilite: {
+        type:String,
+        default: ""
+    },
+    vehiculeOccupe: {
+        type:String,
+        default: ""
+    },
+    dateEntree: {
+        type:String,
+        default: ""
+    },
+
+    dateSortie: {
+        type:String,
+        default: ""
+    },
+
+    proprietaire: {
+        type:String,
+        default: ""
+    }
+
+
+
+}, { timestamps : true});
+
+module.exports = mongoose.model('place', schema, 'places');

feature/place/route/place.route.js

@@ -0,0 +1,27 @@
+const express = require("express");
+const router = express.Router();
+const placeController = require("../controller/place.controller");
+const PlaceModel = require("../model/place.model");
+const advancedResults = require("../../../shared/middleware/advanced-result")
+
+//get All
+//router.route('/').get(vehicleController.getAll);
+
+router
+    .route('/')
+    .get(advancedResults(PlaceModel), placeController.getAll) // path , ref et nom de l'entité
+
+
+//getById
+router.route('/:id').get(placeController.getById);
+
+//create
+router.route('/').post(placeController.create);
+
+//update
+router.route('/:id').put(placeController.update);
+
+//delete
+router.route('/:id').delete(placeController.delete);
+
+module.exports = router

feature/problem/controller/problem.controller.js

@@ -0,0 +1,69 @@
+const ProblemModel= require('../model/problem.model')
+
+//getAll :
+
+module.exports.getAll =(async(req,res)=>{
+    // const problems= await ProblemModel.find({});
+    res.status(200).json(res.advancedResults);
+})
+
+
+//getById :
+
+module.exports.getById= (async(req,res)=>{
+    const problem= await ProblemModel.findById(req.params.id)
+    if(!problem){
+        res.status(200).json({success: false,data: "NoData"});
+        return;
+    }
+    res.status(200).json({success: true, data: problem})
+})
+
+
+//getOne :
+
+module.exports.getOne= (async(req,res)=>{
+    const problem= await ProblemModel.findOne({lastname: req.params.lastname});
+    if(!problem){
+        res.status(200).json({success: false,data: "NoData"});
+        return;
+    }
+    res.status(200).json({success: true,data: problem});
+})
+
+
+//create :
+
+module.exports.create= (async(req,res)=>{
+    let problem= req.body
+    problem= await ProblemModel.create(problem);
+    res.status(200).json({success: true,data: problem})
+})
+
+
+//update :
+
+module.exports.update= (async(req,res)=>{
+    let problem= await ProblemModel.findById(req.params.id);
+    if(!problem){
+        res.status(200).json({success:false,data: "NoData"})
+        return
+    }
+    await ProblemModel.updateOne({_id: req.params.id},req.body)
+    problem= await ProblemModel.findById(req.params.id)
+    res.status(200).json({success: true,data: problem})
+})
+
+
+//delete :
+
+module.exports.delete= (async(req,res)=>{
+    let problem= await ProblemModel.find({})
+    if(!problem){
+        res.status(200).json({success: false,data: "NoData"})
+        return
+    }
+    await ProblemModel.deleteOne({_id: req.params.id})
+    res.status(200).json({success: true, data: {}})
+})
+

feature/problem/model/problem.model.js

@@ -0,0 +1,36 @@
+const mongoose= require('mongoose')
+
+const schema= new mongoose.Schema({
+    codeObject: String,
+    description: {
+        type: String,
+        default: ""
+    },
+    date: {
+        type: String,
+        default: ""
+    },
+    state: {
+        type: String,
+        default: ""
+    },
+    status: {
+        type: String,
+        default: ""
+    },
+    vehicle: {
+        type: mongoose.Schema.ObjectId,
+        ref: 'vehicle'
+    },
+    createdBy: {
+        type: mongoose.Schema.ObjectId,
+        ref: 'user'
+    }
+
+
+},
+    {
+        timestamps: true
+    })
+
+module.exports=mongoose.model('problem',schema)

feature/problem/route/problem.route.js

@@ -0,0 +1,35 @@
+const problemController= require('../controller/problem.controller')
+
+const advancedResults= require('../../../shared/middleware/advanced-result')
+
+const ProblemModel= require('../model/problem.model')
+
+const router= require('express').Router()
+
+//getAll :
+
+router.route('/').get(advancedResults(ProblemModel),problemController.getAll)
+
+//getById :
+
+router.route('/:id').get(problemController.getById)
+
+
+//getOne :
+
+router.route('/lastname/:lastname').get(problemController.getOne)
+
+
+//create :
+
+router.route('/').post(problemController.create)
+
+//update :
+router.route('/:id').put(problemController.update)
+
+//delete :
+
+router.route('/:id').delete(problemController.delete)
+
+module.exports=router;
+

feature/service/controller/service.controller.js

@@ -0,0 +1,53 @@
+const ServiceModel = require("../model/service.model")
+
+
+//getAll
+module.exports.getAll = (async (req, res)=>{
+
+
+
+    res.status(200).json(res.advancedResults);
+})
+
+//getById
+module.exports.getById = (async (req, res)=>{
+    //req.params.id
+    const service = await ServiceModel.findById(req.params.id);
+    if(!service){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+    res.status(200).json({success: true, data :service });
+})
+
+//create
+module.exports.create = (async (req, res)=>{
+    let service = req.body;
+    service = await ServiceModel.create(service);
+    res.status(200).json({success: true, data :service });
+})
+
+//update
+module.exports.update = (async (req, res)=>{
+    let service = await ServiceModel.findById(req.params.id);
+    if(!service){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await ServiceModel.findByIdAndUpdate({_id:req.params.id}, req.body);
+    service = await ServiceModel.findById(req.params.id);
+    res.status(200).json({success: true, data :service });
+})
+
+//delete
+module.exports.delete = (async (req, res)=>{
+    let service = await ServiceModel.findById(req.params.id);
+    if(!service){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await ServiceModel.deleteOne({_id:req.params.id});
+    res.status(200).json({success: true, data :{} });
+})

feature/service/model/service.model.js

@@ -0,0 +1,32 @@
+const mongoose = require("mongoose");
+
+const schema =  mongoose.Schema({
+    //String, Number, Boolean, MongoObject, Object
+    vente: {
+        type:String,
+        default: ""
+    },
+    financement: {
+        type:String,
+        default: ""
+    },
+    assurance: {
+        type:String,
+        default: ""
+    },
+    programme: {
+        type:String,
+        default: ""
+    },
+    location: {
+        type:String,
+        default: ""
+    },
+
+    gestion: {
+        type:String,
+        default: ""
+    }
+}, { timestamps : true});
+
+module.exports = mongoose.model('service', schema, 'services');

feature/service/route/service.route.js

@@ -0,0 +1,27 @@
+const express = require("express");
+const router = express.Router();
+const serviceController = require("../controller/service.controller");
+const ServiceModel = require("../model/service.model");
+const advancedResults = require("../../../shared/middleware/advanced-result")
+
+//get All
+//router.route('/').get(vehicleController.getAll);
+
+router
+    .route('/')
+    .get(advancedResults(ServiceModel), serviceController.getAll) // path , ref et nom de l'entité
+
+
+//getById
+router.route('/:id').get(serviceController.getById);
+
+//create
+router.route('/').post(serviceController.create);
+
+//update
+router.route('/:id').put(serviceController.update);
+
+//delete
+router.route('/:id').delete(serviceController.delete);
+
+module.exports = router

feature/utilisateur/controller/utilisateur.controller.js

@@ -0,0 +1,53 @@
+const UtilisateurModel = require("../model/utilisateur.model")
+
+
+//getAll
+module.exports.getAll = (async (req, res)=>{
+
+
+    //res.status(200).json({success: true, data : utilisateur});
+    res.status(200).json(res.advancedResults);
+})
+
+//getById
+module.exports.getById = (async (req, res)=>{
+    //req.params.id
+    const utilisateur = await UtilisateurModel.findById(req.params.id);
+    if(!utilisateur){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+    res.status(200).json({success: true, data :utilisateur });
+})
+
+//create
+module.exports.create = (async (req, res)=>{
+    let utilisateur = req.body;
+    utilisateur = await UtilisateurModel.create(utilisateur);
+    res.status(200).json({success: true, data :utilisateur });
+})
+
+//update
+module.exports.update = (async (req, res)=>{
+    let utilisateur = await UtilisateurModel.findById(req.params.id);
+    if(!utilisateur){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await UtilisateurModel.updateOne({_id:req.params.id}, req.body);
+    utilisateur = await UtilisateurModel.findById(req.params.id);
+    res.status(200).json({success: true, data :utilisateur });
+})
+
+//delete
+module.exports.delete = (async (req, res)=>{
+    let utilisateur = await UtilisateurModel.findById(req.params.id);
+    if(!utilisateur){
+        res.status(200).json({success: false, data : "noData"});
+        return;
+    }
+
+    await UtilisateurModel.deleteOne({_id:req.params.id});
+    res.status(200).json({success: true, data :{} });
+})

feature/utilisateur/model/utilisateur.model.js

@@ -0,0 +1,29 @@
+const mongoose = require("mongoose");
+const string_decoder = require("string_decoder");
+
+const  schema=  mongoose.Schema({
+    //String, Number, Boolean, MongoObject, Object
+    name: {
+        type: String,
+        default: ""
+    },
+    firstname: {
+        type: String,
+        default: ""
+    },
+    country: {
+        type: String,
+        default: ""
+    },
+    city: {
+        type: String,
+        default: ""
+    }
+}, { timestamps : true});
+
+
+
+
+module.exports = mongoose.model('utilisateur', schema, 'utilisateurs');
+
+

feature/utilisateur/route/utilisateur.route.js

@@ -0,0 +1,27 @@
+const express = require("express");
+const router = express.Router();
+const utilisateurController = require("../controller/utilisateur.controller");
+const utilisateurModel = require("../model/utilisateur.model");
+const advancedResults = require("../../../shared/middleware/advanced-result")
+
+//get All
+//router.route('/').get(utilisateurController.getAll);
+
+router
+    .route('/')
+    .get(advancedResults(utilisateurModel), utilisateurController.getAll) // path , ref et nom de l'entité
+
+
+//getById
+router.route('/:id').get(utilisateurController.getById);
+
+//create
+router.route('/').post(utilisateurController.create);
+
+//update
+router.route('/:id').put(utilisateurController.update);
+
+//delete
+router.route('/:id').delete(utilisateurController.delete);
+
+module.exports = router

server.js

@@ -15,6 +15,28 @@ app.use(cors());
 const vehicleRoute = require("./feature/vehicle/route/vehicle.route");
 app.use("/vehicle", vehicleRoute);
 
+//route contact :
+const contactRoute= require('./feature/contact/route/contact.route')
+app.use("/contact",contactRoute)
+
+//route problem :
+
+const problemRoute= require('./feature/problem/route/problem.route')
+app.use("/problem",problemRoute)
+
+const placeRoute= require('./feature/place/route/place.route')
+app.use("/place",placeRoute)
+
+const serviceRoute= require('./feature/service/route/service.route')
+app.use("/service",serviceRoute)
+
+// route carburant
+const carburantRoute = require("./feature/carburant/route/carburant.route");
+app.use("/carburant", carburantRoute);
+// route utilisateur
+const utilisateurRoute = require("./feature/utilisateur/route/utilisateur.route");
+app.use("/utilisateur", utilisateurRoute);
+
 const server = app.listen(5000, ()=>{
     console.log('Vous êtés connecter au port 5000'.yellow.bold);
 })