constructor() {
     let useSMTP = !!process.env.EMAIL_SMTP;
     if (useSMTP) {
         this.transporter = createTransport(process.env.EMAIL_SMTP);
     } else {
         // default to SES
         if (process.env.EMAIL_SES) {
             this.transporter = createTransport(sesTransport(JSON.parse(process.env.EMAIL_SES)));
         } else {
             this.transporter = createTransport(sesTransport({}));
         }
     }
 }

    constructor(generatorOptions, service?) {
        service = service || 'gmail';

        if(typeof generatorOptions === 'object'){
            this.transporter = nodemailer.createTransport({
                service: service,
                auth: {
                    xoauth2: createXOAuth2Generator(generatorOptions)
                }
            });
        } else {
            this.transporter = nodemailer.createTransport(generatorOptions);
        }
    }

	/**
	 * Sends an email.
	 *
	 * @param requestState
	 * @param {UserDocument} user Recipient
	 * @param {string} subject Subject of the email
	 * @param {string} template Name of the Handlebars template, without path or extension
	 * @param {object} templateData Data passed to the Handlebars renderer
	 * @param {string} [enabledFlag] If set, user profile must have this preference set to true
	 * @param {string} [emailAddress] If set, this email as the recipient's email instead of the user's default.
	 * @return Promise<SentMessageInfo>
	 */
	private async sendEmail(requestState: RequestState, user: UserDocument, subject: string, template: string, templateData: object, enabledFlag?: string, emailAddress?: string): Promise<SentMessageInfo> {

		const what = template.replace(/-/g, ' ');
		if (!this.emailEnabled(user, enabledFlag)) {
			logger.info(requestState, '[mailer.sendEmail] NOT sending %s email to <%s>.', what, user.email);
			return;
		}

		// generate content
		const tpl = await this.getTemplate(template);
		const text = this.wrap(tpl(templateData), 60);

		// setup email
		const email: Mail.Options = {
			from: { name: config.vpdb.email.sender.name, address: config.vpdb.email.sender.email },
			to: { name: user.name, address: emailAddress || user.email },
			subject,
			text,
		};

		// create reusable transporter object using the default SMTP transport
		const transport = nodemailer.createTransport(config.vpdb.email.nodemailer);
		logger.info(requestState, '[mailer.sendEmail] Sending %s email to <%s>...', what, (email.to as Address).address);
		const status = await transport.sendMail(email);

		if (status.messageId) {
			logger.info(requestState, '[mailer.sendEmail] Successfully sent %s mail to <%s> with message ID "%s" (%s).', what, (email.to as Address).address, status.messageId, status.response);
		} else {
			logger.info(requestState, '[mailer.sendEmail] Failed sending %s mail to <%s>: %s.', what, (email.to as Address).address, status.response);
		}
		return status;
	}

  .https.onCall(async (data) => {

    const transporter = nodemailer.createTransport({
      host: 'mail.sfwinterbach.com',
      port: 465,
      secure: true,
      auth: {
        user: functions.config().mailer.email,
        pass: functions.config().mailer.password
      }
    });

    const fromName = 'Kontakt';
    const fromEmail = '[email protected]';
    const to = data.to;
    const text = data.text;

    const mailOptions = {
      from: fromName + ' <' + fromEmail + '>',
      to: to,
      subject: 'Anfrage auf ' + transporter.host,
      text: text,
      html: text,
    };

    const info = await transporter.sendMail(mailOptions);
    console.log('Message sent: %s', info.messageId);
    console.log('Preview URL: %s', nodemailer.getTestMessageUrl(info));
    console.log(info);
    return info;
  });

// EMAIL VERIFICATION
async function email_request(req, res, next) {
  try {
    let found_user:any = await pendingUser.findOne({ _id: req.body.user_id })
    if(!found_user) return res.status(500).send({message: 'User not found'})

    let duplicate_user:any = await pendingUser.findOne({ email: req.body.email })
    let email_in_use = false
    if(duplicate_user) email_in_use = duplicate_user.social_id !== found_user.social_id
    if(await realUser.findOne({ email: req.body.email }) || email_in_use || found_user.email_verified ) return res.status(500).send({ message: 'The email adress is already getting used' })

    let token:any = new emailToken({ user_id: found_user._id, token: crypto.randomBytes(16).toString('hex') })
    await token.save()

    found_user.email = CryptoJS.AES.encrypt(req.body.email, process.env.DECRYPT_KEY);

    await found_user.save()

    let confirmation_link = process.env.NODE_ENV === 'production' ? `https://signup.utopian.io` : `http://localhost:${process.env.REGISTRATION_FRONTEND_PORT}`
    let transporter = nodemailer.createTransport({ host: 'smtp.gmail.com', port: 465, secure: true, auth: { user: process.env.GOOGLE_MAIL_ACCOUNT, pass: process.env.GOOGLE_MAIL_PASSWORD } })
    let mailOptions = { from: process.env.GOOGLE_MAIL_ACCOUNT, to: req.body.email, subject: 'Utopian Email Confirmation', text: 'Hey there,\n\n' + `Please confirm your email for Utopian.io by clicking on this link: ${confirmation_link}/email/confirm/${token.token}` + '.\n' }
    await transporter.sendMail(mailOptions)
    res.status(200).send('A verification email has been sent to ' + found_user.email + '.')
  } catch (error) {
    console.error(error.message)
    res.status(500).json({ message: filter_error_message(error.message)})
  }
}

 static sendEmail(mailOptions) {
   const email = encodeURIComponent(functions.config().smtp.email);
   const password = encodeURIComponent(functions.config().smtp.password);
   const mailTransport = nodemailer.createTransport(
     `smtps://${email}:${password}@authsmtp.uchicago.edu`,
   );
   return new Promise(resolve => mailTransport.sendMail(mailOptions, resolve));
 }

