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