diff options
author | Chocobozzz <me@florianbigard.com> | 2021-05-11 11:15:29 +0200 |
---|---|---|
committer | Chocobozzz <me@florianbigard.com> | 2021-05-11 11:32:31 +0200 |
commit | 7d9ba5c08999c6482f0bc5e0c09c6f55b7724090 (patch) | |
tree | 5f4ea1f06dcb781c9e61062522b53a28a401111f /server/models/actor/actor-follow.ts | |
parent | c07902b9083ab5756436cd020bed5bdfa51028bf (diff) | |
download | PeerTube-7d9ba5c08999c6482f0bc5e0c09c6f55b7724090.tar.gz PeerTube-7d9ba5c08999c6482f0bc5e0c09c6f55b7724090.tar.zst PeerTube-7d9ba5c08999c6482f0bc5e0c09c6f55b7724090.zip |
Cleanup models directory organization
Diffstat (limited to 'server/models/actor/actor-follow.ts')
-rw-r--r-- | server/models/actor/actor-follow.ts | 721 |
1 files changed, 721 insertions, 0 deletions
diff --git a/server/models/actor/actor-follow.ts b/server/models/actor/actor-follow.ts new file mode 100644 index 000000000..4c5f37620 --- /dev/null +++ b/server/models/actor/actor-follow.ts | |||
@@ -0,0 +1,721 @@ | |||
1 | import { difference, values } from 'lodash' | ||
2 | import { IncludeOptions, Op, QueryTypes, Transaction, WhereOptions } from 'sequelize' | ||
3 | import { | ||
4 | AfterCreate, | ||
5 | AfterDestroy, | ||
6 | AfterUpdate, | ||
7 | AllowNull, | ||
8 | BelongsTo, | ||
9 | Column, | ||
10 | CreatedAt, | ||
11 | DataType, | ||
12 | Default, | ||
13 | ForeignKey, | ||
14 | Is, | ||
15 | IsInt, | ||
16 | Max, | ||
17 | Model, | ||
18 | Table, | ||
19 | UpdatedAt | ||
20 | } from 'sequelize-typescript' | ||
21 | import { isActivityPubUrlValid } from '@server/helpers/custom-validators/activitypub/misc' | ||
22 | import { getServerActor } from '@server/models/application/application' | ||
23 | import { VideoModel } from '@server/models/video/video' | ||
24 | import { | ||
25 | MActorFollowActorsDefault, | ||
26 | MActorFollowActorsDefaultSubscription, | ||
27 | MActorFollowFollowingHost, | ||
28 | MActorFollowFormattable, | ||
29 | MActorFollowSubscriptions | ||
30 | } from '@server/types/models' | ||
31 | import { ActivityPubActorType } from '@shared/models' | ||
32 | import { FollowState } from '../../../shared/models/actors' | ||
33 | import { ActorFollow } from '../../../shared/models/actors/follow.model' | ||
34 | import { logger } from '../../helpers/logger' | ||
35 | import { ACTOR_FOLLOW_SCORE, CONSTRAINTS_FIELDS, FOLLOW_STATES, SERVER_ACTOR_NAME } from '../../initializers/constants' | ||
36 | import { AccountModel } from '../account/account' | ||
37 | import { ServerModel } from '../server/server' | ||
38 | import { createSafeIn, getFollowsSort, getSort, searchAttribute, throwIfNotValid } from '../utils' | ||
39 | import { VideoChannelModel } from '../video/video-channel' | ||
40 | import { ActorModel, unusedActorAttributesForAPI } from './actor' | ||
41 | |||
42 | @Table({ | ||
43 | tableName: 'actorFollow', | ||
44 | indexes: [ | ||
45 | { | ||
46 | fields: [ 'actorId' ] | ||
47 | }, | ||
48 | { | ||
49 | fields: [ 'targetActorId' ] | ||
50 | }, | ||
51 | { | ||
52 | fields: [ 'actorId', 'targetActorId' ], | ||
53 | unique: true | ||
54 | }, | ||
55 | { | ||
56 | fields: [ 'score' ] | ||
57 | }, | ||
58 | { | ||
59 | fields: [ 'url' ], | ||
60 | unique: true | ||
61 | } | ||
62 | ] | ||
63 | }) | ||
64 | export class ActorFollowModel extends Model { | ||
65 | |||
66 | @AllowNull(false) | ||
67 | @Column(DataType.ENUM(...values(FOLLOW_STATES))) | ||
68 | state: FollowState | ||
69 | |||
70 | @AllowNull(false) | ||
71 | @Default(ACTOR_FOLLOW_SCORE.BASE) | ||
72 | @IsInt | ||
73 | @Max(ACTOR_FOLLOW_SCORE.MAX) | ||
74 | @Column | ||
75 | score: number | ||
76 | |||
77 | // Allow null because we added this column in PeerTube v3, and don't want to generate fake URLs of remote follows | ||
78 | @AllowNull(true) | ||
79 | @Is('ActorFollowUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url')) | ||
80 | @Column(DataType.STRING(CONSTRAINTS_FIELDS.COMMONS.URL.max)) | ||
81 | url: string | ||
82 | |||
83 | @CreatedAt | ||
84 | createdAt: Date | ||
85 | |||
86 | @UpdatedAt | ||
87 | updatedAt: Date | ||
88 | |||
89 | @ForeignKey(() => ActorModel) | ||
90 | @Column | ||
91 | actorId: number | ||
92 | |||
93 | @BelongsTo(() => ActorModel, { | ||
94 | foreignKey: { | ||
95 | name: 'actorId', | ||
96 | allowNull: false | ||
97 | }, | ||
98 | as: 'ActorFollower', | ||
99 | onDelete: 'CASCADE' | ||
100 | }) | ||
101 | ActorFollower: ActorModel | ||
102 | |||
103 | @ForeignKey(() => ActorModel) | ||
104 | @Column | ||
105 | targetActorId: number | ||
106 | |||
107 | @BelongsTo(() => ActorModel, { | ||
108 | foreignKey: { | ||
109 | name: 'targetActorId', | ||
110 | allowNull: false | ||
111 | }, | ||
112 | as: 'ActorFollowing', | ||
113 | onDelete: 'CASCADE' | ||
114 | }) | ||
115 | ActorFollowing: ActorModel | ||
116 | |||
117 | @AfterCreate | ||
118 | @AfterUpdate | ||
119 | static incrementFollowerAndFollowingCount (instance: ActorFollowModel, options: any) { | ||
120 | if (instance.state !== 'accepted') return undefined | ||
121 | |||
122 | return Promise.all([ | ||
123 | ActorModel.rebuildFollowsCount(instance.actorId, 'following', options.transaction), | ||
124 | ActorModel.rebuildFollowsCount(instance.targetActorId, 'followers', options.transaction) | ||
125 | ]) | ||
126 | } | ||
127 | |||
128 | @AfterDestroy | ||
129 | static decrementFollowerAndFollowingCount (instance: ActorFollowModel, options: any) { | ||
130 | return Promise.all([ | ||
131 | ActorModel.rebuildFollowsCount(instance.actorId, 'following', options.transaction), | ||
132 | ActorModel.rebuildFollowsCount(instance.targetActorId, 'followers', options.transaction) | ||
133 | ]) | ||
134 | } | ||
135 | |||
136 | static removeFollowsOf (actorId: number, t?: Transaction) { | ||
137 | const query = { | ||
138 | where: { | ||
139 | [Op.or]: [ | ||
140 | { | ||
141 | actorId | ||
142 | }, | ||
143 | { | ||
144 | targetActorId: actorId | ||
145 | } | ||
146 | ] | ||
147 | }, | ||
148 | transaction: t | ||
149 | } | ||
150 | |||
151 | return ActorFollowModel.destroy(query) | ||
152 | } | ||
153 | |||
154 | // Remove actor follows with a score of 0 (too many requests where they were unreachable) | ||
155 | static async removeBadActorFollows () { | ||
156 | const actorFollows = await ActorFollowModel.listBadActorFollows() | ||
157 | |||
158 | const actorFollowsRemovePromises = actorFollows.map(actorFollow => actorFollow.destroy()) | ||
159 | await Promise.all(actorFollowsRemovePromises) | ||
160 | |||
161 | const numberOfActorFollowsRemoved = actorFollows.length | ||
162 | |||
163 | if (numberOfActorFollowsRemoved) logger.info('Removed bad %d actor follows.', numberOfActorFollowsRemoved) | ||
164 | } | ||
165 | |||
166 | static isFollowedBy (actorId: number, followerActorId: number) { | ||
167 | const query = 'SELECT 1 FROM "actorFollow" WHERE "actorId" = $followerActorId AND "targetActorId" = $actorId LIMIT 1' | ||
168 | const options = { | ||
169 | type: QueryTypes.SELECT as QueryTypes.SELECT, | ||
170 | bind: { actorId, followerActorId }, | ||
171 | raw: true | ||
172 | } | ||
173 | |||
174 | return VideoModel.sequelize.query(query, options) | ||
175 | .then(results => results.length === 1) | ||
176 | } | ||
177 | |||
178 | static loadByActorAndTarget (actorId: number, targetActorId: number, t?: Transaction): Promise<MActorFollowActorsDefault> { | ||
179 | const query = { | ||
180 | where: { | ||
181 | actorId, | ||
182 | targetActorId: targetActorId | ||
183 | }, | ||
184 | include: [ | ||
185 | { | ||
186 | model: ActorModel, | ||
187 | required: true, | ||
188 | as: 'ActorFollower' | ||
189 | }, | ||
190 | { | ||
191 | model: ActorModel, | ||
192 | required: true, | ||
193 | as: 'ActorFollowing' | ||
194 | } | ||
195 | ], | ||
196 | transaction: t | ||
197 | } | ||
198 | |||
199 | return ActorFollowModel.findOne(query) | ||
200 | } | ||
201 | |||
202 | static loadByActorAndTargetNameAndHostForAPI ( | ||
203 | actorId: number, | ||
204 | targetName: string, | ||
205 | targetHost: string, | ||
206 | t?: Transaction | ||
207 | ): Promise<MActorFollowActorsDefaultSubscription> { | ||
208 | const actorFollowingPartInclude: IncludeOptions = { | ||
209 | model: ActorModel, | ||
210 | required: true, | ||
211 | as: 'ActorFollowing', | ||
212 | where: { | ||
213 | preferredUsername: targetName | ||
214 | }, | ||
215 | include: [ | ||
216 | { | ||
217 | model: VideoChannelModel.unscoped(), | ||
218 | required: false | ||
219 | } | ||
220 | ] | ||
221 | } | ||
222 | |||
223 | if (targetHost === null) { | ||
224 | actorFollowingPartInclude.where['serverId'] = null | ||
225 | } else { | ||
226 | actorFollowingPartInclude.include.push({ | ||
227 | model: ServerModel, | ||
228 | required: true, | ||
229 | where: { | ||
230 | host: targetHost | ||
231 | } | ||
232 | }) | ||
233 | } | ||
234 | |||
235 | const query = { | ||
236 | where: { | ||
237 | actorId | ||
238 | }, | ||
239 | include: [ | ||
240 | actorFollowingPartInclude, | ||
241 | { | ||
242 | model: ActorModel, | ||
243 | required: true, | ||
244 | as: 'ActorFollower' | ||
245 | } | ||
246 | ], | ||
247 | transaction: t | ||
248 | } | ||
249 | |||
250 | return ActorFollowModel.findOne(query) | ||
251 | } | ||
252 | |||
253 | static listSubscribedIn (actorId: number, targets: { name: string, host?: string }[]): Promise<MActorFollowFollowingHost[]> { | ||
254 | const whereTab = targets | ||
255 | .map(t => { | ||
256 | if (t.host) { | ||
257 | return { | ||
258 | [Op.and]: [ | ||
259 | { | ||
260 | $preferredUsername$: t.name | ||
261 | }, | ||
262 | { | ||
263 | $host$: t.host | ||
264 | } | ||
265 | ] | ||
266 | } | ||
267 | } | ||
268 | |||
269 | return { | ||
270 | [Op.and]: [ | ||
271 | { | ||
272 | $preferredUsername$: t.name | ||
273 | }, | ||
274 | { | ||
275 | $serverId$: null | ||
276 | } | ||
277 | ] | ||
278 | } | ||
279 | }) | ||
280 | |||
281 | const query = { | ||
282 | attributes: [ 'id' ], | ||
283 | where: { | ||
284 | [Op.and]: [ | ||
285 | { | ||
286 | [Op.or]: whereTab | ||
287 | }, | ||
288 | { | ||
289 | actorId | ||
290 | } | ||
291 | ] | ||
292 | }, | ||
293 | include: [ | ||
294 | { | ||
295 | attributes: [ 'preferredUsername' ], | ||
296 | model: ActorModel.unscoped(), | ||
297 | required: true, | ||
298 | as: 'ActorFollowing', | ||
299 | include: [ | ||
300 | { | ||
301 | attributes: [ 'host' ], | ||
302 | model: ServerModel.unscoped(), | ||
303 | required: false | ||
304 | } | ||
305 | ] | ||
306 | } | ||
307 | ] | ||
308 | } | ||
309 | |||
310 | return ActorFollowModel.findAll(query) | ||
311 | } | ||
312 | |||
313 | static listFollowingForApi (options: { | ||
314 | id: number | ||
315 | start: number | ||
316 | count: number | ||
317 | sort: string | ||
318 | state?: FollowState | ||
319 | actorType?: ActivityPubActorType | ||
320 | search?: string | ||
321 | }) { | ||
322 | const { id, start, count, sort, search, state, actorType } = options | ||
323 | |||
324 | const followWhere = state ? { state } : {} | ||
325 | const followingWhere: WhereOptions = {} | ||
326 | const followingServerWhere: WhereOptions = {} | ||
327 | |||
328 | if (search) { | ||
329 | Object.assign(followingServerWhere, { | ||
330 | host: { | ||
331 | [Op.iLike]: '%' + search + '%' | ||
332 | } | ||
333 | }) | ||
334 | } | ||
335 | |||
336 | if (actorType) { | ||
337 | Object.assign(followingWhere, { type: actorType }) | ||
338 | } | ||
339 | |||
340 | const query = { | ||
341 | distinct: true, | ||
342 | offset: start, | ||
343 | limit: count, | ||
344 | order: getFollowsSort(sort), | ||
345 | where: followWhere, | ||
346 | include: [ | ||
347 | { | ||
348 | model: ActorModel, | ||
349 | required: true, | ||
350 | as: 'ActorFollower', | ||
351 | where: { | ||
352 | id | ||
353 | } | ||
354 | }, | ||
355 | { | ||
356 | model: ActorModel, | ||
357 | as: 'ActorFollowing', | ||
358 | required: true, | ||
359 | where: followingWhere, | ||
360 | include: [ | ||
361 | { | ||
362 | model: ServerModel, | ||
363 | required: true, | ||
364 | where: followingServerWhere | ||
365 | } | ||
366 | ] | ||
367 | } | ||
368 | ] | ||
369 | } | ||
370 | |||
371 | return ActorFollowModel.findAndCountAll<MActorFollowActorsDefault>(query) | ||
372 | .then(({ rows, count }) => { | ||
373 | return { | ||
374 | data: rows, | ||
375 | total: count | ||
376 | } | ||
377 | }) | ||
378 | } | ||
379 | |||
380 | static listFollowersForApi (options: { | ||
381 | actorId: number | ||
382 | start: number | ||
383 | count: number | ||
384 | sort: string | ||
385 | state?: FollowState | ||
386 | actorType?: ActivityPubActorType | ||
387 | search?: string | ||
388 | }) { | ||
389 | const { actorId, start, count, sort, search, state, actorType } = options | ||
390 | |||
391 | const followWhere = state ? { state } : {} | ||
392 | const followerWhere: WhereOptions = {} | ||
393 | const followerServerWhere: WhereOptions = {} | ||
394 | |||
395 | if (search) { | ||
396 | Object.assign(followerServerWhere, { | ||
397 | host: { | ||
398 | [Op.iLike]: '%' + search + '%' | ||
399 | } | ||
400 | }) | ||
401 | } | ||
402 | |||
403 | if (actorType) { | ||
404 | Object.assign(followerWhere, { type: actorType }) | ||
405 | } | ||
406 | |||
407 | const query = { | ||
408 | distinct: true, | ||
409 | offset: start, | ||
410 | limit: count, | ||
411 | order: getFollowsSort(sort), | ||
412 | where: followWhere, | ||
413 | include: [ | ||
414 | { | ||
415 | model: ActorModel, | ||
416 | required: true, | ||
417 | as: 'ActorFollower', | ||
418 | where: followerWhere, | ||
419 | include: [ | ||
420 | { | ||
421 | model: ServerModel, | ||
422 | required: true, | ||
423 | where: followerServerWhere | ||
424 | } | ||
425 | ] | ||
426 | }, | ||
427 | { | ||
428 | model: ActorModel, | ||
429 | as: 'ActorFollowing', | ||
430 | required: true, | ||
431 | where: { | ||
432 | id: actorId | ||
433 | } | ||
434 | } | ||
435 | ] | ||
436 | } | ||
437 | |||
438 | return ActorFollowModel.findAndCountAll<MActorFollowActorsDefault>(query) | ||
439 | .then(({ rows, count }) => { | ||
440 | return { | ||
441 | data: rows, | ||
442 | total: count | ||
443 | } | ||
444 | }) | ||
445 | } | ||
446 | |||
447 | static listSubscriptionsForApi (options: { | ||
448 | actorId: number | ||
449 | start: number | ||
450 | count: number | ||
451 | sort: string | ||
452 | search?: string | ||
453 | }) { | ||
454 | const { actorId, start, count, sort } = options | ||
455 | const where = { | ||
456 | actorId: actorId | ||
457 | } | ||
458 | |||
459 | if (options.search) { | ||
460 | Object.assign(where, { | ||
461 | [Op.or]: [ | ||
462 | searchAttribute(options.search, '$ActorFollowing.preferredUsername$'), | ||
463 | searchAttribute(options.search, '$ActorFollowing.VideoChannel.name$') | ||
464 | ] | ||
465 | }) | ||
466 | } | ||
467 | |||
468 | const query = { | ||
469 | attributes: [], | ||
470 | distinct: true, | ||
471 | offset: start, | ||
472 | limit: count, | ||
473 | order: getSort(sort), | ||
474 | where, | ||
475 | include: [ | ||
476 | { | ||
477 | attributes: [ 'id' ], | ||
478 | model: ActorModel.unscoped(), | ||
479 | as: 'ActorFollowing', | ||
480 | required: true, | ||
481 | include: [ | ||
482 | { | ||
483 | model: VideoChannelModel.unscoped(), | ||
484 | required: true, | ||
485 | include: [ | ||
486 | { | ||
487 | attributes: { | ||
488 | exclude: unusedActorAttributesForAPI | ||
489 | }, | ||
490 | model: ActorModel, | ||
491 | required: true | ||
492 | }, | ||
493 | { | ||
494 | model: AccountModel.unscoped(), | ||
495 | required: true, | ||
496 | include: [ | ||
497 | { | ||
498 | attributes: { | ||
499 | exclude: unusedActorAttributesForAPI | ||
500 | }, | ||
501 | model: ActorModel, | ||
502 | required: true | ||
503 | } | ||
504 | ] | ||
505 | } | ||
506 | ] | ||
507 | } | ||
508 | ] | ||
509 | } | ||
510 | ] | ||
511 | } | ||
512 | |||
513 | return ActorFollowModel.findAndCountAll<MActorFollowSubscriptions>(query) | ||
514 | .then(({ rows, count }) => { | ||
515 | return { | ||
516 | data: rows.map(r => r.ActorFollowing.VideoChannel), | ||
517 | total: count | ||
518 | } | ||
519 | }) | ||
520 | } | ||
521 | |||
522 | static async keepUnfollowedInstance (hosts: string[]) { | ||
523 | const followerId = (await getServerActor()).id | ||
524 | |||
525 | const query = { | ||
526 | attributes: [ 'id' ], | ||
527 | where: { | ||
528 | actorId: followerId | ||
529 | }, | ||
530 | include: [ | ||
531 | { | ||
532 | attributes: [ 'id' ], | ||
533 | model: ActorModel.unscoped(), | ||
534 | required: true, | ||
535 | as: 'ActorFollowing', | ||
536 | where: { | ||
537 | preferredUsername: SERVER_ACTOR_NAME | ||
538 | }, | ||
539 | include: [ | ||
540 | { | ||
541 | attributes: [ 'host' ], | ||
542 | model: ServerModel.unscoped(), | ||
543 | required: true, | ||
544 | where: { | ||
545 | host: { | ||
546 | [Op.in]: hosts | ||
547 | } | ||
548 | } | ||
549 | } | ||
550 | ] | ||
551 | } | ||
552 | ] | ||
553 | } | ||
554 | |||
555 | const res = await ActorFollowModel.findAll(query) | ||
556 | const followedHosts = res.map(row => row.ActorFollowing.Server.host) | ||
557 | |||
558 | return difference(hosts, followedHosts) | ||
559 | } | ||
560 | |||
561 | static listAcceptedFollowerUrlsForAP (actorIds: number[], t: Transaction, start?: number, count?: number) { | ||
562 | return ActorFollowModel.createListAcceptedFollowForApiQuery('followers', actorIds, t, start, count) | ||
563 | } | ||
564 | |||
565 | static listAcceptedFollowerSharedInboxUrls (actorIds: number[], t: Transaction) { | ||
566 | return ActorFollowModel.createListAcceptedFollowForApiQuery( | ||
567 | 'followers', | ||
568 | actorIds, | ||
569 | t, | ||
570 | undefined, | ||
571 | undefined, | ||
572 | 'sharedInboxUrl', | ||
573 | true | ||
574 | ) | ||
575 | } | ||
576 | |||
577 | static listAcceptedFollowingUrlsForApi (actorIds: number[], t: Transaction, start?: number, count?: number) { | ||
578 | return ActorFollowModel.createListAcceptedFollowForApiQuery('following', actorIds, t, start, count) | ||
579 | } | ||
580 | |||
581 | static async getStats () { | ||
582 | const serverActor = await getServerActor() | ||
583 | |||
584 | const totalInstanceFollowing = await ActorFollowModel.count({ | ||
585 | where: { | ||
586 | actorId: serverActor.id | ||
587 | } | ||
588 | }) | ||
589 | |||
590 | const totalInstanceFollowers = await ActorFollowModel.count({ | ||
591 | where: { | ||
592 | targetActorId: serverActor.id | ||
593 | } | ||
594 | }) | ||
595 | |||
596 | return { | ||
597 | totalInstanceFollowing, | ||
598 | totalInstanceFollowers | ||
599 | } | ||
600 | } | ||
601 | |||
602 | static updateScore (inboxUrl: string, value: number, t?: Transaction) { | ||
603 | const query = `UPDATE "actorFollow" SET "score" = LEAST("score" + ${value}, ${ACTOR_FOLLOW_SCORE.MAX}) ` + | ||
604 | 'WHERE id IN (' + | ||
605 | 'SELECT "actorFollow"."id" FROM "actorFollow" ' + | ||
606 | 'INNER JOIN "actor" ON "actor"."id" = "actorFollow"."actorId" ' + | ||
607 | `WHERE "actor"."inboxUrl" = '${inboxUrl}' OR "actor"."sharedInboxUrl" = '${inboxUrl}'` + | ||
608 | ')' | ||
609 | |||
610 | const options = { | ||
611 | type: QueryTypes.BULKUPDATE, | ||
612 | transaction: t | ||
613 | } | ||
614 | |||
615 | return ActorFollowModel.sequelize.query(query, options) | ||
616 | } | ||
617 | |||
618 | static async updateScoreByFollowingServers (serverIds: number[], value: number, t?: Transaction) { | ||
619 | if (serverIds.length === 0) return | ||
620 | |||
621 | const me = await getServerActor() | ||
622 | const serverIdsString = createSafeIn(ActorFollowModel, serverIds) | ||
623 | |||
624 | const query = `UPDATE "actorFollow" SET "score" = LEAST("score" + ${value}, ${ACTOR_FOLLOW_SCORE.MAX}) ` + | ||
625 | 'WHERE id IN (' + | ||
626 | 'SELECT "actorFollow"."id" FROM "actorFollow" ' + | ||
627 | 'INNER JOIN "actor" ON "actor"."id" = "actorFollow"."targetActorId" ' + | ||
628 | `WHERE "actorFollow"."actorId" = ${me.Account.actorId} ` + // I'm the follower | ||
629 | `AND "actor"."serverId" IN (${serverIdsString})` + // Criteria on followings | ||
630 | ')' | ||
631 | |||
632 | const options = { | ||
633 | type: QueryTypes.BULKUPDATE, | ||
634 | transaction: t | ||
635 | } | ||
636 | |||
637 | return ActorFollowModel.sequelize.query(query, options) | ||
638 | } | ||
639 | |||
640 | private static async createListAcceptedFollowForApiQuery ( | ||
641 | type: 'followers' | 'following', | ||
642 | actorIds: number[], | ||
643 | t: Transaction, | ||
644 | start?: number, | ||
645 | count?: number, | ||
646 | columnUrl = 'url', | ||
647 | distinct = false | ||
648 | ) { | ||
649 | let firstJoin: string | ||
650 | let secondJoin: string | ||
651 | |||
652 | if (type === 'followers') { | ||
653 | firstJoin = 'targetActorId' | ||
654 | secondJoin = 'actorId' | ||
655 | } else { | ||
656 | firstJoin = 'actorId' | ||
657 | secondJoin = 'targetActorId' | ||
658 | } | ||
659 | |||
660 | const selections: string[] = [] | ||
661 | if (distinct === true) selections.push(`DISTINCT("Follows"."${columnUrl}") AS "selectionUrl"`) | ||
662 | else selections.push(`"Follows"."${columnUrl}" AS "selectionUrl"`) | ||
663 | |||
664 | selections.push('COUNT(*) AS "total"') | ||
665 | |||
666 | const tasks: Promise<any>[] = [] | ||
667 | |||
668 | for (const selection of selections) { | ||
669 | let query = 'SELECT ' + selection + ' FROM "actor" ' + | ||
670 | 'INNER JOIN "actorFollow" ON "actorFollow"."' + firstJoin + '" = "actor"."id" ' + | ||
671 | 'INNER JOIN "actor" AS "Follows" ON "actorFollow"."' + secondJoin + '" = "Follows"."id" ' + | ||
672 | `WHERE "actor"."id" = ANY ($actorIds) AND "actorFollow"."state" = 'accepted' AND "Follows"."${columnUrl}" IS NOT NULL ` | ||
673 | |||
674 | if (count !== undefined) query += 'LIMIT ' + count | ||
675 | if (start !== undefined) query += ' OFFSET ' + start | ||
676 | |||
677 | const options = { | ||
678 | bind: { actorIds }, | ||
679 | type: QueryTypes.SELECT, | ||
680 | transaction: t | ||
681 | } | ||
682 | tasks.push(ActorFollowModel.sequelize.query(query, options)) | ||
683 | } | ||
684 | |||
685 | const [ followers, [ dataTotal ] ] = await Promise.all(tasks) | ||
686 | const urls: string[] = followers.map(f => f.selectionUrl) | ||
687 | |||
688 | return { | ||
689 | data: urls, | ||
690 | total: dataTotal ? parseInt(dataTotal.total, 10) : 0 | ||
691 | } | ||
692 | } | ||
693 | |||
694 | private static listBadActorFollows () { | ||
695 | const query = { | ||
696 | where: { | ||
697 | score: { | ||
698 | [Op.lte]: 0 | ||
699 | } | ||
700 | }, | ||
701 | logging: false | ||
702 | } | ||
703 | |||
704 | return ActorFollowModel.findAll(query) | ||
705 | } | ||
706 | |||
707 | toFormattedJSON (this: MActorFollowFormattable): ActorFollow { | ||
708 | const follower = this.ActorFollower.toFormattedJSON() | ||
709 | const following = this.ActorFollowing.toFormattedJSON() | ||
710 | |||
711 | return { | ||
712 | id: this.id, | ||
713 | follower, | ||
714 | following, | ||
715 | score: this.score, | ||
716 | state: this.state, | ||
717 | createdAt: this.createdAt, | ||
718 | updatedAt: this.updatedAt | ||
719 | } | ||
720 | } | ||
721 | } | ||