aboutsummaryrefslogtreecommitdiffhomepage
path: root/server/models/activitypub/actor.ts
diff options
context:
space:
mode:
Diffstat (limited to 'server/models/activitypub/actor.ts')
-rw-r--r--server/models/activitypub/actor.ts699
1 files changed, 0 insertions, 699 deletions
diff --git a/server/models/activitypub/actor.ts b/server/models/activitypub/actor.ts
deleted file mode 100644
index 1af9efac2..000000000
--- a/server/models/activitypub/actor.ts
+++ /dev/null
@@ -1,699 +0,0 @@
1import { values } from 'lodash'
2import { extname } from 'path'
3import { literal, Op, Transaction } from 'sequelize'
4import {
5 AllowNull,
6 BelongsTo,
7 Column,
8 CreatedAt,
9 DataType,
10 DefaultScope,
11 ForeignKey,
12 HasMany,
13 HasOne,
14 Is,
15 Model,
16 Scopes,
17 Table,
18 UpdatedAt
19} from 'sequelize-typescript'
20import { ModelCache } from '@server/models/model-cache'
21import { ActivityIconObject, ActivityPubActorType } from '../../../shared/models/activitypub'
22import { ActorImage } from '../../../shared/models/actors/actor-image.model'
23import { activityPubContextify } from '../../helpers/activitypub'
24import {
25 isActorFollowersCountValid,
26 isActorFollowingCountValid,
27 isActorPreferredUsernameValid,
28 isActorPrivateKeyValid,
29 isActorPublicKeyValid
30} from '../../helpers/custom-validators/activitypub/actor'
31import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
32import {
33 ACTIVITY_PUB,
34 ACTIVITY_PUB_ACTOR_TYPES,
35 CONSTRAINTS_FIELDS,
36 MIMETYPES,
37 SERVER_ACTOR_NAME,
38 WEBSERVER
39} from '../../initializers/constants'
40import {
41 MActor,
42 MActorAccountChannelId,
43 MActorAPAccount,
44 MActorAPChannel,
45 MActorFormattable,
46 MActorFull,
47 MActorHost,
48 MActorServer,
49 MActorSummaryFormattable,
50 MActorUrl,
51 MActorWithInboxes
52} from '../../types/models'
53import { AccountModel } from '../account/account'
54import { ActorImageModel } from '../account/actor-image'
55import { ServerModel } from '../server/server'
56import { isOutdated, throwIfNotValid } from '../utils'
57import { VideoModel } from '../video/video'
58import { VideoChannelModel } from '../video/video-channel'
59import { ActorFollowModel } from './actor-follow'
60
61enum ScopeNames {
62 FULL = 'FULL'
63}
64
65export const unusedActorAttributesForAPI = [
66 'publicKey',
67 'privateKey',
68 'inboxUrl',
69 'outboxUrl',
70 'sharedInboxUrl',
71 'followersUrl',
72 'followingUrl'
73]
74
75@DefaultScope(() => ({
76 include: [
77 {
78 model: ServerModel,
79 required: false
80 },
81 {
82 model: ActorImageModel,
83 as: 'Avatar',
84 required: false
85 }
86 ]
87}))
88@Scopes(() => ({
89 [ScopeNames.FULL]: {
90 include: [
91 {
92 model: AccountModel.unscoped(),
93 required: false
94 },
95 {
96 model: VideoChannelModel.unscoped(),
97 required: false,
98 include: [
99 {
100 model: AccountModel,
101 required: true
102 }
103 ]
104 },
105 {
106 model: ServerModel,
107 required: false
108 },
109 {
110 model: ActorImageModel,
111 as: 'Avatar',
112 required: false
113 },
114 {
115 model: ActorImageModel,
116 as: 'Banner',
117 required: false
118 }
119 ]
120 }
121}))
122@Table({
123 tableName: 'actor',
124 indexes: [
125 {
126 fields: [ 'url' ],
127 unique: true
128 },
129 {
130 fields: [ 'preferredUsername', 'serverId' ],
131 unique: true,
132 where: {
133 serverId: {
134 [Op.ne]: null
135 }
136 }
137 },
138 {
139 fields: [ 'preferredUsername' ],
140 unique: true,
141 where: {
142 serverId: null
143 }
144 },
145 {
146 fields: [ 'inboxUrl', 'sharedInboxUrl' ]
147 },
148 {
149 fields: [ 'sharedInboxUrl' ]
150 },
151 {
152 fields: [ 'serverId' ]
153 },
154 {
155 fields: [ 'avatarId' ]
156 },
157 {
158 fields: [ 'followersUrl' ]
159 }
160 ]
161})
162export class ActorModel extends Model {
163
164 @AllowNull(false)
165 @Column(DataType.ENUM(...values(ACTIVITY_PUB_ACTOR_TYPES)))
166 type: ActivityPubActorType
167
168 @AllowNull(false)
169 @Is('ActorPreferredUsername', value => throwIfNotValid(value, isActorPreferredUsernameValid, 'actor preferred username'))
170 @Column
171 preferredUsername: string
172
173 @AllowNull(false)
174 @Is('ActorUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
175 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
176 url: string
177
178 @AllowNull(true)
179 @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPublicKeyValid, 'public key', true))
180 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.PUBLIC_KEY.max))
181 publicKey: string
182
183 @AllowNull(true)
184 @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPrivateKeyValid, 'private key', true))
185 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.PRIVATE_KEY.max))
186 privateKey: string
187
188 @AllowNull(false)
189 @Is('ActorFollowersCount', value => throwIfNotValid(value, isActorFollowersCountValid, 'followers count'))
190 @Column
191 followersCount: number
192
193 @AllowNull(false)
194 @Is('ActorFollowersCount', value => throwIfNotValid(value, isActorFollowingCountValid, 'following count'))
195 @Column
196 followingCount: number
197
198 @AllowNull(false)
199 @Is('ActorInboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'inbox url'))
200 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
201 inboxUrl: string
202
203 @AllowNull(true)
204 @Is('ActorOutboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'outbox url', true))
205 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
206 outboxUrl: string
207
208 @AllowNull(true)
209 @Is('ActorSharedInboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'shared inbox url', true))
210 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
211 sharedInboxUrl: string
212
213 @AllowNull(true)
214 @Is('ActorFollowersUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'followers url', true))
215 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
216 followersUrl: string
217
218 @AllowNull(true)
219 @Is('ActorFollowingUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'following url', true))
220 @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
221 followingUrl: string
222
223 @AllowNull(true)
224 @Column
225 remoteCreatedAt: Date
226
227 @CreatedAt
228 createdAt: Date
229
230 @UpdatedAt
231 updatedAt: Date
232
233 @ForeignKey(() => ActorImageModel)
234 @Column
235 avatarId: number
236
237 @ForeignKey(() => ActorImageModel)
238 @Column
239 bannerId: number
240
241 @BelongsTo(() => ActorImageModel, {
242 foreignKey: {
243 name: 'avatarId',
244 allowNull: true
245 },
246 as: 'Avatar',
247 onDelete: 'set null',
248 hooks: true
249 })
250 Avatar: ActorImageModel
251
252 @BelongsTo(() => ActorImageModel, {
253 foreignKey: {
254 name: 'bannerId',
255 allowNull: true
256 },
257 as: 'Banner',
258 onDelete: 'set null',
259 hooks: true
260 })
261 Banner: ActorImageModel
262
263 @HasMany(() => ActorFollowModel, {
264 foreignKey: {
265 name: 'actorId',
266 allowNull: false
267 },
268 as: 'ActorFollowings',
269 onDelete: 'cascade'
270 })
271 ActorFollowing: ActorFollowModel[]
272
273 @HasMany(() => ActorFollowModel, {
274 foreignKey: {
275 name: 'targetActorId',
276 allowNull: false
277 },
278 as: 'ActorFollowers',
279 onDelete: 'cascade'
280 })
281 ActorFollowers: ActorFollowModel[]
282
283 @ForeignKey(() => ServerModel)
284 @Column
285 serverId: number
286
287 @BelongsTo(() => ServerModel, {
288 foreignKey: {
289 allowNull: true
290 },
291 onDelete: 'cascade'
292 })
293 Server: ServerModel
294
295 @HasOne(() => AccountModel, {
296 foreignKey: {
297 allowNull: true
298 },
299 onDelete: 'cascade',
300 hooks: true
301 })
302 Account: AccountModel
303
304 @HasOne(() => VideoChannelModel, {
305 foreignKey: {
306 allowNull: true
307 },
308 onDelete: 'cascade',
309 hooks: true
310 })
311 VideoChannel: VideoChannelModel
312
313 static load (id: number): Promise<MActor> {
314 return ActorModel.unscoped().findByPk(id)
315 }
316
317 static loadFull (id: number): Promise<MActorFull> {
318 return ActorModel.scope(ScopeNames.FULL).findByPk(id)
319 }
320
321 static loadFromAccountByVideoId (videoId: number, transaction: Transaction): Promise<MActor> {
322 const query = {
323 include: [
324 {
325 attributes: [ 'id' ],
326 model: AccountModel.unscoped(),
327 required: true,
328 include: [
329 {
330 attributes: [ 'id' ],
331 model: VideoChannelModel.unscoped(),
332 required: true,
333 include: [
334 {
335 attributes: [ 'id' ],
336 model: VideoModel.unscoped(),
337 required: true,
338 where: {
339 id: videoId
340 }
341 }
342 ]
343 }
344 ]
345 }
346 ],
347 transaction
348 }
349
350 return ActorModel.unscoped().findOne(query)
351 }
352
353 static isActorUrlExist (url: string) {
354 const query = {
355 raw: true,
356 where: {
357 url
358 }
359 }
360
361 return ActorModel.unscoped().findOne(query)
362 .then(a => !!a)
363 }
364
365 static listByFollowersUrls (followersUrls: string[], transaction?: Transaction): Promise<MActorFull[]> {
366 const query = {
367 where: {
368 followersUrl: {
369 [Op.in]: followersUrls
370 }
371 },
372 transaction
373 }
374
375 return ActorModel.scope(ScopeNames.FULL).findAll(query)
376 }
377
378 static loadLocalByName (preferredUsername: string, transaction?: Transaction): Promise<MActorFull> {
379 const fun = () => {
380 const query = {
381 where: {
382 preferredUsername,
383 serverId: null
384 },
385 transaction
386 }
387
388 return ActorModel.scope(ScopeNames.FULL)
389 .findOne(query)
390 }
391
392 return ModelCache.Instance.doCache({
393 cacheType: 'local-actor-name',
394 key: preferredUsername,
395 // The server actor never change, so we can easily cache it
396 whitelist: () => preferredUsername === SERVER_ACTOR_NAME,
397 fun
398 })
399 }
400
401 static loadLocalUrlByName (preferredUsername: string, transaction?: Transaction): Promise<MActorUrl> {
402 const fun = () => {
403 const query = {
404 attributes: [ 'url' ],
405 where: {
406 preferredUsername,
407 serverId: null
408 },
409 transaction
410 }
411
412 return ActorModel.unscoped()
413 .findOne(query)
414 }
415
416 return ModelCache.Instance.doCache({
417 cacheType: 'local-actor-name',
418 key: preferredUsername,
419 // The server actor never change, so we can easily cache it
420 whitelist: () => preferredUsername === SERVER_ACTOR_NAME,
421 fun
422 })
423 }
424
425 static loadByNameAndHost (preferredUsername: string, host: string): Promise<MActorFull> {
426 const query = {
427 where: {
428 preferredUsername
429 },
430 include: [
431 {
432 model: ServerModel,
433 required: true,
434 where: {
435 host
436 }
437 }
438 ]
439 }
440
441 return ActorModel.scope(ScopeNames.FULL).findOne(query)
442 }
443
444 static loadByUrl (url: string, transaction?: Transaction): Promise<MActorAccountChannelId> {
445 const query = {
446 where: {
447 url
448 },
449 transaction,
450 include: [
451 {
452 attributes: [ 'id' ],
453 model: AccountModel.unscoped(),
454 required: false
455 },
456 {
457 attributes: [ 'id' ],
458 model: VideoChannelModel.unscoped(),
459 required: false
460 }
461 ]
462 }
463
464 return ActorModel.unscoped().findOne(query)
465 }
466
467 static loadByUrlAndPopulateAccountAndChannel (url: string, transaction?: Transaction): Promise<MActorFull> {
468 const query = {
469 where: {
470 url
471 },
472 transaction
473 }
474
475 return ActorModel.scope(ScopeNames.FULL).findOne(query)
476 }
477
478 static rebuildFollowsCount (ofId: number, type: 'followers' | 'following', transaction?: Transaction) {
479 const sanitizedOfId = parseInt(ofId + '', 10)
480 const where = { id: sanitizedOfId }
481
482 let columnToUpdate: string
483 let columnOfCount: string
484
485 if (type === 'followers') {
486 columnToUpdate = 'followersCount'
487 columnOfCount = 'targetActorId'
488 } else {
489 columnToUpdate = 'followingCount'
490 columnOfCount = 'actorId'
491 }
492
493 return ActorModel.update({
494 [columnToUpdate]: literal(`(SELECT COUNT(*) FROM "actorFollow" WHERE "${columnOfCount}" = ${sanitizedOfId})`)
495 }, { where, transaction })
496 }
497
498 static loadAccountActorByVideoId (videoId: number): Promise<MActor> {
499 const query = {
500 include: [
501 {
502 attributes: [ 'id' ],
503 model: AccountModel.unscoped(),
504 required: true,
505 include: [
506 {
507 attributes: [ 'id', 'accountId' ],
508 model: VideoChannelModel.unscoped(),
509 required: true,
510 include: [
511 {
512 attributes: [ 'id', 'channelId' ],
513 model: VideoModel.unscoped(),
514 where: {
515 id: videoId
516 }
517 }
518 ]
519 }
520 ]
521 }
522 ]
523 }
524
525 return ActorModel.unscoped().findOne(query)
526 }
527
528 getSharedInbox (this: MActorWithInboxes) {
529 return this.sharedInboxUrl || this.inboxUrl
530 }
531
532 toFormattedSummaryJSON (this: MActorSummaryFormattable) {
533 let avatar: ActorImage = null
534 if (this.Avatar) {
535 avatar = this.Avatar.toFormattedJSON()
536 }
537
538 return {
539 url: this.url,
540 name: this.preferredUsername,
541 host: this.getHost(),
542 avatar
543 }
544 }
545
546 toFormattedJSON (this: MActorFormattable) {
547 const base = this.toFormattedSummaryJSON()
548
549 let banner: ActorImage = null
550 if (this.Banner) {
551 banner = this.Banner.toFormattedJSON()
552 }
553
554 return Object.assign(base, {
555 id: this.id,
556 hostRedundancyAllowed: this.getRedundancyAllowed(),
557 followingCount: this.followingCount,
558 followersCount: this.followersCount,
559 banner,
560 createdAt: this.getCreatedAt()
561 })
562 }
563
564 toActivityPubObject (this: MActorAPChannel | MActorAPAccount, name: string) {
565 let icon: ActivityIconObject
566 let image: ActivityIconObject
567
568 if (this.avatarId) {
569 const extension = extname(this.Avatar.filename)
570
571 icon = {
572 type: 'Image',
573 mediaType: MIMETYPES.IMAGE.EXT_MIMETYPE[extension],
574 height: this.Avatar.height,
575 width: this.Avatar.width,
576 url: this.getAvatarUrl()
577 }
578 }
579
580 if (this.bannerId) {
581 const banner = (this as MActorAPChannel).Banner
582 const extension = extname(banner.filename)
583
584 image = {
585 type: 'Image',
586 mediaType: MIMETYPES.IMAGE.EXT_MIMETYPE[extension],
587 height: banner.height,
588 width: banner.width,
589 url: this.getBannerUrl()
590 }
591 }
592
593 const json = {
594 type: this.type,
595 id: this.url,
596 following: this.getFollowingUrl(),
597 followers: this.getFollowersUrl(),
598 playlists: this.getPlaylistsUrl(),
599 inbox: this.inboxUrl,
600 outbox: this.outboxUrl,
601 preferredUsername: this.preferredUsername,
602 url: this.url,
603 name,
604 endpoints: {
605 sharedInbox: this.sharedInboxUrl
606 },
607 publicKey: {
608 id: this.getPublicKeyUrl(),
609 owner: this.url,
610 publicKeyPem: this.publicKey
611 },
612 published: this.getCreatedAt().toISOString(),
613 icon,
614 image
615 }
616
617 return activityPubContextify(json)
618 }
619
620 getFollowerSharedInboxUrls (t: Transaction) {
621 const query = {
622 attributes: [ 'sharedInboxUrl' ],
623 include: [
624 {
625 attribute: [],
626 model: ActorFollowModel.unscoped(),
627 required: true,
628 as: 'ActorFollowing',
629 where: {
630 state: 'accepted',
631 targetActorId: this.id
632 }
633 }
634 ],
635 transaction: t
636 }
637
638 return ActorModel.findAll(query)
639 .then(accounts => accounts.map(a => a.sharedInboxUrl))
640 }
641
642 getFollowingUrl () {
643 return this.url + '/following'
644 }
645
646 getFollowersUrl () {
647 return this.url + '/followers'
648 }
649
650 getPlaylistsUrl () {
651 return this.url + '/playlists'
652 }
653
654 getPublicKeyUrl () {
655 return this.url + '#main-key'
656 }
657
658 isOwned () {
659 return this.serverId === null
660 }
661
662 getWebfingerUrl (this: MActorServer) {
663 return 'acct:' + this.preferredUsername + '@' + this.getHost()
664 }
665
666 getIdentifier () {
667 return this.Server ? `${this.preferredUsername}@${this.Server.host}` : this.preferredUsername
668 }
669
670 getHost (this: MActorHost) {
671 return this.Server ? this.Server.host : WEBSERVER.HOST
672 }
673
674 getRedundancyAllowed () {
675 return this.Server ? this.Server.redundancyAllowed : false
676 }
677
678 getAvatarUrl () {
679 if (!this.avatarId) return undefined
680
681 return WEBSERVER.URL + this.Avatar.getStaticPath()
682 }
683
684 getBannerUrl () {
685 if (!this.bannerId) return undefined
686
687 return WEBSERVER.URL + this.Banner.getStaticPath()
688 }
689
690 isOutdated () {
691 if (this.isOwned()) return false
692
693 return isOutdated(this, ACTIVITY_PUB.ACTOR_REFRESH_INTERVAL)
694 }
695
696 getCreatedAt (this: MActorAPChannel | MActorAPAccount | MActorFormattable) {
697 return this.remoteCreatedAt || this.createdAt
698 }
699}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-15 10:07:12 +0000