Nodemailer avec Gmail et NodeJS

J'essaie d'utiliser nodemailer pour implémenter un formulaire de contact en utilisant NodeJS mais cela ne fonctionne qu'en local, cela ne fonctionne pas sur un serveur distant ...

Mon message d'erreur:

[website.fr-11 (out) 2013-11-09T15:40:26] { [AuthError: Invalid login - 534-5.7.14 <https://accounts.google.com/ContinueSignIn?sarp=1&scc=1&plt=AKgnsbvlX
[website.fr-11 (out) 2013-11-09T15:40:26] 534-5.7.14 V-dFQLgb7aRCYApxlOBuha5ESrQEbRXK0iVtOgBoYeARpm3cLZuUS_86kK7yPis7in3dGC
[website.fr-11 (out) 2013-11-09T15:40:26] 534-5.7.14 N1sqhr3D2IYxHAN3m7QLJGukwPSZVGyhz4nHUXv_ldo9QfqRydPhSvFp9lnev3YQryM5TX
[website.fr-11 (out) 2013-11-09T15:40:26] 534-5.7.14 XL1LZuJL7zCT5dywMVQyWqqg9_TCwbLonJnpezfBLvZwUyersknTP7L-VAAL6rhddMmp_r
[website.fr-11 (out) 2013-11-09T15:40:26] 534-5.7.14 A_5pRpA> Please log in via your web browser and then try again.
[website.fr-11 (out) 2013-11-09T15:40:26] 534-5.7.14 Learn more at https://support.google.com/mail/bin/answer.py?answer=787
[website.fr-11 (out) 2013-11-09T15:40:26] 534 5.7.14 54 fr4sm15630311wib.0 - gsmtp]
[website.fr-11 (out) 2013-11-09T15:40:26]   name: 'AuthError',
[website.fr-11 (out) 2013-11-09T15:40:26]   data: '534-5.7.14 <https://accounts.google.com/ContinueSignIn?sarp=1&scc=1&plt=AKgnsbvlX\r\n534-5.7.14 V-dFQLgb7aRCYApxlOBuha5ESrQEbRXK0iVtOgBoYeARpm3cLZuUS_86kK7yPis7in3dGC\r\n534-5.7.14 N1sqhr3D2IYxHAN3m7QLJGukwPSZVGyhz4nHUXv_ldo9QfqRydPhSvFp9lnev3YQryM5TX\r\n534-5.7.14 XL1LZuJL7zCT5dywMVQyWqqg9_TCwbLonJnpezfBLvZwUyersknTP7L-VAAL6rhddMmp_r\r\n534-5.7.14 A_5pRpA> Please log in via your web browser and then try again.\r\n534-5.7.14 Learn more at https://support.google.com/mail/bin/answer.py?answer=787\r\n534 5.7.14 54 fr4sm15630311wib.0 - gsmtp',
[website.fr-11 (out) 2013-11-09T15:40:26]   stage: 'auth' }

Mon contrôleur:

exports.contact = function(req, res){
    var name = req.body.name;
    var from = req.body.from;
    var message = req.body.message;
    var to = '*******@gmail.com';
    var smtpTransport = nodemailer.createTransport("SMTP",{
        service: "Gmail",
        auth: {
            user: "******@gmail.com",
            pass: "*****"
        }
    });
    var mailOptions = {
        from: from,
        to: to, 
        subject: name+' | new message !',
        text: message
    }
    smtpTransport.sendMail(mailOptions, function(error, response){
        if(error){
            console.log(error);
        }else{
            res.redirect('/');
        }
    });
}

J'ai résolu ce problème en accédant à l'url suivante (en étant connecté à google avec le compte à partir duquel je souhaite envoyer des e-mails):

https://www.google.com/settings/security/lesssecureapps

Là, j'ai activé des applications moins sécurisées.

Terminé

Consultez le guide officiel de nodemailer sur la connexion à Gmail:

https://community.nodemailer.com/using-gmail/

-

Cela fonctionne pour moi après avoir fait ceci:

1. Activez les applications moins sécurisées - https://www.google.com/settings/security/lesssecureapps
2. Désactivez temporairement Captcha pour pouvoir connecter le nouvel appareil / serveur - https://accounts.google.com/b/0/displayunlockcaptcha

Solution facile:

var nodemailer = require('nodemailer');
var smtpTransport = require('nodemailer-smtp-transport');

var transporter = nodemailer.createTransport(smtpTransport({
  service: 'gmail',
  host: 'smtp.gmail.com',
  auth: {
    user: 'somerealemail@gmail.com',
    pass: 'realpasswordforaboveaccount'
  }
}));

