1 import { Transaction } from 'sequelize/types'
2 import { v4 as uuidv4 } from 'uuid'
3 import { UserModel } from '@server/models/user/user'
4 import { MActorDefault } from '@server/types/models/actor'
5 import { ActivityPubActorType } from '../../shared/models/activitypub'
6 import { UserNotificationSetting, UserNotificationSettingValue } from '../../shared/models/users'
7 import { SERVER_ACTOR_NAME, WEBSERVER } from '../initializers/constants'
8 import { sequelizeTypescript } from '../initializers/database'
9 import { AccountModel } from '../models/account/account'
10 import { ActorModel } from '../models/actor/actor'
11 import { UserNotificationSettingModel } from '../models/user/user-notification-setting'
12 import { MAccountDefault, MChannelActor } from '../types/models'
13 import { MUser, MUserDefault, MUserId } from '../types/models/user'
14 import { buildActorInstance, generateAndSaveActorKeys } from './activitypub/actor'
15 import { getLocalAccountActivityPubUrl } from './activitypub/url'
16 import { Emailer } from './emailer'
17 import { LiveManager } from './live-manager'
18 import { Redis } from './redis'
19 import { createLocalVideoChannel } from './video-channel'
20 import { createWatchLaterPlaylist } from './video-playlist'
22 type ChannelNames = { name: string, displayName: string }
24 async function createUserAccountAndChannelAndPlaylist (parameters: {
26 userDisplayName?: string
27 channelNames?: ChannelNames
28 validateUser?: boolean
29 }): Promise<{ user: MUserDefault, account: MAccountDefault, videoChannel: MChannelActor }> {
30 const { userToCreate, userDisplayName, channelNames, validateUser = true } = parameters
32 const { user, account, videoChannel } = await sequelizeTypescript.transaction(async t => {
35 validate: validateUser
38 const userCreated: MUserDefault = await userToCreate.save(userOptions)
39 userCreated.NotificationSetting = await createDefaultUserNotificationSettings(userCreated, t)
41 const accountCreated = await createLocalAccountWithoutKeys({
42 name: userCreated.username,
43 displayName: userDisplayName,
44 userId: userCreated.id,
48 userCreated.Account = accountCreated
50 const channelAttributes = await buildChannelAttributes(userCreated, channelNames)
51 const videoChannel = await createLocalVideoChannel(channelAttributes, accountCreated, t)
53 const videoPlaylist = await createWatchLaterPlaylist(accountCreated, t)
55 return { user: userCreated, account: accountCreated, videoChannel, videoPlaylist }
58 const [ accountActorWithKeys, channelActorWithKeys ] = await Promise.all([
59 generateAndSaveActorKeys(account.Actor),
60 generateAndSaveActorKeys(videoChannel.Actor)
63 account.Actor = accountActorWithKeys
64 videoChannel.Actor = channelActorWithKeys
66 return { user, account, videoChannel }
69 async function createLocalAccountWithoutKeys (parameters: {
73 applicationId: number | null
74 t: Transaction | undefined
75 type?: ActivityPubActorType
77 const { name, displayName, userId, applicationId, t, type = 'Person' } = parameters
78 const url = getLocalAccountActivityPubUrl(name)
80 const actorInstance = buildActorInstance(type, url, name)
81 const actorInstanceCreated: MActorDefault = await actorInstance.save({ transaction: t })
83 const accountInstance = new AccountModel({
84 name: displayName || name,
87 actorId: actorInstanceCreated.id
90 const accountInstanceCreated: MAccountDefault = await accountInstance.save({ transaction: t })
91 accountInstanceCreated.Actor = actorInstanceCreated
93 return accountInstanceCreated
96 async function createApplicationActor (applicationId: number) {
97 const accountCreated = await createLocalAccountWithoutKeys({
98 name: SERVER_ACTOR_NAME,
100 applicationId: applicationId,
105 accountCreated.Actor = await generateAndSaveActorKeys(accountCreated.Actor)
107 return accountCreated
110 async function sendVerifyUserEmail (user: MUser, isPendingEmail = false) {
111 const verificationString = await Redis.Instance.setVerifyEmailVerificationString(user.id)
112 let url = WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString
114 if (isPendingEmail) url += '&isPendingEmail=true'
116 const email = isPendingEmail ? user.pendingEmail : user.email
117 const username = user.username
119 await Emailer.Instance.addVerifyEmailJob(username, email, url)
122 async function getOriginalVideoFileTotalFromUser (user: MUserId) {
123 // Don't use sequelize because we need to use a sub query
124 const query = UserModel.generateUserQuotaBaseSQL({
126 whereUserId: '$userId'
129 const base = await UserModel.getTotalRawQuery(query, user.id)
131 return base + LiveManager.Instance.getLiveQuotaUsedByUser(user.id)
134 // Returns cumulative size of all video files uploaded in the last 24 hours.
135 async function getOriginalVideoFileTotalDailyFromUser (user: MUserId) {
136 // Don't use sequelize because we need to use a sub query
137 const query = UserModel.generateUserQuotaBaseSQL({
139 whereUserId: '$userId',
140 where: '"video"."createdAt" > now() - interval \'24 hours\''
143 const base = await UserModel.getTotalRawQuery(query, user.id)
145 return base + LiveManager.Instance.getLiveQuotaUsedByUser(user.id)
148 async function isAbleToUploadVideo (userId: number, size: number) {
149 const user = await UserModel.loadById(userId)
151 if (user.videoQuota === -1 && user.videoQuotaDaily === -1) return Promise.resolve(true)
153 const [ totalBytes, totalBytesDaily ] = await Promise.all([
154 getOriginalVideoFileTotalFromUser(user),
155 getOriginalVideoFileTotalDailyFromUser(user)
158 const uploadedTotal = size + totalBytes
159 const uploadedDaily = size + totalBytesDaily
161 if (user.videoQuotaDaily === -1) return uploadedTotal < user.videoQuota
162 if (user.videoQuota === -1) return uploadedDaily < user.videoQuotaDaily
164 return uploadedTotal < user.videoQuota && uploadedDaily < user.videoQuotaDaily
167 // ---------------------------------------------------------------------------
170 getOriginalVideoFileTotalFromUser,
171 getOriginalVideoFileTotalDailyFromUser,
172 createApplicationActor,
173 createUserAccountAndChannelAndPlaylist,
174 createLocalAccountWithoutKeys,
179 // ---------------------------------------------------------------------------
181 function createDefaultUserNotificationSettings (user: MUserId, t: Transaction | undefined) {
182 const values: UserNotificationSetting & { userId: number } = {
184 newVideoFromSubscription: UserNotificationSettingValue.WEB,
185 newCommentOnMyVideo: UserNotificationSettingValue.WEB,
186 myVideoImportFinished: UserNotificationSettingValue.WEB,
187 myVideoPublished: UserNotificationSettingValue.WEB,
188 abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
189 videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
190 blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
191 newUserRegistration: UserNotificationSettingValue.WEB,
192 commentMention: UserNotificationSettingValue.WEB,
193 newFollow: UserNotificationSettingValue.WEB,
194 newInstanceFollower: UserNotificationSettingValue.WEB,
195 abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
196 abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
197 autoInstanceFollowing: UserNotificationSettingValue.WEB,
198 newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
199 newPluginVersion: UserNotificationSettingValue.WEB
202 return UserNotificationSettingModel.create(values, { transaction: t })
205 async function buildChannelAttributes (user: MUser, channelNames?: ChannelNames) {
206 if (channelNames) return channelNames
208 let channelName = user.username + '_channel'
210 // Conflict, generate uuid instead
211 const actor = await ActorModel.loadLocalByName(channelName)
212 if (actor) channelName = uuidv4()
214 const videoChannelDisplayName = `Main ${user.username} channel`
218 displayName: videoChannelDisplayName