server/lib/user.ts

   1 import * as uuidv4 from 'uuid/v4'
   2 import { ActivityPubActorType } from '../../shared/models/activitypub'
   3 import { SERVER_ACTOR_NAME, WEBSERVER } from '../initializers/constants'
   4 import { AccountModel } from '../models/account/account'
   5 import { buildActorInstance, getAccountActivityPubUrl, setAsyncActorKeys } from './activitypub'
   6 import { createLocalVideoChannel } from './video-channel'
   7 import { ActorModel } from '../models/activitypub/actor'
   8 import { UserNotificationSettingModel } from '../models/account/user-notification-setting'
   9 import { UserNotificationSetting, UserNotificationSettingValue } from '../../shared/models/users'
  10 import { createWatchLaterPlaylist } from './video-playlist'
  11 import { sequelizeTypescript } from '../initializers/database'
  12 import { Transaction } from 'sequelize/types'
  13 import { Redis } from './redis'
  14 import { Emailer } from './emailer'
  15 import { MAccountDefault, MActorDefault, MChannelActor } from '../typings/models'
  16 import { MUser, MUserDefault, MUserId } from '../typings/models/user'
  17
  18 type ChannelNames = { name: string, displayName: string }
  19
  20 async function createUserAccountAndChannelAndPlaylist (parameters: {
  21   userToCreate: MUser
  22   userDisplayName?: string
  23   channelNames?: ChannelNames
  24   validateUser?: boolean
  25 }): Promise<{ user: MUserDefault, account: MAccountDefault, videoChannel: MChannelActor }> {
  26   const { userToCreate, userDisplayName, channelNames, validateUser = true } = parameters
  27
  28   const { user, account, videoChannel } = await sequelizeTypescript.transaction(async t => {
  29     const userOptions = {
  30       transaction: t,
  31       validate: validateUser
  32     }
  33
  34     const userCreated: MUserDefault = await userToCreate.save(userOptions)
  35     userCreated.NotificationSetting = await createDefaultUserNotificationSettings(userCreated, t)
  36
  37     const accountCreated = await createLocalAccountWithoutKeys({
  38       name: userCreated.username,
  39       displayName: userDisplayName,
  40       userId: userCreated.id,
  41       applicationId: null,
  42       t: t
  43     })
  44     userCreated.Account = accountCreated
  45
  46     const channelAttributes = await buildChannelAttributes(userCreated, channelNames)
  47     const videoChannel = await createLocalVideoChannel(channelAttributes, accountCreated, t)
  48
  49     const videoPlaylist = await createWatchLaterPlaylist(accountCreated, t)
  50
  51     return { user: userCreated, account: accountCreated, videoChannel, videoPlaylist }
  52   })
  53
  54   const [ accountActorWithKeys, channelActorWithKeys ] = await Promise.all([
  55     setAsyncActorKeys(account.Actor),
  56     setAsyncActorKeys(videoChannel.Actor)
  57   ])
  58
  59   account.Actor = accountActorWithKeys
  60   videoChannel.Actor = channelActorWithKeys
  61
  62   return { user, account, videoChannel }
  63 }
  64
  65 async function createLocalAccountWithoutKeys (parameters: {
  66   name: string
  67   displayName?: string
  68   userId: number | null
  69   applicationId: number | null
  70   t: Transaction | undefined
  71   type?: ActivityPubActorType
  72 }) {
  73   const { name, displayName, userId, applicationId, t, type = 'Person' } = parameters
  74   const url = getAccountActivityPubUrl(name)
  75
  76   const actorInstance = buildActorInstance(type, url, name)
  77   const actorInstanceCreated: MActorDefault = await actorInstance.save({ transaction: t })
  78
  79   const accountInstance = new AccountModel({
  80     name: displayName || name,
  81     userId,
  82     applicationId,
  83     actorId: actorInstanceCreated.id
  84   })
  85
  86   const accountInstanceCreated: MAccountDefault = await accountInstance.save({ transaction: t })
  87   accountInstanceCreated.Actor = actorInstanceCreated
  88
  89   return accountInstanceCreated
  90 }
  91
  92 async function createApplicationActor (applicationId: number) {
  93   const accountCreated = await createLocalAccountWithoutKeys({
  94     name: SERVER_ACTOR_NAME,
  95     userId: null,
  96     applicationId: applicationId,
  97     t: undefined,
  98     type: 'Application'
  99   })
 100
 101   accountCreated.Actor = await setAsyncActorKeys(accountCreated.Actor)
 102
 103   return accountCreated
 104 }
 105
 106 async function sendVerifyUserEmail (user: MUser, isPendingEmail = false) {
 107   const verificationString = await Redis.Instance.setVerifyEmailVerificationString(user.id)
 108   let url = WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString
 109
 110   if (isPendingEmail) url += '&isPendingEmail=true'
 111
 112   const email = isPendingEmail ? user.pendingEmail : user.email
 113
 114   await Emailer.Instance.addVerifyEmailJob(email, url)
 115 }
 116
 117 // ---------------------------------------------------------------------------
 118
 119 export {
 120   createApplicationActor,
 121   createUserAccountAndChannelAndPlaylist,
 122   createLocalAccountWithoutKeys,
 123   sendVerifyUserEmail
 124 }
 125
 126 // ---------------------------------------------------------------------------
 127
 128 function createDefaultUserNotificationSettings (user: MUserId, t: Transaction | undefined) {
 129   const values: UserNotificationSetting & { userId: number } = {
 130     userId: user.id,
 131     newVideoFromSubscription: UserNotificationSettingValue.WEB,
 132     newCommentOnMyVideo: UserNotificationSettingValue.WEB,
 133     myVideoImportFinished: UserNotificationSettingValue.WEB,
 134     myVideoPublished: UserNotificationSettingValue.WEB,
 135     videoAbuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
 136     videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
 137     blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
 138     newUserRegistration: UserNotificationSettingValue.WEB,
 139     commentMention: UserNotificationSettingValue.WEB,
 140     newFollow: UserNotificationSettingValue.WEB,
 141     newInstanceFollower: UserNotificationSettingValue.WEB,
 142     autoInstanceFollowing: UserNotificationSettingValue.WEB
 143   }
 144
 145   return UserNotificationSettingModel.create(values, { transaction: t })
 146 }
 147
 148 async function buildChannelAttributes (user: MUser, channelNames?: ChannelNames) {
 149   if (channelNames) return channelNames
 150
 151   let channelName = user.username + '_channel'
 152
 153   // Conflict, generate uuid instead
 154   const actor = await ActorModel.loadLocalByName(channelName)
 155   if (actor) channelName = uuidv4()
 156
 157   const videoChannelDisplayName = `Main ${user.username} channel`
 158
 159   return {
 160     name: channelName,
 161     displayName: videoChannelDisplayName
 162   }
 163 }