update2

express-server/controllers/auth.js

@@ -0,0 +1,190 @@
+const bcrypt = require('bcrypt');
+const { User } = require('../models/user.model');
+const jwt = require('jsonwebtoken');
+const config = require('../config/config.json');
+const nodemailer = require('nodemailer');
+var validator = require('validator');
+const role = require('../lib/role');
+
+
+
+//inscription user
+exports.signup = async (req, res, next) => {
+
+    try {
+
+        // génère une exception
+        if (!req.body.firstname) { throw new Error('Nom introuvable') }
+        if (!req.body.lastname) { throw new Error('Prénom introuvable') }
+        if (!req.body.email) { throw new Error('Adresse email introuvable') }
+        if (!req.body.birthday) { throw new Error('Date de naissance introuvable') }
+        if (!req.body.phonenumber) { throw new Error('Numéro de téléphone introuvable') }
+        if (!req.body.adress) { throw new Error('Adresse introuvable') }
+        if (!validator.isEmail(req.body.email)) { throw new Error('Adresse email invalide') }
+        if (isNaN(Date.parse(req.body.birthday)) || (Date.parse(req.body.birthday)) > 1073692800000) { throw new Error('Date de naissance invalide') }
+
+
+        const user = await User.findOne({ email: req.body.email }, { email: 1 })
+
+        if (user) {
+            res.status(401).json({ success: false, message: 'Adresse email existe déja veuillez renseigner une autre adresse email' })
+        } else {
+
+            bcrypt.hash(req.body.password, 12)
+                .then(hash => {
+                    const user = new User({
+                        firstname: req.body.firstname,
+                        lastname: req.body.lastname,
+                        email: req.body.email,
+                        role: role.Client,
+                        birthday: req.body.birthday,
+                        phonenumber: req.body.phonenumber,
+                        adress: req.body.adress,
+                        isActive: true,
+                        isGain: false,
+                        password: hash
+                    });
+
+                    user.save()
+                        .then(() => {
+                            const token = jwt.sign({ userId: user._id, email: user.email, role: user.role }, config.secret_key, { expiresIn: '10 h' })
+                            res.status(201).json(
+                                { success: true, token, expireIn: `${new Date().getTime() + 120000}` })
+                        })
+                        .catch((err) => res.status(500).json({ success: false, message: err.message }))
+                })
+                .catch(() => res.status(400).json({ success: false, message: 'Erreur dans le mot de passe' }));
+        }
+
+    }
+    catch (err) {
+        res.status(400).json({ success: false, message: err.message })
+    }
+
+};
+
+
+
+
+//login User
+exports.login = (req, res, next) => {
+
+    try {
+
+        // génère une exception
+        if (!req.body.email) { throw new Error('Adresse email introuvable') }
+        if (!req.body.password) { throw new Error('Mot de passe introuvable') }
+        if (!validator.isEmail(req.body.email)) { throw new Error('Adresse email invalide') }
+
+        User.findOne({ email: req.body.email })
+            .then(user => {
+                if (!user) {
+                    return res.status(404).json({ success: false, message: 'Utilisateur non trouvé' });
+                }
+                bcrypt.compare(req.body.password, user.password)
+                    .then(valid => {
+                        if (!valid) { return res.status(401).json({ success: false, message: 'Mot de passe incorrect' }) }
+                        const token = jwt.sign({ userId: user._id, email: user.email, role: user.role }, config.secret_key, { expiresIn: '10 h' })
+                        res.status(200).json(
+                            { success: true, token, expireIn: `${new Date().getTime() + 120000}` })
+                    })
+                    .catch(error => res.status(500).json({ error }))
+            })
+            .catch(error => res.status(500).json({ error }));
+    }
+    catch (err) { res.status(400).json({ success: false, message: err.message }) }
+
+};
+
+
+
+
+//forgot password
+exports.forgotPassword = async (req, res, next) => {
+
+    try {
+
+        // génère une exception
+        if (!req.body.email) { throw new Error('Adresse email introuvable') }
+        if (!validator.isEmail(req.body.email)) { throw new Error('Adresse email invalide') }
+
+        var smtpTransport = nodemailer.createTransport({
+            host: config.email.host,
+            port: config.email.port,
+            secure: true,
+            auth: { user: config.email.user, pass: config.email.pass },
+            tls: { rejectUnauthorized: false }
+        });
+
+        User.findOne({ email: req.body.email })
+            .then((user) => {
+
+                if (!user) {
+                    return res.status(404).json({ success: false, message: 'Utilisateur non trouvé avec cette adresse email' });
+                }
+
+                const token = jwt.sign({ userId: user._id, email: user.email, role: user.role }, config.reset_password_key, { expiresIn: '20m' })
+
+                var mailOptions = {
+                    to: req.body.email,
+                    from: config.email.user,
+                    subject: 'Réinitialisation de votre mot de passe',
+                    html: `<h3>Cliquez sur ce lien pour rénisialiser votre mot de passe</h3>
+                               <p>${config.reset_password_url}/${token}</p> `
+                };
+
+                user.updateOne({ resetLink: token })
+                    .then(() => {
+
+                        smtpTransport.sendMail(mailOptions)
+                            .then(() => res.status(200).json({ success: true, message: `Un e-mail vous a été envoyé pour réinitialiser votre mot de passe` }))
+                            .catch((e) => res.status(500).json({ success: false, message: `${e}` }))
+                    })
+                    .catch((e) => res.status(400).json({ success: false, message: `Réinitialisation de votre mot de passe a échoué` }))
+
+            })
+            .catch(() => res.status(500).json({ success: false, message: 'Erreur dans le serveur' }));
+    }
+    catch (err) { res.status(400).json({ success: false, message: err.message }) }
+};
+
+
+
+
+
+
+//reset password
+exports.resetPassword = async (req, res, next) => {
+
+    try {
+
+        // génère une exception
+        if (!req.body.password) { throw new Error('Nouveau mot de passe introuvable') }
+        if (!req.body.resetLink) { throw new Error('Token introuvable') }
+
+        jwt.verify(req.body.resetLink, config.reset_password_key, (error, decodedToken) => {
+            if (error) { return res.status(401).json({ success: false, message: error.message }) }
+
+            User.findOne({ resetLink: req.body.resetLink })
+                .then((user) => {
+
+                    if (!user) {
+                        return res.status(404).json({ success: false, message: 'Utilisateur non trouvé avec ce token' });
+                    }
+
+                    bcrypt.hash(req.body.password, 12)
+                        .then(hash => {
+
+                            user.updateOne({ resetLink: '', password: hash })
+                                .then(() => { res.status(200).json({ success: false, message: 'Votre mot de passe a été changé avec success' }) })
+                                .catch((err) => res.status(500).json({ success: false, message: err.message }))
+                        })
+                        .catch(() => res.status(400).json({ success: false, message: 'Erreur dans le mot de passe' }));
+                })
+                .catch((e) => res.status(500).json({ success: false, message: `Erreur dans le serveur` }))
+        });
+
+    }
+    catch (err) { res.status(400).json({ success: false, message: err.message }) }
+
+};

