server/models/activitypub/actor.ts

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