X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Faccount%2Faccount.ts;h=c72f9c63df3c418a8953f57b5025fbb95a1d460a;hb=b49f22d8f9a52ab75fd38db2d377249eb58fa678;hp=1ee232537ff635061a2bba3b28d816d8698e0061;hpb=50d6de9c286abcb34ff4234d56d9cbb803db7665;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/models/account/account.ts b/server/models/account/account.ts
index 1ee232537..c72f9c63d 100644
--- a/server/models/account/account.ts
+++ b/server/models/account/account.ts
@@ -1,51 +1,157 @@
-import * as Sequelize from 'sequelize'
+import { FindOptions, Includeable, IncludeOptions, Op, Transaction, WhereOptions } from 'sequelize'
 import {
-  AfterDestroy,
   AllowNull,
+  BeforeDestroy,
   BelongsTo,
   Column,
   CreatedAt,
+  DataType,
+  Default,
   DefaultScope,
   ForeignKey,
   HasMany,
   Is,
   Model,
+  Scopes,
   Table,
   UpdatedAt
 } from 'sequelize-typescript'
-import { isUserUsernameValid } from '../../helpers/custom-validators/users'
+import { ModelCache } from '@server/models/model-cache'
+import { Account, AccountSummary } from '../../../shared/models/actors'
+import { isAccountDescriptionValid } from '../../helpers/custom-validators/accounts'
+import { CONSTRAINTS_FIELDS, SERVER_ACTOR_NAME, WEBSERVER } from '../../initializers/constants'
 import { sendDeleteActor } from '../../lib/activitypub/send'
+import {
+  MAccount,
+  MAccountActor,
+  MAccountAP,
+  MAccountDefault,
+  MAccountFormattable,
+  MAccountSummaryFormattable,
+  MChannelActor
+} from '../../types/models'
 import { ActorModel } from '../activitypub/actor'
+import { ActorFollowModel } from '../activitypub/actor-follow'
 import { ApplicationModel } from '../application/application'
+import { AvatarModel } from '../avatar/avatar'
 import { ServerModel } from '../server/server'
-import { throwIfNotValid } from '../utils'
+import { ServerBlocklistModel } from '../server/server-blocklist'
+import { getSort, throwIfNotValid } from '../utils'
+import { VideoModel } from '../video/video'
 import { VideoChannelModel } from '../video/video-channel'
+import { VideoCommentModel } from '../video/video-comment'
+import { VideoPlaylistModel } from '../video/video-playlist'
+import { AccountBlocklistModel } from './account-blocklist'
 import { UserModel } from './user'
 
-@DefaultScope({
+export enum ScopeNames {
+  SUMMARY = 'SUMMARY'
+}
+
+export type SummaryOptions = {
+  actorRequired?: boolean // Default: true
+  whereActor?: WhereOptions
+  withAccountBlockerIds?: number[]
+}
+
+@DefaultScope(() => ({
   include: [
     {
-      model: () => ActorModel,
-      required: true,
-      include: [
+      model: ActorModel, // Default scope includes avatar and server
+      required: true
+    }
+  ]
+}))
+@Scopes(() => ({
+  [ScopeNames.SUMMARY]: (options: SummaryOptions = {}) => {
+    const whereActor = options.whereActor || undefined
+
+    const serverInclude: IncludeOptions = {
+      attributes: [ 'host' ],
+      model: ServerModel.unscoped(),
+      required: false
+    }
+
+    const queryInclude: Includeable[] = [
+      {
+        attributes: [ 'id', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
+        model: ActorModel.unscoped(),
+        required: options.actorRequired ?? true,
+        where: whereActor,
+        include: [
+          serverInclude,
+
+          {
+            model: AvatarModel.unscoped(),
+            required: false
+          }
+        ]
+      }
+    ]
+
+    const query: FindOptions = {
+      attributes: [ 'id', 'name', 'actorId' ]
+    }
+
+    if (options.withAccountBlockerIds) {
+      queryInclude.push({
+        attributes: [ 'id' ],
+        model: AccountBlocklistModel.unscoped(),
+        as: 'BlockedAccounts',
+        required: false,
+        where: {
+          accountId: {
+            [Op.in]: options.withAccountBlockerIds
+          }
+        }
+      })
+
+      serverInclude.include = [
         {
-          model: () => ServerModel,
-          required: false
+          attributes: [ 'id' ],
+          model: ServerBlocklistModel.unscoped(),
+          required: false,
+          where: {
+            accountId: {
+              [Op.in]: options.withAccountBlockerIds
+            }
+          }
         }
       ]
     }
-  ]
-})
+
+    query.include = queryInclude
+
+    return query
+  }
+}))
 @Table({
-  tableName: 'account'
+  tableName: 'account',
+  indexes: [
+    {
+      fields: [ 'actorId' ],
+      unique: true
+    },
+    {
+      fields: [ 'applicationId' ]
+    },
+    {
+      fields: [ 'userId' ]
+    }
+  ]
 })
-export class AccountModel extends Model<AccountModel> {
+export class AccountModel extends Model {
 
   @AllowNull(false)
-  @Is('AccountName', value => throwIfNotValid(value, isUserUsernameValid, 'account name'))
   @Column
   name: string
 
+  @AllowNull(true)
+  @Default(null)
+  @Is('AccountDescription', value => throwIfNotValid(value, isAccountDescriptionValid, 'description', true))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.USERS.DESCRIPTION.max))
+  description: string
+
   @CreatedAt
   createdAt: Date
 
@@ -86,7 +192,7 @@ export class AccountModel extends Model<AccountModel> {
     },
     onDelete: 'cascade'
   })
