i18n-labelText labelText="Video import with HTTP enabled"
></my-peertube-checkbox>
+ <my-peertube-checkbox
+ inputName="importVideosTorrentEnabled" formControlName="importVideosTorrentEnabled"
+ i18n-labelText labelText="Video import with a torrent file or a magnet URI enabled"
+ ></my-peertube-checkbox>
+
<div i18n class="inner-form-title">Administrator</div>
<div class="form-group">
signupEnabled: null,
signupLimit: this.customConfigValidatorsService.SIGNUP_LIMIT,
importVideosHttpEnabled: null,
+ importVideosTorrentEnabled: null,
adminEmail: this.customConfigValidatorsService.ADMIN_EMAIL,
userVideoQuota: this.userValidatorsService.USER_VIDEO_QUOTA,
transcodingThreads: this.customConfigValidatorsService.TRANSCODING_THREADS,
videos: {
http: {
enabled: this.form.value['importVideosHttpEnabled']
+ },
+ torrent: {
+ enabled: this.form.value['importVideosTorrentEnabled']
}
}
}
transcodingEnabled: this.customConfig.transcoding.enabled,
customizationJavascript: this.customConfig.instance.customizations.javascript,
customizationCSS: this.customConfig.instance.customizations.css,
- importVideosHttpEnabled: this.customConfig.import.videos.http.enabled
+ importVideosHttpEnabled: this.customConfig.import.videos.http.enabled,
+ importVideosTorrentEnabled: this.customConfig.import.videos.torrent.enabled
}
for (const resolution of this.resolutions) {
videos: {
http: {
enabled: false
+ },
+ torrent: {
+ enabled: false
}
}
}
border-radius: 3px;
width: 100%;
min-height: 440px;
+ padding-bottom: 20px;
display: flex;
justify-content: center;
align-items: center;
}
isVideoImportTorrentEnabled () {
- return this.serverService.getConfig().import.videos.http.enabled
+ return this.serverService.getConfig().import.videos.torrent.enabled
}
}
videos:
http: # Classic HTTP or all sites supported by youtube-dl https://rg3.github.io/youtube-dl/supportedsites.html
enabled: false
+ torrent: # Magnet URI or torrent file (use classic TCP/UDP/WebSeed to download the file)
+ enabled: false
instance:
name: 'PeerTube'
videos:
http: # Classic HTTP or all sites supported by youtube-dl https://rg3.github.io/youtube-dl/supportedsites.html
enabled: false
+ torrent: # Magnet URI or torrent file (use classic TCP/UDP/WebSeed to download the file)
+ enabled: false
# Instance settings
instance:
videos:
http:
enabled: true
+ torrent:
+ enabled: true
instance:
default_nsfw_policy: 'display'
\ No newline at end of file
import { asyncMiddleware, authenticate, ensureUserHasRight } from '../../middlewares'
import { customConfigUpdateValidator } from '../../middlewares/validators/config'
import { ClientHtml } from '../../lib/client-html'
-import { CustomConfigAuditView, auditLoggerFactory } from '../../helpers/audit-logger'
+import { auditLoggerFactory, CustomConfigAuditView } from '../../helpers/audit-logger'
const packageJSON = require('../../../../package.json')
const configRouter = express.Router()
videos: {
http: {
enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
+ },
+ torrent: {
+ enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
}
}
},
videos: {
http: {
enabled: CONFIG.IMPORT.VIDEOS.HTTP.ENABLED
+ },
+ torrent: {
+ enabled: CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED
}
}
}
async function getUserVideoImports (req: express.Request, res: express.Response, next: express.NextFunction) {
const user = res.locals.oauth.token.User as UserModel
const resultList = await VideoImportModel.listUserVideoImportsForApi(
- user.Account.id,
+ user.id,
req.query.start as number,
req.query.count as number,
req.query.sort
function addVideoImport (req: express.Request, res: express.Response) {
if (req.body.targetUrl) return addYoutubeDLImport(req, res)
- const file = req.files['torrentfile'][0]
+ const file = req.files && req.files['torrentfile'] ? req.files['torrentfile'][0] : undefined
if (req.body.magnetUri || file) return addTorrentImport(req, res, file)
}
async function addTorrentImport (req: express.Request, res: express.Response, torrentfile: Express.Multer.File) {
const body: VideoImportCreate = req.body
+ const user = res.locals.oauth.token.User
let videoName: string
let torrentName: string
const videoImportAttributes = {
magnetUri,
torrentName,
- state: VideoImportState.PENDING
+ state: VideoImportState.PENDING,
+ userId: user.id
}
const videoImport: VideoImportModel = await insertIntoDB(video, res.locals.videoChannel, tags, videoImportAttributes)
async function addYoutubeDLImport (req: express.Request, res: express.Response) {
const body: VideoImportCreate = req.body
const targetUrl = body.targetUrl
+ const user = res.locals.oauth.token.User
let youtubeDLInfo: YoutubeDLInfo
try {
const tags = body.tags || youtubeDLInfo.tags
const videoImportAttributes = {
targetUrl,
- state: VideoImportState.PENDING
+ state: VideoImportState.PENDING,
+ userId: user.id
}
const videoImport: VideoImportModel = await insertIntoDB(video, res.locals.videoChannel, tags, videoImportAttributes)
// ---------------------------------------------------------------------------
-const LAST_MIGRATION_VERSION = 245
+const LAST_MIGRATION_VERSION = 240
// ---------------------------------------------------------------------------
VIDEOS: {
HTTP: {
get ENABLED () { return config.get<boolean>('import.videos.http.enabled') }
+ },
+ TORRENT: {
+ get ENABLED () { return config.get<boolean>('import.videos.torrent.enabled') }
}
}
},
+++ /dev/null
-import * as Sequelize from 'sequelize'
-import { Migration } from '../../models/migrations'
-import { CONSTRAINTS_FIELDS } from '../index'
-
-async function up (utils: {
- transaction: Sequelize.Transaction
- queryInterface: Sequelize.QueryInterface
- sequelize: Sequelize.Sequelize
-}): Promise<any> {
- {
- const data = {
- type: Sequelize.STRING,
- allowNull: true,
- defaultValue: null
- } as Migration.String
- await utils.queryInterface.changeColumn('videoImport', 'targetUrl', data)
- }
-
- {
- const data = {
- type: Sequelize.STRING(CONSTRAINTS_FIELDS.VIDEO_IMPORTS.URL.max),
- allowNull: true,
- defaultValue: null
- }
- await utils.queryInterface.addColumn('videoImport', 'magnetUri', data)
- }
-
- {
- const data = {
- type: Sequelize.STRING(CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_NAME.max),
- allowNull: true,
- defaultValue: null
- }
- await utils.queryInterface.addColumn('videoImport', 'torrentName', data)
- }
-}
-
-function down (options) {
- throw new Error('Not implemented.')
-}
-
-export { up, down }
tempVideoPath = await downloader()
// Get information about this video
+ const { size } = await statPromise(tempVideoPath)
+ const isAble = await videoImport.User.isAbleToUploadVideo({ size })
+ if (isAble === false) {
+ throw new Error('The user video quota is exceeded with this video to import.')
+ }
+
const { videoFileResolution } = await getVideoFileResolution(tempVideoPath)
const fps = await getVideoFileFPS(tempVideoPath)
- const stats = await statPromise(tempVideoPath)
const duration = await getDurationFromVideoFile(tempVideoPath)
// Create video file object in database
const videoFileData = {
extname: extname(tempVideoPath),
resolution: videoFileResolution,
- size: stats.size,
+ size,
fps,
videoId: videoImport.videoId
}
body('transcoding.resolutions.720p').isBoolean().withMessage('Should have a valid transcoding 720p resolution enabled boolean'),
body('transcoding.resolutions.1080p').isBoolean().withMessage('Should have a valid transcoding 1080p resolution enabled boolean'),
body('import.videos.http.enabled').isBoolean().withMessage('Should have a valid import video http enabled boolean'),
+ body('import.videos.torrent.enabled').isBoolean().withMessage('Should have a valid import video torrent enabled boolean'),
async (req: express.Request, res: express.Response, next: express.NextFunction) => {
logger.debug('Checking customConfigUpdateValidator parameters', { parameters: req.body })
logger.debug('Checking videoImportAddValidator parameters', { parameters: req.body })
const user = res.locals.oauth.token.User
+ const torrentFile = req.files && req.files['torrentfile'] ? req.files['torrentfile'][0] : undefined
if (areValidationErrors(req, res)) return cleanUpReqFiles(req)
- if (CONFIG.IMPORT.VIDEOS.HTTP.ENABLED !== true) {
+ if (req.body.targetUrl && CONFIG.IMPORT.VIDEOS.HTTP.ENABLED !== true) {
cleanUpReqFiles(req)
return res.status(409)
- .json({ error: 'Import is not enabled on this instance.' })
+ .json({ error: 'HTTP import is not enabled on this instance.' })
.end()
}
+ if (CONFIG.IMPORT.VIDEOS.TORRENT.ENABLED !== true && (req.body.magnetUri || torrentFile)) {
+ cleanUpReqFiles(req)
+ return res.status(409)
+ .json({ error: 'Torrent/magnet URI import is not enabled on this instance.' })
+ .end()
+ }
+
if (!await isVideoChannelOfAccountExist(req.body.channelId, user, res)) return cleanUpReqFiles(req)
// Check we have at least 1 required param
- const file = req.files['torrentfile'][0]
- if (!req.body.targetUrl && !req.body.magnetUri && !file) {
+ if (!req.body.targetUrl && !req.body.magnetUri && !torrentFile) {
cleanUpReqFiles(req)
return res.status(400)
return json
}
- isAbleToUploadVideo (videoFile: Express.Multer.File) {
+ isAbleToUploadVideo (videoFile: { size: number }) {
if (this.videoQuota === -1) return Promise.resolve(true)
return UserModel.getOriginalVideoFileTotalFromUser(this)
} from 'sequelize-typescript'
import { CONSTRAINTS_FIELDS, VIDEO_IMPORT_STATES } from '../../initializers'
import { getSort, throwIfNotValid } from '../utils'
-import { VideoModel } from './video'
+import { ScopeNames as VideoModelScopeNames, VideoModel } from './video'
import { isVideoImportStateValid, isVideoImportTargetUrlValid } from '../../helpers/custom-validators/video-imports'
import { VideoImport, VideoImportState } from '../../../shared'
-import { VideoChannelModel } from './video-channel'
-import { AccountModel } from '../account/account'
-import { TagModel } from './tag'
import { isVideoMagnetUriValid } from '../../helpers/custom-validators/videos'
+import { UserModel } from '../account/user'
@DefaultScope({
include: [
{
- model: () => VideoModel,
- required: false,
- include: [
- {
- model: () => VideoChannelModel,
- required: true,
- include: [
- {
- model: () => AccountModel,
- required: true
- }
- ]
- },
- {
- model: () => TagModel
- }
- ]
+ model: () => UserModel.unscoped(),
+ required: true
+ },
+ {
+ model: () => VideoModel.scope([ VideoModelScopeNames.WITH_ACCOUNT_DETAILS, VideoModelScopeNames.WITH_TAGS]),
+ required: false
}
]
})
{
fields: [ 'videoId' ],
unique: true
+ },
+ {
+ fields: [ 'userId' ]
}
]
})
@Column(DataType.TEXT)
error: string
+ @ForeignKey(() => UserModel)
+ @Column
+ userId: number
+
+ @BelongsTo(() => UserModel, {
+ foreignKey: {
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ User: UserModel
+
@ForeignKey(() => VideoModel)
@Column
videoId: number
return VideoImportModel.findById(id)
}
- static listUserVideoImportsForApi (accountId: number, start: number, count: number, sort: string) {
+ static listUserVideoImportsForApi (userId: number, start: number, count: number, sort: string) {
const query = {
distinct: true,
- offset: start,
- limit: count,
- order: getSort(sort),
include: [
{
- model: VideoModel,
- required: false,
- include: [
- {
- model: VideoChannelModel,
- required: true,
- include: [
- {
- model: AccountModel,
- required: true,
- where: {
- id: accountId
- }
- }
- ]
- },
- {
- model: TagModel,
- required: false
- }
- ]
+ model: UserModel.unscoped(), // FIXME: Without this, sequelize try to COUNT(DISTINCT(*)) which is an invalid SQL query
+ required: true
}
- ]
+ ],
+ offset: start,
+ limit: count,
+ order: getSort(sort),
+ where: {
+ userId
+ }
}
- return VideoImportModel.unscoped()
- .findAndCountAll(query)
+ return VideoImportModel.findAndCountAll(query)
.then(({ rows, count }) => {
return {
data: rows,
videos: {
http: {
enabled: false
+ },
+ torrent: {
+ enabled: false
}
}
}
expect(data.transcoding.resolutions['720p']).to.be.true
expect(data.transcoding.resolutions['1080p']).to.be.true
expect(data.import.videos.http.enabled).to.be.true
+ expect(data.import.videos.torrent.enabled).to.be.true
}
function checkUpdatedConfig (data: CustomConfig) {
expect(data.transcoding.resolutions['720p']).to.be.false
expect(data.transcoding.resolutions['1080p']).to.be.false
expect(data.import.videos.http.enabled).to.be.false
+ expect(data.import.videos.torrent.enabled).to.be.false
}
describe('Test config', function () {
videos: {
http: {
enabled: false
+ },
+ torrent: {
+ enabled: false
}
}
}
videos: {
http: {
enabled: false
+ },
+ torrent: {
+ enabled: false
}
}
}
videos: {
http: {
enabled: boolean
+ },
+ torrent: {
+ enabled: boolean
}
}
}
http: {
enabled: boolean
}
+ torrent: {
+ enabled: boolean
+ }
}
}
projects / github / Chocobozzz / PeerTube.git / commitdiff