var mailOptions = {
  from: 'somerealemail@gmail.com',
  to: 'friendsgmailacc@gmail.com',
  subject: 'Sending Email using Node.js[nodemailer]',
  text: 'That was easy!'
};

transporter.sendMail(mailOptions, function(error, info){
  if (error) {
    console.log(error);
  } else {
    console.log('Email sent: ' + info.response);
  }
});  

Étape 1:

allez ici https://myaccount.google.com/lesssecureapps et activez les applications moins sécurisées. Si cela ne fonctionne pas,

Étape 2

allez ici https://accounts.google.com/DisplayUnlockCaptcha et activez / continuez puis essayez.

pour moi, l'étape 1 seule n'a pas fonctionné, j'ai donc dû passer à l'étape 2.

J'ai également essayé de supprimer le paquet nodemailer-smtp-transport et à ma grande surprise, cela fonctionne. mais quand j'ai redémarré mon système, cela m'a donné la même erreur, alors j'ai dû activer l'application la moins sécurisée (je l'ai désactivée après mon travail).

puis pour le plaisir, je viens de l'essayer sans (application moins sécurisée) et vola cela a fonctionné à nouveau!

Vous devez utiliser un jeton XOAuth2 pour vous connecter à Gmail. Pas de soucis, Nodemailer le sait déjà:

