1 files changed, 403 insertions, 129 deletions

diff --git a/server/models/video.js b/server/models/video.js
index 330067cdf..17eff6428 100644
--- a/server/models/video.js
+++ b/server/models/video.js
@@ -1,108 +1,160 @@
 'use strict'
 
+const Buffer = require('safe-buffer').Buffer
 const createTorrent = require('create-torrent')
 const ffmpeg = require('fluent-ffmpeg')
 const fs = require('fs')
 const magnetUtil = require('magnet-uri')
+const map = require('lodash/map')
 const parallel = require('async/parallel')
 const parseTorrent = require('parse-torrent')
 const pathUtils = require('path')
-const mongoose = require('mongoose')
+const values = require('lodash/values')
 
 const constants = require('../initializers/constants')
-const customVideosValidators = require('../helpers/custom-validators').videos
 const logger = require('../helpers/logger')
+const friends = require('../lib/friends')
 const modelUtils = require('./utils')
+const customVideosValidators = require('../helpers/custom-validators').videos
 
 // ---------------------------------------------------------------------------
 
-// TODO: add indexes on searchable columns
-const VideoSchema = mongoose.Schema({
-  name: String,
-  extname: {
-    type: String,
-    enum: [ '.mp4', '.webm', '.ogv' ]
-  },
-  remoteId: mongoose.Schema.Types.ObjectId,
-  description: String,
-  magnet: {
-    infoHash: String
-  },
-  podHost: String,
-  author: String,
-  duration: Number,
-  tags: [ String ],
-  createdDate: {
-    type: Date,
-    default: Date.now
-  }
-})
-
-VideoSchema.path('name').validate(customVideosValidators.isVideoNameValid)
-VideoSchema.path('description').validate(customVideosValidators.isVideoDescriptionValid)
-VideoSchema.path('podHost').validate(customVideosValidators.isVideoPodHostValid)
-VideoSchema.path('author').validate(customVideosValidators.isVideoAuthorValid)
-VideoSchema.path('duration').validate(customVideosValidators.isVideoDurationValid)
-VideoSchema.path('tags').validate(customVideosValidators.isVideoTagsValid)
-
-VideoSchema.methods = {
-  generateMagnetUri,
-  getVideoFilename,
-  getThumbnailName,
-  getPreviewName,
-  getTorrentName,
-  isOwned,
-  toFormatedJSON,
-  toRemoteJSON
-}
-
-VideoSchema.statics = {
-  generateThumbnailFromBase64,
-  getDurationFromFile,
-  listForApi,
-  listByHostAndRemoteId,
-  listByHost,
-  listOwned,
-  listOwnedByAuthor,
-  listRemotes,
-  load,
-  search
-}
-
-VideoSchema.pre('remove', function (next) {
-  const video = this
-  const tasks = []
-
-  tasks.push(
-    function (callback) {
-      removeThumbnail(video, callback)
-    }
-  )
-
-  if (video.isOwned()) {
-    tasks.push(
-      function (callback) {
-        removeFile(video, callback)
+module.exports = function (sequelize, DataTypes) {
+  const Video = sequelize.define('Video',
+    {
+      id: {
+        type: DataTypes.UUID,
+        defaultValue: DataTypes.UUIDV4,
+        primaryKey: true,
+        validate: {
+          isUUID: 4
+        }
       },
-      function (callback) {
-        removeTorrent(video, callback)
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          nameValid: function (value) {
+            const res = customVideosValidators.isVideoNameValid(value)
+            if (res === false) throw new Error('Video name is not valid.')
+          }
+        }
       },
-      function (callback) {
-        removePreview(video, callback)
+      extname: {
+        type: DataTypes.ENUM(values(constants.CONSTRAINTS_FIELDS.VIDEOS.EXTNAME)),
+        allowNull: false
+      },
+      remoteId: {
+        type: DataTypes.UUID,
+        allowNull: true,
+        validate: {
+          isUUID: 4
+        }
+      },
+      description: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          descriptionValid: function (value) {
+            const res = customVideosValidators.isVideoDescriptionValid(value)
+            if (res === false) throw new Error('Video description is not valid.')
+          }
+        }
+      },
+      infoHash: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        validate: {
+          infoHashValid: function (value) {
+            const res = customVideosValidators.isVideoInfoHashValid(value)
+            if (res === false) throw new Error('Video info hash is not valid.')
+          }
+        }
+      },
+      duration: {
+        type: DataTypes.INTEGER,
+        allowNull: false,
+        validate: {
+          durationValid: function (value) {
+            const res = customVideosValidators.isVideoDurationValid(value)
+            if (res === false) throw new Error('Video duration is not valid.')
+          }
+        }
       }
-    )
+    },
+    {
+      indexes: [
+        {
+          fields: [ 'authorId' ]
+        },
+        {
+          fields: [ 'remoteId' ]
+        },
+        {
+          fields: [ 'name' ]
+        },
+        {
+          fields: [ 'createdAt' ]
+        },
+        {
+          fields: [ 'duration' ]
+        },
+        {
+          fields: [ 'infoHash' ]
+        }
+      ],
+      classMethods: {
+        associate,
+
+        generateThumbnailFromData,
+        getDurationFromFile,
+        list,
+        listForApi,
+        listOwnedAndPopulateAuthorAndTags,
+        listOwnedByAuthor,
+        load,
+        loadByHostAndRemoteId,
+        loadAndPopulateAuthor,
+        loadAndPopulateAuthorAndPodAndTags,
+        searchAndPopulateAuthorAndPodAndTags
+      },
+      instanceMethods: {
+        generateMagnetUri,
+        getVideoFilename,
+        getThumbnailName,
+        getPreviewName,
+        getTorrentName,
+        isOwned,
+        toFormatedJSON,
+        toAddRemoteJSON,
+        toUpdateRemoteJSON
+      },
+      hooks: {
+        beforeValidate,
+        beforeCreate,
+        afterDestroy
+      }
+    }
+  )
+
+  return Video
+}
+
+function beforeValidate (video, options, next) {
+  // Put a fake infoHash if it does not exists yet
+  if (video.isOwned() && !video.infoHash) {
+    // 40 hexa length
+    video.infoHash = '0123456789abcdef0123456789abcdef01234567'
   }
 
-  parallel(tasks, next)
-})
+  return next(null)
+}
 
