server/models/video/video-share.ts

   1 import { literal, Op, QueryTypes, Transaction } from 'sequelize'
   2 import { AllowNull, BelongsTo, Column, CreatedAt, DataType, ForeignKey, Is, Model, Scopes, Table, UpdatedAt } from 'sequelize-typescript'
   3 import { AttributesOnly } from '@shared/typescript-utils'
   4 import { isActivityPubUrlValid } from '../../helpers/custom-validators/activitypub/misc'
   5 import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
   6 import { MActorDefault, MActorFollowersUrl, MActorId } from '../../types/models'
   7 import { MVideoShareActor, MVideoShareFull } from '../../types/models/video'
   8 import { ActorModel } from '../actor/actor'
   9 import { buildLocalActorIdsIn, throwIfNotValid } from '../utils'
  10 import { VideoModel } from './video'
  11
  12 enum ScopeNames {
  13   FULL = 'FULL',
  14   WITH_ACTOR = 'WITH_ACTOR'
  15 }
  16
  17 @Scopes(() => ({
  18   [ScopeNames.FULL]: {
  19     include: [
  20       {
  21         model: ActorModel,
  22         required: true
  23       },
  24       {
  25         model: VideoModel,
  26         required: true
  27       }
  28     ]
  29   },
  30   [ScopeNames.WITH_ACTOR]: {
  31     include: [
  32       {
  33         model: ActorModel,
  34         required: true
  35       }
  36     ]
  37   }
  38 }))
  39 @Table({
  40   tableName: 'videoShare',
  41   indexes: [
  42     {
  43       fields: [ 'actorId' ]
  44     },
  45     {
  46       fields: [ 'videoId' ]
  47     },
  48     {
  49       fields: [ 'url' ],
  50       unique: true
  51     }
  52   ]
  53 })
  54 export class VideoShareModel extends Model<Partial<AttributesOnly<VideoShareModel>>> {
  55
  56   @AllowNull(false)
  57   @Is('VideoShareUrl', value => throwIfNotValid(value, isActivityPubUrlValid, 'url'))
  58   @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_SHARE.URL.max))
  59   url: string
  60
  61   @CreatedAt
  62   createdAt: Date
  63
  64   @UpdatedAt
  65   updatedAt: Date
  66
  67   @ForeignKey(() => ActorModel)
  68   @Column
  69   actorId: number
  70
  71   @BelongsTo(() => ActorModel, {
  72     foreignKey: {
  73       allowNull: false
  74     },
  75     onDelete: 'cascade'
  76   })
  77   Actor: ActorModel
  78
  79   @ForeignKey(() => VideoModel)
  80   @Column
  81   videoId: number
  82
  83   @BelongsTo(() => VideoModel, {
  84     foreignKey: {
  85       allowNull: false
  86     },
  87     onDelete: 'cascade'
  88   })
  89   Video: VideoModel
  90
  91   static load (actorId: number | string, videoId: number | string, t?: Transaction): Promise<MVideoShareActor> {
  92     return VideoShareModel.scope(ScopeNames.WITH_ACTOR).findOne({
  93       where: {
  94         actorId,
  95         videoId
  96       },
  97       transaction: t
  98     })
  99   }
 100
 101   static loadByUrl (url: string, t: Transaction): Promise<MVideoShareFull> {
 102     return VideoShareModel.scope(ScopeNames.FULL).findOne({
 103       where: {
 104         url
 105       },
 106       transaction: t
 107     })
 108   }
 109
 110   static listActorIdsAndFollowerUrlsByShare (videoId: number, t: Transaction) {
 111     const query = `SELECT "actor"."id" AS "id", "actor"."followersUrl" AS "followersUrl" ` +
 112                   `FROM "videoShare" ` +
 113                   `INNER JOIN "actor" ON "actor"."id" = "videoShare"."actorId" ` +
 114                   `WHERE "videoShare"."videoId" = :videoId`
 115
 116     const options = {
 117       type: QueryTypes.SELECT as QueryTypes.SELECT,
 118       replacements: { videoId },
 119       transaction: t
 120     }
 121
 122     return VideoShareModel.sequelize.query<MActorId & MActorFollowersUrl>(query, options)
 123   }
 124
 125   static loadActorsWhoSharedVideosOf (actorOwnerId: number, t: Transaction): Promise<MActorDefault[]> {
 126     const safeOwnerId = parseInt(actorOwnerId + '', 10)
 127
 128     // /!\ On actor model
 129     const query = {
 130       where: {
 131         [Op.and]: [
 132           literal(
 133             `EXISTS (` +
 134             `  SELECT 1 FROM "videoShare" ` +
 135             `  INNER JOIN "video" ON "videoShare"."videoId" = "video"."id" ` +
 136             `  INNER JOIN "videoChannel" ON "videoChannel"."id" = "video"."channelId" ` +
 137             `  INNER JOIN "account" ON "account"."id" = "videoChannel"."accountId" ` +
 138             `  WHERE "videoShare"."actorId" = "ActorModel"."id" AND "account"."actorId" = ${safeOwnerId} ` +
 139             `  LIMIT 1` +
 140             `)`
 141           )
 142         ]
 143       },
 144       transaction: t
 145     }
 146
 147     return ActorModel.findAll(query)
 148   }
 149
 150   static loadActorsByVideoChannel (videoChannelId: number, t: Transaction): Promise<MActorDefault[]> {
 151     const safeChannelId = parseInt(videoChannelId + '', 10)
 152
 153     // /!\ On actor model
 154     const query = {
 155       where: {
 156         [Op.and]: [
 157           literal(
 158             `EXISTS (` +
 159             `  SELECT 1 FROM "videoShare" ` +
 160             `  INNER JOIN "video" ON "videoShare"."videoId" = "video"."id" ` +
 161             `  WHERE "videoShare"."actorId" = "ActorModel"."id" AND "video"."channelId" = ${safeChannelId} ` +
 162             `  LIMIT 1` +
 163             `)`
 164           )
 165         ]
 166       },
 167       transaction: t
 168     }
 169
 170     return ActorModel.findAll(query)
 171   }
 172
 173   static listAndCountByVideoId (videoId: number, start: number, count: number, t?: Transaction) {
 174     const query = {
 175       offset: start,
 176       limit: count,
 177       where: {
 178         videoId
 179       },
 180       transaction: t
 181     }
 182
 183     return Promise.all([
 184       VideoShareModel.count(query),
 185       VideoShareModel.findAll(query)
 186     ]).then(([ total, data ]) => ({ total, data }))
 187   }
 188
 189   static listRemoteShareUrlsOfLocalVideos () {
 190     const query = `SELECT "videoShare".url FROM "videoShare" ` +
 191       `INNER JOIN actor ON actor.id = "videoShare"."actorId" AND actor."serverId" IS NOT NULL ` +
 192       `INNER JOIN video ON video.id = "videoShare"."videoId" AND video.remote IS FALSE`
 193
 194     return VideoShareModel.sequelize.query<{ url: string }>(query, {
 195       type: QueryTypes.SELECT,
 196       raw: true
 197     }).then(rows => rows.map(r => r.url))
 198   }
 199
 200   static cleanOldSharesOf (videoId: number, beforeUpdatedAt: Date) {
 201     const query = {
 202       where: {
 203         updatedAt: {
 204           [Op.lt]: beforeUpdatedAt
 205         },
 206         videoId,
 207         actorId: {
 208           [Op.notIn]: buildLocalActorIdsIn()
 209         }
 210       }
 211     }
 212
 213     return VideoShareModel.destroy(query)
 214   }
 215 }