X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=server%2Fmodels%2Fvideo%2Fvideo-file.ts;h=0fd868cd61a33e9a5fdf2c649bc67e65b4376245;hb=dc13348070d808d0ba3feb56a435b835c2e7e791;hp=600141994afcf2c0ae509e5472f59922038bf553;hpb=d4f1e94c89336255537b0b82913591f00e716201;p=github%2FChocobozzz%2FPeerTube.git

diff --git a/server/models/video/video-file.ts b/server/models/video/video-file.ts
index 600141994..0fd868cd6 100644
--- a/server/models/video/video-file.ts
+++ b/server/models/video/video-file.ts
@@ -1,81 +1,128 @@
-import { values } from 'lodash'
+import {
+  AllowNull,
+  BelongsTo,
+  Column,
+  CreatedAt,
+  DataType,
+  Default,
+  ForeignKey,
+  HasMany,
+  Is,
+  Model,
+  Table,
+  UpdatedAt
+} from 'sequelize-typescript'
+import {
+  isVideoFileExtnameValid,
+  isVideoFileInfoHashValid,
+  isVideoFileResolutionValid,
+  isVideoFileSizeValid,
+  isVideoFPSResolutionValid
+} from '../../helpers/custom-validators/videos'
+import { throwIfNotValid } from '../utils'
+import { VideoModel } from './video'
 import * as Sequelize from 'sequelize'
-import { isVideoFileInfoHashValid, isVideoFileResolutionValid, isVideoFileSizeValid } from '../../helpers/custom-validators/videos'
-import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import { VideoRedundancyModel } from '../redundancy/video-redundancy'
 
-import { addMethodsToModel } from '../utils'
-import { VideoFileAttributes, VideoFileInstance } from './video-file-interface'
-
-let VideoFile: Sequelize.Model<VideoFileInstance, VideoFileAttributes>
-
-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)
+  @Is('VideoFileExtname', value => throwIfNotValid(value, isVideoFileExtnameValid, 'extname'))
+  @Column
+  extname: string
+
+  @AllowNull(false)
+  @Is('VideoFileSize', value => throwIfNotValid(value, isVideoFileInfoHashValid, 'info hash'))
+  @Column
+  infoHash: string
 
-// ------------------------------ STATICS ------------------------------
+  @AllowNull(false)
+  @Default(-1)
+  @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
+
+  @HasMany(() => VideoRedundancyModel, {
+    foreignKey: {
+      allowNull: false
+    },
+    onDelete: 'CASCADE',
+    hooks: true
+  })
+  RedundancyVideos: VideoRedundancyModel[]
+
+  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
+    }
 
-// ------------------------------ METHODS ------------------------------
+    return VideoModel.sequelize.query(query, options)
+              .then(results => {
+                return results.length === 1
+              })
+  }
+
+  static loadWithVideo (id: number) {
+    const options = {
+      include: [
+        {
+          model: VideoModel.unscoped(),
+          required: true
+        }
+      ]
+    }
+
+    return VideoFileModel.findById(id, options)
+  }
+
+  hasSameUniqueKeysThan (other: VideoFileModel) {
+    return this.fps === other.fps &&
+      this.resolution === other.resolution &&
+      this.videoId === other.videoId
+  }
+}