-import { Component, OnDestroy, OnInit } from '@angular/core'
+import { Component, OnInit } from '@angular/core'
import { ActivatedRoute, Router } from '@angular/router'
import { NotificationsService } from 'angular2-notifications'
import { AbstractVideoList } from '../../shared/video/abstract-video-list'
templateUrl: './account-videos.component.html',
styleUrls: [ './account-videos.component.scss' ]
})
-export class AccountVideosComponent extends AbstractVideoList implements OnInit, OnDestroy {
+export class AccountVideosComponent extends AbstractVideoList implements OnInit {
titlePage = 'My videos'
currentRoute = '/account/videos'
super.ngOnInit()
}
- ngOnDestroy () {
- super.ngOnDestroy()
- }
-
getVideosObservable () {
return this.videoService.getMyVideos(this.pagination, this.sort)
}
</div>
<div class="header-right">
- <my-search></my-search>
+ <my-header></my-header>
</div>
</div>
import { SharedModule } from './shared'
import { VideosModule } from './videos'
import { MenuComponent, MenuAdminComponent } from './menu'
+import { HeaderComponent } from './header'
export function metaFactory (): MetaLoader {
return new MetaStaticLoader({
AppComponent,
MenuComponent,
- MenuAdminComponent
+ MenuAdminComponent,
+ HeaderComponent
],
imports: [
BrowserModule,
<input
type="text" id="search-video" name="search-video" placeholder="Search..."
- [(ngModel)]="searchCriteria.value" (keyup.enter)="doSearch()"
+ [(ngModel)]="searchValue" (keyup.enter)="doSearch()"
>
<span (click)="doSearch()" class="icon icon-search"></span>
--- /dev/null
+import { Component, OnInit } from '@angular/core'
+import { Router } from '@angular/router'
+import { getParameterByName } from '../shared/misc/utils'
+
+@Component({
+ selector: 'my-header',
+ templateUrl: './header.component.html',
+ styleUrls: [ './header.component.scss' ]
+})
+
+export class HeaderComponent implements OnInit {
+ searchValue = ''
+
+ constructor (private router: Router) {}
+
+ ngOnInit () {
+ const searchQuery = getParameterByName('search', window.location.href)
+ if (searchQuery) this.searchValue = searchQuery
+ }
+
+ doSearch () {
+ if (!this.searchValue) return
+
+ this.router.navigate([ '/videos', 'search' ], {
+ queryParams: { search: this.searchValue }
+ })
+ }
+}
--- /dev/null
+export * from './header.component'
export * from './auth'
export * from './forms'
export * from './rest'
-export * from './search'
export * from './users'
export * from './video-abuse'
export * from './video-blacklist'
--- /dev/null
+// Thanks: https://stackoverflow.com/questions/901115/how-can-i-get-query-string-values-in-javascript
+
+function getParameterByName (name: string, url: string) {
+ if (!url) url = window.location.href
+ name = name.replace(/[\[\]]/g, '\\$&')
+
+ const regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)')
+ const results = regex.exec(url)
+
+ if (!results) return null
+ if (!results[2]) return ''
+
+ return decodeURIComponent(results[2].replace(/\+/g, ' '))
+}
+
+export {
+ getParameterByName
+}
+++ /dev/null
-export * from './search-field.type'
-export * from './search.component'
-export * from './search.model'
-export * from './search.service'
+++ /dev/null
-export type SearchField = 'name' | 'account' | 'host' | 'tags'
+++ /dev/null
-import { Component, OnInit } from '@angular/core'
-import { Router } from '@angular/router'
-import { Search } from './search.model'
-import { SearchService } from './search.service'
-
-@Component({
- selector: 'my-search',
- templateUrl: './search.component.html',
- styleUrls: [ './search.component.scss' ]
-})
-
-export class SearchComponent implements OnInit {
- searchCriteria: Search = {
- field: 'name',
- value: ''
- }
-
- constructor (private searchService: SearchService, private router: Router) {}
-
- ngOnInit () {
- // Subscribe if the search changed
- // Usually changed by videos list component
- this.searchService.updateSearch.subscribe(
- newSearchCriteria => {
- // Put a field by default
- if (!newSearchCriteria.field) {
- newSearchCriteria.field = 'name'
- }
-
- this.searchCriteria = newSearchCriteria
- }
- )
- }
-
- doSearch () {
- // if (this.router.url.indexOf('/videos/list') === -1) {
- // this.router.navigate([ '/videos/list' ])
- // }
-
- this.searchService.searchUpdated.next(this.searchCriteria)
- }
-}
+++ /dev/null
-import { SearchField } from './search-field.type'
-
-export interface Search {
- field: SearchField
- value: string
-}
+++ /dev/null
-import { Injectable } from '@angular/core'
-import { Subject } from 'rxjs/Subject'
-import { ReplaySubject } from 'rxjs/ReplaySubject'
-
-import { Search } from './search.model'
-
-// This class is needed to communicate between videos/ and search component
-// Remove it when we'll be able to subscribe to router changes
-@Injectable()
-export class SearchService {
- searchUpdated: Subject<Search>
- updateSearch: Subject<Search>
-
- constructor () {
- this.updateSearch = new Subject<Search>()
- this.searchUpdated = new ReplaySubject<Search>(1)
- }
-}
import { LoaderComponent } from './misc/loader.component'
import { NumberFormatterPipe } from './misc/number-formatter.pipe'
import { RestExtractor, RestService } from './rest'
-import { SearchComponent, SearchService } from './search'
import { UserService } from './users'
import { VideoAbuseService } from './video-abuse'
import { VideoBlacklistService } from './video-blacklist'
],
declarations: [
- SearchComponent,
LoaderComponent,
VideoThumbnailComponent,
NumberFormatterPipe,
BytesPipe,
KeysPipe,
- SearchComponent,
LoaderComponent,
VideoThumbnailComponent,
AUTH_INTERCEPTOR_PROVIDER,
RestExtractor,
RestService,
- SearchService,
VideoAbuseService,
VideoBlacklistService,
UserService,
-import { OnDestroy, OnInit } from '@angular/core'
+import { OnInit } from '@angular/core'
import { ActivatedRoute, Router } from '@angular/router'
import { NotificationsService } from 'angular2-notifications'
import { Observable } from 'rxjs/Observable'
-import { Subscription } from 'rxjs/Subscription'
import { SortField } from './sort-field.type'
import { VideoPagination } from './video-pagination.model'
import { Video } from './video.model'
-export abstract class AbstractVideoList implements OnInit, OnDestroy {
+export abstract class AbstractVideoList implements OnInit {
pagination: VideoPagination = {
currentPage: 1,
itemsPerPage: 25,
totalItems: null
}
sort: SortField = '-createdAt'
+ defaultSort: SortField = '-createdAt'
videos: Video[] = []
+ loadOnInit = true
protected notificationsService: NotificationsService
protected router: Router
protected route: ActivatedRoute
- protected subActivatedRoute: Subscription
protected abstract currentRoute: string
// Subscribe to route changes
const routeParams = this.route.snapshot.params
this.loadRouteParams(routeParams)
- this.loadMoreVideos('after')
- }
-
- ngOnDestroy () {
- if (this.subActivatedRoute) {
- this.subActivatedRoute.unsubscribe()
- }
+ if (this.loadOnInit === true) this.loadMoreVideos('after')
}
onNearOfTop () {
}
}
+ reloadVideos () {
+ this.videos = []
+ this.loadedPages = {}
+ this.loadMoreVideos('before')
+ }
+
loadMoreVideos (where: 'before' | 'after') {
if (this.loadedPages[this.pagination.currentPage] === true) return
}
protected loadRouteParams (routeParams: { [ key: string ]: any }) {
- this.sort = routeParams['sort'] as SortField || '-createdAt'
+ this.sort = routeParams['sort'] as SortField || this.defaultSort
if (routeParams['page'] !== undefined) {
this.pagination.currentPage = parseInt(routeParams['page'], 10)
import { VideoUpdate } from '../../../../../shared/models/videos/video-update.model'
import { RestExtractor } from '../rest/rest-extractor.service'
import { RestService } from '../rest/rest.service'
-import { Search } from '../search/search.model'
+import { Search } from '../header/search.model'
import { UserService } from '../users/user.service'
import { SortField } from './sort-field.type'
import { VideoDetails } from './video-details.model'
.catch((res) => this.restExtractor.handleError(res))
}
- searchVideos (search: Search, videoPagination: VideoPagination, sort: SortField): Observable<{ videos: Video[], totalVideos: number}> {
- const url = VideoService.BASE_VIDEO_URL + 'search/' + encodeURIComponent(search.value)
+ searchVideos (search: string, videoPagination: VideoPagination, sort: SortField): Observable<{ videos: Video[], totalVideos: number}> {
+ const url = VideoService.BASE_VIDEO_URL + 'search'
const pagination = this.videoPaginationToRestPagination(videoPagination)
let params = new HttpParams()
params = this.restService.addRestGetParams(params, pagination, sort)
-
- if (search.field) params.set('field', search.field)
+ params = params.append('search', search)
return this.authHttp
.get<ResultList<VideoServerModel>>(url, { params })
<div class="margin-content">
<div class="title-page title-page-single">
- Signup
+ Create an account
</div>
<div *ngIf="error" class="alert alert-danger">{{ error }}</div>
export * from './video-recently-added.component'
export * from './video-trending.component'
+export * from './video-search.component'
export * from './shared'
-import { Component, OnDestroy, OnInit } from '@angular/core'
+import { Component, OnInit } from '@angular/core'
import { ActivatedRoute, Router } from '@angular/router'
import { NotificationsService } from 'angular2-notifications'
-import { VideoService } from '../../shared/video/video.service'
import { AbstractVideoList } from '../../shared/video/abstract-video-list'
+import { SortField } from '../../shared/video/sort-field.type'
+import { VideoService } from '../../shared/video/video.service'
@Component({
selector: 'my-videos-recently-added',
styleUrls: [ '../../shared/video/abstract-video-list.scss' ],
templateUrl: '../../shared/video/abstract-video-list.html'
})
-export class VideoRecentlyAddedComponent extends AbstractVideoList implements OnInit, OnDestroy {
+export class VideoRecentlyAddedComponent extends AbstractVideoList implements OnInit {
titlePage = 'Recently added'
currentRoute = '/videos/recently-added'
+ sort: SortField = '-createdAt'
constructor (protected router: Router,
protected route: ActivatedRoute,
super.ngOnInit()
}
- ngOnDestroy () {
- super.ngOnDestroy()
- }
-
getVideosObservable () {
return this.videoService.getVideos(this.pagination, this.sort)
}
--- /dev/null
+import { Component, OnDestroy, OnInit } from '@angular/core'
+import { ActivatedRoute, Router } from '@angular/router'
+import { NotificationsService } from 'angular2-notifications'
+import { AbstractVideoList } from 'app/shared/video/abstract-video-list'
+import { Subscription } from 'rxjs/Subscription'
+import { SortField } from '../../shared/video/sort-field.type'
+import { VideoService } from '../../shared/video/video.service'
+
+@Component({
+ selector: 'my-videos-search',
+ styleUrls: [ '../../shared/video/abstract-video-list.scss' ],
+ templateUrl: '../../shared/video/abstract-video-list.html'
+})
+export class VideoSearchComponent extends AbstractVideoList implements OnInit, OnDestroy {
+ titlePage = 'Search'
+ currentRoute = '/videos/search'
+ loadOnInit = false
+
+ private search = ''
+ private subActivatedRoute: Subscription
+
+ constructor (protected router: Router,
+ protected route: ActivatedRoute,
+ protected notificationsService: NotificationsService,
+ private videoService: VideoService) {
+ super()
+ }
+
+ ngOnInit () {
+ super.ngOnInit()
+
+ this.subActivatedRoute = this.route.queryParams.subscribe(
+ queryParams => {
+ this.search = queryParams['search']
+ this.reloadVideos()
+ },
+
+ err => this.notificationsService.error('Error', err.text)
+ )
+ }
+
+ ngOnDestroy () {
+ if (this.subActivatedRoute) {
+ this.subActivatedRoute.unsubscribe()
+ }
+ }
+
+ getVideosObservable () {
+ return this.videoService.searchVideos(this.search, this.pagination, this.sort)
+ }
+}
-import { Component, OnDestroy, OnInit } from '@angular/core'
+import { Component, OnInit } from '@angular/core'
import { ActivatedRoute, Router } from '@angular/router'
import { NotificationsService } from 'angular2-notifications'
-import { VideoService } from '../../shared/video/video.service'
import { AbstractVideoList } from 'app/shared/video/abstract-video-list'
+import { SortField } from '../../shared/video/sort-field.type'
+import { VideoService } from '../../shared/video/video.service'
@Component({
selector: 'my-videos-trending',
styleUrls: [ '../../shared/video/abstract-video-list.scss' ],
templateUrl: '../../shared/video/abstract-video-list.html'
})
-export class VideoTrendingComponent extends AbstractVideoList implements OnInit, OnDestroy {
+export class VideoTrendingComponent extends AbstractVideoList implements OnInit {
titlePage = 'Trending'
currentRoute = '/videos/trending'
+ defaultSort: SortField = '-views'
constructor (protected router: Router,
protected route: ActivatedRoute,
super.ngOnInit()
}
- ngOnDestroy () {
- super.ngOnDestroy()
- }
-
getVideosObservable () {
return this.videoService.getVideos(this.pagination, this.sort)
}
import { NgModule } from '@angular/core'
import { RouterModule, Routes } from '@angular/router'
import { MetaGuard } from '@ngx-meta/core'
+import { VideoSearchComponent } from './video-list'
import { VideoRecentlyAddedComponent } from './video-list/video-recently-added.component'
import { VideoTrendingComponent } from './video-list/video-trending.component'
import { VideosComponent } from './videos.component'
}
}
},
+ {
+ path: 'search',
+ component: VideoSearchComponent,
+ data: {
+ meta: {
+ title: 'Search videos'
+ }
+ }
+ },
{
path: 'upload',
loadChildren: 'app/videos/+video-edit#VideoAddModule',
},
{
path: ':uuid',
+ pathMatch: 'full',
redirectTo: 'watch/:uuid'
},
{
import { NgModule } from '@angular/core'
import { SharedModule } from '../shared'
-import { VideoMiniatureComponent } from './video-list'
+import { VideoMiniatureComponent, VideoSearchComponent } from './video-list'
import { VideoRecentlyAddedComponent } from './video-list/video-recently-added.component'
import { VideoTrendingComponent } from './video-list/video-trending.component'
import { VideosRoutingModule } from './videos-routing.module'
VideoTrendingComponent,
VideoRecentlyAddedComponent,
- VideoMiniatureComponent
+ VideoMiniatureComponent,
+ VideoSearchComponent
],
exports: [
authenticate,
paginationValidator,
setPagination,
- setVideosSearch,
setVideosSort,
videosAddValidator,
videosGetValidator,
setPagination,
asyncMiddleware(listVideos)
)
+videosRouter.get('/search',
+ videosSearchValidator,
+ paginationValidator,
+ videosSortValidator,
+ setVideosSort,
+ setPagination,
+ asyncMiddleware(searchVideos)
+)
videosRouter.put('/:id',
authenticate,
asyncMiddleware(videosUpdateValidator),
asyncMiddleware(removeVideoRetryWrapper)
)
-videosRouter.get('/search/:value',
- videosSearchValidator,
- paginationValidator,
- videosSortValidator,
- setVideosSort,
- setPagination,
- setVideosSearch,
- asyncMiddleware(searchVideos)
-)
-
// ---------------------------------------------------------------------------
export {
async function searchVideos (req: express.Request, res: express.Response, next: express.NextFunction) {
const resultList = await db.Video.searchAndPopulateAccountAndServerAndTags(
- req.params.value,
- req.query.field,
+ req.query.search,
req.query.start,
req.query.count,
req.query.sort
// Number of results by default for the pagination
const PAGINATION_COUNT_DEFAULT = 15
-// Sortable columns per schema
-const SEARCHABLE_COLUMNS = {
- VIDEOS: [ 'name', 'magnetUri', 'host', 'account', 'tags' ]
-}
-
// Sortable columns per schema
const SORTABLE_COLUMNS = {
USERS: [ 'id', 'username', 'createdAt' ],
REMOTE_SCHEME,
FOLLOW_STATES,
AVATARS_DIR,
- SEARCHABLE_COLUMNS,
SERVER_ACCOUNT_NAME,
PRIVATE_RSA_KEY_SIZE,
SORTABLE_COLUMNS,
export * from './oauth'
export * from './pagination'
export * from './servers'
-export * from './search'
export * from './sort'
export * from './user-right'
+++ /dev/null
-import 'express-validator'
-import * as express from 'express'
-
-function setVideosSearch (req: express.Request, res: express.Response, next: express.NextFunction) {
- if (!req.query.field) req.query.field = 'name'
-
- return next()
-}
-
-// ---------------------------------------------------------------------------
-
-export {
- setVideosSearch
-}
} from '../../helpers/custom-validators/videos'
import { getDurationFromVideoFile } from '../../helpers/ffmpeg-utils'
import { logger } from '../../helpers/logger'
-import { CONSTRAINTS_FIELDS, SEARCHABLE_COLUMNS } from '../../initializers'
+import { CONSTRAINTS_FIELDS } from '../../initializers'
import { database as db } from '../../initializers/database'
import { UserInstance } from '../../models/account/user-interface'
import { VideoInstance } from '../../models/video/video-interface'
]
const videosSearchValidator = [
- param('value').not().isEmpty().withMessage('Should have a valid search'),
- query('field').optional().isIn(SEARCHABLE_COLUMNS.VIDEOS).withMessage('Should have correct searchable column'),
+ query('search').not().isEmpty().withMessage('Should have a valid search'),
(req: express.Request, res: express.Response, next: express.NextFunction) => {
logger.debug('Checking videosSearch parameters', { parameters: req.params })
export type ListUserVideosForApi = (userId: number, start: number, count: number, sort: string) => Bluebird< ResultList<VideoInstance> >
export type SearchAndPopulateAccountAndServerAndTags = (
value: string,
- field: string,
start: number,
count: number,
sort: string
return Video.findOne(options)
}
-searchAndPopulateAccountAndServerAndTags = function (value: string, field: string, start: number, count: number, sort: string) {
+searchAndPopulateAccountAndServerAndTags = function (value: string, start: number, count: number, sort: string) {
const serverInclude: Sequelize.IncludeOptions = {
model: Video['sequelize'].models.Server,
required: false
order: [ getSort(sort), [ Video['sequelize'].models.Tag, 'name', 'ASC' ] ]
}
- if (field === 'tags') {
- const escapedValue = Video['sequelize'].escape('%' + value + '%')
- query.where['id'][Sequelize.Op.in] = Video['sequelize'].literal(
- `(SELECT "VideoTags"."videoId"
- FROM "Tags"
- INNER JOIN "VideoTags" ON "Tags"."id" = "VideoTags"."tagId"
- WHERE name ILIKE ${escapedValue}
- )`
- )
- } else if (field === 'host') {
- // FIXME: Include our server? (not stored in the database)
- serverInclude.where = {
- host: {
- [Sequelize.Op.iLike]: '%' + value + '%'
- }
- }
- serverInclude.required = true
- } else if (field === 'account') {
- accountInclude.where = {
- name: {
- [Sequelize.Op.iLike]: '%' + value + '%'
- }
- }
- } else {
- query.where[field] = {
- [Sequelize.Op.iLike]: '%' + value + '%'
- }
+ // TODO: search on tags too
+ // const escapedValue = Video['sequelize'].escape('%' + value + '%')
+ // query.where['id'][Sequelize.Op.in] = Video['sequelize'].literal(
+ // `(SELECT "VideoTags"."videoId"
+ // FROM "Tags"
+ // INNER JOIN "VideoTags" ON "Tags"."id" = "VideoTags"."tagId"
+ // WHERE name ILIKE ${escapedValue}
+ // )`
+ // )
+
+ // TODO: search on account too
+ // accountInclude.where = {
+ // name: {
+ // [Sequelize.Op.iLike]: '%' + value + '%'
+ // }
+ // }
+ query.where['name'] = {
+ [Sequelize.Op.iLike]: '%' + value + '%'
}
query.include = [
expect(video.views).to.equal(3)
})
- it('Should search the video by name by default', async function () {
+ it('Should search the video by name', async function () {
const res = await searchVideo(server.url, 'my')
expect(res.body.total).to.equal(1)
// })
// })
- it('Should search the video by tag', async function () {
- const res = await searchVideo(server.url, 'tag1', 'tags')
-
- expect(res.body.total).to.equal(1)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data.length).to.equal(1)
-
- const video = res.body.data[0]
- expect(video.name).to.equal('my super name')
- expect(video.category).to.equal(2)
- expect(video.categoryLabel).to.equal('Films')
- expect(video.licence).to.equal(6)
- expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
- expect(video.language).to.equal(3)
- expect(video.languageLabel).to.equal('Mandarin')
- expect(video.nsfw).to.be.ok
- expect(video.description).to.equal('my super description')
- expect(video.serverHost).to.equal('localhost:9001')
- expect(video.account).to.equal('root')
- expect(video.isLocal).to.be.true
- expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
- expect(dateIsValid(video.createdAt)).to.be.true
- expect(dateIsValid(video.updatedAt)).to.be.true
-
- const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
- expect(test).to.equal(true)
- })
+ // Not implemented yet
+ // it('Should search the video by tag', async function () {
+ // const res = await searchVideo(server.url, 'tag1')
+ //
+ // expect(res.body.total).to.equal(1)
+ // expect(res.body.data).to.be.an('array')
+ // expect(res.body.data.length).to.equal(1)
+ //
+ // const video = res.body.data[0]
+ // expect(video.name).to.equal('my super name')
+ // expect(video.category).to.equal(2)
+ // expect(video.categoryLabel).to.equal('Films')
+ // expect(video.licence).to.equal(6)
+ // expect(video.licenceLabel).to.equal('Attribution - Non Commercial - No Derivatives')
+ // expect(video.language).to.equal(3)
+ // expect(video.languageLabel).to.equal('Mandarin')
+ // expect(video.nsfw).to.be.ok
+ // expect(video.description).to.equal('my super description')
+ // expect(video.serverHost).to.equal('localhost:9001')
+ // expect(video.account).to.equal('root')
+ // expect(video.isLocal).to.be.true
+ // expect(video.tags).to.deep.equal([ 'tag1', 'tag2', 'tag3' ])
+ // expect(dateIsValid(video.createdAt)).to.be.true
+ // expect(dateIsValid(video.updatedAt)).to.be.true
+ //
+ // const test = await testVideoImage(server.url, 'video_short.webm', video.thumbnailPath)
+ // expect(test).to.equal(true)
+ // })
- it('Should not find a search by name by default', async function () {
+ it('Should not find a search by name', async function () {
const res = await searchVideo(server.url, 'hello')
expect(res.body.total).to.equal(0)
expect(res.body.data.length).to.equal(0)
})
- it('Should not find a search by author', async function () {
- const res = await searchVideo(server.url, 'hello', 'account')
-
- expect(res.body.total).to.equal(0)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data.length).to.equal(0)
- })
-
- it('Should not find a search by tag', async function () {
- const res = await searchVideo(server.url, 'hello', 'tags')
-
- expect(res.body.total).to.equal(0)
- expect(res.body.data).to.be.an('array')
- expect(res.body.data.length).to.equal(0)
- })
+ // Not implemented yet
+ // it('Should not find a search by author', async function () {
+ // const res = await searchVideo(server.url, 'hello')
+ //
+ // expect(res.body.total).to.equal(0)
+ // expect(res.body.data).to.be.an('array')
+ // expect(res.body.data.length).to.equal(0)
+ // })
+ //
+ // Not implemented yet
+ // it('Should not find a search by tag', async function () {
+ // const res = await searchVideo(server.url, 'hello')
+ //
+ // expect(res.body.total).to.equal(0)
+ // expect(res.body.data).to.be.an('array')
+ // expect(res.body.data.length).to.equal(0)
+ // })
it('Should remove the video', async function () {
await removeVideo(server.url, server.accessToken, videoId)
})
it('Should search the first video', async function () {
- const res = await searchVideoWithPagination(server.url, 'webm', 'name', 0, 1, 'name')
+ const res = await searchVideoWithPagination(server.url, 'webm', 0, 1, 'name')
const videos = res.body.data
expect(res.body.total).to.equal(4)
})
it('Should search the last two videos', async function () {
- const res = await searchVideoWithPagination(server.url, 'webm', 'name', 2, 2, 'name')
+ const res = await searchVideoWithPagination(server.url, 'webm', 2, 2, 'name')
const videos = res.body.data
expect(res.body.total).to.equal(4)
})
it('Should search all the webm videos', async function () {
- const res = await searchVideoWithPagination(server.url, 'webm', 'name', 0, 15)
+ const res = await searchVideoWithPagination(server.url, 'webm', 0, 15)
const videos = res.body.data
expect(res.body.total).to.equal(4)
expect(videos.length).to.equal(4)
})
- it('Should search all the root author videos', async function () {
- const res = await searchVideoWithPagination(server.url, 'root', 'account', 0, 15)
-
- const videos = res.body.data
- expect(res.body.total).to.equal(6)
- expect(videos.length).to.equal(6)
- })
+ // Not implemented yet
+ // it('Should search all the root author videos', async function () {
+ // const res = await searchVideoWithPagination(server.url, 'root', 0, 15)
+ //
+ // const videos = res.body.data
+ // expect(res.body.total).to.equal(6)
+ // expect(videos.length).to.equal(6)
+ // })
// Not implemented yet
// it('Should search all the 9001 port videos', async function () {
.expect(expectedStatus)
}
-function searchVideo (url: string, search: string, field?: string) {
+function searchVideo (url: string, search: string) {
const path = '/api/v1/videos'
const req = request(url)
- .get(path + '/search/' + search)
- .set('Accept', 'application/json')
-
- if (field) req.query({ field })
+ .get(path + '/search')
+ .query({ search })
+ .set('Accept', 'application/json')
return req.expect(200)
- .expect('Content-Type', /json/)
+ .expect('Content-Type', /json/)
}
-function searchVideoWithPagination (url: string, search: string, field: string, start: number, count: number, sort?: string) {
+function searchVideoWithPagination (url: string, search: string, start: number, count: number, sort?: string) {
const path = '/api/v1/videos'
const req = request(url)
- .get(path + '/search/' + search)
+ .get(path + '/search')
.query({ start })
+ .query({ search })
.query({ count })
- .query({ field })
if (sort) req.query({ sort })
const path = '/api/v1/videos'
return request(url)
- .get(path + '/search/' + search)
+ .get(path + '/search')
+ .query({ search })
.query({ sort })
.set('Accept', 'application/json')
.expect(200)
projects / github / Chocobozzz / PeerTube.git / commitdiff