-VideoSchema.pre('save', function (next) {
-  const video = this
+function beforeCreate (video, options, next) {
   const tasks = []
 
   if (video.isOwned()) {
     const videoPath = pathUtils.join(constants.CONFIG.STORAGE.VIDEOS_DIR, video.getVideoFilename())
-    this.podHost = constants.CONFIG.WEBSERVER.HOST
 
     tasks.push(
       // TODO: refractoring
@@ -123,9 +175,8 @@ VideoSchema.pre('save', function (next) {
             if (err) return callback(err)
 
             const parsedTorrent = parseTorrent(torrent)
-            video.magnet.infoHash = parsedTorrent.infoHash
-
-            callback(null)
+            video.set('infoHash', parsedTorrent.infoHash)
+            video.validate().asCallback(callback)
           })
         })
       },
@@ -141,12 +192,72 @@ VideoSchema.pre('save', function (next) {
   }
 
   return next()
-})
+}
+
+function afterDestroy (video, options, next) {
+  const tasks = []
 
-mongoose.model('Video', VideoSchema)
+  tasks.push(
+    function (callback) {
+      removeThumbnail(video, callback)
+    }
+  )
+
+  if (video.isOwned()) {
+    tasks.push(
+      function (callback) {
+        removeFile(video, callback)
+      },
+
+      function (callback) {
+        removeTorrent(video, callback)
+      },
+
+      function (callback) {
+        removePreview(video, callback)
+      },
+
+      function (callback) {
+        const params = {
+          remoteId: video.id
+        }
+
+        friends.removeVideoToFriends(params)
+
+        return callback()
+      }
+    )
+  }
+
+  parallel(tasks, next)
+}
 
 // ------------------------------ METHODS ------------------------------
 