-  Account: ApplicationModel
+  Application: ApplicationModel
 
   @HasMany(() => VideoChannelModel, {
     foreignKey: {
@@ -97,28 +203,119 @@ export class AccountModel extends Model<AccountModel> {
   })
   VideoChannels: VideoChannelModel[]
 
-  @AfterDestroy
-  static sendDeleteIfOwned (instance: AccountModel) {
+  @HasMany(() => VideoPlaylistModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'cascade',
+    hooks: true
+  })
+  VideoPlaylists: VideoPlaylistModel[]
+
+  @HasMany(() => VideoCommentModel, {
+    foreignKey: {
+      allowNull: true
+    },
+    onDelete: 'cascade',
+    hooks: true
+  })
+  VideoComments: VideoCommentModel[]
+
+  @HasMany(() => AccountBlocklistModel, {
+    foreignKey: {
+      name: 'targetAccountId',
+      allowNull: false
+    },
+    as: 'BlockedAccounts',
+    onDelete: 'CASCADE'
+  })
+  BlockedAccounts: AccountBlocklistModel[]
+
+  @BeforeDestroy
+  static async sendDeleteIfOwned (instance: AccountModel, options) {
+    if (!instance.Actor) {
+      instance.Actor = await instance.$get('Actor', { transaction: options.transaction })
+    }
+
+    await ActorFollowModel.removeFollowsOf(instance.Actor.id, options.transaction)
+
     if (instance.isOwned()) {
-      return sendDeleteActor(instance.Actor, undefined)
+      return sendDeleteActor(instance.Actor, options.transaction)
     }
 
     return undefined
   }
 
-  static load (id: number) {
-    return AccountModel.findById(id)
+  static load (id: number, transaction?: Transaction): Promise<MAccountDefault> {
+    return AccountModel.findByPk(id, { transaction })
+  }
+
+  static loadByNameWithHost (nameWithHost: string): Promise<MAccountDefault> {
+    const [ accountName, host ] = nameWithHost.split('@')
+
+    if (!host || host === WEBSERVER.HOST) return AccountModel.loadLocalByName(accountName)
+
+    return AccountModel.loadByNameAndHost(accountName, host)
   }
 
-  static loadByUUID (uuid: string) {
+  static loadLocalByName (name: string): Promise<MAccountDefault> {
+    const fun = () => {
+      const query = {
+        where: {
+          [Op.or]: [
+            {
+              userId: {
+                [Op.ne]: null
+              }
+            },
+            {
+              applicationId: {
+                [Op.ne]: null
+              }
+            }
+          ]
+        },
+        include: [
+          {
+            model: ActorModel,
+            required: true,
+            where: {
+              preferredUsername: name
+            }
+          }
+        ]
+      }
+
+      return AccountModel.findOne(query)
+    }
+
+    return ModelCache.Instance.doCache({
+      cacheType: 'local-account-name',
+      key: name,
+      fun,
+      // The server actor never change, so we can easily cache it
+      whitelist: () => name === SERVER_ACTOR_NAME
+    })
+  }
+
+  static loadByNameAndHost (name: string, host: string): Promise<MAccountDefault> {
     const query = {
       include: [
         {
           model: ActorModel,
           required: true,
           where: {
-            uuid
-          }
+            preferredUsername: name
+          },
+          include: [
+            {
+              model: ServerModel,
+              required: true,
+              where: {
+                host
+              }
+            }
+          ]
         }
       ]
     }
@@ -126,62 +323,139 @@ export class AccountModel extends Model<AccountModel> {
     return AccountModel.findOne(query)
   }
 
-  static loadLocalByName (name: string) {
+  static loadByUrl (url: string, transaction?: Transaction): Promise<MAccountDefault> {
     const query = {
-      where: {
-        name,
-        [ Sequelize.Op.or ]: [
-          {
-            userId: {
-              [ Sequelize.Op.ne ]: null
-            }
-          },
-          {
-            applicationId: {
-              [ Sequelize.Op.ne ]: null
-            }
+      include: [
+        {
+          model: ActorModel,
+          required: true,
+          where: {
+            url
           }
-        ]
-      }
+        }
+      ],
+      transaction
     }
 
     return AccountModel.findOne(query)
   }
 
-  static loadByUrl (url: string, transaction?: Sequelize.Transaction) {
+  static listForApi (start: number, count: number, sort: string) {
+    const query = {
+      offset: start,
+      limit: count,
+      order: getSort(sort)
+    }
+
+    return AccountModel.findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return {
+          data: rows,
+          total: count
+        }
+      })
+  }
+
+  static loadAccountIdFromVideo (videoId: number): Promise<MAccount> {
     const query = {
       include: [
         {
-          model: ActorModel,
+          attributes: [ 'id', 'accountId' ],
+          model: VideoChannelModel.unscoped(),
           required: true,
+          include: [
+            {
+              attributes: [ 'id', 'channelId' ],
+              model: VideoModel.unscoped(),
+              where: {
+                id: videoId
+              }
+            }
+          ]
+        }
+      ]
+    }
+
+    return AccountModel.findOne(query)
+  }
+
+  static listLocalsForSitemap (sort: string): Promise<MAccountActor[]> {
+    const query = {
+      attributes: [ ],
+      offset: 0,
+      order: getSort(sort),
+      include: [
+        {
+          attributes: [ 'preferredUsername', 'serverId' ],
+          model: ActorModel.unscoped(),
           where: {
-            url
+            serverId: null
           }
         }
-      ],
-      transaction
+      ]
     }
 
-    return AccountModel.findOne(query)
+    return AccountModel
+      .unscoped()
+      .findAll(query)
   }
 
-  toFormattedJSON () {
+  getClientUrl () {
+    return WEBSERVER.URL + '/accounts/' + this.Actor.getIdentifier()
+  }
+
+  toFormattedJSON (this: MAccountFormattable): Account {
     const actor = this.Actor.toFormattedJSON()
     const account = {
       id: this.id,
-      name: this.name,
+      displayName: this.getDisplayName(),
+      description: this.description,
       createdAt: this.createdAt,
-      updatedAt: this.updatedAt
+      updatedAt: this.updatedAt,
+      userId: this.userId ? this.userId : undefined
     }
 
     return Object.assign(actor, account)
   }
 
-  toActivityPubObject () {
-    return this.Actor.toActivityPubObject(this.name, 'Account')
+  toFormattedSummaryJSON (this: MAccountSummaryFormattable): AccountSummary {
+    const actor = this.Actor.toFormattedSummaryJSON()
+
+    return {
+      id: this.id,
+      name: actor.name,
+      displayName: this.getDisplayName(),
+      url: actor.url,
+      host: actor.host,
+      avatar: actor.avatar
+    }
+  }
+
+  toActivityPubObject (this: MAccountAP) {
+    const obj = this.Actor.toActivityPubObject(this.name)
+
+    return Object.assign(obj, {
+      summary: this.description
+    })
   }
 
   isOwned () {
     return this.Actor.isOwned()
   }
+
+  isOutdated () {
+    return this.Actor.isOutdated()
+  }
+
+  getDisplayName () {
+    return this.name
+  }
+
+  getLocalUrl (this: MAccountActor | MChannelActor) {
+    return WEBSERVER.URL + `/accounts/` + this.Actor.preferredUsername
+  }
+
+  isBlocked () {
+    return this.BlockedAccounts && this.BlockedAccounts.length !== 0
+  }
 }