express-server/controllers/contact.js

@@ -0,0 +1,164 @@
+const { Contact } = require('../models/contact.model');
+const nodemailer = require('nodemailer');
+const  config  = require('../config/config.json');
+
+
+
+
+
+//post contact
+exports.addContact = async (req, res, next) => {
+
+    try {
+
+        // génère une exception
+        if (!req.body.email) { throw new Error('Adresse email introuvable') }
+        if (!validator.isEmail(req.body.email)) { throw new Error('Adresse email invalide') }
+
+        const contact = new Contact({
+            lastname: req.body.lastname,
+            email: req.body.email,
+            message: req.body.message,
+            is_closed: false
+        });
+
+        contact.save()
+            .then(() => { res.status(201).json({ success: true, message: 'Votre message a été envoyé avec success' }) })
+            .catch((error) => { res.status(500).json(error.message) });
+    }
+    catch (err) { res.status(400).json({ success: false, message: err.message }) }
+};
+
+
+
+//get how many notification 
+exports.notificationContact = async (req, res, next) => {
+
+    Contact.countDocuments({ is_closed: false })
+        .then(
+            (notif) => {
+                res.status(200).json({ success: true, notification: notif });
+            }
+        ).catch(
+            () => { res.status(500).json({ success: false, message: 'Erreur dans le serveur' }) }
+        )
+}
+
+
+// get contact not closed
+exports.getnotclosedContact = async (req, res, next) => {
+
+    Contact.find({ is_closed: false })
+        .then((contact) => { res.status(200).json(contact) })
+        .catch(() => { res.status(500).json({ success: false, message: 'Erreur dans le serveur' }) })
+}
+
+
+
+// get contact closed
+exports.getclosedContact = async (req, res, next) => {
+
+    Contact.find({ is_closed: true })
+        .then((contact) => { res.status(200).json(contact) })
+        .catch(() => { res.status(500).json({ success: false, message: 'Erreur dans le serveur' }) })
+}
+
+
+
+
+
+//response contact 
+exports.ResponseContact = async (req, res, next) => {
+
+    if (req.query.id) {
+        if (req.body.text) {
+
+            Contact.findOne({ _id: req.query.id })
+                .then((item) => {
+
+                    if (item.is_closed === false) {
+
+                        var smtpTransport = nodemailer.createTransport({
+                            host: config.email.host,
+                            port: config.email.port,
+                            secure: true,
+                            auth: { user: config.email.user, pass: config.email.pass },
+                            tls: { rejectUnauthorized: false }, // do not fail on invalid certs 
+                        });
+
+                        var mailOptions = {
+                            to: item.email,
+                            from: config.email.email,
+                            subject: `Réponse  à votre message`,
+                            text: req.body.text
+                        };
+
+                        item.is_closed = true
+                        item.response = req.body.text
+                        item.response_date = new Date()
+
+                        item.save().then(() => {
+
+                            smtpTransport.sendMail(mailOptions)
+                                .then(() => {
+                                    res.status(200).json({ success: true, message: `Votre réponse a été envoyer avec success` })
+                                })
+                                .catch((e) => res.status(500).json({ success: false, message: `${e}` }))
+
+                        }).catch((e) => res.status(500).json({ success: false, message: `${e}` }))
+                    } else {
+                        res.status(400).json({ success: false, message: `Le Message a été fermer` })
+                    }
+                }
+                )
+                .catch((e) => res.status(404).json({ success: false, message: `Message non trouvé` }))
+
+        } else {
+            res.status(400).json({ success: false, message: `Le message est obligatoire` })
+        }
+    } else {
+        res.status(400).json({ success: false, message: `Identifiant du message non trouvé` })
+    }
+}
+
+
+
+
+
+
+//colse contact
+exports.CloseContact = async (req, res, next) => {
+
+    if (req.query.id) {
+
+        if (req.body.is_closed) {
+            Contact.findOne({ _id: req.query.id })
+                .then((item) => {
+                    if (item.is_closed === false) {
+
+                        item.is_closed = req.body.is_closed
+                        item.response_date = new Date()
+
+                        item.save().then(() => {
+                            res.status(200).json({ success: true, message: `Le message a été fermer avec success` })
+
+                        }).catch((e) => res.status(500).json({ success: false, message: `${e}` }))
+
+                    } else {
+                        res.status(400).json({ success: false, message: `Le Message a été fermer` })
+                    }
+                }
+                )
+                .catch((e) => res.status(404).json({ success: false, message: `Message non trouvé` }))
+        }
+        else {
+            res.status(400).json({ success: false, message: `Body non trouvé` })
+        }
+    } else {
+        res.status(400).json({ success: false, message: `Identifiant du message non trouvé` })
+    }
+
+
+}
+
+

