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           videoName: comment.Video.name,
 329           isLocal: comment.isOwned(),
 330           commentCreatedAt: new Date(comment.createdAt).toLocaleString(),
 331           reason: abuse.reason,
 332           flaggedAccount: abuseInstance.FlaggedAccount.getDisplayName(),
 333           action
 334         }
 335       }
 336     } else {
 337       const account = abuseInstance.FlaggedAccount
 338       const accountUrl = account.getClientUrl()
 339
 340       emailPayload = {
 341         template: 'account-abuse-new',
 342         to,
 343         subject: `New account abuse report from ${reporter}`,
 344         locals: {
 345           accountUrl,
 346           accountDisplayName: account.getDisplayName(),
 347           isLocal: account.isOwned(),
 348           reason: abuse.reason,
 349           action
 350         }
 351       }
 352     }
 353
 354     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 355   }
 356
 357   async addVideoAutoBlacklistModeratorsNotification (to: string[], videoBlacklist: MVideoBlacklistLightVideo) {
 358     const VIDEO_AUTO_BLACKLIST_URL = WEBSERVER.URL + '/admin/moderation/video-auto-blacklist/list'
 359     const videoUrl = WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
 360     const channel = (await VideoChannelModel.loadByIdAndPopulateAccount(videoBlacklist.Video.channelId)).toFormattedSummaryJSON()
 361
 362     const emailPayload: EmailPayload = {
 363       template: 'video-auto-blacklist-new',
 364       to,
 365       subject: 'A new video is pending moderation',
 366       locals: {
 367         channel,
 368         videoUrl,
 369         videoName: videoBlacklist.Video.name,
 370         action: {
 371           text: 'Review autoblacklist',
 372           url: VIDEO_AUTO_BLACKLIST_URL
 373         }
 374       }
 375     }
 376
 377     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 378   }
 379
 380   addNewUserRegistrationNotification (to: string[], user: MUser) {
 381     const emailPayload: EmailPayload = {
 382       template: 'user-registered',
 383       to,
 384       subject: `a new user registered on ${WEBSERVER.HOST}: ${user.username}`,
 385       locals: {
 386         user
 387       }
 388     }
 389
 390     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 391   }
 392
 393   addVideoBlacklistNotification (to: string[], videoBlacklist: MVideoBlacklistVideo) {
 394     const videoName = videoBlacklist.Video.name
 395     const videoUrl = WEBSERVER.URL + videoBlacklist.Video.getWatchStaticPath()
 396
 397     const reasonString = videoBlacklist.reason ? ` for the following reason: ${videoBlacklist.reason}` : ''
 398     const blockedString = `Your video ${videoName} (${videoUrl} on ${WEBSERVER.HOST} has been blacklisted${reasonString}.`
 399
 400     const emailPayload: EmailPayload = {
 401       to,
 402       subject: `Video ${videoName} blacklisted`,
 403       text: blockedString,
 404       locals: {
 405         title: 'Your video was blacklisted'
 406       }
 407     }
 408
 409     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 410   }
 411
 412   addVideoUnblacklistNotification (to: string[], video: MVideo) {
 413     const videoUrl = WEBSERVER.URL + video.getWatchStaticPath()
 414
 415     const emailPayload: EmailPayload = {
 416       to,
 417       subject: `Video ${video.name} unblacklisted`,
 418       text: `Your video "${video.name}" (${videoUrl}) on ${WEBSERVER.HOST} has been unblacklisted.`,
 419       locals: {
 420         title: 'Your video was unblacklisted'
 421       }
 422     }
 423
 424     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 425   }
 426
 427   addPasswordResetEmailJob (to: string, resetPasswordUrl: string) {
 428     const emailPayload: EmailPayload = {
 429       template: 'password-reset',
 430       to: [ to ],
 431       subject: 'Reset your account password',
 432       locals: {
 433         resetPasswordUrl
 434       }
 435     }
 436
 437     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 438   }
 439
 440   addPasswordCreateEmailJob (username: string, to: string, createPasswordUrl: string) {
 441     const emailPayload: EmailPayload = {
 442       template: 'password-create',
 443       to: [ to ],
 444       subject: 'Create your account password',
 445       locals: {
 446         username,
 447         createPasswordUrl
 448       }
 449     }
 450
 451     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 452   }
 453
 454   addVerifyEmailJob (to: string, verifyEmailUrl: string) {
 455     const emailPayload: EmailPayload = {
 456       template: 'verify-email',
 457       to: [ to ],
 458       subject: `Verify your email on ${WEBSERVER.HOST}`,
 459       locals: {
 460         verifyEmailUrl
 461       }
 462     }
 463
 464     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 465   }
 466
 467   addUserBlockJob (user: MUser, blocked: boolean, reason?: string) {
 468     const reasonString = reason ? ` for the following reason: ${reason}` : ''
 469     const blockedWord = blocked ? 'blocked' : 'unblocked'
 470
 471     const to = user.email
 472     const emailPayload: EmailPayload = {
 473       to: [ to ],
 474       subject: 'Account ' + blockedWord,
 475       text: `Your account ${user.username} on ${WEBSERVER.HOST} has been ${blockedWord}${reasonString}.`
 476     }
 477
 478     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 479   }
 480
 481   addContactFormJob (fromEmail: string, fromName: string, subject: string, body: string) {
 482     const emailPayload: EmailPayload = {
 483       template: 'contact-form',
 484       to: [ CONFIG.ADMIN.EMAIL ],
 485       replyTo: `"${fromName}" <${fromEmail}>`,
 486       subject: `(contact form) ${subject}`,
 487       locals: {
 488         fromName,
 489         fromEmail,
 490         body
 491       }
 492     }
 493
 494     return JobQueue.Instance.createJob({ type: 'email', payload: emailPayload })
 495   }
 496
 497   async sendMail (options: EmailPayload) {
 498     if (!isEmailEnabled()) {
 499       throw new Error('Cannot send mail because SMTP is not configured.')
 500     }
 501
 502     const fromDisplayName = options.from
 503       ? options.from
 504       : WEBSERVER.HOST
 505
 506     const email = new Email({
 507       send: true,
 508       message: {
 509         from: `"${fromDisplayName}" <${CONFIG.SMTP.FROM_ADDRESS}>`
 510       },
 511       transport: this.transporter,
 512       views: {
 513         root: join(root(), 'dist', 'server', 'lib', 'emails')
 514       },
 515       subjectPrefix: CONFIG.EMAIL.SUBJECT.PREFIX
 516     })
 517
 518     for (const to of options.to) {
 519       await email
 520         .send(merge(
 521           {
 522             template: 'common',
 523             message: {
 524               to,
 525               from: options.from,
 526               subject: options.subject,
 527               replyTo: options.replyTo
 528             },
 529             locals: { // default variables available in all templates
 530               WEBSERVER,
 531               EMAIL: CONFIG.EMAIL,
 532               text: options.text,
 533               subject: options.subject
 534             }
 535           },
 536           options // overriden/new variables given for a specific template in the payload
 537         ) as SendEmailOptions)
 538         .then(res => logger.debug('Sent email.', { res }))
 539         .catch(err => logger.error('Error in email sender.', { err }))
 540     }
 541   }
 542
 543   private dieOnConnectionFailure (err?: Error) {
 544     logger.error('Failed to connect to SMTP %s:%d.', CONFIG.SMTP.HOSTNAME, CONFIG.SMTP.PORT, { err })
 545     process.exit(-1)
 546   }
 547
 548   static get Instance () {
 549     return this.instance || (this.instance = new this())
 550   }
 551 }
 552
 553 // ---------------------------------------------------------------------------
 554
 555 export {
 556   Emailer
 557 }