+function associate (models) {
+  this.belongsTo(models.Author, {
+    foreignKey: {
+      name: 'authorId',
+      allowNull: false
+    },
+    onDelete: 'cascade'
+  })
+
+  this.belongsToMany(models.Tag, {
+    foreignKey: 'videoId',
+    through: models.VideoTag,
+    onDelete: 'cascade'
+  })
+
+  this.hasMany(models.VideoAbuse, {
+    foreignKey: {
+      name: 'videoId',
+      allowNull: false
+    },
+    onDelete: 'cascade'
+  })
+}
+
 function generateMagnetUri () {
   let baseUrlHttp, baseUrlWs
 
@@ -154,8 +265,8 @@ function generateMagnetUri () {
     baseUrlHttp = constants.CONFIG.WEBSERVER.URL
     baseUrlWs = constants.CONFIG.WEBSERVER.WS + '://' + constants.CONFIG.WEBSERVER.HOSTNAME + ':' + constants.CONFIG.WEBSERVER.PORT
   } else {
-    baseUrlHttp = constants.REMOTE_SCHEME.HTTP + '://' + this.podHost
-    baseUrlWs = constants.REMOTE_SCHEME.WS + '://' + this.podHost
+    baseUrlHttp = constants.REMOTE_SCHEME.HTTP + '://' + this.Author.Pod.host
+    baseUrlWs = constants.REMOTE_SCHEME.WS + '://' + this.Author.Pod.host
   }
 
   const xs = baseUrlHttp + constants.STATIC_PATHS.TORRENTS + this.getTorrentName()
@@ -166,7 +277,7 @@ function generateMagnetUri () {
     xs,
     announce,
     urlList,
-    infoHash: this.magnet.infoHash,
+    infoHash: this.infoHash,
     name: this.name
   }
 
@@ -174,20 +285,20 @@ function generateMagnetUri () {
 }
 
 function getVideoFilename () {
-  if (this.isOwned()) return this._id + this.extname
+  if (this.isOwned()) return this.id + this.extname
 
   return this.remoteId + this.extname
 }
 
 function getThumbnailName () {
   // We always have a copy of the thumbnail
-  return this._id + '.jpg'
+  return this.id + '.jpg'
 }
 
 function getPreviewName () {
   const extension = '.jpg'
 
-  if (this.isOwned()) return this._id + extension
+  if (this.isOwned()) return this.id + extension
 
   return this.remoteId + extension
 }
@@ -195,7 +306,7 @@ function getPreviewName () {
 function getTorrentName () {
   const extension = '.torrent'
 
-  if (this.isOwned()) return this._id + extension
+  if (this.isOwned()) return this.id + extension
 
   return this.remoteId + extension
 }
@@ -205,27 +316,37 @@ function isOwned () {
 }
 
 function toFormatedJSON () {
+  let podHost
+
+  if (this.Author.Pod) {
+    podHost = this.Author.Pod.host
+  } else {
+    // It means it's our video
+    podHost = constants.CONFIG.WEBSERVER.HOST
+  }
+
   const json = {
-    id: this._id,
+    id: this.id,
     name: this.name,
     description: this.description,
-    podHost: this.podHost,
+    podHost,
     isLocal: this.isOwned(),
     magnetUri: this.generateMagnetUri(),
-    author: this.author,
+    author: this.Author.name,
     duration: this.duration,
-    tags: this.tags,
-    thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.getThumbnailName(),
-    createdDate: this.createdDate
+    tags: map(this.Tags, 'name'),
+    thumbnailPath: pathUtils.join(constants.STATIC_PATHS.THUMBNAILS, this.getThumbnailName()),
+    createdAt: this.createdAt,
+    updatedAt: this.updatedAt
   }
 
   return json
 }
 
-function toRemoteJSON (callback) {
+function toAddRemoteJSON (callback) {
   const self = this
 
-  // Convert thumbnail to base64
+  // Get thumbnail data to send to the other pod
   const thumbnailPath = pathUtils.join(constants.CONFIG.STORAGE.THUMBNAILS_DIR, this.getThumbnailName())
   fs.readFile(thumbnailPath, function (err, thumbnailData) {
     if (err) {
@@ -236,13 +357,14 @@ function toRemoteJSON (callback) {
     const remoteVideo = {
       name: self.name,
       description: self.description,
-      magnet: self.magnet,
-      remoteId: self._id,
-      author: self.author,
+      infoHash: self.infoHash,
+      remoteId: self.id,
+      author: self.Author.name,
       duration: self.duration,
-      thumbnailBase64: new Buffer(thumbnailData).toString('base64'),
-      tags: self.tags,
-      createdDate: self.createdDate,
+      thumbnailData: thumbnailData.toString('binary'),
+      tags: map(self.Tags, 'name'),
+      createdAt: self.createdAt,
+      updatedAt: self.updatedAt,
       extname: self.extname
     }
 
@@ -250,14 +372,31 @@ function toRemoteJSON (callback) {
   })
 }
 
+function toUpdateRemoteJSON (callback) {
+  const json = {
+    name: this.name,
+    description: this.description,
+    infoHash: this.infoHash,
+    remoteId: this.id,
+    author: this.Author.name,
+    duration: this.duration,
+    tags: map(this.Tags, 'name'),
+    createdAt: this.createdAt,
+    updatedAt: this.updatedAt,
+    extname: this.extname
+  }
+
+  return json
+}
+
 // ------------------------------ STATICS ------------------------------
 
-function generateThumbnailFromBase64 (video, thumbnailData, callback) {
+function generateThumbnailFromData (video, thumbnailData, callback) {
   // Creating the thumbnail for a remote video
 
   const thumbnailName = video.getThumbnailName()
   const thumbnailPath = constants.CONFIG.STORAGE.THUMBNAILS_DIR + thumbnailName
-  fs.writeFile(thumbnailPath, thumbnailData, { encoding: 'base64' }, function (err) {
+  fs.writeFile(thumbnailPath, Buffer.from(thumbnailData, 'binary'), function (err) {
     if (err) return callback(err)
 
     return callback(null, thumbnailName)
@@ -272,51 +411,186 @@ function getDurationFromFile (videoPath, callback) {
   })
 }
 
-function listForApi (start, count, sort, callback) {
-  const query = {}
-  return modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
+function list (callback) {
+  return this.find().asCallback()
 }
 
-function listByHostAndRemoteId (fromHost, remoteId, callback) {
-  this.find({ podHost: fromHost, remoteId: remoteId }, callback)
+function listForApi (start, count, sort, callback) {
+  const query = {
+    offset: start,
+    limit: count,
+    distinct: true, // For the count, a video can have many tags
+    order: [ modelUtils.getSort(sort), [ this.sequelize.models.Tag, 'name', 'ASC' ] ],
+    include: [
+      {
+        model: this.sequelize.models.Author,
+        include: [ { model: this.sequelize.models.Pod, required: false } ]
+      },
+
+      this.sequelize.models.Tag
+    ]
+  }
+
+  return this.findAndCountAll(query).asCallback(function (err, result) {
+    if (err) return callback(err)
+
+    return callback(null, result.rows, result.count)
+  })
 }
 
-function listByHost (fromHost, callback) {
-  this.find({ podHost: fromHost }, callback)
+function loadByHostAndRemoteId (fromHost, remoteId, callback) {
+  const query = {
+    where: {
+      remoteId: remoteId
+    },
+    include: [
+      {
+        model: this.sequelize.models.Author,
+        include: [
+          {
+            model: this.sequelize.models.Pod,
+            required: true,
+            where: {
+              host: fromHost
+            }
+          }
+        ]
+      }
+    ]
+  }
+
+  return this.findOne(query).asCallback(callback)
 }
 
-function listOwned (callback) {
+function listOwnedAndPopulateAuthorAndTags (callback) {
   // If remoteId is null this is *our* video
-  this.find({ remoteId: null }, callback)
+  const query = {
+    where: {
+      remoteId: null
+    },
+    include: [ this.sequelize.models.Author, this.sequelize.models.Tag ]
+  }
+
+  return this.findAll(query).asCallback(callback)
 }
 
 function listOwnedByAuthor (author, callback) {
-  this.find({ remoteId: null, author: author }, callback)
-}
+  const query = {
+    where: {
+      remoteId: null
+    },
+    include: [
+      {
+        model: this.sequelize.models.Author,
+        where: {
+          name: author
+        }
+      }
+    ]
+  }
 
-function listRemotes (callback) {
-  this.find({ remoteId: { $ne: null } }, callback)
+  return this.findAll(query).asCallback(callback)
 }
 
 function load (id, callback) {
-  this.findById(id, callback)
+  return this.findById(id).asCallback(callback)
+}
+
+function loadAndPopulateAuthor (id, callback) {
+  const options = {
+    include: [ this.sequelize.models.Author ]
+  }
+
+  return this.findById(id, options).asCallback(callback)
+}
+
+function loadAndPopulateAuthorAndPodAndTags (id, callback) {
+  const options = {
+    include: [
+      {
+        model: this.sequelize.models.Author,
+        include: [ { model: this.sequelize.models.Pod, required: false } ]
+      },
+      this.sequelize.models.Tag
+    ]
+  }
+
+  return this.findById(id, options).asCallback(callback)
 }
 
-function search (value, field, start, count, sort, callback) {
-  const query = {}
+function searchAndPopulateAuthorAndPodAndTags (value, field, start, count, sort, callback) {
+  const podInclude = {
+    model: this.sequelize.models.Pod,
+    required: false
+  }
+
+  const authorInclude = {
+    model: this.sequelize.models.Author,
+    include: [
+      podInclude
+    ]
+  }
+
+  const tagInclude = {
+    model: this.sequelize.models.Tag
+  }
+
+  const query = {
+    where: {},
+    offset: start,
+    limit: count,
+    distinct: true, // For the count, a video can have many tags
+    order: [ modelUtils.getSort(sort), [ this.sequelize.models.Tag, 'name', 'ASC' ] ]
+  }
+
   // Make an exact search with the magnet
   if (field === 'magnetUri') {
     const infoHash = magnetUtil.decode(value).infoHash
-    query.magnet = {
-      infoHash
-    }
+    query.where.infoHash = infoHash
   } else if (field === 'tags') {
-    query[field] = value
+    const escapedValue = this.sequelize.escape('%' + value + '%')
+    query.where = {
+      id: {
+        $in: this.sequelize.literal(
+          '(SELECT "VideoTags"."videoId" FROM "Tags" INNER JOIN "VideoTags" ON "Tags"."id" = "VideoTags"."tagId" WHERE name LIKE ' + escapedValue + ')'
+        )
+      }
+    }
+  } else if (field === 'host') {
+    // FIXME: Include our pod? (not stored in the database)
+    podInclude.where = {
+      host: {
+        $like: '%' + value + '%'
+      }
+    }
+    podInclude.required = true
+  } else if (field === 'author') {
+    authorInclude.where = {
+      name: {
+        $like: '%' + value + '%'
+      }
+    }
+
+    // authorInclude.or = true
   } else {
-    query[field] = new RegExp(value, 'i')
+    query.where[field] = {
+      $like: '%' + value + '%'
+    }
   }
 
-  modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
+  query.include = [
+    authorInclude, tagInclude
+  ]
+
+  if (tagInclude.where) {
+    // query.include.push([ this.sequelize.models.Tag ])
+  }
+
+  return this.findAndCountAll(query).asCallback(function (err, result) {
+    if (err) return callback(err)
+
+    return callback(null, result.rows, result.count)
+  })
 }
 
 // ---------------------------------------------------------------------------