<ng-template pTemplate="header">
<tr>
- <th style="width: 10%"><my-global-icon iconName="columns"></my-global-icon></th>
+ <th style="width: 10%"></th>
<th style="width: 25%" i18n pSortableColumn="externalChannelUrl">External Channel <p-sortIcon field="externalChannelUrl"></p-sortIcon></th>
<th style="width: 25%" i18n pSortableColumn="videoChannel">Channel <p-sortIcon field="videoChannel"></p-sortIcon></th>
<th style="width: 10%" i18n pSortableColumn="state">State <p-sortIcon field="state"></p-sortIcon></th>
<th style="width: 10%" i18n pSortableColumn="createdAt">Created <p-sortIcon field="createdAt"></p-sortIcon></th>
<th style="width: 10%" i18n pSortableColumn="lastSyncAt">Last synchronization at <p-sortIcon field="lastSyncAt"></p-sortIcon></th>
+ <th></th>
</tr>
</ng-template>
<td>{{ videoChannelSync.createdAt | date: 'short' }}</td>
<td>{{ videoChannelSync.lastSyncAt | date: 'short' }}</td>
+
+ <td>
+ <a i18n routerLink="/my-library/video-imports" [queryParams]="{ search: 'videoChannelSyncId:' + videoChannelSync.id }" class="peertube-button-link grey-button">
+ List imports
+ </a>
+ </td>
</tr>
</ng-template>
</p-table>
}
fullySynchronize (videoChannelSync: VideoChannelSync) {
- this.videoChannelService.importVideos(videoChannelSync.channel.name, videoChannelSync.externalChannelUrl)
+ this.videoChannelService.importVideos(videoChannelSync.channel.name, videoChannelSync.externalChannelUrl, videoChannelSync.id)
.subscribe({
next: () => {
this.notifier.success($localize`Full synchronization requested successfully for ${videoChannelSync.channel.displayName}.`)
this.videoChannelSyncService.createSync(videoChannelSyncCreate)
.pipe(mergeMap(({ videoChannelSync }) => {
return importExistingVideos
- ? this.videoChannelService.importVideos(videoChannelSync.channel.name, videoChannelSync.externalChannelUrl)
+ ? this.videoChannelService.importVideos(videoChannelSync.channel.name, videoChannelSync.externalChannelUrl, videoChannelSync.id)
: Promise.resolve(null)
}))
.subscribe({
<ng-container i18n>My imports</ng-container>
</h1>
+<div class="mb-4 d-flex justify-content-between">
+ <my-advanced-input-filter (search)="onSearch($event)"></my-advanced-input-filter>
+
+ <a routerLink="/my-library/video-channel-syncs" class="button-link">
+ <my-global-icon iconName="repeat" aria-hidden="true"></my-global-icon>
+ <ng-container i18n>My synchronizations</ng-container>
+ </a>
+</div>
+
<p-table
[value]="videoImports" [lazy]="true" [paginator]="totalRecords > 0" [totalRecords]="totalRecords" [rows]="rowsPerPage" [first]="pagination.start"
- [rowsPerPageOptions]="rowsPerPageOptions" [sortField]="sort.field" [sortOrder]="sort.order" (onLazyLoad)="loadLazy($event)" dataKey="id"
+ [rowsPerPageOptions]="rowsPerPageOptions" [sortField]="sort.field" [sortOrder]="sort.order" (onLazyLoad)="loadLazy($event)" [lazyLoadOnInit]="false" dataKey="id"
[showCurrentPageReport]="true" i18n-currentPageReportTemplate
currentPageReportTemplate="Showing {{'{first}'}} to {{'{last}'}} of {{'{totalRecords}'}} imports"
[expandedRowKeys]="expandedRows"
.video-import-error {
color: #ff0000;
}
+
+.button-link {
+ @include peertube-button-link;
+ @include grey-button;
+ @include button-with-icon(18px, 3px, -1px);
+}
switch (state) {
case VideoImportState.FAILED:
return 'badge-red'
+
case VideoImportState.REJECTED:
return 'badge-banned'
+
case VideoImportState.PENDING:
return 'badge-yellow'
+
case VideoImportState.PROCESSING:
return 'badge-blue'
+
default:
return 'badge-green'
}
}
protected reloadData () {
- this.videoImportService.getMyVideoImports(this.pagination, this.sort)
+ this.videoImportService.getMyVideoImports(this.pagination, this.sort, this.search)
.subscribe({
next: resultList => {
this.videoImports = resultList.data
import { HttpClient, HttpParams } from '@angular/common/http'
import { Injectable } from '@angular/core'
import { ComponentPaginationLight, RestExtractor, RestService } from '@app/core'
-import { ActorImage, ResultList, VideoChannel as VideoChannelServer, VideoChannelCreate, VideoChannelUpdate } from '@shared/models'
+import {
+ ActorImage,
+ ResultList,
+ VideoChannel as VideoChannelServer,
+ VideoChannelCreate,
+ VideoChannelUpdate,
+ VideosImportInChannelCreate
+} from '@shared/models'
import { environment } from '../../../../environments/environment'
import { Account } from '../account'
import { AccountService } from '../account/account.service'
.pipe(catchError(err => this.restExtractor.handleError(err)))
}
- importVideos (videoChannelName: string, externalChannelUrl: string) {
+ importVideos (videoChannelName: string, externalChannelUrl: string, syncId?: number) {
const path = VideoChannelService.BASE_VIDEO_CHANNEL_URL + videoChannelName + '/import-videos'
- return this.authHttp.post(path, { externalChannelUrl })
+
+ const body: VideosImportInChannelCreate = {
+ externalChannelUrl,
+ videoChannelSyncId: syncId
+ }
+
+ return this.authHttp.post(path, body)
.pipe(catchError(err => this.restExtractor.handleError(err)))
}
}
.pipe(catchError(res => this.restExtractor.handleError(res)))
}
- getMyVideoImports (pagination: RestPagination, sort: SortMeta): Observable<ResultList<VideoImport>> {
+ getMyVideoImports (pagination: RestPagination, sort: SortMeta, search?: string): Observable<ResultList<VideoImport>> {
let params = new HttpParams()
params = this.restService.addRestGetParams(params, pagination, sort)
+ if (search) {
+ const filters = this.restService.parseQueryStringFilter(search, {
+ videoChannelSyncId: {
+ prefix: 'videoChannelSyncId:'
+ },
+ targetUrl: {
+ prefix: 'targetUrl:'
+ }
+ })
+
+ params = this.restService.addObjectParams(params, filters)
+ }
+
return this.authHttp
.get<ResultList<VideoImport>>(UserService.BASE_USERS_URL + '/me/videos/imports', { params })
.pipe(
usersUpdateMeValidator,
usersVideoRatingValidator
} from '../../../middlewares'
-import { deleteMeValidator, usersVideosValidator, videoImportsSortValidator, videosSortValidator } from '../../../middlewares/validators'
+import {
+ deleteMeValidator,
+ getMyVideoImportsValidator,
+ usersVideosValidator,
+ videoImportsSortValidator,
+ videosSortValidator
+} from '../../../middlewares/validators'
import { updateAvatarValidator } from '../../../middlewares/validators/actor-image'
import { AccountModel } from '../../../models/account/account'
import { AccountVideoRateModel } from '../../../models/account/account-video-rate'
videoImportsSortValidator,
setDefaultSort,
setDefaultPagination,
+ getMyVideoImportsValidator,
asyncMiddleware(getUserVideoImports)
)
const resultList = await VideoImportModel.listUserVideoImportsForApi({
userId: user.id,
- ...pick(req.query, [ 'targetUrl', 'start', 'count', 'sort' ])
+ ...pick(req.query, [ 'targetUrl', 'start', 'count', 'sort', 'search', 'videoChannelSyncId' ])
})
return res.json(getFormattedObjects(resultList.data, resultList.total))
import { getServerActor } from '@server/models/application/application'
import { guessAdditionalAttributesFromQuery } from '@server/models/video/formatter/video-format-utils'
import { MChannelBannerAccountDefault } from '@server/types/models'
-import { ActorImageType, HttpStatusCode, VideoChannelCreate, VideoChannelUpdate } from '@shared/models'
+import { ActorImageType, HttpStatusCode, VideoChannelCreate, VideoChannelUpdate, VideosImportInChannelCreate } from '@shared/models'
import { auditLoggerFactory, getAuditIdFromRes, VideoChannelAuditView } from '../../helpers/audit-logger'
import { resetSequelizeInstance } from '../../helpers/database-utils'
import { buildNSFWFilter, createReqFiles, getCountVideos, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
videoChannelRouter.post('/:nameWithHost/import-videos',
authenticate,
asyncMiddleware(videoChannelsNameWithHostValidator),
- videoChannelImportVideosValidator,
+ asyncMiddleware(videoChannelImportVideosValidator),
ensureIsLocalChannel,
ensureCanManageChannel,
asyncMiddleware(ensureChannelOwnerCanUpload),
}
async function importVideosInChannel (req: express.Request, res: express.Response) {
- const { externalChannelUrl } = req.body
+ const { externalChannelUrl } = req.body as VideosImportInChannelCreate
await JobQueue.Instance.createJob({
type: 'video-channel-import',
payload: {
externalChannelUrl,
- videoChannelId: res.locals.videoChannel.id
+ videoChannelId: res.locals.videoChannel.id,
+ partOfChannelSyncId: res.locals.videoChannelSync?.id
}
})
// ---------------------------------------------------------------------------
-const LAST_MIGRATION_VERSION = 730
+const LAST_MIGRATION_VERSION = 735
// ---------------------------------------------------------------------------
--- /dev/null
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+ transaction: Sequelize.Transaction
+ queryInterface: Sequelize.QueryInterface
+ sequelize: Sequelize.Sequelize
+ db: any
+}): Promise<void> {
+ await utils.queryInterface.addColumn('videoImport', 'videoChannelSyncId', {
+ type: Sequelize.INTEGER,
+ defaultValue: null,
+ allowNull: true,
+ references: {
+ model: 'videoChannelSync',
+ key: 'id'
+ },
+ onUpdate: 'CASCADE',
+ onDelete: 'SET NULL'
+ }, { transaction: utils.transaction })
+}
+
+async function down (utils: {
+ queryInterface: Sequelize.QueryInterface
+ transaction: Sequelize.Transaction
+}) {
+ await utils.queryInterface.dropTable('videoChannelSync', { transaction: utils.transaction })
+}
+
+export {
+ up,
+ down
+}
import { CONFIG } from '@server/initializers/config'
import { synchronizeChannel } from '@server/lib/sync-channel'
import { VideoChannelModel } from '@server/models/video/video-channel'
+import { VideoChannelSyncModel } from '@server/models/video/video-channel-sync'
+import { MChannelSync } from '@server/types/models'
import { VideoChannelImportPayload } from '@shared/models'
export async function processVideoChannelImport (job: Job) {
// Channel import requires only http upload to be allowed
if (!CONFIG.IMPORT.VIDEOS.HTTP.ENABLED) {
- logger.error('Cannot import channel as the HTTP upload is disabled')
- return
+ throw new Error('Cannot import channel as the HTTP upload is disabled')
}
if (!CONFIG.IMPORT.VIDEO_CHANNEL_SYNCHRONIZATION.ENABLED) {
- logger.error('Cannot import channel as the synchronization is disabled')
- return
+ throw new Error('Cannot import channel as the synchronization is disabled')
+ }
+
+ let channelSync: MChannelSync
+ if (payload.partOfChannelSyncId) {
+ channelSync = await VideoChannelSyncModel.loadWithChannel(payload.partOfChannelSyncId)
+
+ if (!channelSync) {
+ throw new Error('Unlnown channel sync specified in videos channel import')
+ }
}
const videoChannel = await VideoChannelModel.loadAndPopulateAccount(payload.videoChannelId)
await synchronizeChannel({
channel: videoChannel,
- externalChannelUrl: payload.externalChannelUrl
+ externalChannelUrl: payload.externalChannelUrl,
+ channelSync
})
} catch (err) {
logger.error(`Failed to import channel ${videoChannel.name}`, { err })
const onlyAfter = sync.lastSyncAt || sync.createdAt
- sync.state = VideoChannelSyncState.PROCESSING
- sync.lastSyncAt = new Date()
- await sync.save()
-
await synchronizeChannel({
channel,
externalChannelUrl: sync.externalChannelUrl,
}) {
const { channel, externalChannelUrl, videosCountLimit, onlyAfter, channelSync } = options
+ if (channelSync) {
+ channelSync.state = VideoChannelSyncState.PROCESSING
+ channelSync.lastSyncAt = new Date()
+ await channelSync.save()
+ }
+
const user = await UserModel.loadByChannelActorId(channel.actorId)
const youtubeDL = new YoutubeDLWrapper(
externalChannelUrl,
children.push(job)
}
+ // Will update the channel sync status
const parent: CreateJobArgument = {
type: 'after-video-channel-import',
payload: {
videoImportAttributes: {
targetUrl,
state: VideoImportState.PENDING,
- userId: user.id
+ userId: user.id,
+ videoChannelSyncId: channelSync?.id
}
})
export * from './video-blacklists'
export * from './video-captions'
export * from './video-channels'
+export * from './video-channel-syncs'
export * from './video-comments'
export * from './video-imports'
export * from './video-ownerships'
--- /dev/null
+import express from 'express'
+import { VideoChannelSyncModel } from '@server/models/video/video-channel-sync'
+import { HttpStatusCode } from '@shared/models'
+
+async function doesVideoChannelSyncIdExist (id: number, res: express.Response) {
+ const sync = await VideoChannelSyncModel.loadWithChannel(+id)
+
+ if (!sync) {
+ res.fail({
+ status: HttpStatusCode.NOT_FOUND_404,
+ message: 'Video channel sync not found'
+ })
+ return false
+ }
+
+ res.locals.videoChannelSync = sync
+ return true
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ doesVideoChannelSyncIdExist
+}
import { isUrlValid } from '@server/helpers/custom-validators/activitypub/misc'
import { logger } from '@server/helpers/logger'
import { CONFIG } from '@server/initializers/config'
-import { VideoChannelModel } from '@server/models/video/video-channel'
import { VideoChannelSyncModel } from '@server/models/video/video-channel-sync'
import { HttpStatusCode, VideoChannelSyncCreate } from '@shared/models'
import { areValidationErrors, doesVideoChannelIdExist } from '../shared'
+import { doesVideoChannelSyncIdExist } from '../shared/video-channel-syncs'
export const ensureSyncIsEnabled = (req: express.Request, res: express.Response, next: express.NextFunction) => {
if (!CONFIG.IMPORT.VIDEO_CHANNEL_SYNCHRONIZATION.ENABLED) {
async (req: express.Request, res: express.Response, next: express.NextFunction) => {
if (areValidationErrors(req, res)) return
- const syncId = parseInt(req.params.id, 10)
- const sync = await VideoChannelSyncModel.loadWithChannel(syncId)
-
- if (!sync) {
- return res.fail({
- status: HttpStatusCode.NOT_FOUND_404,
- message: 'Synchronization not found'
- })
- }
-
- res.locals.videoChannelSync = sync
- res.locals.videoChannel = await VideoChannelModel.loadAndPopulateAccount(sync.videoChannelId)
+ if (!await doesVideoChannelSyncIdExist(+req.params.id, res)) return
+ if (!await doesVideoChannelIdExist(res.locals.videoChannelSync.videoChannelId, res)) return
return next()
}
import { isUrlValid } from '@server/helpers/custom-validators/activitypub/misc'
import { CONFIG } from '@server/initializers/config'
import { MChannelAccountDefault } from '@server/types/models'
+import { VideosImportInChannelCreate } from '@shared/models'
import { HttpStatusCode } from '../../../../shared/models/http/http-error-codes'
-import { isBooleanValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
+import { isBooleanValid, isIdValid, toBooleanOrNull } from '../../../helpers/custom-validators/misc'
import {
isVideoChannelDescriptionValid,
isVideoChannelDisplayNameValid,
import { ActorModel } from '../../../models/actor/actor'
import { VideoChannelModel } from '../../../models/video/video-channel'
import { areValidationErrors, checkUserQuota, doesVideoChannelNameWithHostExist } from '../shared'
+import { doesVideoChannelSyncIdExist } from '../shared/video-channel-syncs'
export const videoChannelsAddValidator = [
body('name').custom(isVideoChannelUsernameValid).withMessage('Should have a valid channel name'),
export const videoChannelImportVideosValidator = [
body('externalChannelUrl').custom(isUrlValid).withMessage('Should have a valid channel url'),
- (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ body('videoChannelSyncId')
+ .optional()
+ .custom(isIdValid).withMessage('Should have a valid channel sync id'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
logger.debug('Checking videoChannelImport parameters', { parameters: req.body })
if (areValidationErrors(req, res)) return
+ const body: VideosImportInChannelCreate = req.body
+
if (!CONFIG.IMPORT.VIDEOS.HTTP.ENABLED) {
return res.fail({
status: HttpStatusCode.FORBIDDEN_403,
})
}
+ if (body.videoChannelSyncId && !await doesVideoChannelSyncIdExist(body.videoChannelSyncId, res)) return
+
return next()
}
]
import express from 'express'
-import { body, param } from 'express-validator'
+import { body, param, query } from 'express-validator'
import { isResolvingToUnicastOnly } from '@server/helpers/dns'
import { isPreImportVideoAccepted } from '@server/lib/moderation'
import { Hooks } from '@server/lib/plugins/hooks'
}
])
+const getMyVideoImportsValidator = [
+ query('videoChannelSyncId')
+ .optional()
+ .custom(isIdValid).withMessage('Should have correct videoChannelSync id'),
+
+ (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking getMyVideoImportsValidator parameters', { parameters: req.params })
+
+ if (areValidationErrors(req, res)) return
+
+ return next()
+ }
+]
+
const videoImportDeleteValidator = [
param('id')
.custom(isIdValid).withMessage('Should have correct import id'),
export {
videoImportAddValidator,
videoImportCancelValidator,
- videoImportDeleteValidator
+ videoImportDeleteValidator,
+ getMyVideoImportsValidator
}
// ---------------------------------------------------------------------------
-import { Op, WhereOptions } from 'sequelize'
+import { IncludeOptions, Op, WhereOptions } from 'sequelize'
import {
AfterUpdate,
AllowNull,
import { isVideoMagnetUriValid } from '../../helpers/custom-validators/videos'
import { CONSTRAINTS_FIELDS, VIDEO_IMPORT_STATES } from '../../initializers/constants'
import { UserModel } from '../user/user'
-import { getSort, throwIfNotValid } from '../utils'
+import { getSort, searchAttribute, throwIfNotValid } from '../utils'
import { ScopeNames as VideoModelScopeNames, VideoModel } from './video'
+import { VideoChannelSyncModel } from './video-channel-sync'
+
+const defaultVideoScope = () => {
+ return VideoModel.scope([
+ VideoModelScopeNames.WITH_ACCOUNT_DETAILS,
+ VideoModelScopeNames.WITH_TAGS,
+ VideoModelScopeNames.WITH_THUMBNAILS
+ ])
+}
@DefaultScope(() => ({
include: [
required: true
},
{
- model: VideoModel.scope([
- VideoModelScopeNames.WITH_ACCOUNT_DETAILS,
- VideoModelScopeNames.WITH_TAGS,
- VideoModelScopeNames.WITH_THUMBNAILS
- ]),
+ model: defaultVideoScope(),
+ required: false
+ },
+ {
+ model: VideoChannelSyncModel.unscoped(),
required: false
}
]
})
Video: VideoModel
+ @ForeignKey(() => VideoChannelSyncModel)
+ @Column
+ videoChannelSyncId: number
+
+ @BelongsTo(() => VideoChannelSyncModel, {
+ foreignKey: {
+ allowNull: true
+ },
+ onDelete: 'set null'
+ })
+ VideoChannelSync: VideoChannelSyncModel
+
@AfterUpdate
static deleteVideoIfFailed (instance: VideoImportModel, options) {
if (instance.state === VideoImportState.FAILED) {
count: number
sort: string
+ search?: string
targetUrl?: string
+ videoChannelSyncId?: number
}) {
- const { userId, start, count, sort, targetUrl } = options
+ const { userId, start, count, sort, targetUrl, videoChannelSyncId, search } = options
const where: WhereOptions = { userId }
+ const include: IncludeOptions[] = [
+ {
+ attributes: [ 'id' ],
+ model: UserModel.unscoped(), // FIXME: Without this, sequelize try to COUNT(DISTINCT(*)) which is an invalid SQL query
+ required: true
+ },
+ {
+ model: VideoChannelSyncModel.unscoped(),
+ required: false
+ }
+ ]
if (targetUrl) where['targetUrl'] = targetUrl
+ if (videoChannelSyncId) where['videoChannelSyncId'] = videoChannelSyncId
+
+ if (search) {
+ include.push({
+ model: defaultVideoScope(),
+ required: true,
+ where: searchAttribute(search, 'name')
+ })
+ } else {
+ include.push({
+ model: defaultVideoScope(),
+ required: false
+ })
+ }
const query = {
distinct: true,
- include: [
- {
- attributes: [ 'id' ],
- model: UserModel.unscoped(), // FIXME: Without this, sequelize try to COUNT(DISTINCT(*)) which is an invalid SQL query
- required: true
- }
- ],
+ include,
offset: start,
limit: count,
order: getSort(sort),
? Object.assign(this.Video.toFormattedJSON(videoFormatOptions), { tags: this.Video.Tags.map(t => t.name) })
: undefined
+ const videoChannelSync = this.VideoChannelSync
+ ? { id: this.VideoChannelSync.id, externalChannelUrl: this.VideoChannelSync.externalChannelUrl }
+ : undefined
+
return {
id: this.id,
error: this.error,
updatedAt: this.updatedAt.toISOString(),
createdAt: this.createdAt.toISOString(),
- video
+ video,
+ videoChannelSync
}
}
--- /dev/null
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
+import 'mocha'
+import { FIXTURE_URLS } from '@server/tests/shared'
+import { areHttpImportTestsDisabled } from '@shared/core-utils'
+import { HttpStatusCode } from '@shared/models'
+import { ChannelsCommand, cleanupTests, createSingleServer, PeerTubeServer, setAccessTokensToServers } from '@shared/server-commands'
+
+describe('Test videos import in a channel API validator', function () {
+ let server: PeerTubeServer
+ const userInfo = {
+ accessToken: '',
+ channelName: 'fake_channel',
+ id: -1,
+ videoQuota: -1,
+ videoQuotaDaily: -1
+ }
+ let command: ChannelsCommand
+
+ // ---------------------------------------------------------------
+
+ before(async function () {
+ this.timeout(30000)
+
+ server = await createSingleServer(1)
+
+ await setAccessTokensToServers([ server ])
+
+ const userCreds = {
+ username: 'fake',
+ password: 'fake_password'
+ }
+
+ {
+ const user = await server.users.create({ username: userCreds.username, password: userCreds.password })
+ userInfo.id = user.id
+ userInfo.accessToken = await server.login.getAccessToken(userCreds)
+ }
+
+ command = server.channels
+ })
+
+ it('Should fail when HTTP upload is disabled', async function () {
+ await server.config.disableImports()
+
+ await command.importVideos({
+ channelName: 'super_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ token: server.accessToken,
+ expectedStatus: HttpStatusCode.FORBIDDEN_403
+ })
+
+ await server.config.enableImports()
+ })
+
+ it('Should fail when externalChannelUrl is not provided', async function () {
+ await command.importVideos({
+ channelName: 'super_channel',
+ externalChannelUrl: null,
+ token: server.accessToken,
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
+ })
+ })
+
+ it('Should fail when externalChannelUrl is malformed', async function () {
+ await command.importVideos({
+ channelName: 'super_channel',
+ externalChannelUrl: 'not-a-url',
+ token: server.accessToken,
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
+ })
+ })
+
+ it('Should fail with a bad sync id', async function () {
+ await command.importVideos({
+ channelName: 'super_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ videoChannelSyncId: 'toto' as any,
+ token: server.accessToken,
+ expectedStatus: HttpStatusCode.BAD_REQUEST_400
+ })
+ })
+
+ it('Should fail with a unknown sync id', async function () {
+ await command.importVideos({
+ channelName: 'super_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ videoChannelSyncId: 42,
+ token: server.accessToken,
+ expectedStatus: HttpStatusCode.NOT_FOUND_404
+ })
+ })
+
+ it('Should fail with no authentication', async function () {
+ await command.importVideos({
+ channelName: 'super_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ token: null,
+ expectedStatus: HttpStatusCode.UNAUTHORIZED_401
+ })
+ })
+
+ it('Should fail when sync is not owned by the user', async function () {
+ await command.importVideos({
+ channelName: 'super_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ token: userInfo.accessToken,
+ expectedStatus: HttpStatusCode.FORBIDDEN_403
+ })
+ })
+
+ it('Should fail when the user has no quota', async function () {
+ await server.users.update({
+ userId: userInfo.id,
+ videoQuota: 0
+ })
+
+ await command.importVideos({
+ channelName: 'fake_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ token: userInfo.accessToken,
+ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413
+ })
+
+ await server.users.update({
+ userId: userInfo.id,
+ videoQuota: userInfo.videoQuota
+ })
+ })
+
+ it('Should fail when the user has no daily quota', async function () {
+ await server.users.update({
+ userId: userInfo.id,
+ videoQuotaDaily: 0
+ })
+
+ await command.importVideos({
+ channelName: 'fake_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ token: userInfo.accessToken,
+ expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413
+ })
+
+ await server.users.update({
+ userId: userInfo.id,
+ videoQuotaDaily: userInfo.videoQuotaDaily
+ })
+ })
+
+ it('Should succeed when sync is run by its owner', async function () {
+ if (!areHttpImportTestsDisabled()) return
+
+ await command.importVideos({
+ channelName: 'fake_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ token: userInfo.accessToken
+ })
+ })
+
+ it('Should succeed when sync is run with root and for another user\'s channel', async function () {
+ if (!areHttpImportTestsDisabled()) return
+
+ await command.importVideos({
+ channelName: 'fake_channel',
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel
+ })
+ })
+
+ after(async function () {
+ await cleanupTests([ server ])
+ })
+})
import './video-files'
import './video-imports'
import './video-channel-syncs'
+import './channel-import-videos'
import './video-playlists'
import './video-source'
import './video-studio'
import 'mocha'
import * as chai from 'chai'
import { omit } from 'lodash'
-import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination, FIXTURE_URLS } from '@server/tests/shared'
-import { areHttpImportTestsDisabled, buildAbsoluteFixturePath } from '@shared/core-utils'
+import { checkBadCountPagination, checkBadSortPagination, checkBadStartPagination } from '@server/tests/shared'
+import { buildAbsoluteFixturePath } from '@shared/core-utils'
import { HttpStatusCode, VideoChannelUpdate } from '@shared/models'
import {
ChannelsCommand,
})
})
- describe('When triggering full synchronization', function () {
-
- it('Should fail when HTTP upload is disabled', async function () {
- await server.config.disableImports()
-
- await command.importVideos({
- channelName: 'super_channel',
- externalChannelUrl: FIXTURE_URLS.youtubeChannel,
- token: server.accessToken,
- expectedStatus: HttpStatusCode.FORBIDDEN_403
- })
-
- await server.config.enableImports()
- })
-
- it('Should fail when externalChannelUrl is not provided', async function () {
- await command.importVideos({
- channelName: 'super_channel',
- externalChannelUrl: null,
- token: server.accessToken,
- expectedStatus: HttpStatusCode.BAD_REQUEST_400
- })
- })
-
- it('Should fail when externalChannelUrl is malformed', async function () {
- await command.importVideos({
- channelName: 'super_channel',
- externalChannelUrl: 'not-a-url',
- token: server.accessToken,
- expectedStatus: HttpStatusCode.BAD_REQUEST_400
- })
- })
-
- it('Should fail with no authentication', async function () {
- await command.importVideos({
- channelName: 'super_channel',
- externalChannelUrl: FIXTURE_URLS.youtubeChannel,
- token: null,
- expectedStatus: HttpStatusCode.UNAUTHORIZED_401
- })
- })
-
- it('Should fail when sync is not owned by the user', async function () {
- await command.importVideos({
- channelName: 'super_channel',
- externalChannelUrl: FIXTURE_URLS.youtubeChannel,
- token: userInfo.accessToken,
- expectedStatus: HttpStatusCode.FORBIDDEN_403
- })
- })
-
- it('Should fail when the user has no quota', async function () {
- await server.users.update({
- userId: userInfo.id,
- videoQuota: 0
- })
-
- await command.importVideos({
- channelName: 'fake_channel',
- externalChannelUrl: FIXTURE_URLS.youtubeChannel,
- token: userInfo.accessToken,
- expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413
- })
-
- await server.users.update({
- userId: userInfo.id,
- videoQuota: userInfo.videoQuota
- })
- })
-
- it('Should fail when the user has no daily quota', async function () {
- await server.users.update({
- userId: userInfo.id,
- videoQuotaDaily: 0
- })
-
- await command.importVideos({
- channelName: 'fake_channel',
- externalChannelUrl: FIXTURE_URLS.youtubeChannel,
- token: userInfo.accessToken,
- expectedStatus: HttpStatusCode.PAYLOAD_TOO_LARGE_413
- })
-
- await server.users.update({
- userId: userInfo.id,
- videoQuotaDaily: userInfo.videoQuotaDaily
- })
- })
-
- it('Should succeed when sync is run by its owner', async function () {
- if (!areHttpImportTestsDisabled()) return
-
- await command.importVideos({
- channelName: 'fake_channel',
- externalChannelUrl: FIXTURE_URLS.youtubeChannel,
- token: userInfo.accessToken
- })
- })
-
- it('Should succeed when sync is run with root and for another user\'s channel', async function () {
- if (!areHttpImportTestsDisabled()) return
-
- await command.importVideos({
- channelName: 'fake_channel',
- externalChannelUrl: FIXTURE_URLS.youtubeChannel
- })
- })
- })
-
describe('When deleting a video channel', function () {
it('Should fail with a non authenticated user', async function () {
await command.delete({ token: 'coucou', channelName: 'super_channel', expectedStatus: HttpStatusCode.UNAUTHORIZED_401 })
await checkBadSortPagination(server.url, myPath, server.accessToken)
})
+ it('Should fail with a bad videoChannelSyncId param', async function () {
+ await makeGetRequest({
+ url: server.url,
+ path: myPath,
+ query: { videoChannelSyncId: 'toto' },
+ token: server.accessToken
+ })
+ })
+
it('Should success with the correct parameters', async function () {
await makeGetRequest({ url: server.url, path: myPath, expectedStatus: HttpStatusCode.OK_200, token: server.accessToken })
})
+/* eslint-disable @typescript-eslint/no-unused-expressions,@typescript-eslint/require-await */
+
import { expect } from 'chai'
import { FIXTURE_URLS } from '@server/tests/shared'
import { areHttpImportTestsDisabled } from '@shared/core-utils'
await server.config.enableChannelSync()
})
- it('Should import a whole channel', async function () {
+ it('Should import a whole channel without specifying the sync id', async function () {
this.timeout(240_000)
await server.channels.importVideos({ channelName: server.store.channel.name, externalChannelUrl: FIXTURE_URLS.youtubeChannel })
expect(videos.total).to.equal(2)
})
+ it('These imports should not have a sync id', async function () {
+ const { total, data } = await server.imports.getMyVideoImports()
+
+ expect(total).to.equal(2)
+ expect(data).to.have.lengthOf(2)
+
+ for (const videoImport of data) {
+ expect(videoImport.videoChannelSync).to.not.exist
+ }
+ })
+
+ it('Should import a whole channel and specifying the sync id', async function () {
+ this.timeout(240_000)
+
+ {
+ server.store.channel.name = 'channel2'
+ const { id } = await server.channels.create({ attributes: { name: server.store.channel.name } })
+ server.store.channel.id = id
+ }
+
+ {
+ const attributes = {
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ videoChannelId: server.store.channel.id
+ }
+
+ const { videoChannelSync } = await server.channelSyncs.create({ attributes })
+ server.store.videoChannelSync = videoChannelSync
+
+ await waitJobs(server)
+ }
+
+ await server.channels.importVideos({
+ channelName: server.store.channel.name,
+ externalChannelUrl: FIXTURE_URLS.youtubeChannel,
+ videoChannelSyncId: server.store.videoChannelSync.id
+ })
+
+ await waitJobs(server)
+ })
+
+ it('These imports should have a sync id', async function () {
+ const { total, data } = await server.imports.getMyVideoImports()
+
+ expect(total).to.equal(4)
+ expect(data).to.have.lengthOf(4)
+
+ const importsWithSyncId = data.filter(i => !!i.videoChannelSync)
+ expect(importsWithSyncId).to.have.lengthOf(2)
+
+ for (const videoImport of importsWithSyncId) {
+ expect(videoImport.videoChannelSync).to.exist
+ expect(videoImport.videoChannelSync.id).to.equal(server.store.videoChannelSync.id)
+ }
+ })
+
+ it('Should be able to filter imports by this sync id', async function () {
+ const { total, data } = await server.imports.getMyVideoImports({ videoChannelSyncId: server.store.videoChannelSync.id })
+
+ expect(total).to.equal(2)
+ expect(data).to.have.lengthOf(2)
+
+ for (const videoImport of data) {
+ expect(videoImport.videoChannelSync).to.exist
+ expect(videoImport.videoChannelSync.id).to.equal(server.store.videoChannelSync.id)
+ }
+ })
+
after(async function () {
await server?.kill()
})
describe('Sync using ' + mode, function () {
let server: PeerTubeServer
let command: ChannelSyncsCommand
+
let startTestDate: Date
+
+ let rootChannelSyncId: number
const userInfo = {
accessToken: '',
username: 'user1',
token: server.accessToken,
expectedStatus: HttpStatusCode.OK_200
})
+ rootChannelSyncId = videoChannelSync.id
// Ensure any missing video not already fetched will be considered as new
await changeDateForSync(videoChannelSync.id, '1970-01-01')
}
})
+ it('Should list imports of a channel synchronization', async function () {
+ const { total, data } = await server.imports.getMyVideoImports({ videoChannelSyncId: rootChannelSyncId })
+
+ expect(total).to.equal(1)
+ expect(data).to.have.lengthOf(1)
+ expect(data[0].video.name).to.equal('test')
+ })
+
it('Should remove user\'s channel synchronizations', async function () {
await command.delete({ channelSyncId: userInfo.syncId })
expect(videoImports[0].targetUrl).to.equal(FIXTURE_URLS.youtube)
})
+ it('Should search in my imports', async function () {
+ const { total, data: videoImports } = await servers[0].imports.getMyVideoImports({ search: 'peertube2' })
+ expect(total).to.equal(1)
+ expect(videoImports).to.have.lengthOf(1)
+
+ expect(videoImports[0].magnetUri).to.equal(FIXTURE_URLS.magnet)
+ expect(videoImports[0].video.name).to.equal('super peertube2 video')
+ })
+
it('Should have the video listed on the two instances', async function () {
this.timeout(120_000)
export interface VideoChannelImportPayload {
externalChannelUrl: string
videoChannelId: number
+
+ partOfChannelSyncId?: number
}
export interface AfterVideoChannelImportPayload {
export * from './video-import-create.model'
export * from './video-import-state.enum'
export * from './video-import.model'
+export * from './videos-import-in-channel-create.model'
error?: string
video?: Video & { tags: string[] }
+
+ videoChannelSync?: {
+ id: number
+ externalChannelUrl: string
+ }
}
--- /dev/null
+export interface VideosImportInChannelCreate {
+ externalChannelUrl: string
+ videoChannelSyncId?: number
+}
import { copy } from 'fs-extra'
import { join } from 'path'
import { parallelTests, randomInt, root } from '@shared/core-utils'
-import { Video, VideoChannel, VideoCreateResult, VideoDetails } from '@shared/models'
+import { Video, VideoChannel, VideoChannelSync, VideoCreateResult, VideoDetails } from '@shared/models'
import { BulkCommand } from '../bulk'
import { CLICommand } from '../cli'
import { CustomPagesCommand } from '../custom-pages'
}
channel?: VideoChannel
+ videoChannelSync?: Partial<VideoChannelSync>
video?: Video
videoCreated?: VideoCreateResult
VideoChannel,
VideoChannelCreate,
VideoChannelCreateResult,
- VideoChannelUpdate
+ VideoChannelUpdate,
+ VideosImportInChannelCreate
} from '@shared/models'
import { unwrapBody } from '../requests'
import { AbstractCommand, OverrideCommandOptions } from '../shared'
})
}
- importVideos (options: OverrideCommandOptions & {
+ importVideos (options: OverrideCommandOptions & VideosImportInChannelCreate & {
channelName: string
- externalChannelUrl: string
}) {
- const { channelName, externalChannelUrl } = options
+ const { channelName, externalChannelUrl, videoChannelSyncId } = options
const path = `/api/v1/video-channels/${channelName}/import-videos`
...options,
path,
- fields: { externalChannelUrl },
+ fields: { externalChannelUrl, videoChannelSyncId },
implicitToken: true,
defaultExpectedStatus: HttpStatusCode.NO_CONTENT_204
})
getMyVideoImports (options: OverrideCommandOptions & {
sort?: string
targetUrl?: string
+ videoChannelSyncId?: number
+ search?: string
} = {}) {
- const { sort, targetUrl } = options
+ const { sort, targetUrl, videoChannelSyncId, search } = options
const path = '/api/v1/users/me/videos/imports'
return this.getRequestBody<ResultList<VideoImport>>({
...options,
path,
- query: { sort, targetUrl },
+ query: { sort, targetUrl, videoChannelSyncId, search },
implicitToken: true,
defaultExpectedStatus: HttpStatusCode.OK_200
})
- $ref: '#/components/parameters/start'
- $ref: '#/components/parameters/count'
- $ref: '#/components/parameters/sort'
+ -
+ name: targetUrl
+ in: query
+ required: false
+ description: Filter on import target URL
+ schema:
+ type: string
+ -
+ name: videoChannelSyncId
+ in: query
+ required: false
+ description: Filter on imports created by a specific channel synchronization
+ schema:
+ type: number
responses:
'200':
description: successful operation
projects / github / Chocobozzz / PeerTube.git / commitdiff
