Guest User

Untitled

a guest
Nov 11th, 2017
74
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. const Receita = require('../models/receita');
  2. const User = require('../models/user');
  3. var nodemailer = require('nodemailer');
  4. const util = require('util');
  5. const fs = require('fs');
  6.  
  7.  
  8. module.exports = {
  9.  
  10.  
  11.  
  12.  
  13.  
  14.     // ******** RECEITAS ********
  15.  
  16.  
  17.  
  18.  
  19.     //Get all receitas
  20.     //router.route('/')
  21.     //.get(ReceitasController.index)
  22.  
  23.     index: async function(req, res, next){
  24.         try{
  25.             console.log("router.route('/')");
  26.             console.log(".get(ReceitasController.index)");
  27.             const receitas = await Receita.find({});
  28.             res.status(200).json(receitas);
  29.         }
  30.         catch(err){
  31.             next(err);
  32.         }  
  33.     },
  34.  
  35.  
  36.     //Get receita por ID
  37.     //router.route('/:ReceitaId')
  38.     //.get(ReceitasController.getReceitaById);
  39.  
  40.     getReceitaById: async function(req,res,next){
  41.         try{
  42.             console.log("router.route('/:ReceitaId')");
  43.             console.log(".get(ReceitasController.index)");
  44.             console.log("req.path",req.path);
  45.        
  46.  
  47.             const receitaId = req.params["ReceitaId"];
  48.             const receita = await Receita.findById(receitaId);
  49.             res.status(200).json(receita);
  50.         }
  51.         catch(err){
  52.             next(err);
  53.         }    
  54.     },
  55.  
  56.  
  57.  
  58.     //Post receita
  59.     //router.route('/')
  60.     //.post(ReceitasController.newReceita);
  61.  
  62.     newReceita: async function(req, res, next) {
  63.         try
  64.         {
  65.             console.log("router.route('/')");
  66.             console.log(".post(ReceitasController.newReceita)")
  67.             console.log('body', req.body["utente"]);
  68.             console.log('params', req.params);
  69.  
  70.             //Validacoes
  71.  
  72.             //receber do body o id do utente
  73.             const utenteId = req.body["utente"];
  74.             //receber do body o id do medico
  75.             const medicoId = req.body["medico"];
  76.             //valida se sao o mesmo user
  77.             if(utenteId==medicoId){
  78.                 return res.status(403).json({ error: "O medico e utente nao podem ter o mesmo id"});
  79.             }
  80.             //procurar em user se existe o utente que é passado no body
  81.             const utente = await User.findById(utenteId);
  82.             console.log('procura utente', utente);
  83.             if(!utente){
  84.                 return res.status(403).json({ error: "O Utente nao existe"});
  85.             }else{
  86.                 if(!utente["utente"]){
  87.                     return res.status(403).json({ error: "O Utente nao existe"});
  88.                 }
  89.             }
  90.             //procurar em users se existe o medico que é passado no body
  91.             const medico = await User.findById(medicoId);
  92.             console.log('procura medico', medico);
  93.             if(!medico){
  94.                 return res.status(403).json({ error: "O Medico nao existe"});
  95.             }else{
  96.                 if(!medico["medico"]){
  97.                     return res.status(403).json({ error: "O Medico nao existe"});
  98.                 }
  99.             }
  100.  
  101.            
  102.             //grava receita se utente e medico existirem no documento users
  103.             const receita = new Receita(req.body);
  104.  
  105.             await receita.save();
  106.            
  107.             return res.status(201).json(receita);
  108.            
  109.         }
  110.         catch(err) {
  111.             next(err);
  112.         }
  113.     },
  114.  
  115.  
  116.     //Modifica receita por id
  117.     //router.route('/:ReceitaId')
  118.     //.put(ReceitasController.replaceReceitaById);
  119.  
  120.     replaceReceitaById: async function(req,res,next){
  121.         try{
  122.  
  123.             console.log("router.route('/:ReceitaId')");
  124.             console.log(".put(ReceitasController.replaceReceitaById)");
  125.             const receitaId = req.params["ReceitaId"];
  126.             const newReceita = req.body;
  127.             const result = await Receita.findByIdAndUpdate(receitaId,newReceita);
  128.             const receita = await Receita.findById(receitaId);
  129.             res.status(200).json(receita);
  130.         }
  131.         catch(err){
  132.             next(err);
  133.         }
  134.     },
  135.  
  136.  
  137.  
  138.  
  139.  
  140.     // ******** PRESCRICOES ********
  141.  
  142.  
  143.  
  144.  
  145.  
  146.     //Get todas Prespricoes
  147.     //router.route('/Prescricoes')
  148.     //.get(ReceitasController.getAllPrescricoes);
  149.  
  150.     getAllPrescricoes: async function(req, res, next) {
  151.         try{
  152.  
  153.  
  154.             console.log("router.route('/Prescricoes')");
  155.             console.log(".get(ReceitasController.getAllPrescricoes)");
  156.  
  157.             /*
  158.             if(req.path !== "/Prescricoes"){
  159.                 next();
  160.             }
  161.             */
  162.  
  163.             const receitas = await Receita.find({});
  164.             var allPrescricoes = new Array();
  165.            
  166.             for(var i in receitas) {
  167.                 const prescricoes=receitas[i]["prescricoes"];
  168.                 for (var j = 0; j < prescricoes.length; j++) {
  169.                     allPrescricoes.push(prescricoes[j]);
  170.                    
  171.                 }          
  172.             }
  173.            
  174.             console.log(allPrescricoes);
  175.  
  176.             //res.status(200).json(allPrescricoes);
  177.  
  178.         }catch(err){
  179.             next(err);
  180.         }
  181.     },
  182.  
  183.  
  184.  
  185.     //Get Prespricao por id
  186.     //router.route('/Prescricoes/:PrescricaoId')
  187.     //.get(ReceitasController.getPrescricaoById);
  188.  
  189.     getPrescricaoById: async function(req, res, next) {
  190.         try{
  191.            
  192.            
  193.             console.log("router.route('/Prescricoes/:PrescricaoId')");
  194.             console.log(".get(ReceitasController.getPrescricaoById)");
  195.  
  196.             const receitas = await Receita.find({});
  197.             const prescricaoId = req.params["PrescricaoId"];
  198.  
  199.             var prescricao;
  200.            
  201.             for(var i in receitas) {
  202.                 const prescricoes=receitas[i]["prescricoes"];
  203.                 for (var j = 0; j < prescricoes.length; j++) {
  204.                     if(prescricoes[j]._id==prescricaoId){
  205.                         return res.status(200).json(prescricoes[j]);
  206.                     }
  207.                 }          
  208.             }  
  209.  
  210.             return res.status(404).json("Não encontrou a prescricao com esse id");
  211.  
  212.             //res.status(200).json(allPrescricoes);
  213.  
  214.         }catch(err){
  215.             next(err);
  216.         }
  217.     },
  218.  
  219.  
  220.  
  221.     //Get Prespricoes de uma receita
  222.     //router.route('/:ReceitaId/Prescricao')
  223.     //.get(ReceitasController.getPrescricoes);
  224.  
  225.     getPrescricoes: async function(req, res, next) {
  226.         try{
  227.             console.log("router.route('/:ReceitaId/Prescricao')");
  228.             console.log(".get(ReceitasController.getPrescricoes)");
  229.             //obter o id da receita nos parametros
  230.            
  231.             const receitaId = req.params["ReceitaId"];
  232.             console.log(receitaId);
  233.            
  234.             const newreceita = await Receita.findById(receitaId);
  235.             console.log(newreceita);
  236.  
  237.             console.log(newreceita["prescricoes"]);
  238.            
  239.             res.status(200).json(newreceita["prescricoes"]);
  240.            
  241.            
  242.         }
  243.         catch(err){
  244.             next(err);
  245.         }
  246.     },
  247.  
  248.  
  249.  
  250.     //Adicionar prescrições por receita
  251.     //router.route('/:ReceitaId/Prescricao')
  252.     //.post(ReceitasController.newPrescricao);
  253.  
  254.     newPrescricao: async function(req, res, next) {
  255.         try{
  256.             console.log("router.route('/:ReceitaId/Prescricao')");
  257.             console.log(".post(ReceitasController.newPrescricao)");
  258.             //obter o id da receita nos parametros
  259.             const receitaId = req.params["ReceitaId"];
  260.             //obter a prescricao que esta no body
  261.             const prescricaoBody = req.body;
  262.             //procurar a receita na bd pelo id
  263.             console.log(receitaId);
  264.             const newreceita = await Receita.findById(receitaId);
  265.             console.log(newreceita);
  266.             newreceita.prescricoes.push(prescricaoBody);
  267.             const result = await newreceita.save();  
  268.             res.status(200).json(newreceita);  
  269.         }
  270.         catch(err){
  271.             next(err);
  272.         }
  273.     },
  274.  
  275.  
  276.  
  277.     //Modificar uma prescricao por receita
  278.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId')
  279.     //.put(ReceitasController.replacePrescricao);
  280.  
  281.     replacePrescricao: async function(req, res, next) {
  282.         try{
  283.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId')");
  284.             console.log(".put(ReceitasController.replacePrescricao)");
  285.             //obter o id da receita nos parametros
  286.             const receitaId = req.params["ReceitaId"];
  287.             //procurar a receita na bd pelo id
  288.             const newReceita = await Receita.findById(receitaId);
  289.             //Obter a lista de prescricoes da receita
  290.             const prescricoes = newReceita["prescricoes"];
  291.             //testar se já houve aviamento (ver se lista de aviamentos vazia)
  292.             const aviamentos = prescricoes.aviamentos;
  293.            
  294.             if(!(aviamentos && aviamentos.length)){
  295.                 const prescricaoId = req.params["PrescricaoId"];
  296.                 //obter a prescricao que esta no body
  297.                 const prescricaoBody = req.body;
  298.    
  299.                 index = await prescricoes.findIndex(elem => elem._id==prescricaoId);
  300.                 prescricoes.splice(index,1);    
  301.                 prescricoes.push(prescricaoBody);
  302.                 const result = await newReceita.save();
  303.                 res.status(200).json(prescricoes);
  304.             }
  305.  
  306.         }
  307.         catch(err){
  308.             next(err);
  309.         }
  310.     },
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.     //Delete uma prescricao por receita
  320.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId')
  321.     //.delete(ReceitasController.delPrescricao);
  322.  
  323.     delPrescricao: async function(req, res, next) {
  324.         try{
  325.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId')");
  326.             console.log(".delete(ReceitasController.delPrescricao)");
  327.             //obter o id da receita nos parametros
  328.             const receitaId = req.params["ReceitaId"];
  329.             //procurar a receita na bd pelo id
  330.             const newReceita = await Receita.findById(receitaId);
  331.             //Obter a lista de prescricoes da receita
  332.             const prescricoes = newReceita["prescricoes"];
  333.             const prescricaoId = req.params["PrescricaoId"];
  334.  
  335.             index = await prescricoes.findIndex(elem => elem._id==prescricaoId);
  336.             prescricoes.splice(index,1);    
  337.             const result = await newReceita.save();
  338.             res.status(200).json(prescricoes);
  339.    
  340.  
  341.         }
  342.         catch(err){
  343.             next(err);
  344.         }
  345.     },
  346.  
  347.  
  348.  
  349.  
  350.  
  351.  
  352.  
  353.  
  354.    
  355.  
  356.  
  357.     //GET Prescrições por aviar até {data} ou todas (sem data opcional)
  358.     //Utente/{id}/prescricao/poraviar/{?data}
  359.     //router.route('/Utente/:UtenteId/Prescricao/Poraviar/:data?')
  360.     //.get(ReceitasController.prescricoesPorAviar);
  361.     prescricoesPorAviar: async function(req,res,next){
  362.         try{
  363.             console.log("router.route('/Utente/:UtenteId/Prescricao/Poraviar/{?data}')");
  364.             console.log(".get(ReceitasController.prescricoesPorAviar)");
  365.  
  366.             const dataReceita = new Date(req.params["data"]);
  367.             const utenteId = req.params["UtenteId"];
  368.             const receitas = await Receita.find({});
  369.             var prescricoesUtente = new Array();
  370.  
  371.             if(dataReceita instanceof Date && isFinite(dataReceita)){
  372.  
  373.                 for(var i in receitas) {
  374.                     const prescricoes=receitas[i]["prescricoes"];
  375.                     if((utenteId==receitas[i]["utente"]) && (receitas[i]["data"]<dataReceita)){
  376.                         for (var j = 0; j < prescricoes.length; j++) {
  377.                             prescricoesUtente.push(prescricoes[j]);
  378.                         }
  379.                     }
  380.                 }
  381.  
  382.             }else{
  383.                 for(var i in receitas) {
  384.                     const prescricoes=receitas[i]["prescricoes"];
  385.                     if(utenteId==receitas[i]["utente"]){
  386.                         for (var j = 0; j < prescricoes.length; j++) {
  387.                             prescricoesUtente.push(prescricoes[j]);
  388.                         }
  389.                     }
  390.                 }
  391.             }
  392.  
  393.             //console.log(prescricoesUtente);
  394.             res.status(200).json(prescricoesUtente);
  395.            
  396.  
  397.         }catch(err){
  398.             next(err);
  399.         }
  400.     },
  401.  
  402.  
  403.  
  404.     //router.route('/:ReceitaId')
  405.     //.delete(ReceitasController.delReceita)
  406.     delReceita: async function(req,res,next){
  407.         try{
  408.             console.log("router.route('/:ReceitaId')");
  409.             console.log(".delete(ReceitasController.delReceita)");
  410.             //obter o id da receita nos parametros
  411.             const receitaId = req.params["ReceitaId"];
  412.             console.log("receitaId",receitaId);
  413.             //procurar a receita na bd pelo id
  414.             const newReceita = await Receita.findByIdAndRemove(receitaId);
  415.             const receitas = await Receita.find();
  416.             res.status(200).json(receitas);
  417.  
  418.         }catch(err){
  419.  
  420.         }
  421.     },
  422.    
  423.  
  424.     // ******** AVIAMENTOS ********
  425.  
  426.  
  427.  
  428.     //POST de um Aviamento
  429.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')
  430.     //.post(ReceitasController.newAviamento)
  431.  
  432.  
  433.     const hasRoleAsync = util.promisify(hasRole);
  434.    
  435.     newAviamento: async function(req, res, next) {
  436.         try{
  437.  
  438.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')");
  439.             console.log(".post(ReceitasController.newAviamento)");
  440.  
  441.            
  442.             const decision = await hasRoleAsync(req.user,'medico');
  443.  
  444.             hasRoleAsync(req.user,'medico',function(decision){
  445.                 if(!decision){
  446.                     return res.status(403).send(
  447.                         { auth: false, token: null, message: 'You have no authorization.'});
  448.                    
  449.                 }    
  450.                 else{
  451.                     //quantidade na prescricao passada no body
  452.                     const quantidadeBody = req.body.quantidade;  
  453.                     const receitaId = req.params["ReceitaId"];
  454.                     const prescricaoId = req.params["PrescricaoId"];
  455.                     const newReceita = await Receita.findById(receitaId);
  456.                     const prescricoes = newReceita["prescricoes"];
  457.                     prescricao = await prescricoes.find(elem => elem._id==prescricaoId);
  458.                     const userId = req.body["farmaceutico"];
  459.                     console.log("userType",userId);
  460.                     const user = await User.findById(userId);
  461.                     console.log("user",user);
  462.                     console.log("user['farmaceutico']:",user['farmaceutico']);
  463.  
  464.                     const aviamento = req.body;
  465.                     dataValidadePrespricao = prescricao["dataValidade"];
  466.                     var dataAviamento = new Date(aviamento.dataAviamento);
  467.  
  468.                     console.log("dataValidadePrespricao",dataValidadePrespricao);
  469.                     console.log("dataAviamento",dataAviamento);
  470.  
  471.            
  472.                     quantidadePrescricao = prescricao.quantidade;
  473.                     //console.log(quantidadePrescricao);
  474.                     if(user['farmaceutico']==true){
  475.  
  476.                         if(dataValidadePrespricao>=dataAviamento){
  477.                             if(quantidadePrescricao>=quantidadeBody && quantidadePrescricao>0){
  478.                                 prescricao.quantidade-=quantidadeBody;
  479.                            
  480.                                 aviamentos = prescricao.aviamentos;
  481.                                 aviamentos.push(aviamento);
  482.                    
  483.                                 const result = await newReceita.save();
  484.                                 res.status(200).json({prescricao});
  485.                             }else{
  486.                                 res.status(400).json("Erro - A quantidade da prescricao eh inferior a quantidade que deseja aviar");            
  487.                             }
  488.                         }else{
  489.                             res.status(400).json("Erro - Data nao valida: superior a data da prescricao");
  490.                         }
  491.                        
  492.                     }else{
  493.                         res.status(400).json("Erro - User invalido - Precisa de ser farmaceutico");
  494.                     }    
  495.                 }  
  496.             });
  497.  
  498.         }
  499.         catch(err){
  500.             next(err);
  501.         }
  502.     },
  503.  
  504.  
  505.  
  506.     //Get aviamentos de uma prescricao
  507.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')
  508.     //.get(ReceitasController.getAviamentos);
  509.  
  510.     getAviamentos: async function(req,res,next){
  511.         try{
  512.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')");
  513.             console.log(".get(ReceitasController.getAviamentos)");
  514.             const receitaId = req.params["ReceitaId"];
  515.             const prescricaoId = req.params["PrescricaoId"];
  516.             const newReceita = await Receita.findById(receitaId);
  517.             const prescricoes = newReceita["prescricoes"];
  518.             prescricao = await prescricoes.find(elem => elem._id==prescricaoId);
  519.             aviamentos = prescricao.aviamentos;
  520.             res.status(200).json(aviamentos);
  521.  
  522.         }catch(err){
  523.             next(err);
  524.         }
  525.     },
  526.  
  527.    
  528.  
  529.     //Get aviamento por id
  530.     //router.route('/Aviamentos/:AviamentoId')
  531.     //.get(ReceitasController.getAviamentoById);
  532.  
  533.     getAviamentoById: async function(req,res,next){
  534.         try{
  535.             console.log("router.route('/Aviamentos/:AviamentoId')");
  536.             console.log(".get(ReceitasController.getAviamentoById)");
  537.             //obter todas as receitas
  538.             //pesquisar em cada recita a lista das prescicoes e verificar se alguma delas tem o id igual ao passado no parametro
  539.             //escrever
  540.  
  541.             //todas as receitas
  542.             const receitas = await Receita.find({});
  543.             const aviamentoId = req.params["AviamentoId"];
  544.  
  545.             for(var i in receitas) {
  546.                 const prescricoes=receitas[i]["prescricoes"];
  547.                 for (var j = 0; j < prescricoes.length; j++) {
  548.                     const aviamentos=prescricoes[j].aviamentos;
  549.                     for (var z = 0; z < aviamentos.length; z++){
  550.                         if(aviamentoId==aviamentos[z]._id){
  551.                             return res.status(200).json(aviamentos[z]);
  552.                         }
  553.                     }
  554.                 }          
  555.             }
  556.  
  557.             return res.status(404).json("Aviamento id nao encontrado");
  558.  
  559.         }catch(err){
  560.             next(err);
  561.         }
  562.     },
  563.    
  564.  
  565.  
  566.     // ******** Outros ********
  567.  
  568.  
  569.  
  570.     //Get receitas por medico
  571.     //router.route('/Medico/:MedicoId')
  572.     //.get(ReceitasController.getReceitasMedico);
  573.     getReceitasMedico: async function(req,res,next){
  574.         try{
  575.             /*
  576.             if(req.path !== "/Prescricoes"){
  577.                 next();
  578.             }*/
  579.  
  580.             console.log("router.route('/Medico/:MedicoId')");
  581.             console.log(".get(ReceitasController.getReceitasMedico)");
  582.            
  583.             const medicoId = req.params["MedicoId"];
  584.             const receitas = await Receita.find({});
  585.             var receitasMedico = new Array();
  586.  
  587.             for(var i in receitas) {
  588.                 console.log("receitas[i]['medico']._id",receitas[i]["medico"]);
  589.                 if(medicoId==receitas[i]["medico"]){
  590.                     receitasMedico.push(receitas[i])
  591.                 }          
  592.             }
  593.  
  594.             console.log(receitasMedico);
  595.             return res.status(200).json(receitasMedico);
  596.  
  597.  
  598.         }catch(err){
  599.  
  600.         }
  601.     },
  602.  
  603.  
  604.  
  605.     //Get receitas por medico
  606.     //router.route('/Medico/:MedicoId')
  607.     //.get(ReceitasController.getReceitasMedico);
  608.     getReceitasMedico: async function(req,res,next){
  609.         try{
  610.             /*
  611.             if(req.path !== "/Prescricoes"){
  612.                 next();
  613.             }*/
  614.  
  615.             console.log("router.route('/Medico/:MedicoId')");
  616.             console.log(".get(ReceitasController.getReceitasMedico)");
  617.            
  618.             const medicoId = req.params["MedicoId"];
  619.             const receitas = await Receita.find({});
  620.             var receitasMedico = new Array();
  621.  
  622.             for(var i in receitas) {
  623.  
  624.                 if(medicoId==receitas[i]["medico"]){
  625.                     receitasMedico.push(receitas[i])
  626.                 }          
  627.             }
  628.  
  629.             res.status(200).json(receitasMedico);
  630.  
  631.  
  632.         }catch(err){
  633.  
  634.         }
  635.     },
  636.  
  637.  
  638.  
  639.     //Get receitas por utente
  640.     //router.route('/Utente/:UtenteId')
  641.     //.get(ReceitasController.getReceitasUtente);
  642.     getReceitasUtente: async function(req,res,next){
  643.         try{
  644.             /*
  645.             if(req.path !== "/Prescricoes"){
  646.                 next();
  647.             }*/
  648.  
  649.             console.log("router.route('/Utente/:UtenteId')");
  650.             console.log(".get(ReceitasController.getReceitasUtente)");
  651.            
  652.             const utenteId = req.params["UtenteId"];
  653.             const receitas = await Receita.find({});
  654.             var receitasUtente = new Array();
  655.  
  656.             for(var i in receitas) {
  657.  
  658.                 if(utenteId==receitas[i]["utente"]){
  659.                     receitasUtente.push(receitas[i])
  660.                 }          
  661.             }
  662.  
  663.             res.status(200).json(receitasUtente);
  664.  
  665.         }catch(err){
  666.  
  667.         }
  668.     },
  669.  
  670.  
  671.    
  672.  
  673.     //Emitir receita ... enviar email ao utente
  674.     //router.route('/:ReceitaId/Emitir')
  675.     //.put(ReceitasController.emitirReceita);
  676.  
  677.     emitirReceita: async function(req, res, next) {
  678.         try{
  679.             console.log("router.route('/:ReceitaId/Emitir')");
  680.             console.log(".put(ReceitasController.emitirReceita)");
  681.             //obter o id da receita nos parametros
  682.             const receitaId = req.params["ReceitaId"];
  683.             console.log("receitaId",receitaId);
  684.             const newReceita = await Receita.findById(receitaId);
  685.             console.log("newReceita",newReceita);
  686.             const user = await User.findById(newReceita["utente"]);
  687.             console.log(user);
  688.  
  689.             var enviado=false;
  690.  
  691.             const utenteEmail = user["email"];
  692.  
  693.            
  694.             if(newReceita["emitida"]===false){
  695.                 newReceita["emitida"]=true;
  696.                
  697.  
  698.                 const user = await User.findOne(newReceita["utente"]);
  699.  
  700.  
  701.                 var transporter = nodemailer.createTransport({
  702.                     service: 'Hotmail',
  703.                     auth: {
  704.                         user: 'gestor.receitas@hotmail.com', // Your email id
  705.                         pass: 'GESTOR?receitas' // Your password
  706.                     }
  707.                 });
  708.    
  709.                 var text = 'Receita emitida: \n\n' + newReceita;          
  710.  
  711.                 var mailOptions = {
  712.                     from: '<gestor.receitas@hotmail.com>', // sender address
  713.                     to: utenteEmail, // list of receivers
  714.                     subject: 'Emissao de Receita', // Subject line
  715.                     text: text //, // plaintext body
  716.                 };
  717.  
  718.    
  719.                 transporter.sendMail(mailOptions, function(error, info){
  720.                     if(error){
  721.                         console.log(error);
  722.                         res.json({error});
  723.                     }else{
  724.                         enviado=true;
  725.                         console.log('Message sent: ' + info.response);
  726.                         res.json({yo: info.response});
  727.                     };
  728.                     transporter.close();
  729.                 });
  730.  
  731.                
  732.            
  733.                
  734.             }
  735.  
  736.             if(enviado==true){
  737.                 const result = await newReceita.save();
  738.                 res.status(200).json(newReceita);
  739.             }
  740.            
  741.         }
  742.         catch(err){
  743.             next(err);
  744.         }
  745.     }
  746.  
  747.  
  748.  
  749.  
  750.  
  751.    
  752. }
  753.  
  754.  
  755.  
  756. const Receita = require('../models/receita');
  757. const User = require('../models/user');
  758. var nodemailer = require('nodemailer');
  759. const util = require('util');
  760. const fs = require('fs');
  761.  
  762.  
  763. module.exports = {
  764.  
  765.  
  766.  
  767.  
  768.  
  769.     // ******** RECEITAS ********
  770.  
  771.  
  772.  
  773.  
  774.     //Get all receitas
  775.     //router.route('/')
  776.     //.get(ReceitasController.index)
  777.  
  778.     index: async function(req, res, next){
  779.         try{
  780.             console.log("router.route('/')");
  781.             console.log(".get(ReceitasController.index)");
  782.             const receitas = await Receita.find({});
  783.             res.status(200).json(receitas);
  784.         }
  785.         catch(err){
  786.             next(err);
  787.         }  
  788.     },
  789.  
  790.  
  791.     //Get receita por ID
  792.     //router.route('/:ReceitaId')
  793.     //.get(ReceitasController.getReceitaById);
  794.  
  795.     getReceitaById: async function(req,res,next){
  796.         try{
  797.             console.log("router.route('/:ReceitaId')");
  798.             console.log(".get(ReceitasController.index)");
  799.             console.log("req.path",req.path);
  800.        
  801.  
  802.             const receitaId = req.params["ReceitaId"];
  803.             const receita = await Receita.findById(receitaId);
  804.             res.status(200).json(receita);
  805.         }
  806.         catch(err){
  807.             next(err);
  808.         }    
  809.     },
  810.  
  811.  
  812.  
  813.     //Post receita
  814.     //router.route('/')
  815.     //.post(ReceitasController.newReceita);
  816.  
  817.     newReceita: async function(req, res, next) {
  818.         try
  819.         {
  820.             console.log("router.route('/')");
  821.             console.log(".post(ReceitasController.newReceita)")
  822.             console.log('body', req.body["utente"]);
  823.             console.log('params', req.params);
  824.  
  825.             //Validacoes
  826.  
  827.             //receber do body o id do utente
  828.             const utenteId = req.body["utente"];
  829.             //receber do body o id do medico
  830.             const medicoId = req.body["medico"];
  831.             //valida se sao o mesmo user
  832.             if(utenteId==medicoId){
  833.                 return res.status(403).json({ error: "O medico e utente nao podem ter o mesmo id"});
  834.             }
  835.             //procurar em user se existe o utente que é passado no body
  836.             const utente = await User.findById(utenteId);
  837.             console.log('procura utente', utente);
  838.             if(!utente){
  839.                 return res.status(403).json({ error: "O Utente nao existe"});
  840.             }else{
  841.                 if(!utente["utente"]){
  842.                     return res.status(403).json({ error: "O Utente nao existe"});
  843.                 }
  844.             }
  845.             //procurar em users se existe o medico que é passado no body
  846.             const medico = await User.findById(medicoId);
  847.             console.log('procura medico', medico);
  848.             if(!medico){
  849.                 return res.status(403).json({ error: "O Medico nao existe"});
  850.             }else{
  851.                 if(!medico["medico"]){
  852.                     return res.status(403).json({ error: "O Medico nao existe"});
  853.                 }
  854.             }
  855.  
  856.            
  857.             //grava receita se utente e medico existirem no documento users
  858.             const receita = new Receita(req.body);
  859.  
  860.             await receita.save();
  861.            
  862.             return res.status(201).json(receita);
  863.            
  864.         }
  865.         catch(err) {
  866.             next(err);
  867.         }
  868.     },
  869.  
  870.  
  871.     //Modifica receita por id
  872.     //router.route('/:ReceitaId')
  873.     //.put(ReceitasController.replaceReceitaById);
  874.  
  875.     replaceReceitaById: async function(req,res,next){
  876.         try{
  877.  
  878.             console.log("router.route('/:ReceitaId')");
  879.             console.log(".put(ReceitasController.replaceReceitaById)");
  880.             const receitaId = req.params["ReceitaId"];
  881.             const newReceita = req.body;
  882.             const result = await Receita.findByIdAndUpdate(receitaId,newReceita);
  883.             const receita = await Receita.findById(receitaId);
  884.             res.status(200).json(receita);
  885.         }
  886.         catch(err){
  887.             next(err);
  888.         }
  889.     },
  890.  
  891.  
  892.  
  893.  
  894.  
  895.     // ******** PRESCRICOES ********
  896.  
  897.  
  898.  
  899.  
  900.  
  901.     //Get todas Prespricoes
  902.     //router.route('/Prescricoes')
  903.     //.get(ReceitasController.getAllPrescricoes);
  904.  
  905.     getAllPrescricoes: async function(req, res, next) {
  906.         try{
  907.  
  908.  
  909.             console.log("router.route('/Prescricoes')");
  910.             console.log(".get(ReceitasController.getAllPrescricoes)");
  911.  
  912.             /*
  913.             if(req.path !== "/Prescricoes"){
  914.                 next();
  915.             }
  916.             */
  917.  
  918.             const receitas = await Receita.find({});
  919.             var allPrescricoes = new Array();
  920.            
  921.             for(var i in receitas) {
  922.                 const prescricoes=receitas[i]["prescricoes"];
  923.                 for (var j = 0; j < prescricoes.length; j++) {
  924.                     allPrescricoes.push(prescricoes[j]);
  925.                    
  926.                 }          
  927.             }
  928.            
  929.             console.log(allPrescricoes);
  930.  
  931.             //res.status(200).json(allPrescricoes);
  932.  
  933.         }catch(err){
  934.             next(err);
  935.         }
  936.     },
  937.  
  938.  
  939.  
  940.     //Get Prespricao por id
  941.     //router.route('/Prescricoes/:PrescricaoId')
  942.     //.get(ReceitasController.getPrescricaoById);
  943.  
  944.     getPrescricaoById: async function(req, res, next) {
  945.         try{
  946.            
  947.            
  948.             console.log("router.route('/Prescricoes/:PrescricaoId')");
  949.             console.log(".get(ReceitasController.getPrescricaoById)");
  950.  
  951.             const receitas = await Receita.find({});
  952.             const prescricaoId = req.params["PrescricaoId"];
  953.  
  954.             var prescricao;
  955.            
  956.             for(var i in receitas) {
  957.                 const prescricoes=receitas[i]["prescricoes"];
  958.                 for (var j = 0; j < prescricoes.length; j++) {
  959.                     if(prescricoes[j]._id==prescricaoId){
  960.                         return res.status(200).json(prescricoes[j]);
  961.                     }
  962.                 }          
  963.             }  
  964.  
  965.             return res.status(404).json("Não encontrou a prescricao com esse id");
  966.  
  967.             //res.status(200).json(allPrescricoes);
  968.  
  969.         }catch(err){
  970.             next(err);
  971.         }
  972.     },
  973.  
  974.  
  975.  
  976.     //Get Prespricoes de uma receita
  977.     //router.route('/:ReceitaId/Prescricao')
  978.     //.get(ReceitasController.getPrescricoes);
  979.  
  980.     getPrescricoes: async function(req, res, next) {
  981.         try{
  982.             console.log("router.route('/:ReceitaId/Prescricao')");
  983.             console.log(".get(ReceitasController.getPrescricoes)");
  984.             //obter o id da receita nos parametros
  985.            
  986.             const receitaId = req.params["ReceitaId"];
  987.             console.log(receitaId);
  988.            
  989.             const newreceita = await Receita.findById(receitaId);
  990.             console.log(newreceita);
  991.  
  992.             console.log(newreceita["prescricoes"]);
  993.            
  994.             res.status(200).json(newreceita["prescricoes"]);
  995.            
  996.            
  997.         }
  998.         catch(err){
  999.             next(err);
  1000.         }
  1001.     },
  1002.  
  1003.  
  1004.  
  1005.     //Adicionar prescrições por receita
  1006.     //router.route('/:ReceitaId/Prescricao')
  1007.     //.post(ReceitasController.newPrescricao);
  1008.  
  1009.     newPrescricao: async function(req, res, next) {
  1010.         try{
  1011.             console.log("router.route('/:ReceitaId/Prescricao')");
  1012.             console.log(".post(ReceitasController.newPrescricao)");
  1013.             //obter o id da receita nos parametros
  1014.             const receitaId = req.params["ReceitaId"];
  1015.             //obter a prescricao que esta no body
  1016.             const prescricaoBody = req.body;
  1017.             //procurar a receita na bd pelo id
  1018.             console.log(receitaId);
  1019.             const newreceita = await Receita.findById(receitaId);
  1020.             console.log(newreceita);
  1021.             newreceita.prescricoes.push(prescricaoBody);
  1022.             const result = await newreceita.save();  
  1023.             res.status(200).json(newreceita);  
  1024.         }
  1025.         catch(err){
  1026.             next(err);
  1027.         }
  1028.     },
  1029.  
  1030.  
  1031.  
  1032.     //Modificar uma prescricao por receita
  1033.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId')
  1034.     //.put(ReceitasController.replacePrescricao);
  1035.  
  1036.     replacePrescricao: async function(req, res, next) {
  1037.         try{
  1038.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId')");
  1039.             console.log(".put(ReceitasController.replacePrescricao)");
  1040.             //obter o id da receita nos parametros
  1041.             const receitaId = req.params["ReceitaId"];
  1042.             //procurar a receita na bd pelo id
  1043.             const newReceita = await Receita.findById(receitaId);
  1044.             //Obter a lista de prescricoes da receita
  1045.             const prescricoes = newReceita["prescricoes"];
  1046.             //testar se já houve aviamento (ver se lista de aviamentos vazia)
  1047.             const aviamentos = prescricoes.aviamentos;
  1048.            
  1049.             if(!(aviamentos && aviamentos.length)){
  1050.                 const prescricaoId = req.params["PrescricaoId"];
  1051.                 //obter a prescricao que esta no body
  1052.                 const prescricaoBody = req.body;
  1053.    
  1054.                 index = await prescricoes.findIndex(elem => elem._id==prescricaoId);
  1055.                 prescricoes.splice(index,1);    
  1056.                 prescricoes.push(prescricaoBody);
  1057.                 const result = await newReceita.save();
  1058.                 res.status(200).json(prescricoes);
  1059.             }
  1060.  
  1061.         }
  1062.         catch(err){
  1063.             next(err);
  1064.         }
  1065.     },
  1066.  
  1067.  
  1068.  
  1069.  
  1070.  
  1071.  
  1072.  
  1073.  
  1074.     //Delete uma prescricao por receita
  1075.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId')
  1076.     //.delete(ReceitasController.delPrescricao);
  1077.  
  1078.     delPrescricao: async function(req, res, next) {
  1079.         try{
  1080.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId')");
  1081.             console.log(".delete(ReceitasController.delPrescricao)");
  1082.             //obter o id da receita nos parametros
  1083.             const receitaId = req.params["ReceitaId"];
  1084.             //procurar a receita na bd pelo id
  1085.             const newReceita = await Receita.findById(receitaId);
  1086.             //Obter a lista de prescricoes da receita
  1087.             const prescricoes = newReceita["prescricoes"];
  1088.             const prescricaoId = req.params["PrescricaoId"];
  1089.  
  1090.             index = await prescricoes.findIndex(elem => elem._id==prescricaoId);
  1091.             prescricoes.splice(index,1);    
  1092.             const result = await newReceita.save();
  1093.             res.status(200).json(prescricoes);
  1094.    
  1095.  
  1096.         }
  1097.         catch(err){
  1098.             next(err);
  1099.         }
  1100.     },
  1101.  
  1102.  
  1103.  
  1104.  
  1105.  
  1106.  
  1107.  
  1108.  
  1109.    
  1110.  
  1111.  
  1112.     //GET Prescrições por aviar até {data} ou todas (sem data opcional)
  1113.     //Utente/{id}/prescricao/poraviar/{?data}
  1114.     //router.route('/Utente/:UtenteId/Prescricao/Poraviar/:data?')
  1115.     //.get(ReceitasController.prescricoesPorAviar);
  1116.     prescricoesPorAviar: async function(req,res,next){
  1117.         try{
  1118.             console.log("router.route('/Utente/:UtenteId/Prescricao/Poraviar/{?data}')");
  1119.             console.log(".get(ReceitasController.prescricoesPorAviar)");
  1120.  
  1121.             const dataReceita = new Date(req.params["data"]);
  1122.             const utenteId = req.params["UtenteId"];
  1123.             const receitas = await Receita.find({});
  1124.             var prescricoesUtente = new Array();
  1125.  
  1126.             if(dataReceita instanceof Date && isFinite(dataReceita)){
  1127.  
  1128.                 for(var i in receitas) {
  1129.                     const prescricoes=receitas[i]["prescricoes"];
  1130.                     if((utenteId==receitas[i]["utente"]) && (receitas[i]["data"]<dataReceita)){
  1131.                         for (var j = 0; j < prescricoes.length; j++) {
  1132.                             prescricoesUtente.push(prescricoes[j]);
  1133.                         }
  1134.                     }
  1135.                 }
  1136.  
  1137.             }else{
  1138.                 for(var i in receitas) {
  1139.                     const prescricoes=receitas[i]["prescricoes"];
  1140.                     if(utenteId==receitas[i]["utente"]){
  1141.                         for (var j = 0; j < prescricoes.length; j++) {
  1142.                             prescricoesUtente.push(prescricoes[j]);
  1143.                         }
  1144.                     }
  1145.                 }
  1146.             }
  1147.  
  1148.             //console.log(prescricoesUtente);
  1149.             res.status(200).json(prescricoesUtente);
  1150.            
  1151.  
  1152.         }catch(err){
  1153.             next(err);
  1154.         }
  1155.     },
  1156.  
  1157.  
  1158.  
  1159.     //router.route('/:ReceitaId')
  1160.     //.delete(ReceitasController.delReceita)
  1161.     delReceita: async function(req,res,next){
  1162.         try{
  1163.             console.log("router.route('/:ReceitaId')");
  1164.             console.log(".delete(ReceitasController.delReceita)");
  1165.             //obter o id da receita nos parametros
  1166.             const receitaId = req.params["ReceitaId"];
  1167.             console.log("receitaId",receitaId);
  1168.             //procurar a receita na bd pelo id
  1169.             const newReceita = await Receita.findByIdAndRemove(receitaId);
  1170.             const receitas = await Receita.find();
  1171.             res.status(200).json(receitas);
  1172.  
  1173.         }catch(err){
  1174.  
  1175.         }
  1176.     },
  1177.    
  1178.  
  1179.     // ******** AVIAMENTOS ********
  1180.  
  1181.  
  1182.  
  1183.     //POST de um Aviamento
  1184.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')
  1185.     //.post(ReceitasController.newAviamento)
  1186.  
  1187.  
  1188.     const hasRoleAsync = util.promisify(hasRole);
  1189.    
  1190.     newAviamento: async function(req, res, next) {
  1191.         try{
  1192.  
  1193.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')");
  1194.             console.log(".post(ReceitasController.newAviamento)");
  1195.  
  1196.            
  1197.             const decision = await hasRoleAsync(req.user,'medico');
  1198.  
  1199.             hasRoleAsync(req.user,'medico',function(decision){
  1200.                 if(!decision){
  1201.                     return res.status(403).send(
  1202.                         { auth: false, token: null, message: 'You have no authorization.'});
  1203.                    
  1204.                 }    
  1205.                 else{
  1206.                     //quantidade na prescricao passada no body
  1207.                     const quantidadeBody = req.body.quantidade;  
  1208.                     const receitaId = req.params["ReceitaId"];
  1209.                     const prescricaoId = req.params["PrescricaoId"];
  1210.                     const newReceita = await Receita.findById(receitaId);
  1211.                     const prescricoes = newReceita["prescricoes"];
  1212.                     prescricao = await prescricoes.find(elem => elem._id==prescricaoId);
  1213.                     const userId = req.body["farmaceutico"];
  1214.                     console.log("userType",userId);
  1215.                     const user = await User.findById(userId);
  1216.                     console.log("user",user);
  1217.                     console.log("user['farmaceutico']:",user['farmaceutico']);
  1218.  
  1219.                     const aviamento = req.body;
  1220.                     dataValidadePrespricao = prescricao["dataValidade"];
  1221.                     var dataAviamento = new Date(aviamento.dataAviamento);
  1222.  
  1223.                     console.log("dataValidadePrespricao",dataValidadePrespricao);
  1224.                     console.log("dataAviamento",dataAviamento);
  1225.  
  1226.            
  1227.                     quantidadePrescricao = prescricao.quantidade;
  1228.                     //console.log(quantidadePrescricao);
  1229.                     if(user['farmaceutico']==true){
  1230.  
  1231.                         if(dataValidadePrespricao>=dataAviamento){
  1232.                             if(quantidadePrescricao>=quantidadeBody && quantidadePrescricao>0){
  1233.                                 prescricao.quantidade-=quantidadeBody;
  1234.                            
  1235.                                 aviamentos = prescricao.aviamentos;
  1236.                                 aviamentos.push(aviamento);
  1237.                    
  1238.                                 const result = await newReceita.save();
  1239.                                 res.status(200).json({prescricao});
  1240.                             }else{
  1241.                                 res.status(400).json("Erro - A quantidade da prescricao eh inferior a quantidade que deseja aviar");            
  1242.                             }
  1243.                         }else{
  1244.                             res.status(400).json("Erro - Data nao valida: superior a data da prescricao");
  1245.                         }
  1246.                        
  1247.                     }else{
  1248.                         res.status(400).json("Erro - User invalido - Precisa de ser farmaceutico");
  1249.                     }    
  1250.                 }  
  1251.             });
  1252.  
  1253.         }
  1254.         catch(err){
  1255.             next(err);
  1256.         }
  1257.     },
  1258.  
  1259.  
  1260.  
  1261.     //Get aviamentos de uma prescricao
  1262.     //router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')
  1263.     //.get(ReceitasController.getAviamentos);
  1264.  
  1265.     getAviamentos: async function(req,res,next){
  1266.         try{
  1267.             console.log("router.route('/:ReceitaId/Prescricao/:PrescricaoId/Aviamento')");
  1268.             console.log(".get(ReceitasController.getAviamentos)");
  1269.             const receitaId = req.params["ReceitaId"];
  1270.             const prescricaoId = req.params["PrescricaoId"];
  1271.             const newReceita = await Receita.findById(receitaId);
  1272.             const prescricoes = newReceita["prescricoes"];
  1273.             prescricao = await prescricoes.find(elem => elem._id==prescricaoId);
  1274.             aviamentos = prescricao.aviamentos;
  1275.             res.status(200).json(aviamentos);
  1276.  
  1277.         }catch(err){
  1278.             next(err);
  1279.         }
  1280.     },
  1281.  
  1282.    
  1283.  
  1284.     //Get aviamento por id
  1285.     //router.route('/Aviamentos/:AviamentoId')
  1286.     //.get(ReceitasController.getAviamentoById);
  1287.  
  1288.     getAviamentoById: async function(req,res,next){
  1289.         try{
  1290.             console.log("router.route('/Aviamentos/:AviamentoId')");
  1291.             console.log(".get(ReceitasController.getAviamentoById)");
  1292.             //obter todas as receitas
  1293.             //pesquisar em cada recita a lista das prescicoes e verificar se alguma delas tem o id igual ao passado no parametro
  1294.             //escrever
  1295.  
  1296.             //todas as receitas
  1297.             const receitas = await Receita.find({});
  1298.             const aviamentoId = req.params["AviamentoId"];
  1299.  
  1300.             for(var i in receitas) {
  1301.                 const prescricoes=receitas[i]["prescricoes"];
  1302.                 for (var j = 0; j < prescricoes.length; j++) {
  1303.                     const aviamentos=prescricoes[j].aviamentos;
  1304.                     for (var z = 0; z < aviamentos.length; z++){
  1305.                         if(aviamentoId==aviamentos[z]._id){
  1306.                             return res.status(200).json(aviamentos[z]);
  1307.                         }
  1308.                     }
  1309.                 }          
  1310.             }
  1311.  
  1312.             return res.status(404).json("Aviamento id nao encontrado");
  1313.  
  1314.         }catch(err){
  1315.             next(err);
  1316.         }
  1317.     },
  1318.    
  1319.  
  1320.  
  1321.     // ******** Outros ********
  1322.  
  1323.  
  1324.  
  1325.     //Get receitas por medico
  1326.     //router.route('/Medico/:MedicoId')
  1327.     //.get(ReceitasController.getReceitasMedico);
  1328.     getReceitasMedico: async function(req,res,next){
  1329.         try{
  1330.             /*
  1331.             if(req.path !== "/Prescricoes"){
  1332.                 next();
  1333.             }*/
  1334.  
  1335.             console.log("router.route('/Medico/:MedicoId')");
  1336.             console.log(".get(ReceitasController.getReceitasMedico)");
  1337.            
  1338.             const medicoId = req.params["MedicoId"];
  1339.             const receitas = await Receita.find({});
  1340.             var receitasMedico = new Array();
  1341.  
  1342.             for(var i in receitas) {
  1343.                 console.log("receitas[i]['medico']._id",receitas[i]["medico"]);
  1344.                 if(medicoId==receitas[i]["medico"]){
  1345.                     receitasMedico.push(receitas[i])
  1346.                 }          
  1347.             }
  1348.  
  1349.             console.log(receitasMedico);
  1350.             return res.status(200).json(receitasMedico);
  1351.  
  1352.  
  1353.         }catch(err){
  1354.  
  1355.         }
  1356.     },
  1357.  
  1358.  
  1359.  
  1360.     //Get receitas por medico
  1361.     //router.route('/Medico/:MedicoId')
  1362.     //.get(ReceitasController.getReceitasMedico);
  1363.     getReceitasMedico: async function(req,res,next){
  1364.         try{
  1365.             /*
  1366.             if(req.path !== "/Prescricoes"){
  1367.                 next();
  1368.             }*/
  1369.  
  1370.             console.log("router.route('/Medico/:MedicoId')");
  1371.             console.log(".get(ReceitasController.getReceitasMedico)");
  1372.            
  1373.             const medicoId = req.params["MedicoId"];
  1374.             const receitas = await Receita.find({});
  1375.             var receitasMedico = new Array();
  1376.  
  1377.             for(var i in receitas) {
  1378.  
  1379.                 if(medicoId==receitas[i]["medico"]){
  1380.                     receitasMedico.push(receitas[i])
  1381.                 }          
  1382.             }
  1383.  
  1384.             res.status(200).json(receitasMedico);
  1385.  
  1386.  
  1387.         }catch(err){
  1388.  
  1389.         }
  1390.     },
  1391.  
  1392.  
  1393.  
  1394.     //Get receitas por utente
  1395.     //router.route('/Utente/:UtenteId')
  1396.     //.get(ReceitasController.getReceitasUtente);
  1397.     getReceitasUtente: async function(req,res,next){
  1398.         try{
  1399.             /*
  1400.             if(req.path !== "/Prescricoes"){
  1401.                 next();
  1402.             }*/
  1403.  
  1404.             console.log("router.route('/Utente/:UtenteId')");
  1405.             console.log(".get(ReceitasController.getReceitasUtente)");
  1406.            
  1407.             const utenteId = req.params["UtenteId"];
  1408.             const receitas = await Receita.find({});
  1409.             var receitasUtente = new Array();
  1410.  
  1411.             for(var i in receitas) {
  1412.  
  1413.                 if(utenteId==receitas[i]["utente"]){
  1414.                     receitasUtente.push(receitas[i])
  1415.                 }          
  1416.             }
  1417.  
  1418.             res.status(200).json(receitasUtente);
  1419.  
  1420.         }catch(err){
  1421.  
  1422.         }
  1423.     },
  1424.  
  1425.  
  1426.    
  1427.  
  1428.     //Emitir receita ... enviar email ao utente
  1429.     //router.route('/:ReceitaId/Emitir')
  1430.     //.put(ReceitasController.emitirReceita);
  1431.  
  1432.     emitirReceita: async function(req, res, next) {
  1433.         try{
  1434.             console.log("router.route('/:ReceitaId/Emitir')");
  1435.             console.log(".put(ReceitasController.emitirReceita)");
  1436.             //obter o id da receita nos parametros
  1437.             const receitaId = req.params["ReceitaId"];
  1438.             console.log("receitaId",receitaId);
  1439.             const newReceita = await Receita.findById(receitaId);
  1440.             console.log("newReceita",newReceita);
  1441.             const user = await User.findById(newReceita["utente"]);
  1442.             console.log(user);
  1443.  
  1444.             var enviado=false;
  1445.  
  1446.             const utenteEmail = user["email"];
  1447.  
  1448.            
  1449.             if(newReceita["emitida"]===false){
  1450.                 newReceita["emitida"]=true;
  1451.                
  1452.  
  1453.                 const user = await User.findOne(newReceita["utente"]);
  1454.  
  1455.  
  1456.                 var transporter = nodemailer.createTransport({
  1457.                     service: 'Hotmail',
  1458.                     auth: {
  1459.                         user: 'gestor.receitas@hotmail.com', // Your email id
  1460.                         pass: 'GESTOR?receitas' // Your password
  1461.                     }
  1462.                 });
  1463.    
  1464.                 var text = 'Receita emitida: \n\n' + newReceita;          
  1465.  
  1466.                 var mailOptions = {
  1467.                     from: '<gestor.receitas@hotmail.com>', // sender address
  1468.                     to: utenteEmail, // list of receivers
  1469.                     subject: 'Emissao de Receita', // Subject line
  1470.                     text: text //, // plaintext body
  1471.                 };
  1472.  
  1473.    
  1474.                 transporter.sendMail(mailOptions, function(error, info){
  1475.                     if(error){
  1476.                         console.log(error);
  1477.                         res.json({error});
  1478.                     }else{
  1479.                         enviado=true;
  1480.                         console.log('Message sent: ' + info.response);
  1481.                         res.json({yo: info.response});
  1482.                     };
  1483.                     transporter.close();
  1484.                 });
  1485.  
  1486.                
  1487.            
  1488.                
  1489.             }
  1490.  
  1491.             if(enviado==true){
  1492.                 const result = await newReceita.save();
  1493.                 res.status(200).json(newReceita);
  1494.             }
  1495.            
  1496.         }
  1497.         catch(err){
  1498.             next(err);
  1499.         }
  1500.     }
  1501.  
  1502.  
  1503.  
  1504.  
  1505.  
  1506.    
  1507. }
Add Comment
Please, Sign In to add comment