Node.js versendet E-Mails basierend auf dem STMP-Protokoll und dem EWS-Protokoll

/**
 * Verwenden Sie Nodemailer, um STMP-E-Mails zu senden. * @param {Object} wählt die Konfiguration zum Senden von E-Mails aus. * @param {Object} smtpCfg SMTP-Serverkonfiguration */
asynchrone Funktion sendMail(opts, smtpCfg) {
 const resultInfo = { code: 0, msg: '', result: null };
 wenn (!smtpCfg) {
 resultInfo.msg = „Informationen zum Senden von E-Mails sind nicht konfiguriert“;
 ErgebnisInfo.code = -1009;
 Ergebnisinfo zurückgeben;
 }

 // Ein Mail-Objekt erstellen const mailOpts = Object.assign(
 {
 // Absender von: `Benachrichtigen <${smtpCfg.auth.user}>`,
 // Betreff: 'Benachrichtigen',
 // Text: opts.content,
 //html: opts.inhalt,
 // Inhalt des Anhangs // /*attachments: [{
 // Dateiname: 'data1.json',
 // Pfad: Pfad.resolve(__dirname, 'data1.json')
 // }, {
 // Dateiname: 'pic01.jpg',
 // Pfad: Pfad.auflösen(__dirname, 'pic01.jpg')
 // }, {
 // Dateiname: 'test.txt',
 // Pfad: Pfad.auflösen(__dirname, 'test.txt')
 // }],*/
 },
 Optionen
 );

 wenn (!mailOpts.to) mailOpts.to = [];
 wenn (!Array.isArray(mailOpts.to)) mailOpts.to = String(mailOpts.to).split(',');
 mailOpts.to = mailOpts.to.map(m => String(m).trim()).filter(m => m.includes('@'));

 wenn (!mailOpts.to.length) {
 resultInfo.msg = „Der E-Mail-Empfänger ist nicht konfiguriert“;
 resultInfo.code = -1010;
 Ergebnisinfo zurückgeben;
 }

 const mailToList = mailOpts.to;
 const transporter = nodemailer.createTransport(smtpCfg);

 // an Liste, die separat gesendet werden soll (const to of mailToList) {
 mailOpts.to = to.trim();
 versuchen {
 const info = warte auf transporter.sendMail(mailOpts);
 console.log('Mail gesendet an:', mailOpts.to, 'Antwort:', info.response);
 resultInfo.msg = info.antwort;
 } Fehler abfangen {
 konsole.log(Fehler);
 ErgebnisInfo.code = -1001;
 resultInfo.msg = Fehler;
 }
 }

 Ergebnisinfo zurückgeben;
}

Konstantenoptionen = {
 Betreff: 'Thema für Test',
 /** E-Mail-Inhalt im HTML-Format*/
 html: `E-Mail-Inhalt für Test: <a href="https://lzw.me" rel="external nofollow" rel="external nofollow" >https://lzw.me</a>`,
 /** TEXT E-Mail-Inhalt im Textformat*/
 text: '',
 an: '[email protected]',
 //Anhangsliste//attachments: [],
};
const smtpConfig = {
 Host: „smtp.qq.com“, //QQ: smtp.qq.com; NetEase: smtp.163.com
 Port: 465, //Portnummer. QQ-Postfach 465, NetEase-Postfach 25
 sicher: wahr,
 Autorisierung:
 Benutzer: '[email protected]', //E-Mail-Kontokennwort: '', //E-Mail-Autorisierungscode},
};
sendMail(opts, smtpConfig).then(Ergebnis => console.log(Ergebnis));

EWS von „node-ews“ importieren;

