1 import { Transaction } from 'sequelize/types'
2 import { logger } from '@server/helpers/logger'
3 import { CONFIG } from '@server/initializers/config'
4 import { UserModel } from '@server/models/user/user'
5 import { MActorDefault } from '@server/types/models/actor'
6 import { ActivityPubActorType } from '../../shared/models/activitypub'
7 import { UserAdminFlag, UserNotificationSetting, UserNotificationSettingValue, UserRole } from '../../shared/models/users'
8 import { SERVER_ACTOR_NAME, WEBSERVER } from '../initializers/constants'
9 import { sequelizeTypescript } from '../initializers/database'
10 import { AccountModel } from '../models/account/account'
11 import { UserNotificationSettingModel } from '../models/user/user-notification-setting'
12 import { MAccountDefault, MChannelActor } from '../types/models'
13 import { MRegistration, 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, findAvailableLocalActorName } 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 function buildUser (options: {
30 role?: UserRole // Default to UserRole.User
31 adminFlags?: UserAdminFlag // Default to UserAdminFlag.NONE
33 emailVerified: boolean | null
35 videoQuota?: number // Default to CONFIG.USER.VIDEO_QUOTA
36 videoQuotaDaily?: number // Default to CONFIG.USER.VIDEO_QUOTA_DAILY
46 videoQuota = CONFIG.USER.VIDEO_QUOTA,
47 videoQuotaDaily = CONFIG.USER.VIDEO_QUOTA_DAILY,
48 adminFlags = UserAdminFlag.NONE,
52 return new UserModel({
57 nsfwPolicy: CONFIG.INSTANCE.DEFAULT_NSFW_POLICY,
58 p2pEnabled: CONFIG.DEFAULTS.P2P.WEBAPP.ENABLED,
72 // ---------------------------------------------------------------------------
74 async function createUserAccountAndChannelAndPlaylist (parameters: {
76 userDisplayName?: string
77 channelNames?: ChannelNames
78 validateUser?: boolean
79 }): Promise<{ user: MUserDefault, account: MAccountDefault, videoChannel: MChannelActor }> {
80 const { userToCreate, userDisplayName, channelNames, validateUser = true } = parameters
82 const { user, account, videoChannel } = await sequelizeTypescript.transaction(async t => {
85 validate: validateUser
88 const userCreated: MUserDefault = await userToCreate.save(userOptions)
89 userCreated.NotificationSetting = await createDefaultUserNotificationSettings(userCreated, t)
91 const accountCreated = await createLocalAccountWithoutKeys({
92 name: userCreated.username,
93 displayName: userDisplayName,
94 userId: userCreated.id,
98 userCreated.Account = accountCreated
100 const channelAttributes = await buildChannelAttributes({ user: userCreated, transaction: t, channelNames })
101 const videoChannel = await createLocalVideoChannel(channelAttributes, accountCreated, t)
103 const videoPlaylist = await createWatchLaterPlaylist(accountCreated, t)
105 return { user: userCreated, account: accountCreated, videoChannel, videoPlaylist }
108 const [ accountActorWithKeys, channelActorWithKeys ] = await Promise.all([
109 generateAndSaveActorKeys(account.Actor),
110 generateAndSaveActorKeys(videoChannel.Actor)
113 account.Actor = accountActorWithKeys
114 videoChannel.Actor = channelActorWithKeys
116 return { user, account, videoChannel }
119 async function createLocalAccountWithoutKeys (parameters: {
122 userId: number | null
123 applicationId: number | null
124 t: Transaction | undefined
125 type?: ActivityPubActorType
127 const { name, displayName, userId, applicationId, t, type = 'Person' } = parameters
128 const url = getLocalAccountActivityPubUrl(name)
130 const actorInstance = buildActorInstance(type, url, name)
131 const actorInstanceCreated: MActorDefault = await actorInstance.save({ transaction: t })
133 const accountInstance = new AccountModel({
134 name: displayName || name,
137 actorId: actorInstanceCreated.id
140 const accountInstanceCreated: MAccountDefault = await accountInstance.save({ transaction: t })
141 accountInstanceCreated.Actor = actorInstanceCreated
143 return accountInstanceCreated
146 async function createApplicationActor (applicationId: number) {
147 const accountCreated = await createLocalAccountWithoutKeys({
148 name: SERVER_ACTOR_NAME,
155 accountCreated.Actor = await generateAndSaveActorKeys(accountCreated.Actor)
157 return accountCreated
160 // ---------------------------------------------------------------------------
162 async function sendVerifyUserEmail (user: MUser, isPendingEmail = false) {
163 const verificationString = await Redis.Instance.setUserVerifyEmailVerificationString(user.id)
164 let verifyEmailUrl = `${WEBSERVER.URL}/verify-account/email?userId=${user.id}&verificationString=${verificationString}`
166 if (isPendingEmail) verifyEmailUrl += '&isPendingEmail=true'
168 const to = isPendingEmail
172 const username = user.username
174 Emailer.Instance.addVerifyEmailJob({ username, to, verifyEmailUrl, isRegistrationRequest: false })
177 async function sendVerifyRegistrationEmail (registration: MRegistration) {
178 const verificationString = await Redis.Instance.setRegistrationVerifyEmailVerificationString(registration.id)
179 const verifyEmailUrl = `${WEBSERVER.URL}/verify-account/email?registrationId=${registration.id}&verificationString=${verificationString}`
181 const to = registration.email
182 const username = registration.username
184 Emailer.Instance.addVerifyEmailJob({ username, to, verifyEmailUrl, isRegistrationRequest: true })
187 // ---------------------------------------------------------------------------
189 async function getOriginalVideoFileTotalFromUser (user: MUserId) {
190 // Don't use sequelize because we need to use a sub query
191 const query = UserModel.generateUserQuotaBaseSQL({
193 whereUserId: '$userId',
197 const base = await UserModel.getTotalRawQuery(query, user.id)
199 return base + LiveQuotaStore.Instance.getLiveQuotaOf(user.id)
202 // Returns cumulative size of all video files uploaded in the last 24 hours.
203 async function getOriginalVideoFileTotalDailyFromUser (user: MUserId) {
204 // Don't use sequelize because we need to use a sub query
205 const query = UserModel.generateUserQuotaBaseSQL({
207 whereUserId: '$userId',
211 const base = await UserModel.getTotalRawQuery(query, user.id)
213 return base + LiveQuotaStore.Instance.getLiveQuotaOf(user.id)
216 async function isAbleToUploadVideo (userId: number, newVideoSize: number) {
217 const user = await UserModel.loadById(userId)
219 if (user.videoQuota === -1 && user.videoQuotaDaily === -1) return Promise.resolve(true)
221 const [ totalBytes, totalBytesDaily ] = await Promise.all([
222 getOriginalVideoFileTotalFromUser(user),
223 getOriginalVideoFileTotalDailyFromUser(user)
226 const uploadedTotal = newVideoSize + totalBytes
227 const uploadedDaily = newVideoSize + totalBytesDaily
230 'Check user %d quota to upload another video.', userId,
231 { totalBytes, totalBytesDaily, videoQuota: user.videoQuota, videoQuotaDaily: user.videoQuotaDaily, newVideoSize }
234 if (user.videoQuotaDaily === -1) return uploadedTotal < user.videoQuota
235 if (user.videoQuota === -1) return uploadedDaily < user.videoQuotaDaily
237 return uploadedTotal < user.videoQuota && uploadedDaily < user.videoQuotaDaily
240 // ---------------------------------------------------------------------------
243 getOriginalVideoFileTotalFromUser,
244 getOriginalVideoFileTotalDailyFromUser,
245 createApplicationActor,
246 createUserAccountAndChannelAndPlaylist,
247 createLocalAccountWithoutKeys,
250 sendVerifyRegistrationEmail,
256 // ---------------------------------------------------------------------------
258 function createDefaultUserNotificationSettings (user: MUserId, t: Transaction | undefined) {
259 const values: UserNotificationSetting & { userId: number } = {
261 newVideoFromSubscription: UserNotificationSettingValue.WEB,
262 newCommentOnMyVideo: UserNotificationSettingValue.WEB,
263 myVideoImportFinished: UserNotificationSettingValue.WEB,
264 myVideoPublished: UserNotificationSettingValue.WEB,
265 abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
266 videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
267 blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
268 newUserRegistration: UserNotificationSettingValue.WEB,
269 commentMention: UserNotificationSettingValue.WEB,
270 newFollow: UserNotificationSettingValue.WEB,
271 newInstanceFollower: UserNotificationSettingValue.WEB,
272 abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
273 abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
274 autoInstanceFollowing: UserNotificationSettingValue.WEB,
275 newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
276 newPluginVersion: UserNotificationSettingValue.WEB,
277 myVideoStudioEditionFinished: UserNotificationSettingValue.WEB
280 return UserNotificationSettingModel.create(values, { transaction: t })
283 async function buildChannelAttributes (options: {
285 transaction?: Transaction
286 channelNames?: ChannelNames
288 const { user, transaction, channelNames } = options
290 if (channelNames) return channelNames
292 const channelName = await findAvailableLocalActorName(user.username + '_channel', transaction)
293 const videoChannelDisplayName = `Main ${user.username} channel`
297 displayName: videoChannelDisplayName