express-server/controllers/email.js

@@ -0,0 +1,71 @@
+const { Email } = require('../models/email.model');
+const { User } = require('../models/user.model');
+const nodemailer = require('nodemailer');
+const config = require('../config/config.json');
+
+
+
+// post email 
+exports.sendEmail = async (req, res, next) => {
+
+    if (req.query) {
+        var query = {}
+        // if (req.query.lastname) { query.lastname = req.query.lastname }
+        // if (req.query.firstname) { query.firstname = req.query.firstname }
+        if (req.query.email) { query.email = req.query.email }
+        if (req.query.isactive) { query.isActive = req.query.isactive }
+        if (req.query.isgain) { query.isGain = req.query.isgain }
+    }
+
+    const email = new Email({
+        title: req.body.title,
+        subject: req.body.subject,
+        text: req.body.text,
+        description: req.body.description
+    });
+
+    if (req.body.title && req.body.subject && req.body.text) {
+
+        const user_db = await User.find(query, { email: 1 })
+        const user_db_email = user_db.map(x => x.email)
+
+
+        var smtpTransport = nodemailer.createTransport({
+            host: config.email.host,
+            port: config.email.port,
+            secure: true,
+            auth: { user: config.email.user, pass: config.email.pass },
+            tls: { rejectUnauthorized: false }
+        });
+
+        var mailOptions = {
+            to: user_db_email,
+            from: config.email.user,
+            subject: req.body.subject,
+            text: req.body.text
+        };
+
+        email.save().then(() => {
+
+            smtpTransport.sendMail(mailOptions)
+                .then(() => res.status(200).json(email))
+                .catch((e) => res.status(500).json({ success: false, message: `${e}` }))
+        }).catch(() => res.status(500).json({ success: false, message: `Erreur dans le serveur` }))
+    } else {
+        res.status(400).json({ success: false, message: `Veuillez renseigner le titre et l'objet et le contexte du mail` })
+    }
+
+
+};
+
+
+
+
+// get email 
+exports.getEmail = async (req, res, next) => {
+
+    Email.find({})
+    .then((email) => { res.status(200).json(email) })
+    .catch( () => { res.status(500).json({success: false, message: 'erreur dans le serveur'}) })
+
+}

