server/lib/emailer.ts

   1 import { readFileSync } from 'fs-extra'
   2 import { merge } from 'lodash'
   3 import { createTransport, Transporter } from 'nodemailer'
   4 import { join } from 'path'
   5 import { VideoChannelModel } from '@server/models/video/video-channel'
   6 import { MVideoBlacklistLightVideo, MVideoBlacklistVideo } from '@server/types/models/video/video-blacklist'
   7 import { MVideoImport, MVideoImportVideo } from '@server/types/models/video/video-import'
   8 import { Abuse, EmailPayload } from '@shared/models'
   9 import { SendEmailOptions } from '../../shared/models/server/emailer.model'
  10 import { isTestInstance, root } from '../helpers/core-utils'
  11 import { bunyanLogger, logger } from '../helpers/logger'
  12 import { CONFIG, isEmailEnabled } from '../initializers/config'
  13 import { WEBSERVER } from '../initializers/constants'
  14 import { MAbuseFull, MActorFollowActors, MActorFollowFull, MUser } from '../types/models'
  15 import { MCommentOwnerVideo, MVideo, MVideoAccountLight } from '../types/models/video'
  16 import { JobQueue } from './job-queue'
  17
  18 const Email = require('email-templates')
  19
  20 class Emailer {
  21
  22   private static instance: Emailer
  23   private initialized = false
  24   private transporter: Transporter
  25
  26   private constructor () {
  27   }
  28
  29   init () {
  30     // Already initialized
  31     if (this.initialized === true) return
  32     this.initialized = true
  33
  34     if (isEmailEnabled()) {
  35       if (CONFIG.SMTP.TRANSPORT === 'smtp') {
  36         logger.info('Using %s:%s as SMTP server.', CONFIG.SMTP.HOSTNAME, CONFIG.SMTP.PORT)
  37
  38         let tls
  39         if (CONFIG.SMTP.CA_FILE) {
  40           tls = {
  41             ca: [ readFileSync(CONFIG.SMTP.CA_FILE) ]
  42           }
  43         }
  44
  45         let auth
  46         if (CONFIG.SMTP.USERNAME && CONFIG.SMTP.PASSWORD) {
  47           auth = {
  48             user: CONFIG.SMTP.USERNAME,
  49             pass: CONFIG.SMTP.PASSWORD
  50           }
  51         }
  52
  53         this.transporter = createTransport({
  54           host: CONFIG.SMTP.HOSTNAME,
  55           port: CONFIG.SMTP.PORT,
  56           secure: CONFIG.SMTP.TLS,
  57           debug: CONFIG.LOG.LEVEL === 'debug',
  58           logger: bunyanLogger as any,
  59           ignoreTLS: CONFIG.SMTP.DISABLE_STARTTLS,
  60           tls,
  61           auth
  62         })
  63       } else { // sendmail
  64         logger.info('Using sendmail to send emails')
  65
  66         this.transporter = createTransport({
  67           sendmail: true,
  68           newline: 'unix',
  69           path: CONFIG.SMTP.SENDMAIL
  70         })
  71       }
  72     } else {
  73       if (!isTestInstance()) {
  74         logger.error('Cannot use SMTP server because of lack of configuration. PeerTube will not be able to send mails!')
  75       }
  76     }
  77   }
  78
  79   static isEnabled () {
  80     if (CONFIG.SMTP.TRANSPORT === 'sendmail') {
  81       return !!CONFIG.SMTP.SENDMAIL
  82     } else if (CONFIG.SMTP.TRANSPORT === 'smtp') {
  83       return !!CONFIG.SMTP.HOSTNAME && !!CONFIG.SMTP.PORT
  84     } else {
  85       return false
  86     }
  87   }
  88
  89   async checkConnectionOrDie () {
  90     if (!this.transporter || CONFIG.SMTP.TRANSPORT !== 'smtp') return
  91
  92     logger.info('Testing SMTP server...')
  93
  94     try {
  95       const success = await this.transporter.verify()
  96       if (success !== true) this.dieOnConnectionFailure()
  97
  98       logger.info('Successfully connected to SMTP server.')
  99     } catch (err) {
 100       this.dieOnConnectionFailure(err)
 101     }
 102   }
 103
 104   addNewVideoFromSubscriberNotification (to: string[], video: MVideoAccountLight) {
 105     const channelName = video.VideoChannel.getDisplayName()
 106     const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 107
 108     const emailPayload: EmailPayload = {
 109       to,
 110       subject: channelName + ' just published a new video',
 111       text: `Your subscription ${channelName} just published a new video: "${video.name}".`,
 112       locals: {
 113         title: 'New content ',
 114         action: {
 115           text: 'View video',
 116           url: videoUrl
 117         }
 118       }
 119     }
 120
 121     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 122   }
 123
 124   addNewFollowNotification (to: string[], actorFollow: MActorFollowFull, followType: 'account' | 'channel') {
 125     const followingName = (actorFollow.ActorFollowing.VideoChannel || actorFollow.ActorFollowing.Account).getDisplayName()
 126
 127     const emailPayload: EmailPayload = {
 128       template: 'follower-on-channel',
 129       to,
 130       subject: `New follower on your channel ${followingName}`,
 131       locals: {
 132         followerName: actorFollow.ActorFollower.Account.getDisplayName(),
 133         followerUrl: actorFollow.ActorFollower.url,
 134         followingName,
 135         followingUrl: actorFollow.ActorFollowing.url,
 136         followType
 137       }
 138     }
 139
 140     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 141   }
 142
 143   addNewInstanceFollowerNotification (to: string[], actorFollow: MActorFollowActors) {
 144     const awaitingApproval = actorFollow.state === 'pending' ? ' awaiting manual approval.' : ''
 145
 146     const emailPayload: EmailPayload = {
 147       to,
 148       subject: 'New instance follower',
 149       text: `Your instance has a new follower: ${actorFollow.ActorFollower.url}${awaitingApproval}.`,
 150       locals: {
 151         title: 'New instance follower',
 152         action: {
 153           text: 'Review followers',
 154           url: WEBSERVER.URL + '/admin/follows/followers-list'
 155         }
 156       }
 157     }
 158
 159     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 160   }
 161
 162   addAutoInstanceFollowingNotification (to: string[], actorFollow: MActorFollowActors) {
 163     const instanceUrl = actorFollow.ActorFollowing.url
 164     const emailPayload: EmailPayload = {
 165       to,
 166       subject: 'Auto instance following',
 167       text: `Your instance automatically followed a new instance: <a href="${instanceUrl}">${instanceUrl}</a>.`
 168     }
 169
 170     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 171   }
 172
 173   myVideoPublishedNotification (to: string[], video: MVideo) {
 174     const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 175
 176     const emailPayload: EmailPayload = {
 177       to,
 178       subject: `Your video ${video.name} has been published`,
 179       text: `Your video "${video.name}" has been published.`,
 180       locals: {
 181         title: 'You video is live',
 182         action: {
 183           text: 'View video',
 184           url: videoUrl
 185         }
 186       }
 187     }
 188
 189     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 190   }
 191
 192   myVideoImportSuccessNotification (to: string[], videoImport: MVideoImportVideo) {
 193     const videoUrl = WEBSERVER.URL + videoImport.Video.getWatchStaticPath()
 194
 195     const emailPayload: EmailPayload = {
 196       to,
 197       subject: `Your video import ${videoImport.getTargetIdentifier()} is complete`,
 198       text: `Your video "${videoImport.getTargetIdentifier()}" just finished importing.`,
 199       locals: {
 200         title: 'Import complete',
 201         action: {
 202           text: 'View video',
 203           url: videoUrl
 204         }
 205       }
 206     }
 207
 208     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 209   }
 210
 211   myVideoImportErrorNotification (to: string[], videoImport: MVideoImport) {
 212     const importUrl = WEBSERVER.URL + '/my-account/video-imports'
 213
 214     const text =
 215       `Your video import "${videoImport.getTargetIdentifier()}" encountered an error.` +
 216       '\n\n' +
 217       `See your videos import dashboard for more information: <a href="${importUrl}">${importUrl}</a>.`
 218
 219     const emailPayload: EmailPayload = {
 220       to,
 221       subject: `Your video import "${videoImport.getTargetIdentifier()}" encountered an error`,
 222       text,
 223       locals: {
 224         title: 'Import failed',
 225         action: {
 226           text: 'Review imports',
 227           url: importUrl
 228         }
 229       }
 230     }
 231
 232     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 233   }
 234
 235   addNewCommentOnMyVideoNotification (to: string[], comment: MCommentOwnerVideo) {
 236     const video = comment.Video
 237     const videoUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath()
 238     const commentUrl = WEBSERVER.URL + comment.getCommentStaticPath()
 239
 240     const emailPayload: EmailPayload = {
 241       template: 'video-comment-new',
 242       to,
 243       subject: 'New comment on your video ' + video.name,
 244       locals: {
 245         accountName: comment.Account.getDisplayName(),
 246         accountUrl: comment.Account.Actor.url,
 247         comment,
 248         video,
 249         videoUrl,
 250         action: {
 251           text: 'View comment',
 252           url: commentUrl
 253         }
 254       }
 255     }
 256
 257     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 258   }
 259
 260   addNewCommentMentionNotification (to: string[], comment: MCommentOwnerVideo) {
 261     const accountName = comment.Account.getDisplayName()
 262     const video = comment.Video
 263     const videoUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath()
 264     const commentUrl = WEBSERVER.URL + comment.getCommentStaticPath()
 265
 266     const emailPayload: EmailPayload = {
 267       template: 'video-comment-mention',
 268       to,
 269       subject: 'Mention on video ' + video.name,
 270       locals: {
 271         comment,
 272         video,
 273         videoUrl,
 274         accountName,
 275         action: {
 276           text: 'View comment',
 277           url: commentUrl
 278         }
 279       }
 280     }
 281
 282     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 283   }
 284
 285   addAbuseModeratorsNotification (to: string[], parameters: {
 286     abuse: Abuse
 287     abuseInstance: MAbuseFull
 288     reporter: string
 289   }) {
 290     const { abuse, abuseInstance, reporter } = parameters
 291
 292     const action = {
 293       text: 'View report #' + abuse.id,
 294       url: WEBSERVER.URL + '/admin/moderation/abuses/list?search=%23' + abuse.id
 295     }
 296
 297     let emailPayload: EmailPayload
 298
 299     if (abuseInstance.VideoAbuse) {
 300       const video = abuseInstance.VideoAbuse.Video
 301       const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 302
 303       emailPayload = {
 304         template: 'video-abuse-new',
 305         to,
 306         subject: `New video abuse report from ${reporter}`,
 307         locals: {
 308           videoUrl,
 309           isLocal: video.remote === false,
 310           videoCreatedAt: new Date(video.createdAt).toLocaleString(),
 311           videoPublishedAt: new Date(video.publishedAt).toLocaleString(),
 312           videoName: video.name,
 313           reason: abuse.reason,
 314           videoChannel: video.VideoChannel,
 315           action
 316         }
 317       }
 318     } else if (abuseInstance.VideoCommentAbuse) {
 319       const comment = abuseInstance.VideoCommentAbuse.VideoComment
 320       const commentUrl = WEBSERVER.URL + comment.Video.getWatchStaticPath() + ';threadId=' + comment.getThreadId()
 321
 322       emailPayload = {
 323         template: 'video-comment-abuse-new',
 324         to,
 325         subject: `New comment abuse report from ${reporter}`,
 326         locals: {
 327           commentUrl,
 328           isLocal: comment.isOwned(),
 329           commentCreatedAt: new Date(comment.createdAt).toLocaleString(),
 330           reason: abuse.reason,
 331           flaggedAccount: abuseInstance.FlaggedAccount.getDisplayName(),
 332           action
 333         }
 334       }
 335     } else {
 336       const account = abuseInstance.FlaggedAccount
 337       const accountUrl = account.getClientUrl()
 338
 339       emailPayload = {
 340         template: 'account-abuse-new',
 341         to,
 342         subject: `New account abuse report from ${reporter}`,
 343         locals: {
 344           accountUrl,
 345           accountDisplayName: account.getDisplayName(),
 346           isLocal: account.isOwned(),
 347           reason: abuse.reason,
 348           action
 349         }
 350       }
 351     }
 352
 353     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 354   }
 355
 356   async addVideoAutoBlacklistModeratorsNotification (to: string[], videoBlacklist: MVideoBlacklistLightVideo) {
 357     const VIDEO_AUTO_BLACKLIST_URL = WEBSERVER.URL + '/admin/moderation/video-auto-blacklist/list'
 358     const videoUrl = WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
 359     const channel = (await VideoChannelModel.loadByIdAndPopulateAccount(videoBlacklist.Video.channelId)).toFormattedSummaryJSON()
 360
 361     const emailPayload: EmailPayload = {
 362       template: 'video-auto-blacklist-new',
 363       to,
 364       subject: 'A new video is pending moderation',
 365       locals: {
 366         channel,
 367         videoUrl,
 368         videoName: videoBlacklist.Video.name,
 369         action: {
 370           text: 'Review autoblacklist',
 371           url: VIDEO_AUTO_BLACKLIST_URL
 372         }
 373       }
 374     }
 375
 376     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 377   }
 378
 379   addNewUserRegistrationNotification (to: string[], user: MUser) {
 380     const emailPayload: EmailPayload = {
 381       template: 'user-registered',
 382       to,
 383       subject: `a new user registered on ${WEBSERVER.HOST}: ${user.username}`,
 384       locals: {
 385         user
 386       }
 387     }
 388
 389     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 390   }
 391
 392   addVideoBlacklistNotification (to: string[], videoBlacklist: MVideoBlacklistVideo) {
 393     const videoName = videoBlacklist.Video.name
 394     const videoUrl = WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
 395
 396     const reasonString = videoBlacklist.reason ? ` for the following reason: ${videoBlacklist.reason}` : ''
 397     const blockedString = `Your video ${videoName} (${videoUrl} on ${WEBSERVER.HOST} has been blacklisted${reasonString}.`
 398
 399     const emailPayload: EmailPayload = {
 400       to,
 401       subject: `Video ${videoName} blacklisted`,
 402       text: blockedString,
 403       locals: {
 404         title: 'Your video was blacklisted'
 405       }
 406     }
 407
 408     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 409   }
 410
 411   addVideoUnblacklistNotification (to: string[], video: MVideo) {
 412     const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 413
 414     const emailPayload: EmailPayload = {
 415       to,
 416       subject: `Video ${video.name} unblacklisted`,
 417       text: `Your video "${video.name}" (${videoUrl}) on ${WEBSERVER.HOST} has been unblacklisted.`,
 418       locals: {
 419         title: 'Your video was unblacklisted'
 420       }
 421     }
 422
 423     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 424   }
 425
 426   addPasswordResetEmailJob (to: string, resetPasswordUrl: string) {
 427     const emailPayload: EmailPayload = {
 428       template: 'password-reset',
 429       to: [ to ],
 430       subject: 'Reset your account password',
 431       locals: {
 432         resetPasswordUrl
 433       }
 434     }
 435
 436     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 437   }
 438
 439   addPasswordCreateEmailJob (username: string, to: string, createPasswordUrl: string) {
 440     const emailPayload: EmailPayload = {
 441       template: 'password-create',
 442       to: [ to ],
 443       subject: 'Create your account password',
 444       locals: {
 445         username,
 446         createPasswordUrl
 447       }
 448     }
 449
 450     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 451   }
 452
 453   addVerifyEmailJob (to: string, verifyEmailUrl: string) {
 454     const emailPayload: EmailPayload = {
 455       template: 'verify-email',
 456       to: [ to ],
 457       subject: `Verify your email on ${WEBSERVER.HOST}`,
 458       locals: {
 459         verifyEmailUrl
 460       }
 461     }
 462
 463     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 464   }
 465
 466   addUserBlockJob (user: MUser, blocked: boolean, reason?: string) {
 467     const reasonString = reason ? ` for the following reason: ${reason}` : ''
 468     const blockedWord = blocked ? 'blocked' : 'unblocked'
 469
 470     const to = user.email
 471     const emailPayload: EmailPayload = {
 472       to: [ to ],
 473       subject: 'Account ' + blockedWord,
 474       text: `Your account ${user.username} on ${WEBSERVER.HOST} has been ${blockedWord}${reasonString}.`
 475     }
 476
 477     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 478   }
 479
 480   addContactFormJob (fromEmail: string, fromName: string, subject: string, body: string) {
 481     const emailPayload: EmailPayload = {
 482       template: 'contact-form',
 483       to: [ CONFIG.ADMIN.EMAIL ],
 484       replyTo: `"${fromName}" <${fromEmail}>`,
 485       subject: `(contact form) ${subject}`,
 486       locals: {
 487         fromName,
 488         fromEmail,
 489         body
 490       }
 491     }
 492
 493     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 494   }
 495
 496   async sendMail (options: EmailPayload) {
 497     if (!isEmailEnabled()) {
 498       throw new Error('Cannot send mail because SMTP is not configured.')
 499     }
 500
 501     const fromDisplayName = options.from
 502       ? options.from
 503       : WEBSERVER.HOST
 504
 505     const email = new Email({
 506       send: true,
 507       message: {
 508         from: `"${fromDisplayName}" <${CONFIG.SMTP.FROM_ADDRESS}>`
 509       },
 510       transport: this.transporter,
 511       views: {
 512         root: join(root(), 'dist', 'server', 'lib', 'emails')
 513       },
 514       subjectPrefix: CONFIG.EMAIL.SUBJECT.PREFIX
 515     })
 516
 517     for (const to of options.to) {
 518       await email
 519         .send(merge(
 520           {
 521             template: 'common',
 522             message: {
 523               to,
 524               from: options.from,
 525               subject: options.subject,
 526               replyTo: options.replyTo
 527             },
 528             locals: { // default variables available in all templates
 529               WEBSERVER,
 530               EMAIL: CONFIG.EMAIL,
 531               text: options.text,
 532               subject: options.subject
 533             }
 534           },
 535           options // overriden/new variables given for a specific template in the payload
 536         ) as SendEmailOptions)
 537         .then(res => logger.debug('Sent email.', { res }))
 538         .catch(err => logger.error('Error in email sender.', { err }))
 539     }
 540   }
 541
 542   private dieOnConnectionFailure (err?: Error) {
 543     logger.error('Failed to connect to SMTP %s:%d.', CONFIG.SMTP.HOSTNAME, CONFIG.SMTP.PORT, { err })
 544     process.exit(-1)
 545   }
 546
 547   static get Instance () {
 548     return this.instance || (this.instance = new this())
 549   }
 550 }
 551
 552 // ---------------------------------------------------------------------------
 553
 554 export {
 555   Emailer
 556 }