server/models/activitypub/actor.ts

   1 import { values } from 'lodash'
   2 import { extname } from 'path'
   3 import {
   4   AllowNull,
   5   BelongsTo,
   6   Column,
   7   CreatedAt,
   8   DataType,
   9   DefaultScope,
  10   ForeignKey,
  11   HasMany,
  12   HasOne,
  13   Is,
  14   Model,
  15   Scopes,
  16   Table,
  17   UpdatedAt
  18 } from 'sequelize-typescript'
  19 import { ActivityPubActorType } from '../../../shared/models/activitypub'
  20 import { Avatar } from '../../../shared/models/avatars/avatar.model'
  21 import { activityPubContextify } from '../../helpers/activitypub'
  22 import {
  23   isActorFollowersCountValid,
  24   isActorFollowingCountValid,
  25   isActorPreferredUsernameValid,
  26   isActorPrivateKeyValid,
  27   isActorPublicKeyValid
  28 } from '../../helpers/custom-validators/activitypub/actor'
  29 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
  30 import { ACTIVITY_PUB, ACTIVITY_PUB_ACTOR_TYPES, CONSTRAINTS_FIELDS, WEBSERVER } from '../../initializers/constants'
  31 import { AccountModel } from '../account/account'
  32 import { AvatarModel } from '../avatar/avatar'
  33 import { ServerModel } from '../server/server'
  34 import { isOutdated, throwIfNotValid } from '../utils'
  35 import { VideoChannelModel } from '../video/video-channel'
  36 import { ActorFollowModel } from './actor-follow'
  37 import { VideoModel } from '../video/video'
  38 import {
  39   MActor,
  40   MActorAccountChannelId,
  41   MActorAP,
  42   MActorFormattable,
  43   MActorFull,
  44   MActorHost,
  45   MActorServer,
  46   MActorSummaryFormattable,
  47   MActorWithInboxes
  48 } from '../../typings/models'
  49 import * as Bluebird from 'bluebird'
  50 import { Op, Transaction } from 'sequelize'
  51
  52 enum ScopeNames {
  53   FULL = 'FULL'
  54 }
  55
  56 export const unusedActorAttributesForAPI = [
  57   'publicKey',
  58   'privateKey',
  59   'inboxUrl',
  60   'outboxUrl',
  61   'sharedInboxUrl',
  62   'followersUrl',
  63   'followingUrl',
  64   'url',
  65   'createdAt',
  66   'updatedAt'
  67 ]
  68
  69 @DefaultScope(() => ({
  70   include: [
  71     {
  72       model: ServerModel,
  73       required: false
  74     },
  75     {
  76       model: AvatarModel,
  77       required: false
  78     }
  79   ]
  80 }))
  81 @Scopes(() => ({
  82   [ScopeNames.FULL]: {
  83     include: [
  84       {
  85         model: AccountModel.unscoped(),
  86         required: false
  87       },
  88       {
  89         model: VideoChannelModel.unscoped(),
  90         required: false,
  91         include: [
  92           {
  93             model: AccountModel,
  94             required: true
  95           }
  96         ]
  97       },
  98       {
  99         model: ServerModel,
 100         required: false
 101       },
 102       {
 103         model: AvatarModel,
 104         required: false
 105       }
 106     ]
 107   }
 108 }))
 109 @Table({
 110   tableName: 'actor',
 111   indexes: [
 112     {
 113       fields: [ 'url' ],
 114       unique: true
 115     },
 116     {
 117       fields: [ 'preferredUsername', 'serverId' ],
 118       unique: true,
 119       where: {
 120         serverId: {
 121           [Op.ne]: null
 122         }
 123       }
 124     },
 125     // {
 126     //   fields: [ 'preferredUsername' ],
 127     //   unique: true,
 128     //   where: {
 129     //     serverId: null
 130     //   }
 131     // },
 132     {
 133       fields: [ 'inboxUrl', 'sharedInboxUrl' ]
 134     },
 135     {
 136       fields: [ 'sharedInboxUrl' ]
 137     },
 138     {
 139       fields: [ 'serverId' ]
 140     },
 141     {
 142       fields: [ 'avatarId' ]
 143     },
 144     {
 145       fields: [ 'followersUrl' ]
 146     }
 147   ]
 148 })
 149 export class ActorModel extends Model<ActorModel> {
 150
 151   @AllowNull(false)
 152   @Column(DataType.ENUM(...values(ACTIVITY_PUB_ACTOR_TYPES)))
 153   type: ActivityPubActorType
 154
 155   @AllowNull(false)
 156   @Is('ActorPreferredUsername', value => throwIfNotValid(value, isActorPreferredUsernameValid, 'actor preferred username'))
 157   @Column
 158   preferredUsername: string
 159
 160   @AllowNull(false)
 161   @Is('ActorUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
 162   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
 163   url: string
 164
 165   @AllowNull(true)
 166   @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPublicKeyValid, 'public key', true))
 167   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.PUBLIC_KEY.max))
 168   publicKey: string
 169
 170   @AllowNull(true)
 171   @Is('ActorPublicKey', value => throwIfNotValid(value, isActorPrivateKeyValid, 'private key', true))
 172   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.PRIVATE_KEY.max))
 173   privateKey: string
 174
 175   @AllowNull(false)
 176   @Is('ActorFollowersCount', value => throwIfNotValid(value, isActorFollowersCountValid, 'followers count'))
 177   @Column
 178   followersCount: number
 179
 180   @AllowNull(false)
 181   @Is('ActorFollowersCount', value => throwIfNotValid(value, isActorFollowingCountValid, 'following count'))
 182   @Column
 183   followingCount: number
 184
 185   @AllowNull(false)
 186   @Is('ActorInboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'inbox url'))
 187   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
 188   inboxUrl: string
 189
 190   @AllowNull(true)
 191   @Is('ActorOutboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'outbox url', true))
 192   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
 193   outboxUrl: string
 194
 195   @AllowNull(true)
 196   @Is('ActorSharedInboxUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'shared inbox url', true))
 197   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
 198   sharedInboxUrl: string
 199
 200   @AllowNull(true)
 201   @Is('ActorFollowersUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'followers url', true))
 202   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
 203   followersUrl: string
 204
 205   @AllowNull(true)
 206   @Is('ActorFollowingUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'following url', true))
 207   @Column(DataType.STRING(CONSTRAINTS_FIELDS.ACTORS.URL.max))
 208   followingUrl: string
 209
 210   @CreatedAt
 211   createdAt: Date
 212
 213   @UpdatedAt
 214   updatedAt: Date
 215
 216   @ForeignKey(() => AvatarModel)
 217   @Column
 218   avatarId: number
 219
 220   @BelongsTo(() => AvatarModel, {
 221     foreignKey: {
 222       allowNull: true
 223     },
 224     onDelete: 'set null',
 225     hooks: true
 226   })
 227   Avatar: AvatarModel
 228
 229   @HasMany(() => ActorFollowModel, {
 230     foreignKey: {
 231       name: 'actorId',
 232       allowNull: false
 233     },
 234     as: 'ActorFollowings',
 235     onDelete: 'cascade'
 236   })
 237   ActorFollowing: ActorFollowModel[]
 238
 239   @HasMany(() => ActorFollowModel, {
 240     foreignKey: {
 241       name: 'targetActorId',
 242       allowNull: false
 243     },
 244     as: 'ActorFollowers',
 245     onDelete: 'cascade'
 246   })
 247   ActorFollowers: ActorFollowModel[]
 248
 249   @ForeignKey(() => ServerModel)
 250   @Column
 251   serverId: number
 252
 253   @BelongsTo(() => ServerModel, {
 254     foreignKey: {
 255       allowNull: true
 256     },
 257     onDelete: 'cascade'
 258   })
 259   Server: ServerModel
 260
 261   @HasOne(() => AccountModel, {
 262     foreignKey: {
 263       allowNull: true
 264     },
 265     onDelete: 'cascade',
 266     hooks: true
 267   })
 268   Account: AccountModel
 269
 270   @HasOne(() => VideoChannelModel, {
 271     foreignKey: {
 272       allowNull: true
 273     },
 274     onDelete: 'cascade',
 275     hooks: true
 276   })
 277   VideoChannel: VideoChannelModel
 278
 279   static load (id: number): Bluebird<MActor> {
 280     return ActorModel.unscoped().findByPk(id)
 281   }
 282
 283   static loadFull (id: number): Bluebird<MActorFull> {
 284     return ActorModel.scope(ScopeNames.FULL).findByPk(id)
 285   }
 286
 287   static loadFromAccountByVideoId (videoId: number, transaction: Transaction): Bluebird<MActor> {
 288     const query = {
 289       include: [
 290         {
 291           attributes: [ 'id' ],
 292           model: AccountModel.unscoped(),
 293           required: true,
 294           include: [
 295             {
 296               attributes: [ 'id' ],
 297               model: VideoChannelModel.unscoped(),
 298               required: true,
 299               include: [
 300                 {
 301                   attributes: [ 'id' ],
 302                   model: VideoModel.unscoped(),
 303                   required: true,
 304                   where: {
 305                     id: videoId
 306                   }
 307                 }
 308               ]
 309             }
 310           ]
 311         }
 312       ],
 313       transaction
 314     }
 315
 316     return ActorModel.unscoped().findOne(query)
 317   }
 318
 319   static isActorUrlExist (url: string) {
 320     const query = {
 321       raw: true,
 322       where: {
 323         url
 324       }
 325     }
 326
 327     return ActorModel.unscoped().findOne(query)
 328       .then(a => !!a)
 329   }
 330
 331   static listByFollowersUrls (followersUrls: string[], transaction?: Transaction): Bluebird<MActorFull[]> {
 332     const query = {
 333       where: {
 334         followersUrl: {
 335           [ Op.in ]: followersUrls
 336         }
 337       },
 338       transaction
 339     }
 340
 341     return ActorModel.scope(ScopeNames.FULL).findAll(query)
 342   }
 343
 344   static loadLocalByName (preferredUsername: string, transaction?: Transaction): Bluebird<MActorFull> {
 345     const query = {
 346       where: {
 347         preferredUsername,
 348         serverId: null
 349       },
 350       transaction
 351     }
 352
 353     return ActorModel.scope(ScopeNames.FULL).findOne(query)
 354   }
 355
 356   static loadByNameAndHost (preferredUsername: string, host: string): Bluebird<MActorFull> {
 357     const query = {
 358       where: {
 359         preferredUsername
 360       },
 361       include: [
 362         {
 363           model: ServerModel,
 364           required: true,
 365           where: {
 366             host
 367           }
 368         }
 369       ]
 370     }
 371
 372     return ActorModel.scope(ScopeNames.FULL).findOne(query)
 373   }
 374
 375   static loadByUrl (url: string, transaction?: Transaction): Bluebird<MActorAccountChannelId> {
 376     const query = {
 377       where: {
 378         url
 379       },
 380       transaction,
 381       include: [
 382         {
 383           attributes: [ 'id' ],
 384           model: AccountModel.unscoped(),
 385           required: false
 386         },
 387         {
 388           attributes: [ 'id' ],
 389           model: VideoChannelModel.unscoped(),
 390           required: false
 391         }
 392       ]
 393     }
 394
 395     return ActorModel.unscoped().findOne(query)
 396   }
 397
 398   static loadByUrlAndPopulateAccountAndChannel (url: string, transaction?: Transaction): Bluebird<MActorFull> {
 399     const query = {
 400       where: {
 401         url
 402       },
 403       transaction
 404     }
 405
 406     return ActorModel.scope(ScopeNames.FULL).findOne(query)
 407   }
 408
 409   static incrementFollows (id: number, column: 'followersCount' | 'followingCount', by: number) {
 410     return ActorModel.increment(column, {
 411       by,
 412       where: {
 413         id
 414       }
 415     })
 416   }
 417
 418   getSharedInbox (this: MActorWithInboxes) {
 419     return this.sharedInboxUrl || this.inboxUrl
 420   }
 421
 422   toFormattedSummaryJSON (this: MActorSummaryFormattable) {
 423     let avatar: Avatar = null
 424     if (this.Avatar) {
 425       avatar = this.Avatar.toFormattedJSON()
 426     }
 427
 428     return {
 429       url: this.url,
 430       name: this.preferredUsername,
 431       host: this.getHost(),
 432       avatar
 433     }
 434   }
 435
 436   toFormattedJSON (this: MActorFormattable) {
 437     const base = this.toFormattedSummaryJSON()
 438
 439     return Object.assign(base, {
 440       id: this.id,
 441       hostRedundancyAllowed: this.getRedundancyAllowed(),
 442       followingCount: this.followingCount,
 443       followersCount: this.followersCount,
 444       createdAt: this.createdAt,
 445       updatedAt: this.updatedAt
 446     })
 447   }
 448
 449   toActivityPubObject (this: MActorAP, name: string) {
 450     let icon = undefined
 451     if (this.avatarId) {
 452       const extension = extname(this.Avatar.filename)
 453       icon = {
 454         type: 'Image',
 455         mediaType: extension === '.png' ? 'image/png' : 'image/jpeg',
 456         url: this.getAvatarUrl()
 457       }
 458     }
 459
 460     const json = {
 461       type: this.type,
 462       id: this.url,
 463       following: this.getFollowingUrl(),
 464       followers: this.getFollowersUrl(),
 465       playlists: this.getPlaylistsUrl(),
 466       inbox: this.inboxUrl,
 467       outbox: this.outboxUrl,
 468       preferredUsername: this.preferredUsername,
 469       url: this.url,
 470       name,
 471       endpoints: {
 472         sharedInbox: this.sharedInboxUrl
 473       },
 474       publicKey: {
 475         id: this.getPublicKeyUrl(),
 476         owner: this.url,
 477         publicKeyPem: this.publicKey
 478       },
 479       icon
 480     }
 481
 482     return activityPubContextify(json)
 483   }
 484
 485   getFollowerSharedInboxUrls (t: Transaction) {
 486     const query = {
 487       attributes: [ 'sharedInboxUrl' ],
 488       include: [
 489         {
 490           attribute: [],
 491           model: ActorFollowModel.unscoped(),
 492           required: true,
 493           as: 'ActorFollowing',
 494           where: {
 495             state: 'accepted',
 496             targetActorId: this.id
 497           }
 498         }
 499       ],
 500       transaction: t
 501     }
 502
 503     return ActorModel.findAll(query)
 504       .then(accounts => accounts.map(a => a.sharedInboxUrl))
 505   }
 506
 507   getFollowingUrl () {
 508     return this.url + '/following'
 509   }
 510
 511   getFollowersUrl () {
 512     return this.url + '/followers'
 513   }
 514
 515   getPlaylistsUrl () {
 516     return this.url + '/playlists'
 517   }
 518
 519   getPublicKeyUrl () {
 520     return this.url + '#main-key'
 521   }
 522
 523   isOwned () {
 524     return this.serverId === null
 525   }
 526
 527   getWebfingerUrl (this: MActorServer) {
 528     return 'acct:' + this.preferredUsername + '@' + this.getHost()
 529   }
 530
 531   getIdentifier () {
 532     return this.Server ? `${this.preferredUsername}@${this.Server.host}` : this.preferredUsername
 533   }
 534
 535   getHost (this: MActorHost) {
 536     return this.Server ? this.Server.host : WEBSERVER.HOST
 537   }
 538
 539   getRedundancyAllowed () {
 540     return this.Server ? this.Server.redundancyAllowed : false
 541   }
 542
 543   getAvatarUrl () {
 544     if (!this.avatarId) return undefined
 545
 546     return WEBSERVER.URL + this.Avatar.getStaticPath()
 547   }
 548
 549   isOutdated () {
 550     if (this.isOwned()) return false
 551
 552     return isOutdated(this, ACTIVITY_PUB.ACTOR_REFRESH_INTERVAL)
 553   }
 554 }