PeerTube/server/models/activitypub/actor-follow.ts

547 lines
14 KiB
TypeScript
Raw Normal View History

2017-12-14 17:38:41 +01:00
import * as Bluebird from 'bluebird'
import { values } from 'lodash'
import * as Sequelize from 'sequelize'
import {
AfterCreate,
AfterDestroy,
AfterUpdate,
AllowNull,
BelongsTo,
Column,
CreatedAt,
DataType,
Default,
ForeignKey,
IsInt,
Max,
Model,
Table,
UpdatedAt
} from 'sequelize-typescript'
2017-12-14 17:38:41 +01:00
import { FollowState } from '../../../shared/models/actors'
2018-09-11 16:27:07 +02:00
import { ActorFollow } from '../../../shared/models/actors/follow.model'
import { logger } from '../../helpers/logger'
2018-02-28 18:04:46 +01:00
import { getServerActor } from '../../helpers/utils'
import { ACTOR_FOLLOW_SCORE } from '../../initializers'
2017-12-14 17:38:41 +01:00
import { FOLLOW_STATES } from '../../initializers/constants'
import { ServerModel } from '../server/server'
import { getSort } from '../utils'
2018-08-23 17:58:39 +02:00
import { ActorModel, unusedActorAttributesForAPI } from './actor'
import { VideoChannelModel } from '../video/video-channel'
2018-08-21 10:34:18 +02:00
import { IIncludeOptions } from '../../../node_modules/sequelize-typescript/lib/interfaces/IIncludeOptions'
2018-08-21 16:18:59 +02:00
import { AccountModel } from '../account/account'
2017-12-14 17:38:41 +01:00
@Table({
tableName: 'actorFollow',
indexes: [
{
fields: [ 'actorId' ]
},
{
fields: [ 'targetActorId' ]
},
{
fields: [ 'actorId', 'targetActorId' ],
unique: true
},
{
fields: [ 'score' ]
2017-12-14 17:38:41 +01:00
}
]
})
export class ActorFollowModel extends Model<ActorFollowModel> {
@AllowNull(false)
@Column(DataType.ENUM(values(FOLLOW_STATES)))
state: FollowState
@AllowNull(false)
@Default(ACTOR_FOLLOW_SCORE.BASE)
@IsInt
@Max(ACTOR_FOLLOW_SCORE.MAX)
@Column
score: number
2017-12-14 17:38:41 +01:00
@CreatedAt
createdAt: Date
@UpdatedAt
updatedAt: Date
@ForeignKey(() => ActorModel)
@Column
actorId: number
@BelongsTo(() => ActorModel, {
foreignKey: {
name: 'actorId',
allowNull: false
},
as: 'ActorFollower',
onDelete: 'CASCADE'
})
ActorFollower: ActorModel
@ForeignKey(() => ActorModel)
@Column
targetActorId: number
@BelongsTo(() => ActorModel, {
foreignKey: {
name: 'targetActorId',
allowNull: false
},
as: 'ActorFollowing',
onDelete: 'CASCADE'
})
ActorFollowing: ActorModel
2018-01-12 11:47:45 +01:00
@AfterCreate
@AfterUpdate
static incrementFollowerAndFollowingCount (instance: ActorFollowModel) {
2018-01-12 12:18:11 +01:00
if (instance.state !== 'accepted') return undefined
2018-01-12 11:47:45 +01:00
return Promise.all([
ActorModel.incrementFollows(instance.actorId, 'followingCount', 1),
ActorModel.incrementFollows(instance.targetActorId, 'followersCount', 1)
])
}
@AfterDestroy
static decrementFollowerAndFollowingCount (instance: ActorFollowModel) {
return Promise.all([
ActorModel.incrementFollows(instance.actorId, 'followingCount',-1),
ActorModel.incrementFollows(instance.targetActorId, 'followersCount', -1)
])
}
// Remove actor follows with a score of 0 (too many requests where they were unreachable)
static async removeBadActorFollows () {
const actorFollows = await ActorFollowModel.listBadActorFollows()
const actorFollowsRemovePromises = actorFollows.map(actorFollow => actorFollow.destroy())
await Promise.all(actorFollowsRemovePromises)
const numberOfActorFollowsRemoved = actorFollows.length
if (numberOfActorFollowsRemoved) logger.info('Removed bad %d actor follows.', numberOfActorFollowsRemoved)
}
static updateActorFollowsScore (goodInboxes: string[], badInboxes: string[], t: Sequelize.Transaction | undefined) {
if (goodInboxes.length === 0 && badInboxes.length === 0) return
logger.info('Updating %d good actor follows and %d bad actor follows scores.', goodInboxes.length, badInboxes.length)
if (goodInboxes.length !== 0) {
ActorFollowModel.incrementScores(goodInboxes, ACTOR_FOLLOW_SCORE.BONUS, t)
2018-03-26 15:54:13 +02:00
.catch(err => logger.error('Cannot increment scores of good actor follows.', { err }))
}
if (badInboxes.length !== 0) {
ActorFollowModel.incrementScores(badInboxes, ACTOR_FOLLOW_SCORE.PENALTY, t)
2018-03-26 15:54:13 +02:00
.catch(err => logger.error('Cannot decrement scores of bad actor follows.', { err }))
}
}
2017-12-14 17:38:41 +01:00
static loadByActorAndTarget (actorId: number, targetActorId: number, t?: Sequelize.Transaction) {
const query = {
where: {
actorId,
targetActorId: targetActorId
},
include: [
{
model: ActorModel,
required: true,
as: 'ActorFollower'
},
{
model: ActorModel,
required: true,
as: 'ActorFollowing'
}
],
transaction: t
}
return ActorFollowModel.findOne(query)
}
2018-08-23 17:58:39 +02:00
static loadByActorAndTargetNameAndHostForAPI (actorId: number, targetName: string, targetHost: string, t?: Sequelize.Transaction) {
2018-08-21 10:34:18 +02:00
const actorFollowingPartInclude: IIncludeOptions = {
model: ActorModel,
required: true,
as: 'ActorFollowing',
where: {
preferredUsername: targetName
2018-08-21 10:34:18 +02:00
},
include: [
{
2018-08-23 17:58:39 +02:00
model: VideoChannelModel.unscoped(),
2018-08-21 10:34:18 +02:00
required: false
}
]
}
if (targetHost === null) {
actorFollowingPartInclude.where['serverId'] = null
} else {
2018-08-21 10:34:18 +02:00
actorFollowingPartInclude.include.push({
model: ServerModel,
required: true,
where: {
host: targetHost
}
})
}
2017-12-14 17:38:41 +01:00
const query = {
where: {
actorId
},
include: [
actorFollowingPartInclude,
{
model: ActorModel,
required: true,
as: 'ActorFollower'
}
2017-12-14 17:38:41 +01:00
],
transaction: t
}
return ActorFollowModel.findOne(query)
2018-08-23 17:58:39 +02:00
.then(result => {
if (result && result.ActorFollowing.VideoChannel) {
result.ActorFollowing.VideoChannel.Actor = result.ActorFollowing
}
return result
})
}
static listSubscribedIn (actorId: number, targets: { name: string, host?: string }[]) {
const whereTab = targets
.map(t => {
if (t.host) {
return {
[ Sequelize.Op.and ]: [
{
'$preferredUsername$': t.name
},
{
'$host$': t.host
}
]
}
}
return {
[ Sequelize.Op.and ]: [
{
'$preferredUsername$': t.name
},
{
'$serverId$': null
}
]
}
})
const query = {
attributes: [],
where: {
[ Sequelize.Op.and ]: [
{
[ Sequelize.Op.or ]: whereTab
},
{
actorId
}
]
},
include: [
{
attributes: [ 'preferredUsername' ],
model: ActorModel.unscoped(),
required: true,
as: 'ActorFollowing',
include: [
{
attributes: [ 'host' ],
model: ServerModel.unscoped(),
required: false
}
]
}
]
}
return ActorFollowModel.findAll(query)
}
2017-12-14 17:38:41 +01:00
static listFollowingForApi (id: number, start: number, count: number, sort: string) {
const query = {
distinct: true,
offset: start,
limit: count,
2018-02-19 09:41:03 +01:00
order: getSort(sort),
2017-12-14 17:38:41 +01:00
include: [
{
model: ActorModel,
required: true,
as: 'ActorFollower',
where: {
id
}
},
{
model: ActorModel,
as: 'ActorFollowing',
required: true,
include: [ ServerModel ]
}
]
}
return ActorFollowModel.findAndCountAll(query)
.then(({ rows, count }) => {
return {
data: rows,
total: count
}
})
}
static listSubscriptionsForApi (id: number, start: number, count: number, sort: string) {
const query = {
2018-08-23 17:58:39 +02:00
attributes: [],
distinct: true,
offset: start,
limit: count,
order: getSort(sort),
where: {
actorId: id
},
include: [
{
2018-08-24 11:04:02 +02:00
attributes: [ 'id' ],
model: ActorModel.unscoped(),
as: 'ActorFollowing',
required: true,
include: [
{
2018-08-24 11:04:02 +02:00
model: VideoChannelModel.unscoped(),
2018-08-21 16:18:59 +02:00
required: true,
include: [
{
2018-08-23 17:58:39 +02:00
attributes: {
exclude: unusedActorAttributesForAPI
},
model: ActorModel,
2018-08-21 16:18:59 +02:00
required: true
2018-08-23 17:58:39 +02:00
},
{
2018-08-24 11:04:02 +02:00
model: AccountModel.unscoped(),
2018-08-23 17:58:39 +02:00
required: true,
include: [
{
attributes: {
exclude: unusedActorAttributesForAPI
},
model: ActorModel,
required: true
}
]
2018-08-21 16:18:59 +02:00
}
]
}
]
}
]
}
return ActorFollowModel.findAndCountAll(query)
.then(({ rows, count }) => {
return {
data: rows.map(r => r.ActorFollowing.VideoChannel),
total: count
}
})
}
2017-12-14 17:38:41 +01:00
static listFollowersForApi (id: number, start: number, count: number, sort: string) {
const query = {
distinct: true,
offset: start,
limit: count,
2018-02-19 09:41:03 +01:00
order: getSort(sort),
2017-12-14 17:38:41 +01:00
include: [
{
model: ActorModel,
required: true,
as: 'ActorFollower',
include: [ ServerModel ]
},
{
model: ActorModel,
as: 'ActorFollowing',
required: true,
where: {
id
}
}
]
}
return ActorFollowModel.findAndCountAll(query)
.then(({ rows, count }) => {
return {
data: rows,
total: count
}
})
}
static listAcceptedFollowerUrlsForApi (actorIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
return ActorFollowModel.createListAcceptedFollowForApiQuery('followers', actorIds, t, start, count)
}
static listAcceptedFollowerSharedInboxUrls (actorIds: number[], t: Sequelize.Transaction) {
2018-01-09 17:22:26 +01:00
return ActorFollowModel.createListAcceptedFollowForApiQuery(
2018-01-09 18:13:00 +01:00
'followers',
2018-01-09 17:22:26 +01:00
actorIds,
t,
undefined,
undefined,
2018-01-09 18:13:00 +01:00
'sharedInboxUrl',
true
2018-01-09 17:22:26 +01:00
)
2017-12-14 17:38:41 +01:00
}
static listAcceptedFollowingUrlsForApi (actorIds: number[], t: Sequelize.Transaction, start?: number, count?: number) {
return ActorFollowModel.createListAcceptedFollowForApiQuery('following', actorIds, t, start, count)
}
2018-02-28 18:04:46 +01:00
static async getStats () {
const serverActor = await getServerActor()
const totalInstanceFollowing = await ActorFollowModel.count({
where: {
actorId: serverActor.id
}
})
const totalInstanceFollowers = await ActorFollowModel.count({
where: {
targetActorId: serverActor.id
}
})
return {
totalInstanceFollowing,
totalInstanceFollowers
}
}
2018-01-09 18:13:00 +01:00
private static async createListAcceptedFollowForApiQuery (
type: 'followers' | 'following',
actorIds: number[],
t: Sequelize.Transaction,
start?: number,
count?: number,
columnUrl = 'url',
distinct = false
) {
2017-12-14 17:38:41 +01:00
let firstJoin: string
let secondJoin: string
if (type === 'followers') {
firstJoin = 'targetActorId'
secondJoin = 'actorId'
} else {
firstJoin = 'actorId'
secondJoin = 'targetActorId'
}
2018-01-09 18:13:00 +01:00
const selections: string[] = []
if (distinct === true) selections.push('DISTINCT("Follows"."' + columnUrl + '") AS "url"')
else selections.push('"Follows"."' + columnUrl + '" AS "url"')
selections.push('COUNT(*) AS "total"')
2017-12-14 17:38:41 +01:00
const tasks: Bluebird<any>[] = []
2018-01-09 18:13:00 +01:00
for (let selection of selections) {
2017-12-14 17:38:41 +01:00
let query = 'SELECT ' + selection + ' FROM "actor" ' +
'INNER JOIN "actorFollow" ON "actorFollow"."' + firstJoin + '" = "actor"."id" ' +
'INNER JOIN "actor" AS "Follows" ON "actorFollow"."' + secondJoin + '" = "Follows"."id" ' +
'WHERE "actor"."id" = ANY ($actorIds) AND "actorFollow"."state" = \'accepted\' '
if (count !== undefined) query += 'LIMIT ' + count
if (start !== undefined) query += ' OFFSET ' + start
const options = {
bind: { actorIds },
type: Sequelize.QueryTypes.SELECT,
transaction: t
}
tasks.push(ActorFollowModel.sequelize.query(query, options))
}
const [ followers, [ { total } ] ] = await Promise.all(tasks)
2017-12-14 17:38:41 +01:00
const urls: string[] = followers.map(f => f.url)
return {
data: urls,
total: parseInt(total, 10)
}
}
private static incrementScores (inboxUrls: string[], value: number, t: Sequelize.Transaction | undefined) {
const inboxUrlsString = inboxUrls.map(url => `'${url}'`).join(',')
2018-01-11 18:35:39 +01:00
const query = `UPDATE "actorFollow" SET "score" = LEAST("score" + ${value}, ${ACTOR_FOLLOW_SCORE.MAX}) ` +
'WHERE id IN (' +
'SELECT "actorFollow"."id" FROM "actorFollow" ' +
'INNER JOIN "actor" ON "actor"."id" = "actorFollow"."actorId" ' +
'WHERE "actor"."inboxUrl" IN (' + inboxUrlsString + ') OR "actor"."sharedInboxUrl" IN (' + inboxUrlsString + ')' +
')'
const options = t ? {
type: Sequelize.QueryTypes.BULKUPDATE,
transaction: t
} : undefined
return ActorFollowModel.sequelize.query(query, options)
}
private static listBadActorFollows () {
const query = {
where: {
score: {
[Sequelize.Op.lte]: 0
}
},
2018-01-19 13:58:13 +01:00
logging: false
}
return ActorFollowModel.findAll(query)
}
2018-09-11 16:27:07 +02:00
toFormattedJSON (): ActorFollow {
2017-12-14 17:38:41 +01:00
const follower = this.ActorFollower.toFormattedJSON()
const following = this.ActorFollowing.toFormattedJSON()
return {
id: this.id,
follower,
following,
score: this.score,
2017-12-14 17:38:41 +01:00
state: this.state,
createdAt: this.createdAt,
updatedAt: this.updatedAt
}
}
}