X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Flib%2Fuser.ts;h=8a6fcebc7b3d4d2ccd0127a08416f6ab077718e2;hb=2539932e16129992a2c0889b4ff527c265a8e2c7;hp=a92f4777bbdfa74ab4e56165f6d3827de8b3ce3a;hpb=f5028693a896a3076dd286ac0030e3d8f78f5ebf;p=github%2FChocobozzz%2FPeerTube.git diff --git a/server/lib/user.ts b/server/lib/user.ts index a92f4777b..8a6fcebc7 100644 --- a/server/lib/user.ts +++ b/server/lib/user.ts @@ -1,42 +1,220 @@ -import { database as db } from '../initializers' -import { UserInstance } from '../models' -import { addVideoAuthorToFriends } from './friends' -import { createVideoChannel } from './video-channel' +import { Transaction } from 'sequelize/types' +import { v4 as uuidv4 } from 'uuid' +import { UserModel } from '@server/models/user/user' +import { MActorDefault } from '@server/types/models/actor' +import { ActivityPubActorType } from '../../shared/models/activitypub' +import { UserNotificationSetting, UserNotificationSettingValue } from '../../shared/models/users' +import { SERVER_ACTOR_NAME, WEBSERVER } from '../initializers/constants' +import { sequelizeTypescript } from '../initializers/database' +import { AccountModel } from '../models/account/account' +import { ActorModel } from '../models/actor/actor' +import { UserNotificationSettingModel } from '../models/user/user-notification-setting' +import { MAccountDefault, MChannelActor } from '../types/models' +import { MUser, MUserDefault, MUserId } from '../types/models/user' +import { buildActorInstance, generateAndSaveActorKeys } from './activitypub/actor' +import { getLocalAccountActivityPubUrl } from './activitypub/url' +import { Emailer } from './emailer' +import { LiveManager } from './live-manager' +import { Redis } from './redis' +import { createLocalVideoChannel } from './video-channel' +import { createWatchLaterPlaylist } from './video-playlist' -async function createUserAuthorAndChannel (user: UserInstance, validateUser = true) { - const res = await db.sequelize.transaction(async t => { +type ChannelNames = { name: string, displayName: string } + +async function createUserAccountAndChannelAndPlaylist (parameters: { + userToCreate: MUser + userDisplayName?: string + channelNames?: ChannelNames + validateUser?: boolean +}): Promise<{ user: MUserDefault, account: MAccountDefault, videoChannel: MChannelActor }> { + const { userToCreate, userDisplayName, channelNames, validateUser = true } = parameters + + const { user, account, videoChannel } = await sequelizeTypescript.transaction(async t => { const userOptions = { transaction: t, validate: validateUser } - const userCreated = await user.save(userOptions) - const authorInstance = db.Author.build({ + const userCreated: MUserDefault = await userToCreate.save(userOptions) + userCreated.NotificationSetting = await createDefaultUserNotificationSettings(userCreated, t) + + const accountCreated = await createLocalAccountWithoutKeys({ name: userCreated.username, - podId: null, // It is our pod - userId: userCreated.id + displayName: userDisplayName, + userId: userCreated.id, + applicationId: null, + t: t }) + userCreated.Account = accountCreated - const authorCreated = await authorInstance.save({ transaction: t }) + const channelAttributes = await buildChannelAttributes(userCreated, channelNames) + const videoChannel = await createLocalVideoChannel(channelAttributes, accountCreated, t) - const remoteVideoAuthor = authorCreated.toAddRemoteJSON() + const videoPlaylist = await createWatchLaterPlaylist(accountCreated, t) - // Now we'll add the video channel's meta data to our friends - const author = await addVideoAuthorToFriends(remoteVideoAuthor, t) + return { user: userCreated, account: accountCreated, videoChannel, videoPlaylist } + }) - const videoChannelInfo = { - name: `Default ${userCreated.username} channel` - } - const videoChannel = await createVideoChannel(videoChannelInfo, authorCreated, t) + const [ accountActorWithKeys, channelActorWithKeys ] = await Promise.all([ + generateAndSaveActorKeys(account.Actor), + generateAndSaveActorKeys(videoChannel.Actor) + ]) + + account.Actor = accountActorWithKeys + videoChannel.Actor = channelActorWithKeys - return { author, videoChannel } + return { user, account, videoChannel } +} + +async function createLocalAccountWithoutKeys (parameters: { + name: string + displayName?: string + userId: number | null + applicationId: number | null + t: Transaction | undefined + type?: ActivityPubActorType +}) { + const { name, displayName, userId, applicationId, t, type = 'Person' } = parameters + const url = getLocalAccountActivityPubUrl(name) + + const actorInstance = buildActorInstance(type, url, name) + const actorInstanceCreated: MActorDefault = await actorInstance.save({ transaction: t }) + + const accountInstance = new AccountModel({ + name: displayName || name, + userId, + applicationId, + actorId: actorInstanceCreated.id }) - return res + const accountInstanceCreated: MAccountDefault = await accountInstance.save({ transaction: t }) + accountInstanceCreated.Actor = actorInstanceCreated + + return accountInstanceCreated +} + +async function createApplicationActor (applicationId: number) { + const accountCreated = await createLocalAccountWithoutKeys({ + name: SERVER_ACTOR_NAME, + userId: null, + applicationId: applicationId, + t: undefined, + type: 'Application' + }) + + accountCreated.Actor = await generateAndSaveActorKeys(accountCreated.Actor) + + return accountCreated +} + +async function sendVerifyUserEmail (user: MUser, isPendingEmail = false) { + const verificationString = await Redis.Instance.setVerifyEmailVerificationString(user.id) + let url = WEBSERVER.URL + '/verify-account/email?userId=' + user.id + '&verificationString=' + verificationString + + if (isPendingEmail) url += '&isPendingEmail=true' + + const email = isPendingEmail ? user.pendingEmail : user.email + const username = user.username + + await Emailer.Instance.addVerifyEmailJob(username, email, url) +} + +async function getOriginalVideoFileTotalFromUser (user: MUserId) { + // Don't use sequelize because we need to use a sub query + const query = UserModel.generateUserQuotaBaseSQL({ + withSelect: true, + whereUserId: '$userId' + }) + + const base = await UserModel.getTotalRawQuery(query, user.id) + + return base + LiveManager.Instance.getLiveQuotaUsedByUser(user.id) +} + +// Returns cumulative size of all video files uploaded in the last 24 hours. +async function getOriginalVideoFileTotalDailyFromUser (user: MUserId) { + // Don't use sequelize because we need to use a sub query + const query = UserModel.generateUserQuotaBaseSQL({ + withSelect: true, + whereUserId: '$userId', + where: '"video"."createdAt" > now() - interval \'24 hours\'' + }) + + const base = await UserModel.getTotalRawQuery(query, user.id) + + return base + LiveManager.Instance.getLiveQuotaUsedByUser(user.id) +} + +async function isAbleToUploadVideo (userId: number, size: number) { + const user = await UserModel.loadById(userId) + + if (user.videoQuota === -1 && user.videoQuotaDaily === -1) return Promise.resolve(true) + + const [ totalBytes, totalBytesDaily ] = await Promise.all([ + getOriginalVideoFileTotalFromUser(user), + getOriginalVideoFileTotalDailyFromUser(user) + ]) + + const uploadedTotal = size + totalBytes + const uploadedDaily = size + totalBytesDaily + + if (user.videoQuotaDaily === -1) return uploadedTotal < user.videoQuota + if (user.videoQuota === -1) return uploadedDaily < user.videoQuotaDaily + + return uploadedTotal < user.videoQuota && uploadedDaily < user.videoQuotaDaily } // --------------------------------------------------------------------------- export { - createUserAuthorAndChannel + getOriginalVideoFileTotalFromUser, + getOriginalVideoFileTotalDailyFromUser, + createApplicationActor, + createUserAccountAndChannelAndPlaylist, + createLocalAccountWithoutKeys, + sendVerifyUserEmail, + isAbleToUploadVideo +} + +// --------------------------------------------------------------------------- + +function createDefaultUserNotificationSettings (user: MUserId, t: Transaction | undefined) { + const values: UserNotificationSetting & { userId: number } = { + userId: user.id, + newVideoFromSubscription: UserNotificationSettingValue.WEB, + newCommentOnMyVideo: UserNotificationSettingValue.WEB, + myVideoImportFinished: UserNotificationSettingValue.WEB, + myVideoPublished: UserNotificationSettingValue.WEB, + abuseAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, + videoAutoBlacklistAsModerator: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, + blacklistOnMyVideo: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, + newUserRegistration: UserNotificationSettingValue.WEB, + commentMention: UserNotificationSettingValue.WEB, + newFollow: UserNotificationSettingValue.WEB, + newInstanceFollower: UserNotificationSettingValue.WEB, + abuseNewMessage: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, + abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, + autoInstanceFollowing: UserNotificationSettingValue.WEB, + newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL, + newPluginVersion: UserNotificationSettingValue.WEB + } + + return UserNotificationSettingModel.create(values, { transaction: t }) +} + +async function buildChannelAttributes (user: MUser, channelNames?: ChannelNames) { + if (channelNames) return channelNames + + let channelName = user.username + '_channel' + + // Conflict, generate uuid instead + const actor = await ActorModel.loadLocalByName(channelName) + if (actor) channelName = uuidv4() + + const videoChannelDisplayName = `Main ${user.username} channel` + + return { + name: channelName, + displayName: videoChannelDisplayName + } }