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