server/lib/user.ts

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