Add federation to ownership change

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

diff --git a/server/models/video/video-file.ts b/server/models/video/video-file.ts
index ead7f3e034d43315e2a662523bed24d72a068927..3bc4855f38afb2bb5c86cb1adf24a8ed96caf0a6 100644 (file)
--- a/server/models/video/video-file.ts
+++ b/server/models/video/video-file.ts
@@ -1,89 +1,86 @@
-import * as Sequelize from 'sequelize'
 import { values } from 'lodash'
-
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { AllowNull, BelongsTo, Column, CreatedAt, DataType, Default, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
 import {
+  isVideoFileInfoHashValid,
   isVideoFileResolutionValid,
   isVideoFileSizeValid,
-  isVideoFileInfoHashValid
-} from '../../helpers'
-
-import { addMethodsToModel } from '../utils'
-import {
-  VideoFileInstance,
-  VideoFileAttributes
-} from './video-file-interface'
-
-let VideoFile: Sequelize.Model<VideoFileInstance, VideoFileAttributes>
+  isVideoFPSResolutionValid
+} from '../../helpers/custom-validators/videos'
+import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { throwIfNotValid } from '../utils'
+import { VideoModel } from './video'
+import * as Sequelize from 'sequelize'
 
-export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
-  VideoFile = sequelize.define<VideoFileInstance, VideoFileAttributes>('VideoFile',
+@Table({
+  tableName: 'videoFile',
+  indexes: [
     {
-      resolution: {
-        type: DataTypes.INTEGER,
-        allowNull: false,
-        validate: {
-          resolutionValid: value => {
-            const res = isVideoFileResolutionValid(value)
-            if (res === false) throw new Error('Video file resolution is not valid.')
-          }
-        }
-      },
-      size: {
-        type: DataTypes.BIGINT,
-        allowNull: false,
-        validate: {
-          sizeValid: value => {
-            const res = isVideoFileSizeValid(value)
-            if (res === false) throw new Error('Video file size is not valid.')
-          }
-        }
-      },
-      extname: {
-        type: DataTypes.ENUM(values(CONSTRAINTS_FIELDS.VIDEOS.EXTNAME)),
-        allowNull: false
-      },
-      infoHash: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        validate: {
-          infoHashValid: value => {
-            const res = isVideoFileInfoHashValid(value)
-            if (res === false) throw new Error('Video file info hash is not valid.')
-          }
-        }
-      }
+      fields: [ 'videoId' ]
     },
     {
-      indexes: [
-        {
-          fields: [ 'videoId' ]
-        },
-        {
-          fields: [ 'infoHash' ]
-        }
-      ]
+      fields: [ 'infoHash' ]
+    },
+    {
+      fields: [ 'videoId', 'resolution', 'fps' ],
+      unique: true
     }
-  )
-
-  const classMethods = [
-    associate
   ]
-  addMethodsToModel(VideoFile, classMethods)
+})
+export class VideoFileModel extends Model<VideoFileModel> {
+  @CreatedAt
+  createdAt: Date
 
-  return VideoFile
-}
+  @UpdatedAt
+  updatedAt: Date
+
+  @AllowNull(false)
+  @Is('VideoFileResolution', value => throwIfNotValid(value, isVideoFileResolutionValid, 'resolution'))
+  @Column
+  resolution: number
+
+  @AllowNull(false)
+  @Is('VideoFileSize', value => throwIfNotValid(value, isVideoFileSizeValid, 'size'))
+  @Column(DataType.BIGINT)
+  size: number
+
+  @AllowNull(false)
+  @Column(DataType.ENUM(values(CONSTRAINTS_FIELDS.VIDEOS.EXTNAME)))
+  extname: string
+
+  @AllowNull(false)
+  @Is('VideoFileSize', value => throwIfNotValid(value, isVideoFileInfoHashValid, 'info hash'))
+  @Column
+  infoHash: string
 
-// ------------------------------ STATICS ------------------------------
+  @AllowNull(true)
+  @Default(null)
+  @Is('VideoFileFPS', value => throwIfNotValid(value, isVideoFPSResolutionValid, 'fps'))
+  @Column
+  fps: number
 
-function associate (models) {
-  VideoFile.belongsTo(models.Video, {
+  @ForeignKey(() => VideoModel)
+  @Column
+  videoId: number
+
+  @BelongsTo(() => VideoModel, {
     foreignKey: {
-      name: 'videoId',
       allowNull: false
     },
     onDelete: 'CASCADE'
   })
-}
+  Video: VideoModel
 
-// ------------------------------ METHODS ------------------------------
+  static isInfohashExists (infoHash: string) {
+    const query = 'SELECT 1 FROM "videoFile" WHERE "infoHash" = $infoHash LIMIT 1'
+    const options = {
+      type: Sequelize.QueryTypes.SELECT,
+      bind: { infoHash },
+      raw: true
+    }
+
+    return VideoModel.sequelize.query(query, options)
+              .then(results => {
+                return results.length === 1
+              })
+  }
+}