Add downloadingEnabled property to video model

[github/Chocobozzz/PeerTube.git] / server / models / video / video-blacklist.ts

diff --git a/server/models/video/video-blacklist.ts b/server/models/video/video-blacklist.ts
index dc49852b66a3ca8e239bd6ca61310ecf527c91b6..67f7cd4871c0aeef041996ff11f557002e26ebfd 100644 (file)
--- a/server/models/video/video-blacklist.ts
+++ b/server/models/video/video-blacklist.ts
@@ -1,106 +1,120 @@
-import * as Sequelize from 'sequelize'
-
-import { addMethodsToModel, getSort } from '../utils'
 import {
-  BlacklistedVideoInstance,
-  BlacklistedVideoAttributes,
-
-  BlacklistedVideoMethods
-} from './video-blacklist-interface'
-
-let BlacklistedVideo: Sequelize.Model<BlacklistedVideoInstance, BlacklistedVideoAttributes>
-let toFormattedJSON: BlacklistedVideoMethods.ToFormattedJSON
-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',
-    {},
+  AfterCreate,
+  AfterDestroy,
+  AllowNull,
+  BelongsTo,
+  Column,
+  CreatedAt,
+  DataType,
+  ForeignKey,
+  Is,
+  Model,
+  Table,
+  UpdatedAt
+} from 'sequelize-typescript'
+import { getSortOnModel, SortType, throwIfNotValid } from '../utils'
+import { VideoModel } from './video'
+import { isVideoBlacklistReasonValid } from '../../helpers/custom-validators/video-blacklist'
+import { Emailer } from '../../lib/emailer'
+import { VideoBlacklist } from '../../../shared/models/videos'
+import { CONSTRAINTS_FIELDS } from '../../initializers'
+
+@Table({
+  tableName: 'videoBlacklist',
+  indexes: [
     {
-      indexes: [
-        {
-          fields: [ 'videoId' ],
-          unique: true
-        }
-      ]
+      fields: [ 'videoId' ],
+      unique: true
     }
-  )
-
-  const classMethods = [
-    associate,
-
-    countTotal,
-    list,
-    listForApi,
-    loadById,
-    loadByVideoId
-  ]
-  const instanceMethods = [
-    toFormattedJSON
   ]
-  addMethodsToModel(BlacklistedVideo, classMethods, instanceMethods)
+})
+export class VideoBlacklistModel extends Model<VideoBlacklistModel> {
 
-  return BlacklistedVideo
-}
+  @AllowNull(true)
+  @Is('VideoBlacklistReason', value => throwIfNotValid(value, isVideoBlacklistReasonValid, 'reason'))
+  @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_BLACKLIST.REASON.max))
+  reason: string
 
-// ------------------------------ METHODS ------------------------------
+  @CreatedAt
+  createdAt: Date
 
-toFormattedJSON = function (this: BlacklistedVideoInstance) {
-  return {
-    id: this.id,
-    videoId: this.videoId,
-    createdAt: this.createdAt
-  }
-}
+  @UpdatedAt
+  updatedAt: Date
 
-// ------------------------------ STATICS ------------------------------
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
 
-function associate (models) {
-  BlacklistedVideo.belongsTo(models.Video, {
+  @BelongsTo(() => VideoModel, {
     foreignKey: {
-      name: 'videoId',
       allowNull: false
     },
-    onDelete: 'CASCADE'
+    onDelete: 'cascade'
   })
-}
-
-countTotal = function () {
-  return BlacklistedVideo.count()
-}
+  Video: VideoModel
 
-list = function () {
-  return BlacklistedVideo.findAll()
-}
+  @AfterCreate
+  static sendBlacklistEmailNotification (instance: VideoBlacklistModel) {
+    return Emailer.Instance.addVideoBlacklistReportJob(instance.videoId, instance.reason)
+  }
 
-listForApi = function (start: number, count: number, sort: string) {
-  const query = {
-    offset: start,
-    limit: count,
-    order: [ getSort(sort) ]
+  @AfterDestroy
+  static sendUnblacklistEmailNotification (instance: VideoBlacklistModel) {
+    return Emailer.Instance.addVideoUnblacklistReportJob(instance.videoId)
   }
 
-  return BlacklistedVideo.findAndCountAll(query).then(({ rows, count }) => {
-    return {
-      data: rows,
-      total: count
+  static listForApi (start: number, count: number, sort: SortType) {
+    const query = {
+      offset: start,
+      limit: count,
+      order: getSortOnModel(sort.sortModel, sort.sortValue),
+      include: [
+        {
+          model: VideoModel,
+          required: true
+        }
+      ]
     }
-  })
-}
 
-loadById = function (id: number) {
-  return BlacklistedVideo.findById(id)
-}
+    return VideoBlacklistModel.findAndCountAll(query)
+      .then(({ rows, count }) => {
+        return {
+          data: rows,
+          total: count
+        }
+      })
+  }
 
-loadByVideoId = function (id: number) {
-  const query = {
-    where: {
-      videoId: id
+  static loadByVideoId (id: number) {
+    const query = {
+      where: {
+        videoId: id
+      }
     }
+
+    return VideoBlacklistModel.findOne(query)
   }
 
-  return BlacklistedVideo.findOne(query)
+  toFormattedJSON (): VideoBlacklist {
+    const video = this.Video
+
+    return {
+      id: this.id,
+      createdAt: this.createdAt,
+      updatedAt: this.updatedAt,
+      reason: this.reason,
+
+      video: {
+        id: video.id,
+        name: video.name,
+        uuid: video.uuid,
+        description: video.description,
+        duration: video.duration,
+        views: video.views,
+        likes: video.likes,
+        dislikes: video.dislikes,
+        nsfw: video.nsfw
+      }
+    }
+  }
 }