X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;ds=sidebyside;f=server%2Fmodels%2Fvideo%2Fvideo-blacklist.ts;h=aa18896da05a7360da197f42a76fd6a1c19a4045;hb=ceb8f322118b24508abc6dd0bc6813a43610eff3;hp=3576c96f6c108e2123ef9fc1f9900c508a483540;hpb=70c065d64c330196d371941d9294a55da6e3aa37;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/models/video/video-blacklist.ts b/server/models/video/video-blacklist.ts
index 3576c96f6..aa18896da 100644
--- a/server/models/video/video-blacklist.ts
+++ b/server/models/video/video-blacklist.ts
@@ -1,103 +1,133 @@
-import * as Sequelize from 'sequelize'
-
-import { addMethodsToModel, getSort } from '../utils'
-import {
-  BlacklistedVideoClass,
-  BlacklistedVideoInstance,
-  BlacklistedVideoAttributes,
-
-  BlacklistedVideoMethods
-} from './video-blacklist-interface'
-
-let BlacklistedVideo: Sequelize.Model<BlacklistedVideoInstance, BlacklistedVideoAttributes>
-let toFormatedJSON: BlacklistedVideoMethods.ToFormatedJSON
-let countTotal: BlacklistedVideoMethods.CountTotal
-let list: BlacklistedVideoMethods.List
-let listForApi: BlacklistedVideoMethods.ListForApi
-let loadById: BlacklistedVideoMethods.LoadById
-let loadByVideoId: BlacklistedVideoMethods.LoadByVideoId
-
-export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
-  BlacklistedVideo = sequelize.define<BlacklistedVideoInstance, BlacklistedVideoAttributes>('BlacklistedVideo',
-    {},
+import { FindOptions } from 'sequelize'
+import { AllowNull, BelongsTo, Column, CreatedAt, DataType, Default, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { MVideoBlacklist, MVideoBlacklistFormattable } from '@server/types/models'
+import { VideoBlacklist, VideoBlacklistType } from '../../../shared/models/videos'
+import { isVideoBlacklistReasonValid, isVideoBlacklistTypeValid } from '../../helpers/custom-validators/video-blacklist'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import { getBlacklistSort, searchAttribute, SortType, throwIfNotValid } from '../utils'
+import { ThumbnailModel } from './thumbnail'
+import { VideoModel } from './video'
+import { ScopeNames as VideoChannelScopeNames, SummaryOptions, VideoChannelModel } from './video-channel'
+
+@Table({
+  tableName: 'videoBlacklist',
+  indexes: [
     {
-      indexes: [
-        {
-          fields: [ 'videoId' ],
-          unique: true
-        }
-      ]
+      fields: [ 'videoId' ],
+      unique: true
     }
-  )
-
-  const classMethods = [
-    associate,
-
-    countTotal,
-    list,
-    listForApi,
-    loadById,
-    loadByVideoId
-  ]
-  const instanceMethods = [
-    toFormatedJSON
   ]
-  addMethodsToModel(BlacklistedVideo, classMethods, instanceMethods)
-
-  return BlacklistedVideo
-}
-
-// ------------------------------ METHODS ------------------------------
-
-toFormatedJSON = function (this: BlacklistedVideoInstance) {
-  return {
-    id: this.id,
-    videoId: this.videoId,
-    createdAt: this.createdAt
-  }
-}
-
-// ------------------------------ STATICS ------------------------------
-
-function associate (models) {
-  BlacklistedVideo.belongsTo(models.Video, {
-    foreignKey: 'videoId',
+})
+export class VideoBlacklistModel extends Model {
+
+  @AllowNull(true)
+  @Is('VideoBlacklistReason', value => throwIfNotValid(value, isVideoBlacklistReasonValid, 'reason', true))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_BLACKLIST.REASON.max))
+  reason: string
+
+  @AllowNull(false)
+  @Column
+  unfederated: boolean
+
+  @AllowNull(false)
+  @Default(null)
+  @Is('VideoBlacklistType', value => throwIfNotValid(value, isVideoBlacklistTypeValid, 'type'))
+  @Column
+  type: VideoBlacklistType
+
+  @CreatedAt
+  createdAt: Date
+
+  @UpdatedAt
+  updatedAt: Date
+
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
+
+  @BelongsTo(() => VideoModel, {
+    foreignKey: {
+      allowNull: false
+    },
     onDelete: 'cascade'
   })
-}
-
-countTotal = function (callback: BlacklistedVideoMethods.CountTotalCallback) {
-  return BlacklistedVideo.count().asCallback(callback)
-}
+  Video: VideoModel
+
+  static listForApi (parameters: {
+    start: number
+    count: number
+    sort: SortType
+    search?: string
+    type?: VideoBlacklistType
+  }) {
+    const { start, count, sort, search, type } = parameters
+
+    function buildBaseQuery (): FindOptions {
+      return {
+        offset: start,
+        limit: count,
+        order: getBlacklistSort(sort.sortModel, sort.sortValue)
+      }
+    }
 
-list = function (callback: BlacklistedVideoMethods.ListCallback) {
-  return BlacklistedVideo.findAll().asCallback(callback)
-}
+    const countQuery = buildBaseQuery()
+
+    const findQuery = buildBaseQuery()
+    findQuery.include = [
+      {
+        model: VideoModel,
+        required: true,
+        where: searchAttribute(search, 'name'),
+        include: [
+          {
+            model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, { withAccount: true } as SummaryOptions ] }),
+            required: true
+          },
+          {
+            model: ThumbnailModel,
+            attributes: [ 'type', 'filename' ],
+            required: false
+          }
+        ]
+      }
+    ]
+
+    if (type) {
+      countQuery.where = { type }
+      findQuery.where = { type }
+    }
 
-listForApi = function (start: number, count: number, sort: string, callback: BlacklistedVideoMethods.ListForApiCallback) {
-  const query = {
-    offset: start,
-    limit: count,
-    order: [ getSort(sort) ]
+    return Promise.all([
+      VideoBlacklistModel.count(countQuery),
+      VideoBlacklistModel.findAll(findQuery)
+    ]).then(([ count, rows ]) => {
+      return {
+        data: rows,
+        total: count
+      }
+    })
   }
 
-  return BlacklistedVideo.findAndCountAll(query).asCallback(function (err, result) {
-    if (err) return callback(err)
+  static loadByVideoId (id: number): Promise<MVideoBlacklist> {
+    const query = {
+      where: {
+        videoId: id
+      }
+    }
 
-    return callback(null, result.rows, result.count)
-  })
-}
+    return VideoBlacklistModel.findOne(query)
+  }
 
-loadById = function (id: number, callback: BlacklistedVideoMethods.LoadByIdCallback) {
-  return BlacklistedVideo.findById(id).asCallback(callback)
-}
+  toFormattedJSON (this: MVideoBlacklistFormattable): VideoBlacklist {
+    return {
+      id: this.id,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      reason: this.reason,
+      unfederated: this.unfederated,
+      type: this.type,
 
-loadByVideoId = function (id: string, callback: BlacklistedVideoMethods.LoadByIdCallback) {
-  const query = {
-    where: {
-      videoId: id
+      video: this.Video.toFormattedJSON()
     }
   }
-
-  return BlacklistedVideo.find(query).asCallback(callback)
 }