import { AdminComponent } from './admin.component'
import { FriendsRoutes } from './friends'
-import { RequestSchedulersRoutes } from './request-schedulers'
import { UsersRoutes } from './users'
import { VideoAbusesRoutes } from './video-abuses'
import { VideoBlacklistRoutes } from './video-blacklist'
pathMatch: 'full'
},
...FriendsRoutes,
- ...RequestSchedulersRoutes,
...UsersRoutes,
...VideoAbusesRoutes,
...VideoBlacklistRoutes
import { AdminComponent } from './admin.component'
import { AdminRoutingModule } from './admin-routing.module'
import { FriendsComponent, FriendAddComponent, FriendListComponent, FriendService } from './friends'
-import { RequestSchedulersComponent, RequestSchedulersStatsComponent, RequestSchedulersService } from './request-schedulers'
import { UsersComponent, UserAddComponent, UserUpdateComponent, UserListComponent, UserService } from './users'
import { VideoAbusesComponent, VideoAbuseListComponent } from './video-abuses'
import { VideoBlacklistComponent, VideoBlacklistListComponent } from './video-blacklist'
FriendAddComponent,
FriendListComponent,
- RequestSchedulersComponent,
- RequestSchedulersStatsComponent,
-
UsersComponent,
UserAddComponent,
UserUpdateComponent,
providers: [
FriendService,
- RequestSchedulersService,
UserService
]
})
res => {
if (res === false) return
- this.friendService.makeFriends(notEmptyHosts).subscribe(
+ this.friendService.follow(notEmptyHosts).subscribe(
status => {
this.notificationsService.success('Success', 'Make friends request sent!')
// Wait requests between pods
}
protected loadData () {
- this.friendService.getFriends(this.pagination, this.sort)
+ this.friendService.getFollowing(this.pagination, this.sort)
.subscribe(
resultList => {
this.friends = resultList.data
component: FriendsComponent,
canActivate: [ UserRightGuard ],
data: {
- userRight: UserRight.MANAGE_PODS
+ userRight: UserRight.MANAGE_PEERTUBE_FOLLOW
},
children: [
{
private restExtractor: RestExtractor
) {}
- getF
riends (pagination: RestPagination, sort: SortMeta): Observable<ResultList<Pod>> {
+ getF
ollowing (pagination: RestPagination, sort: SortMeta): Observable<ResultList<Pod>> {
let params = new HttpParams()
params = this.restService.addRestGetParams(params, pagination, sort)
- return this.authHttp.get<ResultList<Pod>>(FriendService.BASE_FRIEND_URL, { params })
+ return this.authHttp.get<ResultList<Account>>(API_URL + '/followers', { params })
.map(res => this.restExtractor.convertResultListDateToHuman(res))
.catch(res => this.restExtractor.handleError(res))
}
- makeFriends (notEmptyHosts: String[]) {
+ follow (notEmptyHosts: String[]) {
const body = {
hosts: notEmptyHosts
}
- return this.authHttp.post(FriendService.BASE_FRIEND_URL + 'make-friends', body)
+ return this.authHttp.post(API_URL + '/follow', body)
.map(this.restExtractor.extractDataBool)
.catch(res => this.restExtractor.handleError(res))
}
+++ /dev/null
-export * from './request-schedulers-stats'
-export * from './shared'
-export * from './request-schedulers.component'
-export * from './request-schedulers.routes'
+++ /dev/null
-export * from './request-schedulers-stats.component'
+++ /dev/null
-<div class="row">
- <div class="content-padding">
-
- <h3>Requests stats</h3>
-
- <ng-template [ngIf]="stats">
- <div *ngFor="let requestSchedulerName of statsTitles | keys" class="col-lg-4 col-md-12">
- <div class="panel panel-default" *ngIf="stats[requestSchedulerName] !== null">
- <div class="panel-heading">{{ statsTitles[requestSchedulerName] }}</div>
-
- <div class="panel-body">
- <div class="requests-general">
- <div>
- <span class="label-description">Remaining requests:</span>
- {{ stats[requestSchedulerName].totalRequests }}
- </div>
-
- <div>
- <span class="label-description">Interval seconds between requests:</span>
- {{ stats[requestSchedulerName].secondsInterval }}
- </div>
-
- <div>
- <span class="label-description">Remaining time before the scheduled request:</span>
- {{ stats[requestSchedulerName].remainingSeconds }}
- </div>
- </div>
-
- <div class="requests-limit">
- <div>
- <span class="label-description">Maximum number of different pods for a scheduled request:</span>
- {{ stats[requestSchedulerName].requestsLimitPods }}
- </div>
-
- <div>
- <span class="label-description">Maximum number of requests per pod for a scheduled request:</span>
- {{ stats[requestSchedulerName].requestsLimitPerPod }}
- </div>
- </div>
- </div>
- </div>
- </div>
- </ng-template>
-
- </div>
-</div>
+++ /dev/null
-.label-description {
- font-weight: bold;
- color: black;
-}
-
-.requests-limit {
- margin-top: 20px;
-}
+++ /dev/null
-import { Component, OnInit, OnDestroy } from '@angular/core'
-
-import { NotificationsService } from 'angular2-notifications'
-
-import { RequestSchedulersService, RequestSchedulerStatsAttributes } from '../shared'
-import { RequestSchedulerStats } from '../../../../../../shared'
-
-@Component({
- selector: 'my-request-schedulers-stats',
- templateUrl: './request-schedulers-stats.component.html',
- styleUrls: [ './request-schedulers-stats.component.scss' ]
-})
-export class RequestSchedulersStatsComponent implements OnInit, OnDestroy {
- statsTitles = {
- requestScheduler: 'Basic request scheduler',
- requestVideoEventScheduler: 'Video events request scheduler',
- requestVideoQaduScheduler: 'Quick and dirty video updates request scheduler'
- }
-
- stats: RequestSchedulerStats
-
- private intervals: { [ id: string ]: number } = {
- requestScheduler: null,
- requestVideoEventScheduler: null,
- requestVideoQaduScheduler: null
- }
-
- private timeouts: { [ id: string ]: number } = {
- requestScheduler: null,
- requestVideoEventScheduler: null,
- requestVideoQaduScheduler: null
- }
-
- constructor (
- private notificationsService: NotificationsService,
- private requestService: RequestSchedulersService
- ) { }
-
- ngOnInit () {
- this.getStats()
- this.runIntervals()
- }
-
- ngOnDestroy () {
- Object.keys(this.stats).forEach(requestSchedulerName => {
- if (this.intervals[requestSchedulerName] !== null) {
- window.clearInterval(this.intervals[requestSchedulerName])
- }
-
- if (this.timeouts[requestSchedulerName] !== null) {
- window.clearTimeout(this.timeouts[requestSchedulerName])
- }
- })
- }
-
- getStats () {
- this.requestService.getStats().subscribe(
- stats => this.stats = stats,
-
- err => this.notificationsService.error('Error', err.message)
- )
- }
-
- private runIntervals () {
- Object.keys(this.intervals).forEach(requestSchedulerName => {
- this.intervals[requestSchedulerName] = window.setInterval(() => {
- const stats: RequestSchedulerStatsAttributes = this.stats[requestSchedulerName]
-
- stats.remainingMilliSeconds -= 1000
-
- if (stats.remainingMilliSeconds <= 0) {
- this.timeouts[requestSchedulerName] = window.setTimeout(() => this.getStats(), stats.remainingMilliSeconds + 100)
- }
- }, 1000)
- })
- }
-}
+++ /dev/null
-import { Component } from '@angular/core'
-
-@Component({
- template: '<router-outlet></router-outlet>'
-})
-export class RequestSchedulersComponent {
-}
+++ /dev/null
-import { Routes } from '@angular/router'
-
-import { UserRightGuard } from '../../core'
-import { UserRight } from '../../../../../shared'
-import { RequestSchedulersComponent } from './request-schedulers.component'
-import { RequestSchedulersStatsComponent } from './request-schedulers-stats'
-
-export const RequestSchedulersRoutes: Routes = [
- {
- path: 'requests',
- component: RequestSchedulersComponent,
- canActivate: [ UserRightGuard ],
- data: {
- userRight: UserRight.MANAGE_REQUEST_SCHEDULERS
- },
- children: [
- {
- path: '',
- redirectTo: 'stats',
- pathMatch: 'full'
- },
- {
- path: 'stats',
- component: RequestSchedulersStatsComponent,
- data: {
- meta: {
- title: 'Request stats'
- }
- }
- }
- ]
- }
-]
+++ /dev/null
-export * from './request-schedulers-stats-attributes.model'
-export * from './request-schedulers.service'
+++ /dev/null
-import { RequestSchedulerStatsAttributes as FormattedRequestSchedulerStatsAttributes } from '../../../../../../shared'
-
-export interface Request {
- request: any
- to: any
-}
-
-export class RequestSchedulerStatsAttributes implements FormattedRequestSchedulerStatsAttributes {
- requestsLimitPods: number
- requestsLimitPerPod: number
- milliSecondsInterval: number
- remainingMilliSeconds: number
- totalRequests: number
-
- constructor (hash: {
- requestsLimitPods: number,
- requestsLimitPerPod: number,
- milliSecondsInterval: number,
- remainingMilliSeconds: number,
- totalRequests: number
- }) {
- this.requestsLimitPods = hash.requestsLimitPods
- this.requestsLimitPerPod = hash.requestsLimitPerPod
- this.milliSecondsInterval = hash.milliSecondsInterval
- this.remainingMilliSeconds = hash.remainingMilliSeconds
- this.totalRequests = hash.totalRequests
- }
-
- get remainingSeconds () {
- return Math.floor(this.remainingMilliSeconds / 1000)
- }
-
- get secondsInterva () {
- return Math.floor(this.milliSecondsInterval / 1000)
- }
-
-}
+++ /dev/null
-import { Injectable } from '@angular/core'
-import { HttpClient } from '@angular/common/http'
-import { Observable } from 'rxjs/Observable'
-import 'rxjs/add/operator/catch'
-import 'rxjs/add/operator/map'
-
-import { RequestSchedulerStats } from '../../../../../../shared'
-import { RestExtractor } from '../../../shared'
-import { RequestSchedulerStatsAttributes } from './request-schedulers-stats-attributes.model'
-
-@Injectable()
-export class RequestSchedulersService {
- private static BASE_REQUEST_URL = API_URL + '/api/v1/request-schedulers/'
-
- constructor (
- private authHttp: HttpClient,
- private restExtractor: RestExtractor
- ) {}
-
- getStats () {
- return this.authHttp.get<RequestSchedulerStats>(RequestSchedulersService.BASE_REQUEST_URL + 'stats')
- .map(res => this.buildRequestObjects(res))
- .catch(res => this.restExtractor.handleError(res))
- }
-
- private buildRequestObjects (data: RequestSchedulerStats) {
- const requestSchedulers: { [ id: string ]: RequestSchedulerStatsAttributes } = {}
-
- Object.keys(data).forEach(requestSchedulerName => {
- requestSchedulers[requestSchedulerName] = new RequestSchedulerStatsAttributes(data[requestSchedulerName])
- })
-
- return requestSchedulers
- }
-}
displayNSFW: boolean
email: string
videoQuota: number
- author: {
+ account: {
id: number
uuid: string
}
this.user.displayNSFW = res.displayNSFW
this.user.role = res.role
this.user.videoChannels = res.videoChannels
- this.user.author = res.author
+ this.user.account = res.account
this.user.save()
}
displayNSFW: res.displayNSFW,
email: res.email,
videoQuota: res.videoQuota,
- author: res.author,
+ account: res.account,
videoChannels: res.videoChannels
}
displayNSFW: obj.displayNSFW,
videoQuota: obj.videoQuota,
videoChannels: obj.videoChannels,
- author: obj.author
+ account: obj.account
}
const hashTokens = {
accessToken: obj.access_token,
List friends
</a>
- <a *ngIf="hasRequestsStatRight()" routerLink="/admin/requests/stats" routerLinkActive="active">
- <span class="hidden-xs glyphicon glyphicon-stats"></span>
- Request stats
- </a>
-
<a *ngIf="hasVideoAbusesRight()" routerLink="/admin/video-abuses" routerLinkActive="active">
<span class="hidden-xs glyphicon glyphicon-alert"></span>
Video abuses
}
hasFriendsRight () {
- return this.auth.getUser().hasRight(UserRight.MANAGE_PODS)
- }
-
- hasRequestsStatRight () {
- return this.auth.getUser().hasRight(UserRight.MANAGE_REQUEST_SCHEDULERS)
+ return this.auth.getUser().hasRight(UserRight.MANAGE_PEERTUBE_FOLLOW)
}
hasVideoAbusesRight () {
private routesPerRight = {
[UserRight.MANAGE_USERS]: '/admin/users',
- [UserRight.MANAGE_PODS]: '/admin/friends',
- [UserRight.MANAGE_REQUEST_SCHEDULERS]: '/admin/requests/stats',
+ [UserRight.MANAGE_PEERTUBE_FOLLOW]: '/admin/friends',
[UserRight.MANAGE_VIDEO_ABUSES]: '/admin/video-abuses',
[UserRight.MANAGE_VIDEO_BLACKLIST]: '/admin/video-blacklist'
}
const adminRights = [
UserRight.MANAGE_USERS,
- UserRight.MANAGE_PODS,
- UserRight.MANAGE_REQUEST_SCHEDULERS,
+ UserRight.MANAGE_PEERTUBE_FOLLOW,
UserRight.MANAGE_VIDEO_ABUSES,
UserRight.MANAGE_VIDEO_BLACKLIST
]
-export type SearchField = 'name' | 'author' | 'host' | 'tags'
+export type SearchField = 'name' | 'account' | 'host' | 'tags'
export class SearchComponent implements OnInit {
fieldChoices = {
name: 'Name',
- author: 'Author',
- host: 'Pod Host',
+ account: 'Account',
+ host: 'Host',
tags: 'Tags'
}
searchCriteria: Search = {
videoQuota?: number,
displayNSFW?: boolean,
createdAt?: Date,
- author?: {
+ account?: {
id: number
uuid: string
},
role: UserRole
displayNSFW: boolean
videoQuota: number
- author: {
+ account: {
id: number
uuid: string
}
this.username = hash.username
this.email = hash.email
this.role = hash.role
- this.author = hash.author
+ this.account = hash.account
if (hash.videoChannels !== undefined) {
this.videoChannels = hash.videoChannels
</div>
<div class="row video-small-blocks">
- <div class="col-xs-5 col-xs-3 col-md-3 video-small-block video-small-block-author">
- <a class="option" title="Access to all videos of this user" [routerLink]="['/videos/list', { field: 'author', search: video.author }]">
+ <div class="col-xs-5 col-xs-3 col-md-3 video-small-block video-small-block-account">
+ <a class="option" title="Access to all videos of this user" [routerLink]="['/videos/list', { field: 'account', search: video.account }]">
<span class="glyphicon glyphicon-user"></span>
<span class="video-small-block-text">{{ video.by }}</span>
</a>
border-style: solid;
}
- .video-small-block-author, .video-small-block-more {
+ .video-small-block-account, .video-small-block-more {
a.option {
display: block;
font-size: 18px !important;
}
- .video-small-block-author {
+ .video-small-block-account {
padding-left: 10px;
padding-right: 10px;
}
font-size: 10px !important;
}
- .video-small-block-author {
+ .video-small-block-account {
padding-left: 5px;
padding-right: 5px;
}
} from '../../../../../shared'
export class VideoDetails extends Video implements VideoDetailsServerModel {
- author: string
+ account: string
by: string
createdAt: Date
updatedAt: Date
}
isRemovableBy (user: AuthUser) {
- return user && this.isLocal === true && (this.author === user.username || user.hasRight(UserRight.REMOVE_ANY_VIDEO))
+ return user && this.isLocal === true && (this.account === user.username || user.hasRight(UserRight.REMOVE_ANY_VIDEO))
}
isBlackistableBy (user: AuthUser) {
}
isUpdatableBy (user: AuthUser) {
- return user && this.isLocal === true && user.username === this.author
+ return user && this.isLocal === true && user.username === this.account
}
}
import { User } from '../../shared'
export class Video implements VideoServerModel {
- author: string
+ account: string
by: string
createdAt: Date
updatedAt: Date
dislikes: number
nsfw: boolean
- private static createByString (author: string, podHost: string) {
- return author + '@' + podHost
+ private static createByString (account: string, podHost: string) {
+ return account + '@' + podHost
}
private static createDurationString (duration: number) {
absoluteAPIUrl = window.location.origin
}
- this.author = hash.author
+ this.account = hash.account
this.createdAt = new Date(hash.createdAt.toString())
this.categoryLabel = hash.categoryLabel
this.category = hash.category
this.dislikes = hash.dislikes
this.nsfw = hash.nsfw
- this.by = Video.createByString(hash.author, hash.podHost)
+ this.by = Video.createByString(hash.account, hash.podHost)
}
isVideoNSFWForUser (user: User) {
</span>
</div>
- <a [routerLink]="['/videos/list', { field: 'author', search: video.author, sort: currentSort }]" class="video-miniature-author">{{ video.by }}</a>
+ <a [routerLink]="['/videos/list', { field: 'account', search: video.account, sort: currentSort }]" class="video-miniature-account">{{ video.by }}</a>
<span class="video-miniature-created-at">{{ video.createdAt | date:'short' }}</span>
</div>
</div>
}
}
- .video-miniature-author, .video-miniature-created-at {
+ .video-miniature-account, .video-miniature-created-at {
display: block;
margin-left: 1px;
font-size: 11px;
opacity: 0.9;
}
- .video-miniature-author {
+ .video-miniature-account {
transition: color 0.2s;
&:hover {
projects / oweals / peertube.git / commitdiff