express-server/controllers/employee.js

@@ -0,0 +1,157 @@
+const { Ticket } = require('../models/ticket.model');
+const { User } = require('../models/user.model');
+const bcrypt = require('bcrypt');
+const Role = require('../lib/role')
+var validator = require('validator');
+
+
+
+// ajout employé
+exports.postEmployee = async (req, res, next) => {
+
+  try {
+
+      // génère une exception
+      if (!req.body.firstname) { throw new Error('Nom introuvable') }
+      if (!req.body.lastname) { throw new Error('Prénom introuvable') }
+      if (!req.body.password) { throw new Error('Mot de passe introuvable') }
+      if (!req.body.email) { throw new Error('Adresse email introuvable') }
+      if (!req.body.birthday) { throw new Error('Date de naissance introuvable') }
+      if (!req.body.phonenumber) { throw new Error('Numéro de téléphone introuvable') }
+      if (!validator.isEmail(req.body.email)) { throw new Error('Adresse email invalide') }
+      if (isNaN(Date.parse(req.body.birthday)) || (Date.parse(req.body.birthday)) > 1073692800000) { throw new Error('Date de naissance invalide') }
+
+
+      const user = await User.findOne({ email: req.body.email }, { email: 1 })
+
+      if (user) {
+          res.status(400).json({ success: false, message: 'Adresse email existe déja veuillez renseigner une autre adresse email' })
+      } else {
+
+          bcrypt.hash(req.body.password, 12)
+              .then(hash => {
+                  const user = new User({
+                      firstname: req.body.firstname,
+                      lastname: req.body.lastname,
+                      email: req.body.email,
+                      role: Role.Employee,
+                      birthday: req.body.birthday,
+                      phonenumber: req.body.phonenumber,
+                      isActive: true,
+                      password: hash
+                  });
+
+                  user.save()
+                      .then(() => {
+                          res.status(201).json({ success: true,  message: 'Employé ajouté avec succès'})
+                      })
+                      .catch((err) => res.status(500).json({ success: false,  message: 'Erreur dans le serveur' }))
+              })
+              .catch(() => res.status(400).json({ success: false, message: 'Erreur dans le mot de passe' }));
+      }
+  }
+  catch (err) {
+      res.status(500).json({ success: false, message: err.message })
+  }
+
+};
+
+
+
+
+
+
+
+//get employee by id
+exports.getEmployeeById = async (req, res) => {
+
+    User.findById(req.params.id, {password:0, __v:0})
+    .then( (employee) => {
+
+    res.status(200).send(employee);
+    })
+    .catch(() => {
+      res.status(404).send({
+        success: false,
+        message: 'user not found'
+      }
+      );
+    })
+};
+
+
+
+
+//delete employee by id
+exports.deleteEmployeeById = async (req, res) => {
+
+const employee = await User.findByIdAndRemove(req.params.id);
+  if (!employee) return res.status(404).json('employee not found');
+  res.status(200).json('user deleted successfully!');
+  
+};
+
+
+
+
+//patch user by id
+exports.patchUserById = async (req, res, next) => {
+
+    const user = await User.findById(req.params.id);
+    const phonenumber = req.body.phonenumber;
+    const password = req.body.password
+    const adresse = req.body.adresse;
+  
+    if (phonenumber) { user.phonenumber = phonenumber }
+    if (password) { user.password = password }
+    if (adresse) { user.adresse = adresse }
+  
+    await user.save() // on sauvegarde les modifications
+  
+    res.json(user)
+};
+
+
+
+
+//get all employees
+ exports.getAllEmployees = async (req, res, next) => {
+
+    var page = parseInt(req.query.page) || 1;
+    var limit = parseInt(req.query.limit) || 5;
+  
+    if (req.query) {
+      var query = {role: Role.Employee}
+      if (req.query.lastname) { query.lastname = { $regex: req.query.lastname } }
+      if (req.query.firstname) { query.firstname = { $regex: req.query.firstname } }
+      if (req.query.email) { query.email = { $regex: req.query.email } }
+    }
+  
+    await User.find(query, {password:0, resetLink:0, __v:0})
+      .sort({ register_date: -1 })
+      .skip((page - 1) * limit)
+      .limit(limit)
+      .exec((err, doc) => {
+        if (err) {
+          return res.status(500).json(err);
+        }
+        User.countDocuments(query).exec((count_error, count) => {
+          if (err) {
+            return res.status(404).json(count_error);
+          }
+          return res.status(200).json({
+            success: true,
+            page: page,
+            page_size: doc.length,
+            total: count,
+            employees: doc
+          });
+        });
+      });
+ };
+
+
+
+
+
+

