'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)
+module.exports = function (sequelize, DataTypes) {
+ // TODO: add indexes on searchable columns
+ const Video = sequelize.define('Video',
+ {
+ id: {
+ type: DataTypes.UUID,
+ defaultValue: DataTypes.UUIDV4,
+ primaryKey: true,
+ validate: {
+ isUUID: 4
+ }
+ },
+ 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.')
+ }
+ }
+ },
+ 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,
+ listByHostAndRemoteId,
+ listOwnedAndPopulateAuthorAndTags,
+ listOwnedByAuthor,
+ load,
+ loadAndPopulateAuthor,
+ loadAndPopulateAuthorAndPodAndTags,
+ searchAndPopulateAuthorAndPodAndTags
+ },
+ instanceMethods: {
+ generateMagnetUri,
+ getVideoFilename,
+ getThumbnailName,
+ getPreviewName,
+ getTorrentName,
+ isOwned,
+ toFormatedJSON,
+ toRemoteJSON
+ },
+ hooks: {
+ beforeValidate,
+ beforeCreate,
+ afterDestroy
+ }
}
)
+ return Video
+}
+
+function beforeValidate (video, options, next) {
if (video.isOwned()) {
- tasks.push(
- function (callback) {
- removeFile(video, callback)
- },
- function (callback) {
- removeTorrent(video, callback)
- },
- function (callback) {
- removePreview(video, callback)
- }
- )
+ // 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
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)
})
})
},
}
return next()
-})
+}
-mongoose.model('Video', VideoSchema)
+function afterDestroy (video, options, next) {
+ const tasks = []
+
+ 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 = {
+ name: video.name,
+ 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'
+ })
+}
+
function generateMagnetUri () {
let baseUrlHttp, baseUrlWs
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()
xs,
announce,
urlList,
- infoHash: this.magnet.infoHash,
+ infoHash: this.infoHash,
name: this.name
}
}
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
}
function getTorrentName () {
const extension = '.torrent'
- if (this.isOwned()) return this._id + extension
+ if (this.isOwned()) return this.id + extension
return this.remoteId + extension
}
}
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,
+ tags: map(this.Tags, 'name'),
thumbnailPath: constants.STATIC_PATHS.THUMBNAILS + '/' + this.getThumbnailName(),
- createdDate: this.createdDate
+ createdAt: this.createdAt
}
return json
function toRemoteJSON (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) {
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,
- podHost: self.podHost
+ thumbnailData: thumbnailData.toString('binary'),
+ tags: map(self.Tags, 'name'),
+ createdAt: self.createdAt,
+ extname: self.extname
}
return callback(null, remoteVideo)
// ------------------------------ 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)
})
}
+function list (callback) {
+ return this.find().asCallback()
+}
+
function listForApi (start, count, sort, callback) {
- const query = {}
- return modelUtils.listForApiWithCount.call(this, query, 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 listByHostAndRemoteId (fromHost, remoteId, callback) {
- this.find({ podHost: fromHost, remoteId: remoteId }, callback)
-}
+ const query = {
+ where: {
+ remoteId: remoteId
+ },
+ include: [
+ {
+ model: this.sequelize.models.Author,
+ include: [
+ {
+ model: this.sequelize.models.Pod,
+ required: true,
+ where: {
+ host: fromHost
+ }
+ }
+ ]
+ }
+ ]
+ }
-function listByHost (fromHost, callback) {
- this.find({ podHost: fromHost }, callback)
+ return this.findAll(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 search (value, field, start, count, sort, callback) {
- const query = {}
+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 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 + '%'
+ }
+ }
+
+ query.include = [
+ authorInclude, tagInclude
+ ]
+
+ if (tagInclude.where) {
+ // query.include.push([ this.sequelize.models.Tag ])
}
- modelUtils.listForApiWithCount.call(this, query, start, count, sort, callback)
+ return this.findAndCountAll(query).asCallback(function (err, result) {
+ if (err) return callback(err)
+
+ return callback(null, result.rows, result.count)
+ })
}
// ---------------------------------------------------------------------------
projects / github / Chocobozzz / PeerTube.git / blobdiff