1 import { Transaction } from 'sequelize/types'
2 import { buildUUID } from '@server/helpers/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 { generateAndSaveActorKeys } from './activitypub/actors'
15 import { getLocalAccountActivityPubUrl } from './activitypub/url'
16 import { Emailer } from './emailer'
17 import { LiveQuotaStore } from './live/live-quota-store'
18 import { buildActorInstance } from './local-actor'
19 import { Redis } from './redis'
20 import { createLocalVideoChannel } from './video-channel'
21 import { createWatchLaterPlaylist } from './video-playlist'
23 type ChannelNames = { name: string, displayName: string }
25 async function createUserAccountAndChannelAndPlaylist (parameters: {
27 userDisplayName?: string
28 channelNames?: ChannelNames
29 validateUser?: boolean
30 }): Promise<{ user: MUserDefault, account: MAccountDefault, videoChannel: MChannelActor }> {
31 const { userToCreate, userDisplayName, channelNames, validateUser = true } = parameters
33 const { user, account, videoChannel } = await sequelizeTypescript.transaction(async t => {
36 validate: validateUser
39 const userCreated: MUserDefault = await userToCreate.save(userOptions)
40 userCreated.NotificationSetting = await createDefaultUserNotificationSettings(userCreated, t)
42 const accountCreated = await createLocalAccountWithoutKeys({
43 name: userCreated.username,
44 displayName: userDisplayName,
45 userId: userCreated.id,
49 userCreated.Account = accountCreated
51 const channelAttributes = await buildChannelAttributes(userCreated, t, channelNames)
52 const videoChannel = await createLocalVideoChannel(channelAttributes, accountCreated, t)
54 const videoPlaylist = await createWatchLaterPlaylist(accountCreated, t)
56 return { user: userCreated, account: accountCreated, videoChannel, videoPlaylist }
59 const [ accountActorWithKeys, channelActorWithKeys ] = await Promise.all([
60 generateAndSaveActorKeys(account.Actor),
61 generateAndSaveActorKeys(videoChannel.Actor)
64 account.Actor = accountActorWithKeys
65 videoChannel.Actor = channelActorWithKeys
67 return { user, account, videoChannel }
70 async function createLocalAccountWithoutKeys (parameters: {
74 applicationId: number | null
75 t: Transaction | undefined
76 type?: ActivityPubActorType
78 const { name, displayName, userId, applicationId, t, type = 'Person' } = parameters
79 const url = getLocalAccountActivityPubUrl(name)
81 const actorInstance = buildActorInstance(type, url, name)
82 const actorInstanceCreated: MActorDefault = await actorInstance.save({ transaction: t })
84 const accountInstance = new AccountModel({
85 name: displayName || name,
88 actorId: actorInstanceCreated.id
91 const accountInstanceCreated: MAccountDefault = await accountInstance.save({ transaction: t })
92 accountInstanceCreated.Actor = actorInstanceCreated
94 return accountInstanceCreated
97 async function createApplicationActor (applicationId: number) {
98 const accountCreated = await createLocalAccountWithoutKeys({
99 name: SERVER_ACTOR_NAME,
101 applicationId: applicationId,
106 accountCreated.Actor = await generateAndSaveActorKeys(accountCreated.Actor)
108 return accountCreated
111 async function sendVerifyUserEmail (user: MUser, isPendingEmail = false) {
112 const verificationString = await Redis.Instance.setVerifyEmailVerificationString(user.id)
113 let url = WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString
115 if (isPendingEmail) url += '&isPendingEmail=true'
117 const email = isPendingEmail ? user.pendingEmail : user.email
118 const username = user.username
120 await Emailer.Instance.addVerifyEmailJob(username, email, url)
123 async function getOriginalVideoFileTotalFromUser (user: MUserId) {
124 // Don't use sequelize because we need to use a sub query
125 const query = UserModel.generateUserQuotaBaseSQL({
127 whereUserId: '$userId'
130 const base = await UserModel.getTotalRawQuery(query, user.id)
132 return base + LiveQuotaStore.Instance.getLiveQuotaOf(user.id)
135 // Returns cumulative size of all video files uploaded in the last 24 hours.
136 async function getOriginalVideoFileTotalDailyFromUser (user: MUserId) {
137 // Don't use sequelize because we need to use a sub query
138 const query = UserModel.generateUserQuotaBaseSQL({
140 whereUserId: '$userId',
141 where: '"video"."createdAt" > now() - interval \'24 hours\''
144 const base = await UserModel.getTotalRawQuery(query, user.id)
146 return base + LiveQuotaStore.Instance.getLiveQuotaOf(user.id)
149 async function isAbleToUploadVideo (userId: number, newVideoSize: number) {
150 const user = await UserModel.loadById(userId)
152 if (user.videoQuota === -1 && user.videoQuotaDaily === -1) return Promise.resolve(true)
154 const [ totalBytes, totalBytesDaily ] = await Promise.all([
155 getOriginalVideoFileTotalFromUser(user),
156 getOriginalVideoFileTotalDailyFromUser(user)
159 const uploadedTotal = newVideoSize + totalBytes
160 const uploadedDaily = newVideoSize + totalBytesDaily
162 if (user.videoQuotaDaily === -1) return uploadedTotal < user.videoQuota
163 if (user.videoQuota === -1) return uploadedDaily < user.videoQuotaDaily
165 return uploadedTotal < user.videoQuota && uploadedDaily < user.videoQuotaDaily
168 // ---------------------------------------------------------------------------
171 getOriginalVideoFileTotalFromUser,
172 getOriginalVideoFileTotalDailyFromUser,
173 createApplicationActor,
174 createUserAccountAndChannelAndPlaylist,
175 createLocalAccountWithoutKeys,
180 // ---------------------------------------------------------------------------
182 function createDefaultUserNotificationSettings (user: MUserId, t: Transaction | undefined) {
183 const values: UserNotificationSetting & { userId: number } = {
185 newVideoFromSubscription: UserNotificationSettingValue.WEB,
186 newCommentOnMyVideo: UserNotificationSettingValue.WEB,
187 myVideoImportFinished: UserNotificationSettingValue.WEB,
188 myVideoPublished: UserNotificationSettingValue.WEB,
189 abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
190 videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
191 blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
192 newUserRegistration: UserNotificationSettingValue.WEB,
193 commentMention: UserNotificationSettingValue.WEB,
194 newFollow: UserNotificationSettingValue.WEB,
195 newInstanceFollower: UserNotificationSettingValue.WEB,
196 abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
197 abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
198 autoInstanceFollowing: UserNotificationSettingValue.WEB,
199 newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
200 newPluginVersion: UserNotificationSettingValue.WEB
203 return UserNotificationSettingModel.create(values, { transaction: t })
206 async function buildChannelAttributes (user: MUser, transaction?: Transaction, channelNames?: ChannelNames) {
207 if (channelNames) return channelNames
209 let channelName = user.username + '_channel'
211 // Conflict, generate uuid instead
212 const actor = await ActorModel.loadLocalByName(channelName, transaction)
213 if (actor) channelName = buildUUID()
215 const videoChannelDisplayName = `Main ${user.username} channel`
219 displayName: videoChannelDisplayName