Init commit
This commit is contained in:
ShreejitPanchal
241
server/core/models/account/account-blocklist.ts
Normal file
241
server/core/models/account/account-blocklist.ts
Normal file
@@ -0,0 +1,241 @@
|
||||
import { FindOptions, Op, QueryTypes } from 'sequelize'
|
||||
import { BelongsTo, Column, CreatedAt, ForeignKey, Table, UpdatedAt } from 'sequelize-typescript'
|
||||
import { AccountBlock } from '@peertube/peertube-models'
|
||||
import { handlesToNameAndHost } from '@server/helpers/actors.js'
|
||||
import { MAccountBlocklist, MAccountBlocklistFormattable } from '@server/types/models/index.js'
|
||||
import { ActorModel } from '../actor/actor.js'
|
||||
import { ServerModel } from '../server/server.js'
|
||||
import { SequelizeModel, createSafeIn, getSort, searchAttribute } from '../shared/index.js'
|
||||
import { AccountModel } from './account.js'
|
||||
import { WEBSERVER } from '@server/initializers/constants.js'
|
||||
|
||||
@Table({
|
||||
tableName: 'accountBlocklist',
|
||||
indexes: [
|
||||
{
|
||||
fields: [ 'accountId', 'targetAccountId' ],
|
||||
unique: true
|
||||
},
|
||||
{
|
||||
fields: [ 'targetAccountId' ]
|
||||
}
|
||||
]
|
||||
})
|
||||
export class AccountBlocklistModel extends SequelizeModel<AccountBlocklistModel> {
|
||||
@CreatedAt
|
||||
declare createdAt: Date
|
||||
|
||||
@UpdatedAt
|
||||
declare updatedAt: Date
|
||||
|
||||
@ForeignKey(() => AccountModel)
|
||||
@Column
|
||||
declare accountId: number
|
||||
|
||||
@BelongsTo(() => AccountModel, {
|
||||
foreignKey: {
|
||||
name: 'accountId',
|
||||
allowNull: false
|
||||
},
|
||||
as: 'ByAccount',
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare ByAccount: Awaited<AccountModel>
|
||||
|
||||
@ForeignKey(() => AccountModel)
|
||||
@Column
|
||||
declare targetAccountId: number
|
||||
|
||||
@BelongsTo(() => AccountModel, {
|
||||
foreignKey: {
|
||||
name: 'targetAccountId',
|
||||
allowNull: false
|
||||
},
|
||||
as: 'BlockedAccount',
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare BlockedAccount: Awaited<AccountModel>
|
||||
|
||||
static isAccountMutedByAccounts (accountIds: number[], targetAccountId: number) {
|
||||
const query = {
|
||||
attributes: [ 'accountId', 'id' ],
|
||||
where: {
|
||||
accountId: {
|
||||
[Op.in]: accountIds
|
||||
},
|
||||
targetAccountId
|
||||
},
|
||||
raw: true
|
||||
}
|
||||
|
||||
return AccountBlocklistModel.unscoped()
|
||||
.findAll(query)
|
||||
.then(rows => {
|
||||
const result: { [accountId: number]: boolean } = {}
|
||||
|
||||
for (const accountId of accountIds) {
|
||||
result[accountId] = !!rows.find(r => r.accountId === accountId)
|
||||
}
|
||||
|
||||
return result
|
||||
})
|
||||
}
|
||||
|
||||
static loadByAccountAndTarget (accountId: number, targetAccountId: number): Promise<MAccountBlocklist> {
|
||||
const query = {
|
||||
where: {
|
||||
accountId,
|
||||
targetAccountId
|
||||
}
|
||||
}
|
||||
|
||||
return AccountBlocklistModel.findOne(query)
|
||||
}
|
||||
|
||||
static listForApi (parameters: {
|
||||
start: number
|
||||
count: number
|
||||
sort: string
|
||||
search?: string
|
||||
accountId: number
|
||||
}) {
|
||||
const { start, count, sort, search, accountId } = parameters
|
||||
|
||||
const getQuery = (forCount: boolean) => {
|
||||
const query: FindOptions = {
|
||||
offset: start,
|
||||
limit: count,
|
||||
order: getSort(sort),
|
||||
where: { accountId }
|
||||
}
|
||||
|
||||
if (search) {
|
||||
Object.assign(query.where, {
|
||||
[Op.or]: [
|
||||
searchAttribute(search, '$BlockedAccount.name$'),
|
||||
searchAttribute(search, '$BlockedAccount.Actor.url$')
|
||||
]
|
||||
})
|
||||
}
|
||||
|
||||
if (forCount !== true) {
|
||||
query.include = [
|
||||
{
|
||||
model: AccountModel,
|
||||
required: true,
|
||||
as: 'ByAccount'
|
||||
},
|
||||
{
|
||||
model: AccountModel,
|
||||
required: true,
|
||||
as: 'BlockedAccount'
|
||||
}
|
||||
]
|
||||
} else if (search) { // We need some joins when counting with search
|
||||
query.include = [
|
||||
{
|
||||
model: AccountModel.unscoped(),
|
||||
required: true,
|
||||
as: 'BlockedAccount',
|
||||
include: [
|
||||
{
|
||||
model: ActorModel.unscoped(),
|
||||
required: true
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
return query
|
||||
}
|
||||
|
||||
return Promise.all([
|
||||
AccountBlocklistModel.count(getQuery(true)),
|
||||
AccountBlocklistModel.findAll(getQuery(false))
|
||||
]).then(([ total, data ]) => ({ total, data }))
|
||||
}
|
||||
|
||||
static listHandlesBlockedBy (accountIds: number[]): Promise<string[]> {
|
||||
const query = {
|
||||
attributes: [ 'id' ],
|
||||
where: {
|
||||
accountId: {
|
||||
[Op.in]: accountIds
|
||||
}
|
||||
},
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'id' ],
|
||||
model: AccountModel.unscoped(),
|
||||
required: true,
|
||||
as: 'BlockedAccount',
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'preferredUsername' ],
|
||||
model: ActorModel.unscoped(),
|
||||
required: true,
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'host' ],
|
||||
model: ServerModel.unscoped(),
|
||||
required: false
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
return AccountBlocklistModel.findAll(query)
|
||||
.then(entries => {
|
||||
return entries.map(e => {
|
||||
const host = e.BlockedAccount.Actor.Server?.host ?? WEBSERVER.HOST
|
||||
|
||||
return `${e.BlockedAccount.Actor.preferredUsername}@${host}`
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
static getBlockStatus (byAccountIds: number[], handles: string[]): Promise<{ name: string, host: string, accountId: number }[]> {
|
||||
const sanitizedHandles = handlesToNameAndHost(handles)
|
||||
|
||||
const localHandles = sanitizedHandles.filter(h => !h.host)
|
||||
.map(h => h.name)
|
||||
|
||||
const remoteHandles = sanitizedHandles.filter(h => !!h.host)
|
||||
.map(h => [ h.name, h.host ])
|
||||
|
||||
const handlesWhere: string[] = []
|
||||
|
||||
if (localHandles.length !== 0) {
|
||||
handlesWhere.push(`("actor"."preferredUsername" IN (:localHandles) AND "server"."id" IS NULL)`)
|
||||
}
|
||||
|
||||
if (remoteHandles.length !== 0) {
|
||||
handlesWhere.push(`(("actor"."preferredUsername", "server"."host") IN (:remoteHandles))`)
|
||||
}
|
||||
|
||||
const rawQuery = `SELECT "accountBlocklist"."accountId", "actor"."preferredUsername" AS "name", "server"."host" ` +
|
||||
`FROM "accountBlocklist" ` +
|
||||
`INNER JOIN "account" ON "account"."id" = "accountBlocklist"."targetAccountId" ` +
|
||||
`INNER JOIN "actor" ON "actor"."accountId" = "account"."id" ` +
|
||||
`LEFT JOIN "server" ON "server"."id" = "actor"."serverId" ` +
|
||||
`WHERE "accountBlocklist"."accountId" IN (${createSafeIn(AccountBlocklistModel.sequelize, byAccountIds)}) ` +
|
||||
`AND (${handlesWhere.join(' OR ')})`
|
||||
|
||||
return AccountBlocklistModel.sequelize.query(rawQuery, {
|
||||
type: QueryTypes.SELECT as QueryTypes.SELECT,
|
||||
replacements: { byAccountIds, localHandles, remoteHandles }
|
||||
})
|
||||
}
|
||||
|
||||
toFormattedJSON (this: MAccountBlocklistFormattable): AccountBlock {
|
||||
return {
|
||||
byAccount: this.ByAccount.toFormattedJSON(),
|
||||
blockedAccount: this.BlockedAccount.toFormattedJSON(),
|
||||
createdAt: this.createdAt
|
||||
}
|
||||
}
|
||||
}
|
||||
279
server/core/models/account/account-video-rate.ts
Normal file
279
server/core/models/account/account-video-rate.ts
Normal file
@@ -0,0 +1,279 @@
|
||||
import { AccountVideoRate, type VideoRateType } from '@peertube/peertube-models'
|
||||
import {
|
||||
MAccountVideoRate,
|
||||
MAccountVideoRateAccountUrl,
|
||||
MAccountVideoRateAccountVideo,
|
||||
MAccountVideoRateFormattable,
|
||||
MAccountVideoRateVideoUrl
|
||||
} from '@server/types/models/index.js'
|
||||
import { FindOptions, Op, QueryTypes, Transaction } from 'sequelize'
|
||||
import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Is, Table, UpdatedAt } from 'sequelize-typescript'
|
||||
import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc.js'
|
||||
import { CONSTRAINTS_FIELDS, USER_EXPORT_MAX_ITEMS, VIDEO_RATE_TYPES } from '../../initializers/constants.js'
|
||||
import { ActorModel } from '../actor/actor.js'
|
||||
import { SequelizeModel, getSort, throwIfNotValid } from '../shared/index.js'
|
||||
import { SummaryOptions, VideoChannelModel, ScopeNames as VideoChannelScopeNames } from '../video/video-channel.js'
|
||||
import { VideoModel } from '../video/video.js'
|
||||
import { AccountModel } from './account.js'
|
||||
|
||||
/*
|
||||
Account rates per video.
|
||||
*/
|
||||
@Table({
|
||||
tableName: 'accountVideoRate',
|
||||
indexes: [
|
||||
{
|
||||
fields: [ 'videoId', 'accountId' ],
|
||||
unique: true
|
||||
},
|
||||
{
|
||||
fields: [ 'videoId' ]
|
||||
},
|
||||
{
|
||||
fields: [ 'accountId' ]
|
||||
},
|
||||
{
|
||||
fields: [ 'videoId', 'type' ]
|
||||
},
|
||||
{
|
||||
fields: [ 'url' ],
|
||||
unique: true
|
||||
}
|
||||
]
|
||||
})
|
||||
export class AccountVideoRateModel extends SequelizeModel<AccountVideoRateModel> {
|
||||
@AllowNull(false)
|
||||
@Column(DataType.ENUM(...Object.values(VIDEO_RATE_TYPES)))
|
||||
declare type: VideoRateType
|
||||
|
||||
@AllowNull(false)
|
||||
@Is('AccountVideoRateUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
|
||||
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_RATES.URL.max))
|
||||
declare url: string
|
||||
|
||||
@CreatedAt
|
||||
declare createdAt: Date
|
||||
|
||||
@UpdatedAt
|
||||
declare updatedAt: Date
|
||||
|
||||
@ForeignKey(() => VideoModel)
|
||||
@Column
|
||||
declare videoId: number
|
||||
|
||||
@BelongsTo(() => VideoModel, {
|
||||
foreignKey: {
|
||||
allowNull: false
|
||||
},
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare Video: Awaited<VideoModel>
|
||||
|
||||
@ForeignKey(() => AccountModel)
|
||||
@Column
|
||||
declare accountId: number
|
||||
|
||||
@BelongsTo(() => AccountModel, {
|
||||
foreignKey: {
|
||||
allowNull: false
|
||||
},
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare Account: Awaited<AccountModel>
|
||||
|
||||
static load (accountId: number, videoId: number, transaction?: Transaction): Promise<MAccountVideoRate> {
|
||||
const options: FindOptions = {
|
||||
where: {
|
||||
accountId,
|
||||
videoId
|
||||
}
|
||||
}
|
||||
if (transaction) options.transaction = transaction
|
||||
|
||||
return AccountVideoRateModel.findOne(options)
|
||||
}
|
||||
|
||||
static loadByAccountAndVideoOrUrl (accountId: number, videoId: number, url: string, t?: Transaction): Promise<MAccountVideoRate> {
|
||||
const options: FindOptions = {
|
||||
where: {
|
||||
[Op.or]: [
|
||||
{
|
||||
accountId,
|
||||
videoId
|
||||
},
|
||||
{
|
||||
url
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
if (t) options.transaction = t
|
||||
|
||||
return AccountVideoRateModel.findOne(options)
|
||||
}
|
||||
|
||||
static loadLocalAndPopulateVideo (
|
||||
rateType: VideoRateType,
|
||||
accountName: string,
|
||||
videoId: number,
|
||||
t?: Transaction
|
||||
): Promise<MAccountVideoRateAccountVideo> {
|
||||
const options: FindOptions = {
|
||||
where: {
|
||||
videoId,
|
||||
type: rateType
|
||||
},
|
||||
include: [
|
||||
{
|
||||
model: AccountModel.unscoped(),
|
||||
required: true,
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'id', 'url', 'followersUrl', 'preferredUsername' ],
|
||||
model: ActorModel.unscoped(),
|
||||
required: true,
|
||||
where: {
|
||||
[Op.and]: [
|
||||
ActorModel.wherePreferredUsername(accountName),
|
||||
{ serverId: null }
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
{
|
||||
model: VideoModel.unscoped(),
|
||||
required: true
|
||||
}
|
||||
]
|
||||
}
|
||||
if (t) options.transaction = t
|
||||
|
||||
return AccountVideoRateModel.findOne(options)
|
||||
}
|
||||
|
||||
static loadByUrl (url: string, transaction: Transaction) {
|
||||
const options: FindOptions = {
|
||||
where: {
|
||||
url
|
||||
}
|
||||
}
|
||||
if (transaction) options.transaction = transaction
|
||||
|
||||
return AccountVideoRateModel.findOne(options)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
static listByAccountForApi (options: {
|
||||
start: number
|
||||
count: number
|
||||
sort: string
|
||||
type?: string
|
||||
accountId: number
|
||||
}) {
|
||||
const getQuery = (forCount: boolean) => {
|
||||
const query: FindOptions = {
|
||||
offset: options.start,
|
||||
limit: options.count,
|
||||
order: getSort(options.sort),
|
||||
where: {
|
||||
accountId: options.accountId
|
||||
}
|
||||
}
|
||||
|
||||
if (options.type) query.where['type'] = options.type
|
||||
|
||||
if (forCount !== true) {
|
||||
query.include = [
|
||||
{
|
||||
model: VideoModel,
|
||||
required: true,
|
||||
include: [
|
||||
{
|
||||
model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, { withAccount: true } as SummaryOptions ] }),
|
||||
required: true
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
return query
|
||||
}
|
||||
|
||||
return Promise.all([
|
||||
AccountVideoRateModel.count(getQuery(true)),
|
||||
AccountVideoRateModel.findAll(getQuery(false))
|
||||
]).then(([ total, data ]) => ({ total, data }))
|
||||
}
|
||||
|
||||
static listRemoteRateUrlsOfLocalVideos () {
|
||||
const query = `SELECT "accountVideoRate".url FROM "accountVideoRate" ` +
|
||||
`INNER JOIN account ON account.id = "accountVideoRate"."accountId" ` +
|
||||
`INNER JOIN actor ON "actor"."accountId" = account."id" AND actor."serverId" IS NOT NULL ` +
|
||||
`INNER JOIN video ON video.id = "accountVideoRate"."videoId" AND video.remote IS FALSE`
|
||||
|
||||
return AccountVideoRateModel.sequelize.query<{ url: string }>(query, {
|
||||
type: QueryTypes.SELECT,
|
||||
raw: true
|
||||
}).then(rows => rows.map(r => r.url))
|
||||
}
|
||||
|
||||
static listAndCountAccountUrlsByVideoId (rateType: VideoRateType, videoId: number, start: number, count: number, t?: Transaction) {
|
||||
const query = {
|
||||
offset: start,
|
||||
limit: count,
|
||||
where: {
|
||||
videoId,
|
||||
type: rateType
|
||||
},
|
||||
transaction: t,
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'id' ],
|
||||
model: AccountModel.unscoped(),
|
||||
required: true,
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'url', 'accountId' ],
|
||||
model: ActorModel.unscoped(),
|
||||
required: true
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
return Promise.all([
|
||||
AccountVideoRateModel.count(query),
|
||||
AccountVideoRateModel.findAll<MAccountVideoRateAccountUrl>(query)
|
||||
]).then(([ total, data ]) => ({ total, data }))
|
||||
}
|
||||
|
||||
static listRatesOfAccountIdForExport (accountId: number, rateType: VideoRateType): Promise<MAccountVideoRateVideoUrl[]> {
|
||||
return AccountVideoRateModel.findAll({
|
||||
where: {
|
||||
accountId,
|
||||
type: rateType
|
||||
},
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'url' ],
|
||||
model: VideoModel,
|
||||
required: true
|
||||
}
|
||||
],
|
||||
limit: USER_EXPORT_MAX_ITEMS
|
||||
})
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
toFormattedJSON (this: MAccountVideoRateFormattable): AccountVideoRate {
|
||||
return {
|
||||
video: this.Video.toFormattedJSON(),
|
||||
rating: this.type
|
||||
}
|
||||
}
|
||||
}
|
||||
533
server/core/models/account/account.ts
Normal file
533
server/core/models/account/account.ts
Normal file
@@ -0,0 +1,533 @@
|
||||
import { Account, AccountSummary, ActivityPubActor, ActivityUrlObject, VideoPrivacy } from '@peertube/peertube-models'
|
||||
import { AttributesOnly } from '@peertube/peertube-typescript-utils'
|
||||
import { ModelCache } from '@server/models/shared/model-cache.js'
|
||||
import { FindOptions, IncludeOptions, Includeable, Op, Transaction, WhereOptions, literal } from 'sequelize'
|
||||
import {
|
||||
AllowNull,
|
||||
BeforeDestroy,
|
||||
BelongsTo,
|
||||
Column,
|
||||
CreatedAt,
|
||||
DataType,
|
||||
Default,
|
||||
DefaultScope,
|
||||
ForeignKey,
|
||||
HasMany,
|
||||
HasOne,
|
||||
Is,
|
||||
Scopes,
|
||||
Table,
|
||||
UpdatedAt
|
||||
} from 'sequelize-typescript'
|
||||
import { isAccountDescriptionValid } from '../../helpers/custom-validators/accounts.js'
|
||||
import { CONSTRAINTS_FIELDS, SERVER_ACTOR_NAME, WEBSERVER } from '../../initializers/constants.js'
|
||||
import { sendDeleteActor } from '../../lib/activitypub/send/send-delete.js'
|
||||
import {
|
||||
MAccount,
|
||||
MAccountAP,
|
||||
MAccountDefault,
|
||||
MAccountFormattable,
|
||||
MAccountHost,
|
||||
MAccountIdHost,
|
||||
MAccountSummaryFormattable,
|
||||
MChannelIdHost
|
||||
} from '../../types/models/index.js'
|
||||
import { ActorImageModel } from '../actor/actor-image.js'
|
||||
import { ActorModel, actorSummaryAttributes } from '../actor/actor.js'
|
||||
import { ApplicationModel } from '../application/application.js'
|
||||
import { AccountAutomaticTagPolicyModel } from '../automatic-tag/account-automatic-tag-policy.js'
|
||||
import { CommentAutomaticTagModel } from '../automatic-tag/comment-automatic-tag.js'
|
||||
import { VideoAutomaticTagModel } from '../automatic-tag/video-automatic-tag.js'
|
||||
import { ServerBlocklistModel } from '../server/server-blocklist.js'
|
||||
import { ServerModel, serverSummaryAttributes } from '../server/server.js'
|
||||
import { SequelizeModel, buildSQLAttributes, getSort, throwIfNotValid } from '../shared/index.js'
|
||||
import { UserModel } from '../user/user.js'
|
||||
import { VideoChannelCollaboratorModel } from '../video/video-channel-collaborator.js'
|
||||
import { VideoChannelModel } from '../video/video-channel.js'
|
||||
import { VideoCommentModel } from '../video/video-comment.js'
|
||||
import { VideoPlaylistModel } from '../video/video-playlist.js'
|
||||
import { VideoModel } from '../video/video.js'
|
||||
import { AccountBlocklistModel } from './account-blocklist.js'
|
||||
|
||||
export enum ScopeNames {
|
||||
SUMMARY = 'SUMMARY'
|
||||
}
|
||||
|
||||
const accountSummaryAttributes = [ 'id', 'name' ] as const satisfies (keyof AttributesOnly<AccountModel>)[]
|
||||
|
||||
export type SummaryOptions = {
|
||||
actorRequired?: boolean // Default: true
|
||||
whereActor?: WhereOptions
|
||||
whereServer?: WhereOptions
|
||||
withAccountBlockerIds?: number[]
|
||||
forCount?: boolean
|
||||
}
|
||||
|
||||
@DefaultScope(() => ({
|
||||
include: [
|
||||
{
|
||||
model: ActorModel, // Default scope includes avatar and server
|
||||
required: true
|
||||
}
|
||||
]
|
||||
}))
|
||||
@Scopes(() => ({
|
||||
[ScopeNames.SUMMARY]: (options: SummaryOptions = {}) => {
|
||||
const serverInclude: IncludeOptions = {
|
||||
attributes: serverSummaryAttributes,
|
||||
model: ServerModel.unscoped(),
|
||||
required: !!options.whereServer,
|
||||
where: options.whereServer
|
||||
}
|
||||
|
||||
const actorInclude: Includeable = {
|
||||
attributes: actorSummaryAttributes,
|
||||
model: ActorModel.unscoped(),
|
||||
required: options.actorRequired ?? true,
|
||||
where: options.whereActor,
|
||||
include: [ serverInclude ]
|
||||
}
|
||||
|
||||
if (options.forCount !== true) {
|
||||
actorInclude.include.push({
|
||||
model: ActorImageModel,
|
||||
as: 'Avatars',
|
||||
required: false
|
||||
})
|
||||
}
|
||||
|
||||
const queryInclude: Includeable[] = [
|
||||
actorInclude
|
||||
]
|
||||
|
||||
const query: FindOptions = {
|
||||
attributes: accountSummaryAttributes
|
||||
}
|
||||
|
||||
if (options.withAccountBlockerIds) {
|
||||
queryInclude.push({
|
||||
attributes: [ 'id' ],
|
||||
model: AccountBlocklistModel.unscoped(),
|
||||
as: 'BlockedBy',
|
||||
required: false,
|
||||
where: {
|
||||
accountId: {
|
||||
[Op.in]: options.withAccountBlockerIds
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
serverInclude.include = [
|
||||
{
|
||||
attributes: [ 'id' ],
|
||||
model: ServerBlocklistModel.unscoped(),
|
||||
required: false,
|
||||
where: {
|
||||
accountId: {
|
||||
[Op.in]: options.withAccountBlockerIds
|
||||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
query.include = queryInclude
|
||||
|
||||
return query
|
||||
}
|
||||
}))
|
||||
@Table({
|
||||
tableName: 'account',
|
||||
indexes: [
|
||||
{
|
||||
fields: [ 'applicationId' ]
|
||||
},
|
||||
{
|
||||
fields: [ 'userId' ]
|
||||
}
|
||||
]
|
||||
})
|
||||
export class AccountModel extends SequelizeModel<AccountModel> {
|
||||
@AllowNull(false)
|
||||
@Column
|
||||
declare name: string
|
||||
|
||||
@AllowNull(true)
|
||||
@Default(null)
|
||||
@Is('AccountDescription', value => throwIfNotValid(value, isAccountDescriptionValid, 'description', true))
|
||||
@Column(DataType.STRING(CONSTRAINTS_FIELDS.USERS.DESCRIPTION.max))
|
||||
declare description: string
|
||||
|
||||
@CreatedAt
|
||||
declare createdAt: Date
|
||||
|
||||
@UpdatedAt
|
||||
declare updatedAt: Date
|
||||
|
||||
@ForeignKey(() => UserModel)
|
||||
@Column
|
||||
declare userId: number
|
||||
|
||||
@BelongsTo(() => UserModel, {
|
||||
foreignKey: {
|
||||
allowNull: true
|
||||
},
|
||||
onDelete: 'cascade'
|
||||
})
|
||||
declare User: Awaited<UserModel>
|
||||
|
||||
@ForeignKey(() => ApplicationModel)
|
||||
@Column
|
||||
declare applicationId: number
|
||||
|
||||
@BelongsTo(() => ApplicationModel, {
|
||||
foreignKey: {
|
||||
allowNull: true
|
||||
},
|
||||
onDelete: 'cascade'
|
||||
})
|
||||
declare Application: Awaited<ApplicationModel>
|
||||
|
||||
@HasMany(() => VideoChannelModel, {
|
||||
foreignKey: {
|
||||
allowNull: false
|
||||
},
|
||||
onDelete: 'cascade',
|
||||
hooks: true
|
||||
})
|
||||
declare VideoChannels: Awaited<VideoChannelModel>[]
|
||||
|
||||
@HasMany(() => VideoPlaylistModel, {
|
||||
foreignKey: {
|
||||
allowNull: false
|
||||
},
|
||||
onDelete: 'cascade',
|
||||
hooks: true
|
||||
})
|
||||
declare VideoPlaylists: Awaited<VideoPlaylistModel>[]
|
||||
|
||||
@HasMany(() => VideoCommentModel, {
|
||||
foreignKey: {
|
||||
allowNull: true
|
||||
},
|
||||
onDelete: 'cascade',
|
||||
hooks: true
|
||||
})
|
||||
declare VideoComments: Awaited<VideoCommentModel>[]
|
||||
|
||||
@HasMany(() => AccountBlocklistModel, {
|
||||
foreignKey: {
|
||||
name: 'targetAccountId',
|
||||
allowNull: false
|
||||
},
|
||||
as: 'BlockedBy',
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare BlockedBy: Awaited<AccountBlocklistModel>[]
|
||||
|
||||
@HasMany(() => AccountAutomaticTagPolicyModel, {
|
||||
foreignKey: {
|
||||
name: 'accountId',
|
||||
allowNull: false
|
||||
},
|
||||
onDelete: 'cascade'
|
||||
})
|
||||
declare AccountAutomaticTagPolicies: Awaited<AccountAutomaticTagPolicyModel>[]
|
||||
|
||||
@HasMany(() => CommentAutomaticTagModel, {
|
||||
foreignKey: 'accountId',
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare CommentAutomaticTags: Awaited<CommentAutomaticTagModel>[]
|
||||
|
||||
@HasMany(() => VideoAutomaticTagModel, {
|
||||
foreignKey: 'accountId',
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare VideoAutomaticTags: Awaited<VideoAutomaticTagModel>[]
|
||||
|
||||
@HasMany(() => VideoChannelCollaboratorModel, {
|
||||
foreignKey: 'accountId',
|
||||
onDelete: 'CASCADE'
|
||||
})
|
||||
declare VideoChannelCollaborators: Awaited<VideoChannelCollaboratorModel>[]
|
||||
|
||||
@HasOne(() => ActorModel, {
|
||||
foreignKey: {
|
||||
allowNull: true
|
||||
},
|
||||
hooks: true,
|
||||
onDelete: 'cascade'
|
||||
})
|
||||
declare Actor: Awaited<ActorModel>
|
||||
|
||||
@BeforeDestroy
|
||||
static async sendDeleteIfOwned (instance: AccountModel, options) {
|
||||
if (!instance.Actor) {
|
||||
instance.Actor = await instance.$get('Actor', { transaction: options.transaction })
|
||||
}
|
||||
|
||||
if (instance.isLocal()) {
|
||||
return sendDeleteActor(instance.Actor, options.transaction)
|
||||
}
|
||||
|
||||
return undefined
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
static getSQLAttributes (tableName: string, aliasPrefix = '') {
|
||||
return buildSQLAttributes({
|
||||
model: this,
|
||||
tableName,
|
||||
aliasPrefix
|
||||
})
|
||||
}
|
||||
|
||||
static getSQLSummaryAttributes (tableName: string, aliasPrefix = '') {
|
||||
return buildSQLAttributes({
|
||||
model: this,
|
||||
tableName,
|
||||
aliasPrefix,
|
||||
includeAttributes: accountSummaryAttributes
|
||||
})
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
static load (id: number, transaction?: Transaction): Promise<MAccountDefault> {
|
||||
return AccountModel.findByPk(id, { transaction })
|
||||
}
|
||||
|
||||
static loadByHandle (handle: string): Promise<MAccountDefault> {
|
||||
const [ accountName, host ] = handle.split('@')
|
||||
|
||||
if (!host || host === WEBSERVER.HOST) return AccountModel.loadLocalByName(accountName)
|
||||
|
||||
return AccountModel.loadByNameAndHost(accountName, host)
|
||||
}
|
||||
|
||||
static loadLocalByName (name: string): Promise<MAccountDefault> {
|
||||
const fun = () => {
|
||||
const query = {
|
||||
where: {
|
||||
[Op.or]: [
|
||||
{
|
||||
userId: {
|
||||
[Op.ne]: null
|
||||
}
|
||||
},
|
||||
{
|
||||
applicationId: {
|
||||
[Op.ne]: null
|
||||
}
|
||||
}
|
||||
]
|
||||
},
|
||||
include: [
|
||||
{
|
||||
model: ActorModel,
|
||||
required: true,
|
||||
where: ActorModel.wherePreferredUsername(name)
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
return AccountModel.findOne(query)
|
||||
}
|
||||
|
||||
return ModelCache.Instance.doCache({
|
||||
cacheType: 'server-account',
|
||||
key: name,
|
||||
fun,
|
||||
// The server actor never change, so we can easily cache it
|
||||
whitelist: () => name === SERVER_ACTOR_NAME
|
||||
})
|
||||
}
|
||||
|
||||
static loadByNameAndHost (name: string, host: string): Promise<MAccountDefault> {
|
||||
const query = {
|
||||
include: [
|
||||
{
|
||||
model: ActorModel,
|
||||
required: true,
|
||||
where: ActorModel.wherePreferredUsername(name),
|
||||
include: [
|
||||
{
|
||||
model: ServerModel,
|
||||
required: true,
|
||||
where: {
|
||||
host
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
return AccountModel.findOne(query)
|
||||
}
|
||||
|
||||
static loadByUrl (url: string, transaction?: Transaction): Promise<MAccountDefault> {
|
||||
const query = {
|
||||
include: [
|
||||
{
|
||||
model: ActorModel,
|
||||
required: true,
|
||||
where: {
|
||||
url
|
||||
}
|
||||
}
|
||||
],
|
||||
transaction
|
||||
}
|
||||
|
||||
return AccountModel.findOne(query)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
static loadAccountIdFromVideo (videoId: number): Promise<MAccount> {
|
||||
const query = {
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'id', 'accountId' ],
|
||||
model: VideoChannelModel.unscoped(),
|
||||
required: true,
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'id', 'channelId' ],
|
||||
model: VideoModel.unscoped(),
|
||||
where: {
|
||||
id: videoId
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
return AccountModel.findOne(query)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
static listForApi (start: number, count: number, sort: string) {
|
||||
const query = {
|
||||
offset: start,
|
||||
limit: count,
|
||||
order: getSort(sort)
|
||||
}
|
||||
|
||||
return Promise.all([
|
||||
AccountModel.count(),
|
||||
AccountModel.findAll(query)
|
||||
]).then(([ total, data ]) => ({ total, data }))
|
||||
}
|
||||
|
||||
static listLocalsForSitemap (sort: string): Promise<MAccountHost[]> {
|
||||
return AccountModel.unscoped().findAll({
|
||||
attributes: [],
|
||||
offset: 0,
|
||||
order: getSort(sort),
|
||||
include: [
|
||||
{
|
||||
attributes: [ 'preferredUsername', 'serverId' ],
|
||||
model: ActorModel.unscoped(),
|
||||
where: {
|
||||
serverId: null
|
||||
}
|
||||
},
|
||||
{
|
||||
attributes: [ 'id' ],
|
||||
model: VideoChannelModel.unscoped(),
|
||||
required: true,
|
||||
where: {
|
||||
[Op.and]: [
|
||||
literal(`EXISTS (SELECT 1 FROM "video" WHERE "privacy" = ${VideoPrivacy.PUBLIC} AND "channelId" = "VideoChannels"."id")`)
|
||||
]
|
||||
}
|
||||
}
|
||||
]
|
||||
})
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
toFormattedJSON (this: MAccountFormattable): Account {
|
||||
return {
|
||||
...this.Actor.toFormattedJSON(false),
|
||||
|
||||
id: this.id,
|
||||
displayName: this.getDisplayName(),
|
||||
description: this.description,
|
||||
updatedAt: this.updatedAt,
|
||||
userId: this.userId ?? undefined
|
||||
}
|
||||
}
|
||||
|
||||
toFormattedSummaryJSON (this: MAccountSummaryFormattable): AccountSummary {
|
||||
const actor = this.Actor.toFormattedSummaryJSON()
|
||||
|
||||
return {
|
||||
id: this.id,
|
||||
displayName: this.getDisplayName(),
|
||||
|
||||
name: actor.name,
|
||||
url: actor.url,
|
||||
host: actor.host,
|
||||
avatars: actor.avatars
|
||||
}
|
||||
}
|
||||
|
||||
async toActivityPubObject (this: MAccountAP): Promise<ActivityPubActor> {
|
||||
const obj = await this.Actor.toActivityPubObject(this.name)
|
||||
|
||||
return Object.assign(obj, {
|
||||
url: [
|
||||
{
|
||||
type: 'Link',
|
||||
mediaType: 'text/html',
|
||||
href: this.getClientUrl(true)
|
||||
},
|
||||
{
|
||||
type: 'Link',
|
||||
mediaType: 'text/html',
|
||||
href: this.getClientUrl(false)
|
||||
},
|
||||
{
|
||||
type: 'Link',
|
||||
mediaType: 'text/html',
|
||||
href: this.Actor.url
|
||||
}
|
||||
] as ActivityUrlObject[],
|
||||
|
||||
summary: this.description
|
||||
})
|
||||
}
|
||||
|
||||
isLocal () {
|
||||
return this.Actor.isLocal()
|
||||
}
|
||||
|
||||
isOutdated () {
|
||||
return this.Actor.isOutdated()
|
||||
}
|
||||
|
||||
getDisplayName () {
|
||||
return this.name
|
||||
}
|
||||
|
||||
// Avoid error when running this method on MAccount... | MChannel...
|
||||
getClientUrl (this: MAccountIdHost | MChannelIdHost, channelsSuffix = true) {
|
||||
const suffix = channelsSuffix
|
||||
? '/video-channels'
|
||||
: ''
|
||||
|
||||
return WEBSERVER.URL + '/a/' + this.Actor.getIdentifier() + suffix
|
||||
}
|
||||
|
||||
isBlocked () {
|
||||
return this.BlockedBy && this.BlockedBy.length !== 0
|
||||
}
|
||||
}
|
||||
69
server/core/models/account/actor-custom-page.ts
Normal file
69
server/core/models/account/actor-custom-page.ts
Normal file
@@ -0,0 +1,69 @@
|
||||
import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Table, UpdatedAt } from 'sequelize-typescript'
|
||||
import { CustomPage } from '@peertube/peertube-models'
|
||||
import { ActorModel } from '../actor/actor.js'
|
||||
import { getServerActor } from '../application/application.js'
|
||||
import { SequelizeModel } from '../shared/index.js'
|
||||
|
||||
@Table({
|
||||
tableName: 'actorCustomPage',
|
||||
indexes: [
|
||||
{
|
||||
fields: [ 'actorId', 'type' ],
|
||||
unique: true
|
||||
}
|
||||
]
|
||||
})
|
||||
export class ActorCustomPageModel extends SequelizeModel<ActorCustomPageModel> {
|
||||
@AllowNull(true)
|
||||
@Column(DataType.TEXT)
|
||||
declare content: string
|
||||
|
||||
@AllowNull(false)
|
||||
@Column
|
||||
declare type: 'homepage'
|
||||
|
||||
@CreatedAt
|
||||
declare createdAt: Date
|
||||
|
||||
@UpdatedAt
|
||||
declare updatedAt: Date
|
||||
|
||||
@ForeignKey(() => ActorModel)
|
||||
@Column
|
||||
declare actorId: number
|
||||
|
||||
@BelongsTo(() => ActorModel, {
|
||||
foreignKey: {
|
||||
name: 'actorId',
|
||||
allowNull: false
|
||||
},
|
||||
onDelete: 'cascade'
|
||||
})
|
||||
declare Actor: Awaited<ActorModel>
|
||||
|
||||
static async updateInstanceHomepage (content: string) {
|
||||
const serverActor = await getServerActor()
|
||||
|
||||
return ActorCustomPageModel.upsert({
|
||||
content,
|
||||
actorId: serverActor.id,
|
||||
type: 'homepage'
|
||||
})
|
||||
}
|
||||
|
||||
static async loadInstanceHomepage () {
|
||||
const serverActor = await getServerActor()
|
||||
|
||||
return ActorCustomPageModel.findOne({
|
||||
where: {
|
||||
actorId: serverActor.id
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
toFormattedJSON (): CustomPage {
|
||||
return {
|
||||
content: this.content
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user