express-server/controllers/gain.js

@@ -0,0 +1,50 @@
+const { Ticket } = require('../models/ticket.model');
+const { User } = require('../models/user.model');
+
+
+
+//consulter les gains
+exports.gain = async (req, res, next) => {
+
+    try {
+        
+        // génère une exception
+        if (!req.query.id) { throw new Error(`Identifiant utilisateur introuvable`) }
+        if (!req.body.code) { throw new Error(`Code introuvable`) }
+        if (isNaN(req.body.code)) { throw new Error(`Votre code n'est pas un chiffre`) }
+        if (req.body.code.toString().length != 10) { throw new Error(`Votre code est différent de 10 chiffres`) }
+
+        
+        User.findById(req.query.id)
+            .then((user) => {
+
+                Ticket.findOne({ code: req.body.code })
+                    .then((ticket) => {
+                        if (ticket) {
+                            if (ticket.isUsed === false) {
+
+                                ticket.isUsed = true;
+                                ticket.date_used = new Date();
+
+                                ticket.save()
+                                    .then((ticket) => {
+                                        user.isGain = true;
+                                        user.gains.push(ticket);
+                                        user.save()
+                                            .then(() => res.status(200).send(ticket))
+                                            .catch(() => res.status(500).json({ success: false, message: `Erreur dans le serveur` }))
+                                    })
+                                    .catch(() => res.status(500).json({ success: false, message: `Erreur dans le serveur` }))
+
+                            } else { res.status(400).json({ success: false, message: `Le code a déjà été utilisé` }) }
+                        } else { res.status(400).json({ success: false, message: `Le code est erroné` }) }
+
+                    })
+                    .catch(() => res.status(500).json({ success: false, message: `Erreur dans le serveur` }));
+
+            })
+            .catch(() => res.status(404).json({ success: false, message: `Utilisateur non trouvé` }))
+
+    }
+    catch (err) { res.status(400).json({ success: false, message: err.message }) }
+};

express-server/controllers/resetpassword.js

