X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=client%2Fsrc%2Fapp%2Fcore%2Fserver%2Fserver.service.ts;h=ec904bf57b96dcee88c99e6c2ac70137ed9c7675;hb=ba430d7516bc5b1324b60571ba7594460969b7fb;hp=a5be9e19958406fed4edb3972ba914b479262890;hpb=63c4db6d71b98523753c51747e308682d9a2e8a0;p=github%2FChocobozzz%2FPeerTube.git diff --git a/client/src/app/core/server/server.service.ts b/client/src/app/core/server/server.service.ts index a5be9e199..ec904bf57 100644 --- a/client/src/app/core/server/server.service.ts +++ b/client/src/app/core/server/server.service.ts @@ -1,92 +1,279 @@ +import { first, map, share, shareReplay, switchMap, tap } from 'rxjs/operators' import { HttpClient } from '@angular/common/http' -import { Injectable } from '@angular/core' -import 'rxjs/add/operator/do' -import { ReplaySubject } from 'rxjs/ReplaySubject' -import { ServerConfig } from '../../../../../shared' +import { Inject, Injectable, LOCALE_ID } from '@angular/core' +import { peertubeLocalStorage } from '@app/shared/misc/peertube-web-storage' +import { Observable, of, Subject } from 'rxjs' +import { getCompleteLocale, ServerConfig } from '../../../../../shared' import { environment } from '../../../environments/environment' +import { VideoConstant } from '../../../../../shared/models/videos' +import { isDefaultLocale, peertubeTranslate } from '../../../../../shared/models/i18n' +import { getDevLocale, isOnDevLocale } from '@app/shared/i18n/i18n-utils' +import { sortBy } from '@app/shared/misc/utils' @Injectable() export class ServerService { private static BASE_CONFIG_URL = environment.apiUrl + '/api/v1/config/' private static BASE_VIDEO_URL = environment.apiUrl + '/api/v1/videos/' + private static BASE_VIDEO_PLAYLIST_URL = environment.apiUrl + '/api/v1/video-playlists/' + private static BASE_LOCALE_URL = environment.apiUrl + '/client/locales/' + private static CONFIG_LOCAL_STORAGE_KEY = 'server-config' - videoPrivaciesLoaded = new ReplaySubject(1) - videoCategoriesLoaded = new ReplaySubject(1) - videoLicencesLoaded = new ReplaySubject(1) - videoLanguagesLoaded = new ReplaySubject(1) + configReloaded = new Subject() + private localeObservable: Observable + private videoLicensesObservable: Observable[]> + private videoCategoriesObservable: Observable[]> + private videoPrivaciesObservable: Observable[]> + private videoPlaylistPrivaciesObservable: Observable[]> + private videoLanguagesObservable: Observable[]> + private configObservable: Observable + + private configReset = false + + private configLoaded = false private config: ServerConfig = { + instance: { + name: 'PeerTube', + shortDescription: 'PeerTube, a federated (ActivityPub) video streaming platform ' + + 'using P2P (BitTorrent) directly in the web browser with WebTorrent and Angular.', + defaultClientRoute: '', + isNSFW: false, + defaultNSFWPolicy: 'do_not_list' as 'do_not_list', + customizations: { + javascript: '', + css: '' + } + }, + plugin: { + registered: [] + }, + theme: { + registered: [], + default: 'default' + }, + email: { + enabled: false + }, + contactForm: { + enabled: false + }, + serverVersion: 'Unknown', signup: { - allowed: false + allowed: false, + allowedForCurrentIP: false, + requiresEmailVerification: false }, transcoding: { - enabledResolutions: [] + enabledResolutions: [], + hls: { + enabled: false + }, + webtorrent: { + enabled: true + } + }, + avatar: { + file: { + size: { max: 0 }, + extensions: [] + } + }, + video: { + image: { + size: { max: 0 }, + extensions: [] + }, + file: { + extensions: [] + } + }, + videoCaption: { + file: { + size: { max: 0 }, + extensions: [] + } + }, + user: { + videoQuota: -1, + videoQuotaDaily: -1 + }, + import: { + videos: { + http: { + enabled: false + }, + torrent: { + enabled: false + } + } + }, + trending: { + videos: { + intervalDays: 0 + } + }, + autoBlacklist: { + videos: { + ofUsers: { + enabled: false + } + } + }, + tracker: { + enabled: true } } - private videoCategories: Array<{ id: number, label: string }> = [] - private videoLicences: Array<{ id: number, label: string }> = [] - private videoLanguages: Array<{ id: number, label: string }> = [] - private videoPrivacies: Array<{ id: number, label: string }> = [] - constructor (private http: HttpClient) {} - - loadConfig () { - this.http.get(ServerService.BASE_CONFIG_URL) - .subscribe(data => this.config = data) + constructor ( + private http: HttpClient, + @Inject(LOCALE_ID) private localeId: string + ) { + this.loadConfigLocally() } - loadVideoCategories () { - return this.loadVideoAttributeEnum('categories', this.videoCategories, this.videoCategoriesLoaded) - } + getServerVersionAndCommit () { + const serverVersion = this.config.serverVersion + const commit = this.config.serverCommit || '' - loadVideoLicences () { - return this.loadVideoAttributeEnum('licences', this.videoLicences, this.videoLicencesLoaded) - } + let result = serverVersion + if (commit) result += '...' + commit - loadVideoLanguages () { - return this.loadVideoAttributeEnum('languages', this.videoLanguages, this.videoLanguagesLoaded) + return result } - loadVideoPrivacies () { - return this.loadVideoAttributeEnum('privacies', this.videoPrivacies, this.videoPrivaciesLoaded) + resetConfig () { + this.configLoaded = false + this.configReset = true } getConfig () { + if (this.configLoaded) return of(this.config) + + if (!this.configObservable) { + this.configObservable = this.http.get(ServerService.BASE_CONFIG_URL) + .pipe( + tap(this.saveConfigLocally), + tap(() => this.configLoaded = true), + tap(() => { + if (this.configReset) { + this.configReloaded.next() + this.configReset = false + } + }), + share() + ) + } + + return this.configObservable + } + + getTmpConfig () { return this.config } getVideoCategories () { - return this.videoCategories + if (!this.videoCategoriesObservable) { + this.videoCategoriesObservable = this.loadAttributeEnum(ServerService.BASE_VIDEO_URL, 'categories', true) + } + + return this.videoCategoriesObservable.pipe(first()) } getVideoLicences () { - return this.videoLicences + if (!this.videoLicensesObservable) { + this.videoLicensesObservable = this.loadAttributeEnum(ServerService.BASE_VIDEO_URL, 'licences') + } + + return this.videoLicensesObservable.pipe(first()) } getVideoLanguages () { - return this.videoLanguages + if (!this.videoLanguagesObservable) { + this.videoLanguagesObservable = this.loadAttributeEnum(ServerService.BASE_VIDEO_URL, 'languages', true) + } + + return this.videoLanguagesObservable.pipe(first()) } getVideoPrivacies () { - return this.videoPrivacies + if (!this.videoPrivaciesObservable) { + this.videoPrivaciesObservable = this.loadAttributeEnum(ServerService.BASE_VIDEO_URL, 'privacies') + } + + return this.videoPrivaciesObservable.pipe(first()) } - private loadVideoAttributeEnum ( + getVideoPlaylistPrivacies () { + if (!this.videoPlaylistPrivaciesObservable) { + this.videoPlaylistPrivaciesObservable = this.loadAttributeEnum(ServerService.BASE_VIDEO_PLAYLIST_URL, 'privacies') + } + + return this.videoPlaylistPrivaciesObservable.pipe(first()) + } + + getServerLocale () { + if (!this.localeObservable) { + const completeLocale = isOnDevLocale() ? getDevLocale() : getCompleteLocale(this.localeId) + + // Default locale, nothing to translate + if (isDefaultLocale(completeLocale)) { + this.localeObservable = of({}).pipe(shareReplay()) + } else { + this.localeObservable = this.http + .get(ServerService.BASE_LOCALE_URL + completeLocale + '/server.json') + .pipe(shareReplay()) + } + } + + return this.localeObservable.pipe(first()) + } + + private loadAttributeEnum ( + baseUrl: string, attributeName: 'categories' | 'licences' | 'languages' | 'privacies', - hashToPopulate: { id: number, label: string }[], - notifier: ReplaySubject + sort = false ) { - return this.http.get(ServerService.BASE_VIDEO_URL + attributeName) - .subscribe(data => { - Object.keys(data) - .forEach(dataKey => { - hashToPopulate.push({ - id: parseInt(dataKey, 10), - label: data[dataKey] - }) - }) - - notifier.next(true) - }) + return this.getServerLocale() + .pipe( + switchMap(translations => { + return this.http.get<{ [ id: string ]: string }>(baseUrl + attributeName) + .pipe(map(data => ({ data, translations }))) + }), + map(({ data, translations }) => { + const hashToPopulate: VideoConstant[] = [] + + Object.keys(data) + .forEach(dataKey => { + const label = data[ dataKey ] + + hashToPopulate.push({ + id: (attributeName === 'languages' ? dataKey : parseInt(dataKey, 10)) as T, + label: peertubeTranslate(label, translations) + }) + }) + + if (sort === true) sortBy(hashToPopulate, 'label') + + return hashToPopulate + }), + shareReplay() + ) + } + + private saveConfigLocally (config: ServerConfig) { + peertubeLocalStorage.setItem(ServerService.CONFIG_LOCAL_STORAGE_KEY, JSON.stringify(config)) + } + + private loadConfigLocally () { + const configString = peertubeLocalStorage.getItem(ServerService.CONFIG_LOCAL_STORAGE_KEY) + + if (configString) { + try { + const parsed = JSON.parse(configString) + Object.assign(this.config, parsed) + } catch (err) { + console.error('Cannot parse config saved in local storage.', err) + } + } } }