export const sendReplyEmail = (address: IAddress) => {
  if (transporter == null) {
    transporter = nodemailer.createTransport({
      /**
       * 采用连接池链接，节省资源
       */
      pool: true as any,
      /**
       * qq 邮箱配置文档
       * http://service.mail.qq.com/cgi-bin/help?subtype=1&&id=28&&no=331
       */
      host: 'smtp.qq.com',
      port: 587,
      // secure: true,
      auth: {
        user: process.env.QQSMTP_USER,
        pass: process.env.QQSMTP_PASS,
      }
    })
  }
  const html = replyTemplate(address.data)
  log.info('sendEmail.ready', {
    address,
    html
  })
  let mailOptions = {
    /**
     * 发件人，email 必须和 user 一致
     */
    from: `Said <${process.env.QQSMTP_USER}>`, // sender address
    /**
     * 收件人，多个人使用 , 号分割
     * [email protected], Mailer <[email protected]>
     */
    to: address.to, // list of receivers
    /**
     * 标题
     */
    subject: address.subject, // Subject line
    /**
     * 邮件正文
     */
    html,   // html body
  }
  /**
   * 发送邮件
   */
  transporter.sendMail(mailOptions).then(messageInfo => {
    log.info('sendEmail.success', messageInfo)
  }).catch(err => {
    log.error('sendEmail.error', err)
  })
}

  async setup () {
    // create reusable transporter method (opens pool of SMTP connections)
    this.insert(nodemailer.createTransport(this.config.transport))

    if (this.config.plugins) {
      for (let pluginKey of Object.keys(this.config.plugins)) {
        this.app.nodemailer.use(pluginKey, this.config.plugins[pluginKey])
      }
    }

    await this.app.nodemailer.verify()
  }

export function sendResetMail(to, from, content, options, done) {
	var smtpTransport = nodemailer.createTransport(options);
	var mailOptions = {
		to: to,
		from: from,
		subject: "Password Reset",
		html: content
	};
	smtpTransport.sendMail(mailOptions, (err) => {
		return done(err);
	});
}

    router.post('/contact', function (req, res) {
        console.log("Contact information " + req.body.name + "   " + req.body.email + "   " + req.body.message);
        var transporter = nodemailer.createTransport({
            service: 'Gmail',
            auth: config.mail
        });
        config.mailOptions.subject = 'Cleaning customer ' + req.body.name;
        config.mailOptions.text = req.body.message + "\n" + "From: " + req.body.email;
        transporter.sendMail(config.mailOptions, function (error, info) {
///            res.redirect("/");
        });
    });

postman.init = () => {

   const email = mailer.createTransport({
       service: appConfig.smtp_service.name,
       auth: {
           user: appConfig.smtp_service.username,
           pass: appConfig.smtp_service.password
       }
   });

   postman._email = email;

};

    nodemailer.createTestAccount((_err, _account) => {
      const transporter = nodemailer.createTransport(config.mail);

      // setup email data with unicode symbols
      const mailOptions = {
        from: `"RAP2 Notifier" <${config.mailSender}>`, // sender address
        to,
        subject,
        html,
      };

      // send mail with defined transport object
      transporter.sendMail(mailOptions)
    })