@@ -0,0 +1,46 @@
+const { Ticket } = require('../models/ticket.model');
+const { User } = require('../models/user.model');
+const jwt = require('jsonwebtoken');
+const config = require('../config/config.json');
+
+
+
+
+//get user by id
+exports.resetPassword = async (req, res, next) => {
+
+   
+    User.findOne({ email: req.body.email })
+        .then(user => {
+            if (!user) {
+                return res.status(404).json({success: false, message: 'utilisateur non trouvé avec cette adresse email' });
+            }
+            const token = jwt.sign({ userId: user._id, email: user.email, role: user.role }, config.secret_key, { expiresIn: '20m' })
+            
+
+            var mailOptions = {
+                to: req.body.email,
+                from: 'fatboar.burgers@gmail.com',
+                subject: 'Activation de compte',
+                html: `<h2>Cliquez sur ce lien pour renisialiser votre mot de passe</h2>
+                       <p>http://localhost:4000/api/auth/resetpassword/${token}</p> `
+            };
+           
+        })
+        .catch(error => res.status(500).json({ error }));
+
+};
+
+
+
+
+
+
+ // bcrypt.compare(req.body.password, user.password)
+            //     .then(valid => {
+            //         if (!valid) { return res.status(401).json({success: false, message: 'mot de passe incorrect' }); }
+            //         const token = jwt.sign({ userId: user._id, email: user.email, role: user.role }, config.secret_key, { expiresIn: '10 h' })
+            //         res.status(200).json(
+            //             { success: true, token, expireIn: `${new Date().getTime() + 120000}` })
+            //     })
+            //     .catch(error => res.status(500).json({ error }))

express-server/controllers/restaurant.js

@@ -0,0 +1,24 @@
+const { Restaurant } = require('../models/restaurant.model');
+
+//get all users
+exports.getAllRestaurants = async (req, res, next) => {
+
+  Restaurant.find({}).then((data) => { res.status(200).json(data) })
+                     .catch(() => { res.status(500).json({ success: false, message: 'Erreur dans le serveur' }) })
+};
+
+
+
+//post user 
+exports.postAllRestaurants = async (req, res, next) => {
+  const ticket = new Restaurant({
+    index: req.body.index,
+    name: req.body.name,
+    adress: req.body.adress,
+    longitude: req.body.longitude,
+    latitude: req.body.latitude
+  });
+  ticket.save().then( () => { res.status(201).json({ success: true, message: 'Restaurant ajouté avec succès!'})})
+               .catch( (error) => { res.status(400).send( error )});
+};
+

express-server/controllers/statistique.js

@@ -0,0 +1,52 @@
+const { Ticket } = require('../models/ticket.model');
+
+
+//get all users
+exports.getStatistique = async (req, res, next) => {
+
+  try {
+
+    //une entrée ou un dessert au choix
+    const e_ou_d_c_total = await Ticket.countDocuments({ gains: 'une entrée ou un dessert au choix' })
+    const e_ou_d_c_used = await Ticket.countDocuments({ gains: 'une entrée ou un dessert au choix', isUsed: true })
+    const e_ou_d_c_served = await Ticket.countDocuments({ gains: 'une entrée ou un dessert au choix', isUsed: true, isServed: true })
+
+    //un burger au choix
+    const b_c_total = await Ticket.countDocuments({ gains: 'un burger au choix' })
+    const b_c_used = await Ticket.countDocuments({ gains: 'un burger au choix', isUsed: true })
+    const b_c_served = await Ticket.countDocuments({ gains: 'un burger au choix', isUsed: true, isServed: true })
+
+
+    //un menu du jour
+    const m_j_total = await Ticket.countDocuments({ gains: 'un menu du jour' })
+    const m_j_used = await Ticket.countDocuments({ gains: 'un menu du jour', isUsed: true })
+    const m_j_served = await Ticket.countDocuments({ gains: 'un menu du jour', isUsed: true, isServed: true })
+
+    //un menu au choix
+    const m_c_total = await Ticket.countDocuments({ gains: 'un menu au choix' })
+    const m_c_used = await Ticket.countDocuments({ gains: 'un menu au choix', isUsed: true })
+    const m_c_served = await Ticket.countDocuments({ gains: 'un menu au choix', isUsed: true, isServed: true })
+
+
+    //70% de réduction
+    const r_total = await Ticket.countDocuments({ gains: '70% de réduction' })
+    const r_used = await Ticket.countDocuments({ gains: '70% de réduction', isUsed: true })
+    const r_served = await Ticket.countDocuments({ gains: '70% de réduction', isUsed: true, isServed: true })
+
+
+    res.status(200).json({
+      success: true,
+      data: [{ gain: 'une entrée ou un dessert au choix', used: e_ou_d_c_used, served: e_ou_d_c_served, total: e_ou_d_c_total },
+      { gain: 'un burger au choix', used: b_c_used, served: b_c_served, total: b_c_total },
+      { gain: 'un menu du jour', used: m_j_used, served: m_j_served, total: m_j_total },
+      { gain: 'un menu au choix', used: m_c_used, served: m_c_served, total: m_c_total },
+      { gain: '70% de réduction', used: r_used, served: r_served, total: r_total }
+      ]
+    })
+
+  }
+  catch (err) {
+    res.status(500).json({ success: false, message: err.message })
+  }
+
+};