Schnittstelle IEwsSendOptions exportieren {
 Autorisierung:
 Benutzer: Zeichenfolge;
 Pass?: Zeichenfolge;
 /** Der verschlüsselte Kennwortschlüssel (NTLMAuth.nt_password). Wenn es sich um einen String handelt, sollte es das Ergebnis der Hex-Kodierung sein*/
 nt_password?: Zeichenfolge | Puffer;
 /** Mit Passwort verschlüsselter Schlüssel (NTLMAuth.lm_password). Wenn es sich um einen String handelt, sollte es das Ergebnis der Hex-Kodierung sein*/
 lm_password?: Zeichenfolge | Puffer;
 };
 /**Adresse austauschen*/
 Host?: Zeichenfolge;
 /** E-Mail-Betreff */
 Betreff?: Zeichenfolge;
 /** E-Mail-Inhalt im HTML-Format*/
 html?: Zeichenfolge;
 /** TEXT – Inhalt des E-Mail-Textkörpers im Textformat (niedrigere Priorität als HTML-Parameter) */
 Text?: Zeichenfolge;
 zu?: Zeichenfolge;
}

/**
 * E-Mail über Exchange (EWS) senden*/
exportiere asynchrone Funktion sendMailByNodeEws(Optionen: IEwsSendOptions) {
 const resultInfo = { code: 0, msg: '', result: null };

 if (!Optionen) {
 ErgebnisInfo.code = -1001;
 resultInfo.msg = „Optionen dürfen nicht null sein“;
 } sonst wenn (!options.auth) {
 ErgebnisInfo.code = -1002;
 resultInfo.msg = 'Options.auth{user,pass} darf nicht null sein';
 } sonst wenn (!options.auth.user || (!options.auth.pass && !options.auth.lm_password)) {
 ErgebnisInfo.code = -1003;
 resultInfo.msg = „Options.auth.user oder Options.auth.password dürfen nicht null sein“;
 }

 wenn (ErgebnisInfo.Code) ErgebnisInfo zurückgeben;

 const ewsConfig = {
 Benutzername: options.auth.user,
 Passwort: options.auth.pass,
 nt_password: Optionen.auth.nt_password,
 lm_password: Optionen.auth.lm_password,
 Host: Optionen.Host,
 // Authentifizierung: "basic",
 };

 wenn (ewsConfig.nt_password && Typ von ewsConfig.nt_password === 'Zeichenfolge') {
 ewsConfig.nt_password = Puffer.from(ewsConfig.nt_password, 'hex');
 }

 wenn (ewsConfig.lm_password && Typ von ewsConfig.lm_password === 'Zeichenfolge') {
 ewsConfig.lm_password = Puffer.from(ewsConfig.lm_password, 'hex');
 }

 Objekt.Schlüssel(ewsConfig).forEach(Schlüssel => {
 wenn (!ewsConfig[Schlüssel]) lösche ewsConfig[Schlüssel];
 });

 // node-ews initialisieren
 const ews = new EWS(ewsConfig);
 // EWS-API-Funktion definieren
 const ewsFunction = "Erstellen eines Elements";
 // Argumente der EWS-API-Funktion definieren
 const ewsArgs = {
 Attribute:
  MessageDisposition: 'SendenUndSpeichernKopie',
 },
 GespeicherteItemFolderId: {
  DistinguishedFolderId: {
  Attribute:
   ID: 'sentitems',
  },
  },
 },
 Artikel: {
  Nachricht: {
  Artikelklasse: 'IPM.Note',
  Betreff: options.subject,
  Körper: {
   Attribute:
   BodyType: options.html ? 'HTML' : 'Text',
   },
   $Wert: Optionen.html || Optionen.text,
  },
  An Empfänger: {
   Postfach:
   E-Mail-Adresse: options.to,
   },
  },
  IsRead: 'false',
  },
 },
 };

 versuchen {
 const Ergebnis = warte auf ews.run(ewsFunction, ewsArgs);
 // console.log('Mail gesendet an:', options.to, 'Antwort:', Ergebnis);
 resultInfo.result = Ergebnis;
 wenn (Ergebnis.ResponseMessages.MessageText) resultInfo.msg = Ergebnis.ResponseMessages.MessageText;
 } fangen (Fehler) {
 Konsole.log(Fehlerstapel);
 ErgebnisInfo.code = 1001;
 resultInfo.msg = Fehlerstapel;
 }

 Ergebnisinfo zurückgeben;
}

