import { MetaGuard } from '@ngx-meta/core'
import { AdminComponent } from './admin.component'
-import { FriendsRoutes } from './friends'
+import { FollowsRoutes } from './follows'
import { UsersRoutes } from './users'
import { VideoAbusesRoutes } from './video-abuses'
import { VideoBlacklistRoutes } from './video-blacklist'
redirectTo: 'users',
pathMatch: 'full'
},
- ...FriendsRoutes,
+ ...FollowsRoutes,
...UsersRoutes,
...VideoAbusesRoutes,
...VideoBlacklistRoutes
import { NgModule } from '@angular/core'
-
-import { AdminComponent } from './admin.component'
+import { TabsModule } from 'ngx-bootstrap/tabs'
+import { SharedModule } from '../shared'
import { AdminRoutingModule } from './admin-routing.module'
-import { FriendsComponent, FriendAddComponent, FriendListComponent, FriendService } from './friends'
-import { UsersComponent, UserAddComponent, UserUpdateComponent, UserListComponent, UserService } from './users'
-import { VideoAbusesComponent, VideoAbuseListComponent } from './video-abuses'
+import { AdminComponent } from './admin.component'
+import { FollowersListComponent, FollowingAddComponent, FollowsComponent, FollowService } from './follows'
+import { FollowingListComponent } from './follows/following-list/following-list.component'
+import { UserAddComponent, UserListComponent, UsersComponent, UserService, UserUpdateComponent } from './users'
+import { VideoAbuseListComponent, VideoAbusesComponent } from './video-abuses'
import { VideoBlacklistComponent, VideoBlacklistListComponent } from './video-blacklist'
-import { SharedModule } from '../shared'
@NgModule({
imports: [
AdminRoutingModule,
+ TabsModule.forRoot(),
SharedModule
],
declarations: [
AdminComponent,
- FriendsComponent,
- FriendAddComponent,
- FriendListComponent,
+ FollowsComponent,
+ FollowingAddComponent,
+ FollowersListComponent,
+ FollowingListComponent,
UsersComponent,
UserAddComponent,
],
providers: [
- FriendService,
+ FollowService,
UserService
]
})
--- /dev/null
+<div class="row">
+ <div class="content-padding">
+ <h3>Followers list</h3>
+
+ <p-dataTable
+ [value]="followers" [lazy]="true" [paginator]="true" [totalRecords]="totalRecords" [rows]="rowsPerPage"
+ sortField="createdAt" (onLazyLoad)="loadLazy($event)"
+ >
+ <p-column field="id" header="ID"></p-column>
+ <p-column field="host" header="Host"></p-column>
+ <p-column field="email" header="Email"></p-column>
+ <p-column field="score" header="Score"></p-column>
+ <p-column field="createdAt" header="Created date" [sortable]="true"></p-column>
+ </p-dataTable>
+ </div>
+</div>
--- /dev/null
+.btn {
+ margin-top: 10px;
+}
--- /dev/null
+import { Component, OnInit } from '@angular/core'
+
+import { NotificationsService } from 'angular2-notifications'
+import { SortMeta } from 'primeng/primeng'
+
+import { ConfirmService } from '../../../core'
+import { RestTable, RestPagination } from '../../../shared'
+import { Pod } from '../../../../../../shared'
+import { FollowService } from '../shared'
+
+@Component({
+ selector: 'my-followers-list',
+ templateUrl: './followers-list.component.html',
+ styleUrls: [ './followers-list.component.scss' ]
+})
+export class FollowersListComponent extends RestTable {
+ followers: Pod[] = []
+ totalRecords = 0
+ rowsPerPage = 10
+ sort: SortMeta = { field: 'createdAt', order: 1 }
+ pagination: RestPagination = { count: this.rowsPerPage, start: 0 }
+
+ constructor (
+ private notificationsService: NotificationsService,
+ private followService: FollowService
+ ) {
+ super()
+ }
+
+ protected loadData () {
+ this.followService.getFollowers(this.pagination, this.sort)
+ .subscribe(
+ resultList => {
+ this.followers = resultList.data
+ this.totalRecords = resultList.total
+ },
+
+ err => this.notificationsService.error('Error', err.message)
+ )
+ }
+}
--- /dev/null
+export * from './followers-list.component'
--- /dev/null
+<div class="row">
+ <div class="content-padding">
+
+ <h3>Add following</h3>
+
+ <div *ngIf="error" class="alert alert-danger">{{ error }}</div>
+
+ <form (ngSubmit)="addFollowing()" [formGroup]="form">
+ <div class="form-group" *ngFor="let host of hosts; let id = index; trackBy:customTrackBy">
+ <label [for]="'host-' + id">Host (so without "http://")</label>
+
+ <div class="input-group">
+ <input
+ type="text" class="form-control" placeholder="example.com"
+ [id]="'host-' + id" [formControlName]="'host-' + id"
+ />
+ <span class="input-group-btn">
+ <button *ngIf="displayAddField(id)" (click)="addField()" class="btn btn-default" type="button">+</button>
+ <button *ngIf="displayRemoveField(id)" (click)="removeField(id)" class="btn btn-default" type="button">-</button>
+ </span>
+ </div>
+
+ <div [hidden]="form.controls['host-' + id].valid || form.controls['host-' + id].pristine" class="alert alert-warning">
+ It should be a valid host.
+ </div>
+ </div>
+
+ <div *ngIf="canMakeFriends() === false" class="alert alert-warning">
+ It seems that you are not on a HTTPS pod. Your webserver need to have TLS activated in order to follow servers.
+ </div>
+
+ <input type="submit" value="Add following" class="btn btn-default" [disabled]="!isFormValid()">
+ </form>
+ </div>
+</div>
--- /dev/null
+table {
+ margin-bottom: 40px;
+}
+
+.input-group-btn button {
+ width: 35px;
+}
--- /dev/null
+import { Component, OnInit } from '@angular/core'
+import { FormControl, FormGroup } from '@angular/forms'
+import { Router } from '@angular/router'
+
+import { NotificationsService } from 'angular2-notifications'
+
+import { ConfirmService } from '../../../core'
+import { validateHost } from '../../../shared'
+import { FollowService } from '../shared'
+
+@Component({
+ selector: 'my-following-add',
+ templateUrl: './following-add.component.html',
+ styleUrls: [ './following-add.component.scss' ]
+})
+export class FollowingAddComponent implements OnInit {
+ form: FormGroup
+ hosts: string[] = [ ]
+ error: string = null
+
+ constructor (
+ private router: Router,
+ private notificationsService: NotificationsService,
+ private confirmService: ConfirmService,
+ private followService: FollowService
+ ) {}
+
+ ngOnInit () {
+ this.form = new FormGroup({})
+ this.addField()
+ }
+
+ addField () {
+ this.form.addControl(`host-${this.hosts.length}`, new FormControl('', [ validateHost ]))
+ this.hosts.push('')
+ }
+
+ canMakeFriends () {
+ return window.location.protocol === 'https:'
+ }
+
+ customTrackBy (index: number, obj: any): any {
+ return index
+ }
+
+ displayAddField (index: number) {
+ return index === (this.hosts.length - 1)
+ }
+
+ displayRemoveField (index: number) {
+ return (index !== 0 || this.hosts.length > 1) && index !== (this.hosts.length - 1)
+ }
+
+ isFormValid () {
+ // Do not check the last input
+ for (let i = 0; i < this.hosts.length - 1; i++) {
+ if (!this.form.controls[`host-${i}`].valid) return false
+ }
+
+ const lastIndex = this.hosts.length - 1
+ // If the last input (which is not the first) is empty, it's ok
+ if (this.hosts[lastIndex] === '' && lastIndex !== 0) {
+ return true
+ } else {
+ return this.form.controls[`host-${lastIndex}`].valid
+ }
+ }
+
+ removeField (index: number) {
+ // Remove the last control
+ this.form.removeControl(`host-${this.hosts.length - 1}`)
+ this.hosts.splice(index, 1)
+ }
+
+ addFollowing () {
+ this.error = ''
+
+ const notEmptyHosts = this.getNotEmptyHosts()
+ if (notEmptyHosts.length === 0) {
+ this.error = 'You need to specify at least 1 host.'
+ return
+ }
+
+ if (!this.isHostsUnique(notEmptyHosts)) {
+ this.error = 'Hosts need to be unique.'
+ return
+ }
+
+ const confirmMessage = 'Are you sure to make friends with:<br /> - ' + notEmptyHosts.join('<br /> - ')
+ this.confirmService.confirm(confirmMessage, 'Follow new server(s)').subscribe(
+ res => {
+ if (res === false) return
+
+ this.followService.follow(notEmptyHosts).subscribe(
+ status => {
+ this.notificationsService.success('Success', 'Follow request(s) sent!')
+ // Wait requests between pods
+ setTimeout(() => this.router.navigate([ '/admin/friends/list' ]), 1000)
+ },
+
+ err => this.notificationsService.error('Error', err.message)
+ )
+ }
+ )
+ }
+
+ private getNotEmptyHosts () {
+ const notEmptyHosts = []
+
+ Object.keys(this.form.value).forEach((hostKey) => {
+ const host = this.form.value[hostKey]
+ if (host !== '') notEmptyHosts.push(host)
+ })
+
+ return notEmptyHosts
+ }
+
+ private isHostsUnique (hosts: string[]) {
+ return hosts.every(host => hosts.indexOf(host) === hosts.lastIndexOf(host))
+ }
+}
--- /dev/null
+export * from './following-add.component'
--- /dev/null
+<div class="row">
+ <div class="content-padding">
+ <h3>Following list</h3>
+
+ <p-dataTable
+ [value]="following" [lazy]="true" [paginator]="true" [totalRecords]="totalRecords" [rows]="rowsPerPage"
+ sortField="createdAt" (onLazyLoad)="loadLazy($event)"
+ >
+ <p-column field="id" header="ID"></p-column>
+ <p-column field="host" header="Host"></p-column>
+ <p-column field="email" header="Email"></p-column>
+ <p-column field="score" header="Score"></p-column>
+ <p-column field="createdAt" header="Created date" [sortable]="true"></p-column>
+ </p-dataTable>
+ </div>
+</div>
--- /dev/null
+import { Component, OnInit } from '@angular/core'
+
+import { NotificationsService } from 'angular2-notifications'
+import { SortMeta } from 'primeng/primeng'
+
+import { ConfirmService } from '../../../core'
+import { RestTable, RestPagination } from '../../../shared'
+import { Pod } from '../../../../../../shared'
+import { FollowService } from '../shared'
+
+@Component({
+ selector: 'my-followers-list',
+ templateUrl: './following-list.component.html'
+})
+export class FollowingListComponent extends RestTable {
+ following: Pod[] = []
+ totalRecords = 0
+ rowsPerPage = 10
+ sort: SortMeta = { field: 'createdAt', order: 1 }
+ pagination: RestPagination = { count: this.rowsPerPage, start: 0 }
+
+ constructor (
+ private notificationsService: NotificationsService,
+ private followService: FollowService
+ ) {
+ super()
+ }
+
+ protected loadData () {
+ this.followService.getFollowing(this.pagination, this.sort)
+ .subscribe(
+ resultList => {
+ this.following = resultList.data
+ this.totalRecords = resultList.total
+ },
+
+ err => this.notificationsService.error('Error', err.message)
+ )
+ }
+}
--- /dev/null
+export * from './following-list.component'
--- /dev/null
+<div class="follows-menu">
+ <tabset #followsMenuTabs>
+ <tab *ngFor="let link of links">
+ <ng-template tabHeading>
+ <a class="tab-link" [routerLink]="link.path">{{ link.title }}</a>
+ </ng-template>
+ </tab>
+ </tabset>
+</div>
+
+<router-outlet></router-outlet>
--- /dev/null
+.follows-menu {
+ margin-top: 20px;
+}
+
+tabset /deep/ {
+ .nav-link {
+ padding: 0;
+ }
+
+ .tab-link {
+ display: block;
+ text-align: center;
+ height: 40px;
+ width: 120px;
+ line-height: 40px;
+
+ &:hover, &:active, &:focus {
+ text-decoration: none !important;
+ }
+ }
+}
--- /dev/null
+import { AfterViewInit, Component, ViewChild } from '@angular/core'
+import { TabsetComponent } from 'ngx-bootstrap/tabs'
+
+@Component({
+ templateUrl: './follows.component.html',
+ styleUrls: [ './follows.component.scss' ]
+})
+export class FollowsComponent implements AfterViewInit {
+ @ViewChild('followsMenuTabs') followsMenuTabs: TabsetComponent
+
+ links = [
+ {
+ path: 'following-list',
+ title: 'Following'
+ },
+ {
+ path: 'following-add',
+ title: 'Follow'
+ },
+ {
+ path: 'followers-list',
+ title: 'Followers'
+ }
+ ]
+
+ ngAfterViewInit () {
+ // Avoid issue with change detector
+ setTimeout(() => this.updateActiveTab())
+ }
+
+ private updateActiveTab () {
+ const url = window.location.pathname
+
+ for (let i = 0; i < this.links.length; i++) {
+ const path = this.links[i].path
+
+ if (url.endsWith(path) === true) {
+ this.followsMenuTabs.tabs[i].active = true
+ return
+ }
+ }
+ }
+}
--- /dev/null
+import { Routes } from '@angular/router'
+
+import { UserRightGuard } from '../../core'
+import { FollowsComponent } from './follows.component'
+import { FollowingAddComponent } from './following-add'
+import { FollowersListComponent } from './followers-list'
+import { UserRight } from '../../../../../shared'
+import { FollowingListComponent } from './following-list/following-list.component'
+
+export const FollowsRoutes: Routes = [
+ {
+ path: 'follows',
+ component: FollowsComponent,
+ canActivate: [ UserRightGuard ],
+ data: {
+ userRight: UserRight.MANAGE_APPLICATION_FOLLOW
+ },
+ children: [
+ {
+ path: '',
+ redirectTo: 'following-list',
+ pathMatch: 'full'
+ },
+ {
+ path: 'following-list',
+ component: FollowingListComponent,
+ data: {
+ meta: {
+ title: 'Following list'
+ }
+ }
+ },
+ {
+ path: 'followers-list',
+ component: FollowersListComponent,
+ data: {
+ meta: {
+ title: 'Followers list'
+ }
+ }
+ },
+ {
+ path: 'following-add',
+ component: FollowingAddComponent,
+ data: {
+ meta: {
+ title: 'Add follow'
+ }
+ }
+ }
+ ]
+ }
+]
--- /dev/null
+export * from './following-add'
+export * from './followers-list'
+export * from './following-list'
+export * from './shared'
+export * from './follows.component'
+export * from './follows.routes'
--- /dev/null
+import { Injectable } from '@angular/core'
+import { HttpClient, HttpParams } from '@angular/common/http'
+import { Observable } from 'rxjs/Observable'
+import 'rxjs/add/operator/catch'
+import 'rxjs/add/operator/map'
+
+import { SortMeta } from 'primeng/primeng'
+
+import { RestExtractor, RestPagination, RestService } from '../../../shared'
+import { Pod, ResultList } from '../../../../../../shared'
+
+@Injectable()
+export class FollowService {
+ private static BASE_APPLICATION_URL = API_URL + '/api/v1/application'
+
+ constructor (
+ private authHttp: HttpClient,
+ private restService: RestService,
+ private restExtractor: RestExtractor
+ ) {}
+
+ getFollowing (pagination: RestPagination, sort: SortMeta): Observable<ResultList<Pod>> {
+ let params = new HttpParams()
+ params = this.restService.addRestGetParams(params, pagination, sort)
+
+ return this.authHttp.get<ResultList<Account>>(FollowService.BASE_APPLICATION_URL + '/following', { params })
+ .map(res => this.restExtractor.convertResultListDateToHuman(res))
+ .catch(res => this.restExtractor.handleError(res))
+ }
+
+ getFollowers (pagination: RestPagination, sort: SortMeta): Observable<ResultList<Pod>> {
+ let params = new HttpParams()
+ params = this.restService.addRestGetParams(params, pagination, sort)
+
+ return this.authHttp.get<ResultList<Account>>(FollowService.BASE_APPLICATION_URL + '/followers', { params })
+ .map(res => this.restExtractor.convertResultListDateToHuman(res))
+ .catch(res => this.restExtractor.handleError(res))
+ }
+
+ follow (notEmptyHosts: String[]) {
+ const body = {
+ hosts: notEmptyHosts
+ }
+
+ return this.authHttp.post(FollowService.BASE_APPLICATION_URL + '/follow', body)
+ .map(this.restExtractor.extractDataBool)
+ .catch(res => this.restExtractor.handleError(res))
+ }
+}
--- /dev/null
+export * from './follow.service'
+++ /dev/null
-<div class="row">
- <div class="content-padding">
-
- <h3>Make friends</h3>
-
- <div *ngIf="error" class="alert alert-danger">{{ error }}</div>
-
- <form (ngSubmit)="makeFriends()" [formGroup]="form">
- <div class="form-group" *ngFor="let host of hosts; let id = index; trackBy:customTrackBy">
- <label [for]="'host-' + id">Host (so without "http://")</label>
-
- <div class="input-group">
- <input
- type="text" class="form-control" placeholder="example.com"
- [id]="'host-' + id" [formControlName]="'host-' + id"
- />
- <span class="input-group-btn">
- <button *ngIf="displayAddField(id)" (click)="addField()" class="btn btn-default" type="button">+</button>
- <button *ngIf="displayRemoveField(id)" (click)="removeField(id)" class="btn btn-default" type="button">-</button>
- </span>
- </div>
-
- <div [hidden]="form.controls['host-' + id].valid || form.controls['host-' + id].pristine" class="alert alert-warning">
- It should be a valid host.
- </div>
- </div>
-
- <div *ngIf="canMakeFriends() === false" class="alert alert-warning">
- It seems that you are not on a HTTPS pod. Your webserver need to have TLS activated in order to make friends.
- </div>
-
- <input type="submit" value="Make friends" class="btn btn-default" [disabled]="!isFormValid()">
- </form>
- </div>
-</div>
+++ /dev/null
-table {
- margin-bottom: 40px;
-}
-
-.input-group-btn button {
- width: 35px;
-}
+++ /dev/null
-import { Component, OnInit } from '@angular/core'
-import { FormControl, FormGroup } from '@angular/forms'
-import { Router } from '@angular/router'
-
-import { NotificationsService } from 'angular2-notifications'
-
-import { ConfirmService } from '../../../core'
-import { validateHost } from '../../../shared'
-import { FriendService } from '../shared'
-
-@Component({
- selector: 'my-friend-add',
- templateUrl: './friend-add.component.html',
- styleUrls: [ './friend-add.component.scss' ]
-})
-export class FriendAddComponent implements OnInit {
- form: FormGroup
- hosts: string[] = [ ]
- error: string = null
-
- constructor (
- private router: Router,
- private notificationsService: NotificationsService,
- private confirmService: ConfirmService,
- private friendService: FriendService
- ) {}
-
- ngOnInit () {
- this.form = new FormGroup({})
- this.addField()
- }
-
- addField () {
- this.form.addControl(`host-${this.hosts.length}`, new FormControl('', [ validateHost ]))
- this.hosts.push('')
- }
-
- canMakeFriends () {
- return window.location.protocol === 'https:'
- }
-
- customTrackBy (index: number, obj: any): any {
- return index
- }
-
- displayAddField (index: number) {
- return index === (this.hosts.length - 1)
- }
-
- displayRemoveField (index: number) {
- return (index !== 0 || this.hosts.length > 1) && index !== (this.hosts.length - 1)
- }
-
- isFormValid () {
- // Do not check the last input
- for (let i = 0; i < this.hosts.length - 1; i++) {
- if (!this.form.controls[`host-${i}`].valid) return false
- }
-
- const lastIndex = this.hosts.length - 1
- // If the last input (which is not the first) is empty, it's ok
- if (this.hosts[lastIndex] === '' && lastIndex !== 0) {
- return true
- } else {
- return this.form.controls[`host-${lastIndex}`].valid
- }
- }
-
- removeField (index: number) {
- // Remove the last control
- this.form.removeControl(`host-${this.hosts.length - 1}`)
- this.hosts.splice(index, 1)
- }
-
- makeFriends () {
- this.error = ''
-
- const notEmptyHosts = this.getNotEmptyHosts()
- if (notEmptyHosts.length === 0) {
- this.error = 'You need to specify at least 1 host.'
- return
- }
-
- if (!this.isHostsUnique(notEmptyHosts)) {
- this.error = 'Hosts need to be unique.'
- return
- }
-
- const confirmMessage = 'Are you sure to make friends with:<br /> - ' + notEmptyHosts.join('<br /> - ')
- this.confirmService.confirm(confirmMessage, 'Make friends').subscribe(
- res => {
- if (res === false) return
-
- this.friendService.follow(notEmptyHosts).subscribe(
- status => {
- this.notificationsService.success('Success', 'Make friends request sent!')
- // Wait requests between pods
- setTimeout(() => this.router.navigate([ '/admin/friends/list' ]), 1000)
- },
-
- err => this.notificationsService.error('Error', err.message)
- )
- }
- )
- }
-
- private getNotEmptyHosts () {
- const notEmptyHosts = []
-
- Object.keys(this.form.value).forEach((hostKey) => {
- const host = this.form.value[hostKey]
- if (host !== '') notEmptyHosts.push(host)
- })
-
- return notEmptyHosts
- }
-
- private isHostsUnique (hosts: string[]) {
- return hosts.every(host => hosts.indexOf(host) === hosts.lastIndexOf(host))
- }
-}
+++ /dev/null
-export * from './friend-add.component'
+++ /dev/null
-<div class="row">
- <div class="content-padding">
- <h3>Friends list</h3>
-
- <p-dataTable
- [value]="friends" [lazy]="true" [paginator]="true" [totalRecords]="totalRecords" [rows]="rowsPerPage"
- sortField="createdAt" (onLazyLoad)="loadLazy($event)"
- >
- <p-column field="id" header="ID"></p-column>
- <p-column field="host" header="Host"></p-column>
- <p-column field="email" header="Email"></p-column>
- <p-column field="score" header="Score"></p-column>
- <p-column field="createdAt" header="Created date" [sortable]="true"></p-column>
- <p-column header="Delete" styleClass="action-cell">
- <ng-template pTemplate="body" let-pod="rowData">
- <span (click)="removeFriend(pod)" class="glyphicon glyphicon-remove glyphicon-black" title="Remove this pod"></span>
- </ng-template>
- </p-column>
- </p-dataTable>
-
- <a *ngIf="hasFriends()" class="btn btn-danger pull-left" (click)="quitFriends()">
- Quit friends
- </a>
-
- <a *ngIf="!hasFriends()" class="btn btn-success pull-right" [routerLink]="[ '/admin/friends/add' ]">
- Make friends
- </a>
- </div>
-</div>
+++ /dev/null
-.btn {
- margin-top: 10px;
-}
+++ /dev/null
-import { Component, OnInit } from '@angular/core'
-
-import { NotificationsService } from 'angular2-notifications'
-import { SortMeta } from 'primeng/primeng'
-
-import { ConfirmService } from '../../../core'
-import { RestTable, RestPagination } from '../../../shared'
-import { Pod } from '../../../../../../shared'
-import { FriendService } from '../shared'
-
-@Component({
- selector: 'my-friend-list',
- templateUrl: './friend-list.component.html',
- styleUrls: ['./friend-list.component.scss']
-})
-export class FriendListComponent extends RestTable implements OnInit {
- friends: Pod[] = []
- totalRecords = 0
- rowsPerPage = 10
- sort: SortMeta = { field: 'createdAt', order: 1 }
- pagination: RestPagination = { count: this.rowsPerPage, start: 0 }
-
- constructor (
- private notificationsService: NotificationsService,
- private confirmService: ConfirmService,
- private friendService: FriendService
- ) {
- super()
- }
-
- ngOnInit () {
- this.loadData()
- }
-
- hasFriends () {
- return this.friends.length !== 0
- }
-
- quitFriends () {
- const confirmMessage = 'Do you really want to quit your friends? All their videos will be deleted.'
- this.confirmService.confirm(confirmMessage, 'Quit friends').subscribe(
- res => {
- if (res === false) return
-
- this.friendService.quitFriends().subscribe(
- status => {
- this.notificationsService.success('Success', 'Friends left!')
- this.loadData()
- },
-
- err => this.notificationsService.error('Error', err.message)
- )
- }
- )
- }
-
- removeFriend (friend: Pod) {
- const confirmMessage = 'Do you really want to remove this friend ? All its videos will be deleted.'
-
- this.confirmService.confirm(confirmMessage, 'Remove').subscribe(
- res => {
- if (res === false) return
-
- this.friendService.removeFriend(friend).subscribe(
- status => {
- this.notificationsService.success('Success', 'Friend removed')
- this.loadData()
- },
-
- err => this.notificationsService.error('Error', err.message)
- )
- }
- )
- }
-
- protected loadData () {
- this.friendService.getFollowing(this.pagination, this.sort)
- .subscribe(
- resultList => {
- this.friends = resultList.data
- this.totalRecords = resultList.total
- },
-
- err => this.notificationsService.error('Error', err.message)
- )
- }
-}
+++ /dev/null
-export * from './friend-list.component'
+++ /dev/null
-import { Component } from '@angular/core'
-
-@Component({
- template: '<router-outlet></router-outlet>'
-})
-export class FriendsComponent {
-}
+++ /dev/null
-import { Routes } from '@angular/router'
-
-import { UserRightGuard } from '../../core'
-import { FriendsComponent } from './friends.component'
-import { FriendAddComponent } from './friend-add'
-import { FriendListComponent } from './friend-list'
-import { UserRight } from '../../../../../shared'
-
-export const FriendsRoutes: Routes = [
- {
- path: 'friends',
- component: FriendsComponent,
- canActivate: [ UserRightGuard ],
- data: {
- userRight: UserRight.MANAGE_PEERTUBE_FOLLOW
- },
- children: [
- {
- path: '',
- redirectTo: 'list',
- pathMatch: 'full'
- },
- {
- path: 'list',
- component: FriendListComponent,
- data: {
- meta: {
- title: 'Friends list'
- }
- }
- },
- {
- path: 'add',
- component: FriendAddComponent,
- data: {
- meta: {
- title: 'Add friends'
- }
- }
- }
- ]
- }
-]
+++ /dev/null
-export * from './friend-add'
-export * from './friend-list'
-export * from './shared'
-export * from './friends.component'
-export * from './friends.routes'
+++ /dev/null
-import { Injectable } from '@angular/core'
-import { HttpClient, HttpParams } from '@angular/common/http'
-import { Observable } from 'rxjs/Observable'
-import 'rxjs/add/operator/catch'
-import 'rxjs/add/operator/map'
-
-import { SortMeta } from 'primeng/primeng'
-
-import { RestExtractor, RestPagination, RestService } from '../../../shared'
-import { Pod, ResultList } from '../../../../../../shared'
-
-@Injectable()
-export class FriendService {
- private static BASE_FRIEND_URL = API_URL + '/api/v1/pods/'
-
- constructor (
- private authHttp: HttpClient,
- private restService: RestService,
- private restExtractor: RestExtractor
- ) {}
-
- getFollowing (pagination: RestPagination, sort: SortMeta): Observable<ResultList<Pod>> {
- let params = new HttpParams()
- params = this.restService.addRestGetParams(params, pagination, sort)
-
- return this.authHttp.get<ResultList<Account>>(API_URL + '/api/v1/pods/followers', { params })
- .map(res => this.restExtractor.convertResultListDateToHuman(res))
- .catch(res => this.restExtractor.handleError(res))
- }
-
- follow (notEmptyHosts: String[]) {
- const body = {
- hosts: notEmptyHosts
- }
-
- return this.authHttp.post(API_URL + '/api/v1/pods/follow', body)
- .map(this.restExtractor.extractDataBool)
- .catch(res => this.restExtractor.handleError(res))
- }
-
- quitFriends () {
- return this.authHttp.get(FriendService.BASE_FRIEND_URL + 'quit-friends')
- .map(this.restExtractor.extractDataBool)
- .catch(res => this.restExtractor.handleError(res))
- }
-
- removeFriend (friend: Pod) {
- return this.authHttp.delete(FriendService.BASE_FRIEND_URL + friend.id)
- .map(this.restExtractor.extractDataBool)
- .catch(res => this.restExtractor.handleError(res))
- }
-}
+++ /dev/null
-export * from './friend.service'
List users
</a>
- <a *ngIf="hasFriendsRight()" routerLink="/admin/friends" routerLinkActive="active">
+ <a *ngIf="hasApplicationFollowRight()" routerLink="/admin/follows" routerLinkActive="active">
<span class="hidden-xs glyphicon glyphicon-cloud"></span>
- List friends
+ Manage follows
</a>
<a *ngIf="hasVideoAbusesRight()" routerLink="/admin/video-abuses" routerLinkActive="active">
return this.auth.getUser().hasRight(UserRight.MANAGE_USERS)
}
- hasFriendsRight () {
- return this.auth.getUser().hasRight(UserRight.MANAGE_PEERTUBE_FOLLOW)
+ hasApplicationFollowRight () {
+ return this.auth.getUser().hasRight(UserRight.MANAGE_APPLICATION_FOLLOW)
}
hasVideoAbusesRight () {
private routesPerRight = {
[UserRight.MANAGE_USERS]: '/admin/users',
- [UserRight.MANAGE_PEERTUBE_FOLLOW]: '/admin/friends',
+ [UserRight.MANAGE_APPLICATION_FOLLOW]: '/admin/friends',
[UserRight.MANAGE_VIDEO_ABUSES]: '/admin/video-abuses',
[UserRight.MANAGE_VIDEO_BLACKLIST]: '/admin/video-blacklist'
}
const adminRights = [
UserRight.MANAGE_USERS,
- UserRight.MANAGE_PEERTUBE_FOLLOW,
+ UserRight.MANAGE_APPLICATION_FOLLOW,
UserRight.MANAGE_VIDEO_ABUSES,
UserRight.MANAGE_VIDEO_BLACKLIST
]
db.init(true)
.then(() => {
- // FIXME: check if has followers
+ // FIXME: check if has following
// return hasFriends()
return true
})
const page = req.params.page || 1
const { start, count } = pageToStartAndCount(page, ACTIVITY_PUB.COLLECTION_ITEMS_PER_PAGE)
- const result = await db.Account.listAcceptedFollowerUrlsForApi(account.id, start, count)
+ const result = await db.AccountFollow.listAcceptedFollowerUrlsForApi(account.id, start, count)
const activityPubResult = activityPubCollectionPagination(req.url, page, result)
return res.json(activityPubResult)
const page = req.params.page || 1
const { start, count } = pageToStartAndCount(page, ACTIVITY_PUB.COLLECTION_ITEMS_PER_PAGE)
- const result = await db.Account.listAcceptedFollowingUrlsForApi(account.id, start, count)
+ const result = await db.AccountFollow.listAcceptedFollowingUrlsForApi(account.id, start, count)
const activityPubResult = activityPubCollectionPagination(req.url, page, result)
return res.json(activityPubResult)
import * as express from 'express'
-
-import { badRequest } from '../../helpers'
-import { inboxRouter } from './inbox'
import { activityPubClientRouter } from './client'
+import { inboxRouter } from './inbox'
const activityPubRouter = express.Router()
activityPubRouter.use('/', inboxRouter)
activityPubRouter.use('/', activityPubClientRouter)
-activityPubRouter.use('/*', badRequest)
// ---------------------------------------------------------------------------
--- /dev/null
+import * as express from 'express'
+import { UserRight } from '../../../../shared/models/users/user-right.enum'
+import { getFormattedObjects } from '../../../helpers'
+import { logger } from '../../../helpers/logger'
+import { getApplicationAccount } from '../../../helpers/utils'
+import { getAccountFromWebfinger } from '../../../helpers/webfinger'
+import { SERVER_ACCOUNT_NAME } from '../../../initializers/constants'
+import { database as db } from '../../../initializers/database'
+import { sendFollow } from '../../../lib/activitypub/send-request'
+import { asyncMiddleware, paginationValidator, setFollowersSort, setPagination } from '../../../middlewares'
+import { authenticate } from '../../../middlewares/oauth'
+import { setBodyHostsPort } from '../../../middlewares/pods'
+import { setFollowingSort } from '../../../middlewares/sort'
+import { ensureUserHasRight } from '../../../middlewares/user-right'
+import { followValidator } from '../../../middlewares/validators/pods'
+import { followersSortValidator, followingSortValidator } from '../../../middlewares/validators/sort'
+
+const applicationFollowsRouter = express.Router()
+
+applicationFollowsRouter.get('/following',
+ paginationValidator,
+ followingSortValidator,
+ setFollowingSort,
+ setPagination,
+ asyncMiddleware(listFollowing)
+)
+
+applicationFollowsRouter.post('/follow',
+ authenticate,
+ ensureUserHasRight(UserRight.MANAGE_APPLICATION_FOLLOW),
+ followValidator,
+ setBodyHostsPort,
+ asyncMiddleware(follow)
+)
+
+applicationFollowsRouter.get('/followers',
+ paginationValidator,
+ followersSortValidator,
+ setFollowersSort,
+ setPagination,
+ asyncMiddleware(listFollowers)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+ applicationFollowsRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function listFollowing (req: express.Request, res: express.Response, next: express.NextFunction) {
+ const applicationAccount = await getApplicationAccount()
+ const resultList = await db.AccountFollow.listFollowingForApi(applicationAccount.id, req.query.start, req.query.count, req.query.sort)
+
+ return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+async function listFollowers (req: express.Request, res: express.Response, next: express.NextFunction) {
+ const applicationAccount = await getApplicationAccount()
+ const resultList = await db.AccountFollow.listFollowersForApi(applicationAccount.id, req.query.start, req.query.count, req.query.sort)
+
+ return res.json(getFormattedObjects(resultList.data, resultList.total))
+}
+
+async function follow (req: express.Request, res: express.Response, next: express.NextFunction) {
+ const hosts = req.body.hosts as string[]
+ const fromAccount = await getApplicationAccount()
+
+ const tasks: Promise<any>[] = []
+ const accountName = SERVER_ACCOUNT_NAME
+
+ for (const host of hosts) {
+
+ // We process each host in a specific transaction
+ // First, we add the follow request in the database
+ // Then we send the follow request to other account
+ const p = loadLocalOrGetAccountFromWebfinger(accountName, host)
+ .then(accountResult => {
+ let targetAccount = accountResult.account
+
+ return db.sequelize.transaction(async t => {
+ if (accountResult.loadedFromDB === false) {
+ targetAccount = await targetAccount.save({ transaction: t })
+ }
+
+ const [ accountFollow ] = await db.AccountFollow.findOrCreate({
+ where: {
+ accountId: fromAccount.id,
+ targetAccountId: targetAccount.id
+ },
+ defaults: {
+ state: 'pending',
+ accountId: fromAccount.id,
+ targetAccountId: targetAccount.id
+ },
+ transaction: t
+ })
+
+ // Send a notification to remote server
+ if (accountFollow.state === 'pending') {
+ await sendFollow(fromAccount, targetAccount, t)
+ }
+ })
+ })
+ .catch(err => logger.warn('Cannot follow server %s.', `${accountName}@${host}`, err))
+
+ tasks.push(p)
+ }
+
+ await Promise.all(tasks)
+
+ return res.status(204).end()
+}
+
+async function loadLocalOrGetAccountFromWebfinger (name: string, host: string) {
+ let loadedFromDB = true
+ let account = await db.Account.loadByNameAndHost(name, host)
+
+ if (!account) {
+ const nameWithDomain = name + '@' + host
+ account = await getAccountFromWebfinger(nameWithDomain)
+ loadedFromDB = false
+ }
+
+ return { account, loadedFromDB }
+}
--- /dev/null
+import * as express from 'express'
+import { applicationFollowsRouter } from './follows'
+
+const applicationRouter = express.Router()
+
+applicationRouter.use('/', applicationFollowsRouter)
+
+// ---------------------------------------------------------------------------
+
+export {
+ applicationRouter
+}
import { oauthClientsRouter } from './oauth-clients'
import { configRouter } from './config'
-import { podsRouter } from './pods'
+import { applicationRouter } from './application'
import { usersRouter } from './users'
import { videosRouter } from './videos'
const apiRouter = express.Router()
+apiRouter.use('/application', applicationRouter)
apiRouter.use('/oauth-clients', oauthClientsRouter)
apiRouter.use('/config', configRouter)
-apiRouter.use('/pods', podsRouter)
apiRouter.use('/users', usersRouter)
apiRouter.use('/videos', videosRouter)
apiRouter.use('/ping', pong)
+++ /dev/null
-import * as express from 'express'
-import { UserRight } from '../../../shared/models/users/user-right.enum'
-import { getFormattedObjects } from '../../helpers'
-import { logger } from '../../helpers/logger'
-import { getApplicationAccount } from '../../helpers/utils'
-import { getAccountFromWebfinger } from '../../helpers/webfinger'
-import { SERVER_ACCOUNT_NAME } from '../../initializers/constants'
-import { database as db } from '../../initializers/database'
-import { sendFollow } from '../../lib/activitypub/send-request'
-import { asyncMiddleware, paginationValidator, setFollowersSort, setPagination } from '../../middlewares'
-import { authenticate } from '../../middlewares/oauth'
-import { setBodyHostsPort } from '../../middlewares/pods'
-import { setFollowingSort } from '../../middlewares/sort'
-import { ensureUserHasRight } from '../../middlewares/user-right'
-import { followValidator } from '../../middlewares/validators/pods'
-import { followersSortValidator, followingSortValidator } from '../../middlewares/validators/sort'
-
-const podsRouter = express.Router()
-
-podsRouter.get('/following',
- paginationValidator,
- followingSortValidator,
- setFollowingSort,
- setPagination,
- asyncMiddleware(listFollowing)
-)
-
-podsRouter.post('/follow',
- authenticate,
- ensureUserHasRight(UserRight.MANAGE_PEERTUBE_FOLLOW),
- followValidator,
- setBodyHostsPort,
- asyncMiddleware(follow)
-)
-
-podsRouter.get('/followers',
- paginationValidator,
- followersSortValidator,
- setFollowersSort,
- setPagination,
- asyncMiddleware(listFollowers)
-)
-
-// ---------------------------------------------------------------------------
-
-export {
- podsRouter
-}
-
-// ---------------------------------------------------------------------------
-
-async function listFollowing (req: express.Request, res: express.Response, next: express.NextFunction) {
- const applicationAccount = await getApplicationAccount()
- const resultList = await db.Account.listFollowingForApi(applicationAccount.id, req.query.start, req.query.count, req.query.sort)
-
- return res.json(getFormattedObjects(resultList.data, resultList.total))
-}
-
-async function listFollowers (req: express.Request, res: express.Response, next: express.NextFunction) {
- const applicationAccount = await getApplicationAccount()
- const resultList = await db.Account.listFollowersForApi(applicationAccount.id, req.query.start, req.query.count, req.query.sort)
-
- return res.json(getFormattedObjects(resultList.data, resultList.total))
-}
-
-async function follow (req: express.Request, res: express.Response, next: express.NextFunction) {
- const hosts = req.body.hosts as string[]
- const fromAccount = await getApplicationAccount()
-
- const tasks: Promise<any>[] = []
- const accountName = SERVER_ACCOUNT_NAME
-
- for (const host of hosts) {
-
- // We process each host in a specific transaction
- // First, we add the follow request in the database
- // Then we send the follow request to other account
- const p = loadLocalOrGetAccountFromWebfinger(accountName, host)
- .then(accountResult => {
- let targetAccount = accountResult.account
-
- return db.sequelize.transaction(async t => {
- if (accountResult.loadedFromDB === false) {
- targetAccount = await targetAccount.save({ transaction: t })
- }
-
- const [ accountFollow ] = await db.AccountFollow.findOrCreate({
- where: {
- accountId: fromAccount.id,
- targetAccountId: targetAccount.id
- },
- defaults: {
- state: 'pending',
- accountId: fromAccount.id,
- targetAccountId: targetAccount.id
- },
- transaction: t
- })
-
- // Send a notification to remote server
- if (accountFollow.state === 'pending') {
- await sendFollow(fromAccount, targetAccount, t)
- }
- })
- })
- .catch(err => logger.warn('Cannot follow server %s.', `${accountName}@${host}`, err))
-
- tasks.push(p)
- }
-
- await Promise.all(tasks)
-
- return res.status(204).end()
-}
-
-async function loadLocalOrGetAccountFromWebfinger (name: string, host: string) {
- let loadedFromDB = true
- let account = await db.Account.loadByNameAndHost(name, host)
-
- if (!account) {
- const nameWithDomain = name + '@' + host
- account = await getAccountFromWebfinger(nameWithDomain)
- loadedFromDB = false
- }
-
- return { account, loadedFromDB }
-}
const webfingerRouter = express.Router()
-webfingerRouter.use('/.well-known/webfinger',
+webfingerRouter.get('/.well-known/webfinger',
webfingerValidator,
webfingerController
)
// ---------------------------------------------------------------------------
async function broadcastToFollowers (data: any, fromAccount: AccountInstance, t: Sequelize.Transaction) {
- const result = await db.Account.listAcceptedFollowerUrlsForApi(fromAccount.id, 0)
+ const result = await db.AccountFollow.listAcceptedFollowerUrlsForApi(fromAccount.id, 0)
const jobPayload = {
uris: result.data,
import * as Sequelize from 'sequelize'
import * as Bluebird from 'bluebird'
import { FollowState } from '../../../shared/models/accounts/follow.model'
+import { ResultList } from '../../../shared/models/result-list.model'
+import { AccountInstance } from './account-interface'
export namespace AccountFollowMethods {
export type LoadByAccountAndTarget = (accountId: number, targetAccountId: number) => Bluebird<AccountFollowInstance>
+
+ export type ListFollowingForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountInstance> >
+ export type ListFollowersForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountInstance> >
+
+ export type ListAcceptedFollowerUrlsForApi = (id: number, start: number, count?: number) => Promise< ResultList<string> >
+ export type ListAcceptedFollowingUrlsForApi = (id: number, start: number, count?: number) => Promise< ResultList<string> >
}
export interface AccountFollowClass {
loadByAccountAndTarget: AccountFollowMethods.LoadByAccountAndTarget
+ listFollowersForApi: AccountFollowMethods.ListFollowersForApi
+ listFollowingForApi: AccountFollowMethods.ListFollowingForApi
+
+ listAcceptedFollowerUrlsForApi: AccountFollowMethods.ListAcceptedFollowerUrlsForApi
+ listAcceptedFollowingUrlsForApi: AccountFollowMethods.ListAcceptedFollowingUrlsForApi
}
export interface AccountFollowAttributes {
id: number
createdAt: Date
updatedAt: Date
+
+ AccountFollower?: AccountInstance
+ AccountFollowing?: AccountInstance
}
export interface AccountFollowModel extends AccountFollowClass, Sequelize.Model<AccountFollowInstance, AccountFollowAttributes> {}
import { values } from 'lodash'
import * as Sequelize from 'sequelize'
-import { addMethodsToModel } from '../utils'
+import { addMethodsToModel, getSort } from '../utils'
import { AccountFollowAttributes, AccountFollowInstance, AccountFollowMethods } from './account-follow-interface'
import { FOLLOW_STATES } from '../../initializers/constants'
let AccountFollow: Sequelize.Model<AccountFollowInstance, AccountFollowAttributes>
let loadByAccountAndTarget: AccountFollowMethods.LoadByAccountAndTarget
+let listFollowingForApi: AccountFollowMethods.ListFollowingForApi
+let listFollowersForApi: AccountFollowMethods.ListFollowersForApi
+let listAcceptedFollowerUrlsForApi: AccountFollowMethods.ListAcceptedFollowerUrlsForApi
+let listAcceptedFollowingUrlsForApi: AccountFollowMethods.ListAcceptedFollowingUrlsForApi
export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
AccountFollow = sequelize.define<AccountFollowInstance, AccountFollowAttributes>('AccountFollow',
const classMethods = [
associate,
- loadByAccountAndTarget
+ loadByAccountAndTarget,
+ listFollowingForApi,
+ listFollowersForApi,
+ listAcceptedFollowerUrlsForApi,
+ listAcceptedFollowingUrlsForApi
]
addMethodsToModel(AccountFollow, classMethods)
name: 'accountId',
allowNull: false
},
- as: 'accountFollowers',
+ as: 'AccountFollower',
onDelete: 'CASCADE'
})
name: 'targetAccountId',
allowNull: false
},
- as: 'accountFollowing',
+ as: 'AccountFollowing',
onDelete: 'CASCADE'
})
}
return AccountFollow.findOne(query)
}
+
+listFollowingForApi = function (id: number, start: number, count: number, sort: string) {
+ const query = {
+ distinct: true,
+ offset: start,
+ limit: count,
+ order: [ getSort(sort) ],
+ include: [
+ {
+ model: AccountFollow[ 'sequelize' ].models.Account,
+ required: true,
+ as: 'AccountFollower',
+ where: {
+ id
+ }
+ },
+ {
+ model: AccountFollow['sequelize'].models.Account,
+ as: 'AccountFollowing',
+ required: true,
+ include: [ AccountFollow['sequelize'].models.Pod ]
+ }
+ ]
+ }
+
+ return AccountFollow.findAndCountAll(query).then(({ rows, count }) => {
+ return {
+ data: rows.map(r => r.AccountFollowing),
+ total: count
+ }
+ })
+}
+
+listFollowersForApi = function (id: number, start: number, count: number, sort: string) {
+ const query = {
+ distinct: true,
+ offset: start,
+ limit: count,
+ order: [ getSort(sort) ],
+ include: [
+ {
+ model: AccountFollow[ 'sequelize' ].models.Account,
+ required: true,
+ as: 'AccountFollower',
+ include: [ AccountFollow['sequelize'].models.Pod ]
+ },
+ {
+ model: AccountFollow['sequelize'].models.Account,
+ as: 'AccountFollowing',
+ required: true,
+ where: {
+ id
+ }
+ }
+ ]
+ }
+
+ return AccountFollow.findAndCountAll(query).then(({ rows, count }) => {
+ return {
+ data: rows.map(r => r.AccountFollower),
+ total: count
+ }
+ })
+}
+
+listAcceptedFollowerUrlsForApi = function (id: number, start: number, count?: number) {
+ return createListAcceptedFollowForApiQuery('followers', id, start, count)
+}
+
+listAcceptedFollowingUrlsForApi = function (id: number, start: number, count?: number) {
+ return createListAcceptedFollowForApiQuery('following', id, start, count)
+}
+
+// ------------------------------ UTILS ------------------------------
+
+async function createListAcceptedFollowForApiQuery (type: 'followers' | 'following', id: number, start: number, count?: number) {
+ let firstJoin: string
+ let secondJoin: string
+
+ if (type === 'followers') {
+ firstJoin = 'targetAccountId'
+ secondJoin = 'accountId'
+ } else {
+ firstJoin = 'accountId'
+ secondJoin = 'targetAccountId'
+ }
+
+ const selections = [ '"Followers"."url" AS "url"', 'COUNT(*) AS "total"' ]
+ const tasks: Promise<any>[] = []
+
+ for (const selection of selections) {
+ let query = 'SELECT ' + selection + ' FROM "Account" ' +
+ 'INNER JOIN "AccountFollow" ON "AccountFollow"."' + firstJoin + '" = "Account"."id" ' +
+ 'INNER JOIN "Account" AS "Follows" ON "Followers"."id" = "Follows"."' + secondJoin + '" ' +
+ 'WHERE "Account"."id" = $id AND "AccountFollow"."state" = \'accepted\' ' +
+ 'LIMIT ' + start
+
+ if (count !== undefined) query += ', ' + count
+
+ const options = {
+ bind: { id },
+ type: Sequelize.QueryTypes.SELECT
+ }
+ tasks.push(AccountFollow['sequelize'].query(query, options))
+ }
+
+ const [ followers, [ { total } ]] = await Promise.all(tasks)
+ const urls: string[] = followers.map(f => f.url)
+
+ return {
+ data: urls,
+ total: parseInt(total, 10)
+ }
+}
export type LoadLocalByName = (name: string) => Bluebird<AccountInstance>
export type LoadByNameAndHost = (name: string, host: string) => Bluebird<AccountInstance>
export type ListOwned = () => Bluebird<AccountInstance[]>
- export type ListAcceptedFollowerUrlsForApi = (id: number, start: number, count?: number) => Promise< ResultList<string> >
- export type ListAcceptedFollowingUrlsForApi = (id: number, start: number, count?: number) => Promise< ResultList<string> >
- export type ListFollowingForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountInstance> >
- export type ListFollowersForApi = (id: number, start: number, count: number, sort: string) => Bluebird< ResultList<AccountInstance> >
export type ToActivityPubObject = (this: AccountInstance) => ActivityPubActor
export type ToFormattedJSON = (this: AccountInstance) => FormattedAccount
loadLocalByName: AccountMethods.LoadLocalByName
loadByNameAndHost: AccountMethods.LoadByNameAndHost
listOwned: AccountMethods.ListOwned
- listAcceptedFollowerUrlsForApi: AccountMethods.ListAcceptedFollowerUrlsForApi
- listAcceptedFollowingUrlsForApi: AccountMethods.ListAcceptedFollowingUrlsForApi
- listFollowingForApi: AccountMethods.ListFollowingForApi
- listFollowersForApi: AccountMethods.ListFollowersForApi
}
export interface AccountAttributes {
AccountMethods
} from './account-interface'
import { sendDeleteAccount } from '../../lib/activitypub/send-request'
-import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import { CONFIG, CONSTRAINTS_FIELDS } from '../../initializers/constants'
let Account: Sequelize.Model<AccountInstance, AccountAttributes>
let loadAccountByPodAndUUID: AccountMethods.LoadAccountByPodAndUUID
let loadLocalByName: AccountMethods.LoadLocalByName
let loadByNameAndHost: AccountMethods.LoadByNameAndHost
let listOwned: AccountMethods.ListOwned
-let listAcceptedFollowerUrlsForApi: AccountMethods.ListAcceptedFollowerUrlsForApi
-let listAcceptedFollowingUrlsForApi: AccountMethods.ListAcceptedFollowingUrlsForApi
-let listFollowingForApi: AccountMethods.ListFollowingForApi
-let listFollowersForApi: AccountMethods.ListFollowersForApi
let isOwned: AccountMethods.IsOwned
let toActivityPubObject: AccountMethods.ToActivityPubObject
let toFormattedJSON: AccountMethods.ToFormattedJSON
unique: true
},
{
- fields: [ 'name', 'podId' ],
+ fields: [ 'name', 'podId', 'applicationId' ],
unique: true
}
],
loadByUrl,
loadLocalByName,
loadByNameAndHost,
- listOwned,
- listAcceptedFollowerUrlsForApi,
- listAcceptedFollowingUrlsForApi,
- listFollowingForApi,
- listFollowersForApi
+ listOwned
]
const instanceMethods = [
isOwned,
}
toFormattedJSON = function (this: AccountInstance) {
+ let host = this.Pod ? this.Pod.host : CONFIG.WEBSERVER.HOST
+
const json = {
id: this.id,
- host: this.Pod.host,
+ host,
name: this.name
}
}
getFollowingUrl = function (this: AccountInstance) {
- return this.url + '/followers'
+ return this.url + '/following'
}
getFollowersUrl = function (this: AccountInstance) {
return Account.findAll(query)
}
-listAcceptedFollowerUrlsForApi = function (id: number, start: number, count?: number) {
- return createListAcceptedFollowForApiQuery('followers', id, start, count)
-}
-
-listAcceptedFollowingUrlsForApi = function (id: number, start: number, count?: number) {
- return createListAcceptedFollowForApiQuery('following', id, start, count)
-}
-
-listFollowingForApi = function (id: number, start: number, count: number, sort: string) {
- const query = {
- distinct: true,
- offset: start,
- limit: count,
- order: [ getSort(sort) ],
- include: [
- {
- model: Account['sequelize'].models.AccountFollow,
- required: true,
- as: 'following',
- include: [
- {
- model: Account['sequelize'].models.Account,
- as: 'accountFollowing',
- required: true,
- include: [ Account['sequelize'].models.Pod ]
- }
- ]
- }
- ]
- }
-
- return Account.findAndCountAll(query).then(({ rows, count }) => {
- return {
- data: rows,
- total: count
- }
- })
-}
-
-listFollowersForApi = function (id: number, start: number, count: number, sort: string) {
- const query = {
- distinct: true,
- offset: start,
- limit: count,
- order: [ getSort(sort) ],
- include: [
- {
- model: Account['sequelize'].models.AccountFollow,
- required: true,
- as: 'followers',
- include: [
- {
- model: Account['sequelize'].models.Account,
- as: 'accountFollowers',
- required: true,
- include: [ Account['sequelize'].models.Pod ]
- }
- ]
- }
- ]
- }
-
- return Account.findAndCountAll(query).then(({ rows, count }) => {
- return {
- data: rows,
- total: count
- }
- })
-}
-
loadApplication = function () {
return Account.findOne({
include: [
return Account.find(query)
}
-
-// ------------------------------ UTILS ------------------------------
-
-async function createListAcceptedFollowForApiQuery (type: 'followers' | 'following', id: number, start: number, count?: number) {
- let firstJoin: string
- let secondJoin: string
-
- if (type === 'followers') {
- firstJoin = 'targetAccountId'
- secondJoin = 'accountId'
- } else {
- firstJoin = 'accountId'
- secondJoin = 'targetAccountId'
- }
-
- const selections = [ '"Followers"."url" AS "url"', 'COUNT(*) AS "total"' ]
- const tasks: Promise<any>[] = []
-
- for (const selection of selections) {
- let query = 'SELECT ' + selection + ' FROM "Account" ' +
- 'INNER JOIN "AccountFollow" ON "AccountFollow"."' + firstJoin + '" = "Account"."id" ' +
- 'INNER JOIN "Account" AS "Follows" ON "Followers"."id" = "Follows"."' + secondJoin + '" ' +
- 'WHERE "Account"."id" = $id AND "AccountFollow"."state" = \'accepted\' ' +
- 'LIMIT ' + start
-
- if (count !== undefined) query += ', ' + count
-
- const options = {
- bind: { id },
- type: Sequelize.QueryTypes.SELECT
- }
- tasks.push(Account['sequelize'].query(query, options))
- }
-
- const [ followers, [ { total } ]] = await Promise.all(tasks)
- const urls: string[] = followers.map(f => f.url)
-
- return {
- data: urls,
- total: parseInt(total, 10)
- }
-}
export enum UserRight {
ALL,
MANAGE_USERS,
- MANAGE_PEERTUBE_FOLLOW,
+ MANAGE_APPLICATION_FOLLOW,
MANAGE_VIDEO_ABUSES,
MANAGE_VIDEO_BLACKLIST,
REMOVE_ANY_VIDEO,
- REMOVE_ANY_VIDEO_CHANNEL,
+ REMOVE_ANY_VIDEO_CHANNEL
}
projects / oweals / peertube.git / commitdiff