express-server/controllers/tirage.js

@@ -0,0 +1,139 @@
+
+const { Tirage } = require('../models/tirage.model');
+const { User } = require('../models/user.model');
+const moment = require('moment');
+moment().format();
+
+
+
+// date de tirage au sort
+exports.postDateTirage = async (req, res, next) => {
+
+    const tirage = new Tirage({
+        tirage_date: req.body.date,
+    });
+
+    const valid_date = moment(req.body.date, moment.ISO_8601, true).isValid();
+
+    if (req.body.date) {
+        if (valid_date === true) {
+            exist_tirage = await Tirage.countDocuments();
+            if (exist_tirage === 0) {
+                tirage.save().then(
+                    () => {
+                        res.status(201).json({
+                            success: true,
+                            date: req.body.date,
+                            message: `Date enregistré avec succès`
+                        });
+                    }
+                ).catch((err) => { res.status(500).json({ success: false, message: err.message }) });
+            } else {
+                res.status(400).json({ success: false, message: `La date est déjà  définie` });
+            }
+
+        } else {
+            res.status(400).json({ success: false, message: `Date invalide` });
+        }
+    }
+    else {
+        res.status(400).json({ success: false, message: `Date introuvable` });
+    }
+
+};
+
+
+//tirage au sort 
+exports.getTirage = async (req, res, next) => {
+
+    db_tirage = await Tirage.findOne()
+    date_now = new Date();
+
+    if (db_tirage !== null) {
+
+        if (db_tirage.isExecuted === false) {
+
+            if (db_tirage.tirage_date && date_now.getFullYear() === new Date(db_tirage.tirage_date).getFullYear()
+                && date_now.getMonth() === new Date(db_tirage.tirage_date).getMonth()
+                && date_now.getDate() === new Date(db_tirage.tirage_date).getDate()) {
+
+                // exec tirage au sort
+                User.countDocuments({ isActive: true }).exec(function (err, count) {
+                    if (count !== 0) {
+                        var random = Math.floor(Math.random() * count);
+
+                        User.findOne().skip(random).exec(
+                            function (err, result) {
+
+                                db_tirage.nb_users = count;
+                                db_tirage.random_user = random;
+                                db_tirage.isExecuted = true;
+                                db_tirage.executed_date = new Date();
+                                db_tirage.winner = result;
+
+                                db_tirage.save().then(
+                                    () => {
+                                        res.status(200).json({
+                                            success: true,
+                                            db_tirage
+                                        });
+                                    }
+                                ).catch(
+                                    (error) => {
+                                        res.status(400).json({
+                                            error
+                                        });
+                                    }
+                                );
+                            });
+                    } else {
+                        res.json({
+                            success: false,
+                            count: "users not exists",
+
+                        })
+                    }
+                })
+
+            } else {
+                res.json({
+                    success: false,
+                    message: 'La date choisi ne correspond pas a la date du tirage au sort',
+                })
+            }
+
+        } else {
+            res.json({
+                success: false,
+                message: "Le tirage a été déja effectué",
+            })
+        }
+    }
+    else {
+        res.json({
+            success: false,
+            message: "La date n'est pas encore choisi",
+        })
+    }
+};
+
+
+
+
+//get winner of tirage
+exports.getWinnerTirage = async (req, res, next) => {
+
+    count_tirage = await Tirage.countDocuments();
+    tirage = await Tirage.findOne();
+
+    if (count_tirage === 0) {
+
+        res.status(404).json({
+            success: false,
+            message: `le tirage au sort n'est pas encore effectué`
+        });
+    }
+    else {
+        res.status(200).json(tirage);
+    }
+};

express-server/controllers/user.js