sendMailByNodeEws({
 Autorisierung:
 Benutzer: '[email protected]',
 Pass: '123456',
 /** Der verschlüsselte Kennwortschlüssel (NTLMAuth.nt_password). Wenn es sich um einen String handelt, sollte es das Ergebnis der Hex-Kodierung sein*/
 nt_password: '',
 /** Mit Passwort verschlüsselter Schlüssel (NTLMAuth.lm_password). Wenn es sich um einen String handelt, sollte es das Ergebnis der Hex-Kodierung sein*/
 lm_password: '',
 },
 /**Adresse austauschen*/
 Host: 'https://ews.xxx.com',
 /** E-Mail-Betreff */
 Betreff: 'Thema für Test',
 /** E-Mail-Inhalt im HTML-Format*/
 html: `E-Mail-Inhalt für Test: <a href="https://lzw.me" rel="external nofollow" rel="external nofollow" >https://lzw.me</a>`,
 /** TEXT – Inhalt des E-Mail-Textkörpers im Textformat (niedrigere Priorität als HTML-Parameter) */
 text: '',
 an: '[email protected]',
})

importiere { ntlm als NTLMAuth } von 'httpntlm';

/** Konvertieren Sie das eingegebene E-Mail-Kontokennwort in das NTLMAuth-Schlüsselformat (Hex) und geben Sie es aus*/
const getHashedPwd = () => {
 const passwordPlainText = process.argv.slice(2)[0];

 wenn (!passwordPlainText) {
 console.log('VERWENDUNG: \n\tnode get-hashed-pwd.js [Passwort]');
 zurückkehren;
 }

 const nt_password = NTLMAuth.create_NT_hashed_password(passwordPlainText.trim());
 const lm_password = NTLMAuth.create_LM_hashed_password(passwordPlainText.trim());

 // console.log('\n Passwort:', passwordPlainText);
 console.log(`nt_password:`, nt_password.toString('hex'));
 console.log(`lm_password:`, lm_password.toString('hex'));

 zurückkehren {
 nt_password,
 lm_password,
 };
};

getHashedPwd();

/**
 * Verwenden Sie `ews-javascript-api` um (MS Exchange) E-Mails zu senden */
exportiere asynchrone Funktion sendMailByEwsJApi(Optionen: IEwsSendOptions) {
 const resultInfo = { code: 0, msg: '', result: null };

 if (!Optionen) {
 ErgebnisInfo.code = -1001;
 resultInfo.msg = „Optionen dürfen nicht null sein“;
 } sonst wenn (!options.auth) {
 ErgebnisInfo.code = -1002;
 resultInfo.msg = 'Options.auth{user,pass} darf nicht null sein';
 } sonst wenn (!options.auth.user || (!options.auth.pass && !options.auth.lm_password)) {
 ErgebnisInfo.code = -1003;
 resultInfo.msg = „Options.auth.user oder Options.auth.password dürfen nicht null sein“;
 }

 const ews = erfordern('ews-javascript-api');
 const exch = neuer ews.ExchangeService(ews.ExchangeVersion.Exchange2010);
 exch.Credentials = neue ews.WebCredentials(Optionen.auth.user, Optionen.auth.pass);
 exch.Url = neuer ews.Uri(Optionen.Host);
 ews.EwsLogging.DebugLogEnabled = true; // false, um das Debuggen auszuschalten.

 const msgattach = neue ews.EmailMessage(exch);
 msgattach.Subject = Optionen.Subject;
 msgattach.Body = neuer ews.MessageBody(ews.BodyType.HTML, escape(optionen.html || optionen.text));
 wenn (!Array.isArray(options.to)) options.to = [options.to];
 Optionen.zu.fürEach(zu => msgattach.ToRecipients.Add(zu));
 // msgattach.Importance = ews.Importance.High;

 // Anhang senden // msgattach.Attachments.AddFileAttachment('anzuhängender Dateiname.txt', 'c29tZSB0ZXh0');

 versuchen {
 const Ergebnis = warte auf msgattach.SendAndSaveCopy(); // .Send();
 console.log('FERTIG!', Ergebnis);
 resultInfo.result = Ergebnis;
 } fangen (Fehler) {
 console.log('FEHLER:', err);
 ErgebnisInfo.code = 1001;
 resultInfo.msg = Fehler;
 }
 Ergebnisinfo zurückgeben;
}