export async function getTransport (): Promise<nodemailer.Transporter> {
  try {
    let config = await getMailConfig(process.env.NODE_ENV || 'development')
    let logger = getLogger(config.logfile)
    let transport = nodemailer.createTransport(mailGun({
      auth: {
        api_key: config.api_key,
        domain: config.domain
      },
      logger: logger
    }))
    return transport
  } catch (err) {
    throw err
  }
}

 sendEmail: function (to: string, subject: string, content: string, callback: void) {
     var mailer = require("nodemailer");
     var smtpTransport = mailer.createTransport("SMTP", {
         service: "Gmail",
         auth: {
             user: '[email protected]',
             pass: 'ttlpta840465'
         }
     });
     var mailOptions = {
         to: to,
         subject: subject,
         text: content
     };
     smtpTransport.sendMail(mailOptions, callback);
 },

	constructor() {
		super();

		this.smtpOptions = {
			host: Mailer.host,
			port: Mailer.port,
			secure: Mailer.secureConnection,
			auth: {
				user: Mailer.username,
				pass: Mailer.password,
			},
			requireTLS: Mailer.requireTLS,
		};
		this.transporter = Nodemailer.createTransport(this.smtpOptions);
		this.validator = new Validator();
		this.emailTemplates = new EmailTemplates();
	}

        handler: async function (req, res, next) {
            const model: Requests.ForgotPassword = req.validatedBody;
            let user: User;

            if (!UserDb.exists(model.username.toLowerCase())) {
                // Do not let the client know that the username does not exist.

                return next();
            }

            const token = await seal({
                exp: Date.now() + ((1000 * 60) * 90), // 90 minutes in milliseconds
                username: model.username,
            } as ResetToken, Constants.IRON_PASSWORD);

            const url = `${req.domainWithProtocol}/auth/reset-password?token=${encodeURIComponent(token)}`;
            const message = {
                content: {
                    from: {
                        name: "Support",
                        email: `support@${Constants.EMAIL_DOMAIN}`,
                    },
                    subject: `[${Constants.APP_NAME}] Reset your password.`,
                    html: `<p>Hello,</p><p>You recently requested to reset your password for ${Constants.APP_NAME}. Please click the link below to reset your password.</p><p><a href='${url}'>Click here to reset your password.</a></p><p>If you did not request a password reset, please ignore this email or reply to let us know. This password reset is only valid for the next 90 minutes.</p><p>Thanks, <br/> The ${Constants.APP_NAME} Team</p>`
                },
                recipients: [{
                    address: {
                        email: model.username,
                    }
                }]
            }

            //Send the password reset email
            const transporter = createTransport({ transport: 'sparkpost', sparkPostApiKey: Constants.SPARKPOST_API_KEY } as any);

            transporter.sendMail(message as any, (error, info) => {
                if (error) {
                    return next(boom.wrap(error));
                };

                res.json({});

                return next();
            });
        }

 function sendResetPasswordEmail(user: UserModel, done: Function) {
   const transporter = nodemailer.createTransport({
     service: "SendGrid",
     auth: {
       user: process.env.SENDGRID_USER,
       pass: process.env.SENDGRID_PASSWORD
     }
   });
   const mailOptions = {
     to: user.email,
     from: "[email protected]",
     subject: "Your password has been changed",
     text: `Hello,\n\nThis is a confirmation that the password for your account ${user.email} has just been changed.\n`
   };
   transporter.sendMail(mailOptions, (err) => {
     req.flash("success", { msg: "Success! Your password has been changed." });
     done(err);
   });
 }

let send = (message:Message, callback:Callback):void => {
  let transporter = nodeMailer.createTransport({
    service: 'gmail',
    auth: {
      user: GMAIL_APP_EMAIL,
      pass: GMAIL_APP_PASSWORD
    }
  }, {
    from: GMAIL_SENDER_EMAIL
  });
  transporter.sendMail(message, (error, info) => {
    if (error) {
      console.log('Message not sent: ' + error);
      callback(false);
    }
    console.log('Message sent: ' + info.response);
    callback(true);
  });
};

    async sendMail(ctx, next) {
        const id = ctx.request.body['username'],
            email = ctx.request.body['email'];
        let transporter = nodemailer.createTransport({
            service: 'QQ',
            auth: {
                user: '[email protected]',
                pass: 'puvisfhhlggpbdjg'
            }
        });

        let code = (new Date).getTime();
        dict[id] = code;

        let mailOptions = {
            from: '[email protected]', // sender address
            to: email,
            // to: '[email protected]', // list of receivers
            subject: '某某某网站邮箱验证', // Subject line
            text: '某某某网站邮箱验证', // plaintext body
            html: `
                <div>
                    <p>${id}，您好：</p>
                    <p style="text-indent: 2em;">感谢您使用某某某网站！</p>
                    <p style="text-indent: 2em;">请点击如下链接，以完成您账户的注册：</p>
                    <p style="text-indent: 2em;">
                        <a href='http://192.168.99.100:8080/api/v2/user/${id}/verifiy-code/${code}'>http://192.168.99.100:8080/api/v2/user/${id}/verifiy-code/${code}</a>
                    </p>
                    <p style="text-indent: 2em;">（如果不能点击该链接地址，请复制并粘贴到浏览器的地址输入框）</p>
                </div>
            ` // html body
        };

        transporter.sendMail(mailOptions, function (error, info) {
            if (error) {
                console.error(error);
            } else {
                console.log('Message sent: ' + info.response);
            }
        });
        ctx.body = 'success';
    }

    public sendEmail(toEmailAddress: string, bccAddresses: string, subject: string, body: string) {
        var smtpTransport: Transport = nodemailer.createTransport("SMTP", this.smtpOptions.getNodemailerSmtpOptions());

        var message: any = {
            from: this.fromEmail,
            to: toEmailAddress,
            bcc: bccAddresses,
            subject: subject,
            html: body
        };

        smtpTransport.sendMail(message, (error) => {
            if (error) {
                this.logger.log("Mail error: " + error.message);
            }
            else {
                this.logger.log("Sent email to " + toEmailAddress + " bcc: " + bccAddresses + ": " + subject);
            }
            smtpTransport.close();
        });
    }