@@ -0,0 +1,170 @@
+const { Ticket } = require('../models/ticket.model');
+const { User } = require('../models/user.model');
+const bcrypt = require('bcrypt');
+const Role = require('../lib/role')
+
+
+
+//get user by id
+exports.getUserById = async (req, res, next) => {
+
+  User.findById(req.params.id, { password: 0, resetLink: 0, __v: 0 })
+    .then((user) => { res.status(200).json(user) })
+    .catch(() => { res.status(404).json({ success: false, message: `Utilisateur non trouvé` }) })
+};
+
+
+
+
+//delete user by id
+exports.deleteUserById = async (req, res, next) => {
+
+  User.deleteOne({_id: req.params.id})
+    .then(() => { res.status(200).json({ success: true, message: `Utilisateur supprimé avec succès!` })})
+    .catch( () => { res.status(400).json({ success: false, message: `Utilisateur non trouvé` }) });
+
+};
+
+
+
+
+//patch user by id
+exports.patchUserById = async (req, res, next) => {
+
+
+  if (req.body.email || req.body.password || req.body.phonenumber || req.body.adress) {
+
+    User.findOne({ _id: req.params.id })
+      .then(user => {
+
+
+        if (req.body.email) {
+
+          User.findOne({ email: req.body.email })
+            .then((user_db) => {
+
+              if (user_db) {
+
+                if (user_db._id !== user._id) { res.status(200).json({ success: true, message: 'adresse mail exist' })}
+              }
+              else {
+                user.email = req.body.email
+
+              }
+
+            })
+            .catch((err) => res.status(300).json({ success: false, message: err.message }))
+        }
+
+
+        if (req.body.password && req.body.newpassword) {
+
+          bcrypt.compare(req.body.password, user.password)
+            .then(valid => {
+
+              if (!valid) { return res.status(401).json({ success: false, message: 'mot de passe incorrect' }); }
+
+              bcrypt.hash(req.body.newpassword, 12)
+                .then(hash => {
+
+                  user.password = hash
+
+
+                })
+                .catch(() => res.status(400).json({ success: false, message: 'erreur dans le password' }));
+            })
+            .catch(error => res.status(500).json({ error }))
+
+        }
+
+
+
+
+        if (req.body.adress) {
+          if (typeof req.body.adress === "string") {
+            user.adress = req.body.adress
+          } else {
+            res.status(400).json({ success: false, message: 'erreur dans le adresse' })
+          }
+
+
+        }
+
+        if (req.body.phonenumber) {
+
+          user.phonenumber = req.body.phonenumber
+
+        }
+
+        user.save()
+          .then(() => { res.status(200).json({ success: true, message: ' changé avec success' }) })
+          .catch((err) => res.status(500).json({ success: false, message: err.message }))
+
+
+
+      })
+
+
+
+
+      .catch(() => res.status(404).json({ success: false, message: 'utilisateur non trouvé' }));
+
+
+
+    // else {
+    //   res.status(400).json({ success: false, message: 'mot de passe introuvable' });
+    // }
+
+  } else {
+    res.status(400).json({ success: false, message: 'Aucun attribut envoyé' });
+  }
+
+
+};
+
+
+
+
+//get all users
+exports.getAllUsers = async (req, res, next) => {
+
+  var page = parseInt(req.query.page) || 1;
+  var limit = parseInt(req.query.limit) || 10;
+  console.log(req.query)
+  if (req.query) {
+    var query = {role : Role.Client}
+    if (req.query.lastname) { query.lastname = { $regex: req.query.lastname } }
+    if (req.query.firstname) { query.firstname = { $regex: req.query.firstname } }
+    if (req.query.adress) { query.adress = { $regex: req.query.adress } }
+    if (req.query.email) { query.email = req.query.email }
+    if (req.query.startregister && req.query.endregister) { query.register_date = { "$gte": req.query.startregister, "$lt": req.query.endregister } }
+  }
+
+  await User.find(query, { password: 0, resetLink: 0, __v: 0 })
+    .sort({ register_date: -1 })
+    .skip((page - 1) * limit)
+    .limit(limit)
+    .exec((err, doc) => {
+      if (err) {
+        return res.status(500).json(err);
+      }
+      User.countDocuments(query).exec((count_error, count) => {
+        if (err) {
+          return res.status(404).json(count_error);
+        }
+        return res.status(200).json({
+          success: true,
+          page: page,
+          page_size: doc.length,
+          total: count,
+          users: doc
+        });
+      });
+    });
+};
+
+
+
+
+
+