var smtpTransport = nodemailer.createTransport('SMTP', {
    service: 'Gmail',
    auth: {
      XOAuth2: {
        user: smtpConfig.user,
        clientId: smtpConfig.client_id,
        clientSecret: smtpConfig.client_secret,
        refreshToken: smtpConfig.refresh_token,
        accessToken: smtpConfig.access_token,
        timeout: smtpConfig.access_timeout - Date.now()
      }
    }
  };

Vous devrez accéder à la console Google Cloud pour enregistrer votre application. Ensuite, vous devez récupérer les jetons d'accès pour les comptes que vous souhaitez utiliser. Vous pouvez utiliser passeportjs pour cela.

Voici à quoi cela ressemble dans mon code:

var passport = require('passport'),
    GoogleStrategy = require('./google_oauth2'),
    config = require('../config');

passport.use('google-imap', new GoogleStrategy({
  clientID: config('google.api.client_id'),
  clientSecret: config('google.api.client_secret')
}, function (accessToken, refreshToken, profile, done) {
  console.log(accessToken, refreshToken, profile);
  done(null, {
    access_token: accessToken,
    refresh_token: refreshToken,
    profile: profile
  });
}));

exports.mount = function (app) {
  app.get('/add-imap/:address?', function (req, res, next) {
    passport.authorize('google-imap', {
        scope: [
          'https://mail.google.com/',
          'https://www.googleapis.com/auth/userinfo.email'
        ],
        callbackURL: config('web.vhost') + '/add-imap',
        accessType: 'offline',
        approvalPrompt: 'force',
        loginHint: req.params.address
      })(req, res, function () {
        res.send(req.user);
      });
  });
};

J'ai eu le même problème. Autoriser les "applications moins sécurisées" dans mes paramètres de sécurité Google a permis de le faire fonctionner!

A bien fonctionné:

1- installer nodemailer , package s'il n'est pas installé (tapez cmd):npm install nodemailer

2- Accédez à https://myaccount.google.com/lesssecureapps et activez Autoriser les applications moins sécurisées .

3- écrire du code:

var nodemailer = require('nodemailer');

var transporter = nodemailer.createTransport({
    service: 'gmail',
    auth: {
        user: 'trueUsername@gmail.com',
        pass: 'truePassword'
    }
});

const mailOptions = {
    from: 'any@any.com', // sender address
    to: 'true@true.com', // list of receivers
    subject: 'test mail', // Subject line
    html: '<h1>this is a test mail.</h1>'// plain text body
};

transporter.sendMail(mailOptions, function (err, info) {
    if(err)
        console.log(err)
    else
        console.log(info);
})

4- profitez-en!

Le même problème m'est arrivé aussi. J'ai testé mon système sur localhost puis déployé sur le serveur (qui est situé dans un pays différent), puis lorsque j'essaye le système sur le serveur de production, j'ai vu cette erreur. J'ai essayé ceux-ci pour le réparer:

1. https://www.google.com/settings/security/lesssecureapps Je l'ai activé mais ce n'était pas ma solution
2. https://g.co/allowaccess J'ai autorisé l'accès de l'extérieur pendant un temps limité et cela a résolu mon problème.

Pour moi, cela fonctionne de cette façon, en utilisant le port et la sécurité (j'ai eu des problèmes pour envoyer des e-mails à partir de gmail en utilisant PHP sans paramètres de sécurité)

J'espère aidera quelqu'un.

var sendEmail = function(somedata){
  var smtpConfig = {
    host: 'smtp.gmail.com',
    port: 465,
    secure: true, // use SSL, 
                  // you can try with TLS, but port is then 587
    auth: {
      user: '***@gmail.com', // Your email id
      pass: '****' // Your password
    }
  };

  var transporter = nodemailer.createTransport(smtpConfig);
  // replace hardcoded options with data passed (somedata)
  var mailOptions = {
    from: 'xxxx@gmail.com', // sender address
    to: 'yyyy@gmail.com', // list of receivers
    subject: 'Test email', // Subject line
    text: 'this is some text', //, // plaintext body
    html: '<b>Hello world ✔</b>' // You can choose to send an HTML body instead
  }

  transporter.sendMail(mailOptions, function(error, info){
    if(error){
      return false;
    }else{
      console.log('Message sent: ' + info.response);
      return true;
    };
  });
}

exports.contact = function(req, res){
   // call sendEmail function and do something with it
   sendEmail(somedata);
}

toutes les config sont listées ici (y compris des exemples)

Aucune des solutions ci-dessus n'a fonctionné pour moi. J'ai utilisé le code qui existe dans la documentation de NodeMailer . Cela ressemble à ceci:

let transporter = nodemailer.createTransport({
    host: 'smtp.gmail.com',
    port: 465,
    secure: true,
    auth: {
        type: 'OAuth2',
        user: 'user@example.com',
        serviceClient: '113600000000000000000',
        privateKey: '-----BEGIN PRIVATE KEY-----\nMIIEvgIBADANBg...',
        accessToken: 'ya29.Xx_XX0xxxxx-xX0X0XxXXxXxXXXxX0x',
        expires: 1484314697598
    }
}); 

Essayez de désactiver les captchas dans votre compte Gmail; étant probablement déclenché en fonction de l'adresse IP du demandeur. Voir: Comment utiliser GMail en tant que serveur SMTP gratuit et surmonter le captcha

J'ai trouvé que la méthode la plus simple, décrite dans cet article mentionné dans la réponse de Greg T , était de créer un mot de passe d'application disponible après l'activation de 2FA pour le compte.

myaccount.google.com> Connexion et sécurité> Connexion à Google> Mots de passe d'application

Cela vous donne un mot de passe alternatif pour le compte, puis vous configurez simplement nodemailer en tant que service SMTP normal.

var smtpTransport = nodemailer.createTransport({
    host: "smtp.gmail.com",
    port: 587,
    auth: {
        user: "username@gmail.com",
        pass: "app password"
    }
});

Bien que Google recommande Oauth2 comme la meilleure option, cette méthode est simple et n'a pas encore été mentionnée dans cette question.

Conseil supplémentaire: j'ai également trouvé que vous pouvez ajouter le nom de votre application à l'adresse «de» et GMail ne le remplace pas uniquement par l'adresse e-mail du compte, comme il le fait si vous essayez d'utiliser une autre adresse. c'est à dire.

from: 'My Pro App Name <username@gmail.com>'

Il est résolu en utilisant le nodemailer-smtp-transportmodule dans createTransport.

var smtpTransport = require('nodemailer-smtp-transport');

var transport = nodemailer.createTransport(smtpTransport({
    service: 'gmail',
    auth: {
        user: '*******@gmail.com',
        pass: '*****password'
    }
}));

Si vous utilisez Express, express-mailers'enroule nodemailertrès bien et est très facile à utiliser:

//# config/mailer.js    
module.exports = function(app) {
  if (!app.mailer) {
    var mailer = require('express-mailer');
    console.log('[MAIL] Mailer using user ' + app.config.mail.auth.user);
    return mailer.extend(app, {
      from: app.config.mail.auth.user,
      host: 'smtp.gmail.com',
      secureConnection: true,
      port: 465,
      transportMethod: 'SMTP',
      auth: {
        user: app.config.mail.auth.user,
        pass: app.config.mail.auth.pass
      }
    });
  }
};

//# some.js
require('./config/mailer.js)(app);
app.mailer.send("path/to/express/views/some_view", {
  to: ctx.email,
  subject: ctx.subject,
  context: ctx
}, function(err) {
  if (err) {
    console.error("[MAIL] Email failed", err);
    return;
  }
  console.log("[MAIL] Email sent");
});

//#some_view.ejs
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
  <head>
    <title><%= subject %></title>
  </head>
  <body>
  ... 
  </body>
</html>

tout votre code est correct, il ne vous reste que le lien https://myaccount.google.com/security

et continuez à faire défiler vers le bas et vous trouverez Autoriser les applications moins sécurisées: ON et continuer, vous ne trouverez aucune erreur.

Ajoutez simplement "hôte", cela fonctionnera.

host: 'smtp.gmail.com'

Puis activez "lesssecureapps" en cliquant sur le lien ci-dessous

https://myaccount.google.com/lesssecureapps

Pour une raison quelconque, le simple fait d'autoriser une configuration d'application moins sécurisée ne fonctionnait pas pour moi, même le captcha. J'ai dû faire une autre étape qui consiste à activer la configuration IMAP:

Depuis la page d'aide de Google: https://support.google.com/mail/answer/7126229?p=WebLoginRequired&visit_id=1-636691283281086184-1917832285&rd=3#cantsignin

• En haut à droite, cliquez sur Paramètres Paramètres.
• Cliquez sur Paramètres.
• Cliquez sur l'onglet Transfert et POP / IMAP.
• Dans la section "Accès IMAP", sélectionnez Activer IMAP.
• Cliquez sur Enregistrer les modifications.

exports.mailSend = (res, fileName, object1, object2, to, subject,   callback)=> {
var smtpTransport = nodemailer.createTransport('SMTP',{ //smtpTransport
host: 'hostname,
port: 1234,
secureConnection: false,
//   tls: {
//     ciphers:'SSLv3'
// },
auth: {
  user: 'username',
  pass: 'password'
}

});
res.render(fileName, {
info1: object1,
info2: object2
}, function (err, HTML) {

smtpTransport.sendMail({
  from: "mail@from.com",
  to: to,
  subject: subject,
  html: HTML
}
  , function (err, responseStatus) {
      if(responseStatus)
    console.log("checking dta", responseStatus.message);
    callback(err, responseStatus)
  });
});
}

Vous devez ajouter le type secureConnection dans votre code.

J'utilisais une ancienne version de nodemailer 0.4.1 et j'avais ce problème. J'ai mis à jour à 0.5.15 et tout fonctionne bien maintenant.

Package.json édité pour refléter les changements ensuite

npm install

Assistez simplement à ceux-ci: 1- L'authentification Gmail pour autoriser les e-mails de bas niveau n'accepte pas avant de redémarrer votre navigateur client 2- Si vous souhaitez envoyer un e-mail avec nodemailer et que vous ne souhaitez pas utiliser le protocole xouath2, vous devez écrire comme secureconnection: false comme ci-dessous

const routes = require('express').Router();
var nodemailer = require('nodemailer');
var smtpTransport = require('nodemailer-smtp-transport');



routes.get('/test', (req, res) => {
  res.status(200).json({ message: 'test!' });
});

routes.post('/Email', (req, res) =>{

    var smtpTransport = nodemailer.createTransport({
        host: "smtp.gmail.com",
        secureConnection: false,
        port: 587,
        requiresAuth: true,
        domains: ["gmail.com", "googlemail.com"],
        auth: {
            user: "your gmail account", 
            pass: "your password*"
        }
});  

  var mailOptions = {
      from: 'from@gmail.com',
      to:'to@gmail.com',
      subject: req.body.subject,
      //text: req.body.content,
      html: '<p>'+req.body.content+' </p>'
  };

  smtpTransport.sendMail(mailOptions, (error, info) => {
    if (error) {
        return console.log('Error while sending mail: ' + error);
    } else {
        console.log('Message sent: %s', info.messageId);
    }
    smtpTransport.close();
});  

})

module.exports = routes;

installez d'abord nodemailer

npm install nodemailer  --save

importer dans un fichier js

const nodemailer = require("nodemailer");

const smtpTransport = nodemailer.createTransport({
    service: "Gmail",
    auth: {
        user: "example@gmail.com",
        pass: "password"
    },
    tls: {
        rejectUnauthorized: false
    }
});






 const mailOptions = {
        from: "example@gmail.com",
        to: sending@gmail.com,
        subject: "Welcome to ",
        text: 'hai send from me'.
    };


    smtpTransport.sendMail(mailOptions, function (error, response) {
        if (error) {
            console.log(error);
        }
        else {
            console.log("mail sent");
        }
    });

travaillant dans mon application