client/src/app/core/server/server.service.ts

   1 import { Observable, of, Subject } from 'rxjs'
   2 import { first, map, share, shareReplay, switchMap, tap } from 'rxjs/operators'
   3 import { HttpClient } from '@angular/common/http'
   4 import { Inject, Injectable, LOCALE_ID } from '@angular/core'
   5 import { getDevLocale, isOnDevLocale, sortBy } from '@app/helpers'
   6 import { peertubeLocalStorage } from '@root-helpers/peertube-web-storage'
   7 import { getCompleteLocale, isDefaultLocale, peertubeTranslate } from '@shared/core-utils/i18n'
   8 import { SearchTargetType, ServerConfig, ServerStats, VideoConstant } from '@shared/models'
   9 import { environment } from '../../../environments/environment'
  10
  11 @Injectable()
  12 export class ServerService {
  13   private static BASE_CONFIG_URL = environment.apiUrl + '/api/v1/config/'
  14   private static BASE_VIDEO_URL = environment.apiUrl + '/api/v1/videos/'
  15   private static BASE_VIDEO_PLAYLIST_URL = environment.apiUrl + '/api/v1/video-playlists/'
  16   private static BASE_LOCALE_URL = environment.apiUrl + '/client/locales/'
  17   private static BASE_STATS_URL = environment.apiUrl + '/api/v1/server/stats'
  18
  19   private static CONFIG_LOCAL_STORAGE_KEY = 'server-config'
  20
  21   configReloaded = new Subject<ServerConfig>()
  22
  23   private localeObservable: Observable<any>
  24   private videoLicensesObservable: Observable<VideoConstant<number>[]>
  25   private videoCategoriesObservable: Observable<VideoConstant<number>[]>
  26   private videoPrivaciesObservable: Observable<VideoConstant<number>[]>
  27   private videoPlaylistPrivaciesObservable: Observable<VideoConstant<number>[]>
  28   private videoLanguagesObservable: Observable<VideoConstant<string>[]>
  29   private configObservable: Observable<ServerConfig>
  30
  31   private configReset = false
  32
  33   private configLoaded = false
  34   private config: ServerConfig = {
  35     instance: {
  36       name: 'PeerTube',
  37       shortDescription: 'PeerTube, a federated (ActivityPub) video streaming platform  ' +
  38                         'using P2P (BitTorrent) directly in the web browser with WebTorrent and Angular.',
  39       isNSFW: false,
  40       defaultNSFWPolicy: 'do_not_list' as 'do_not_list',
  41       defaultClientRoute: '',
  42       customizations: {
  43         javascript: '',
  44         css: ''
  45       }
  46     },
  47     plugin: {
  48       registered: [],
  49       registeredExternalAuths: [],
  50       registeredIdAndPassAuths: []
  51     },
  52     theme: {
  53       registered: [],
  54       default: 'default'
  55     },
  56     email: {
  57       enabled: false
  58     },
  59     contactForm: {
  60       enabled: false
  61     },
  62     serverVersion: 'Unknown',
  63     signup: {
  64       allowed: false,
  65       allowedForCurrentIP: false,
  66       requiresEmailVerification: false
  67     },
  68     transcoding: {
  69       enabledResolutions: [],
  70       hls: {
  71         enabled: false
  72       },
  73       webtorrent: {
  74         enabled: true
  75       }
  76     },
  77     live: {
  78       enabled: false,
  79       allowReplay: true,
  80       maxDuration: null,
  81       maxInstanceLives: -1,
  82       maxUserLives: -1,
  83       transcoding: {
  84         enabled: false,
  85         enabledResolutions: []
  86       },
  87       rtmp: {
  88         port: 1935
  89       }
  90     },
  91     avatar: {
  92       file: {
  93         size: { max: 0 },
  94         extensions: []
  95       }
  96     },
  97     video: {
  98       image: {
  99         size: { max: 0 },
 100         extensions: []
 101       },
 102       file: {
 103         extensions: []
 104       }
 105     },
 106     videoCaption: {
 107       file: {
 108         size: { max: 0 },
 109         extensions: []
 110       }
 111     },
 112     user: {
 113       videoQuota: -1,
 114       videoQuotaDaily: -1
 115     },
 116     import: {
 117       videos: {
 118         http: {
 119           enabled: false
 120         },
 121         torrent: {
 122           enabled: false
 123         }
 124       }
 125     },
 126     trending: {
 127       videos: {
 128         intervalDays: 0,
 129         algorithms: {
 130           enabled: [ 'hot', 'most-viewed', 'most-liked' ],
 131           default: 'most-viewed'
 132         }
 133       }
 134     },
 135     autoBlacklist: {
 136       videos: {
 137         ofUsers: {
 138           enabled: false
 139         }
 140       }
 141     },
 142     tracker: {
 143       enabled: true
 144     },
 145     followings: {
 146       instance: {
 147         autoFollowIndex: {
 148           indexUrl: 'https://instances.joinpeertube.org'
 149         }
 150       }
 151     },
 152     broadcastMessage: {
 153       enabled: false,
 154       message: '',
 155       level: 'info',
 156       dismissable: false
 157     },
 158     search: {
 159       remoteUri: {
 160         users: true,
 161         anonymous: false
 162       },
 163       searchIndex: {
 164         enabled: false,
 165         url: '',
 166         disableLocalSearch: false,
 167         isDefaultSearch: false
 168       }
 169     }
 170   }
 171
 172   constructor (
 173     private http: HttpClient,
 174     @Inject(LOCALE_ID) private localeId: string
 175   ) {
 176     this.loadConfigLocally()
 177   }
 178
 179   getServerVersionAndCommit () {
 180     const serverVersion = this.config.serverVersion
 181     const commit = this.config.serverCommit || ''
 182
 183     let result = serverVersion
 184     if (commit) result += '...' + commit
 185
 186     return result
 187   }
 188
 189   resetConfig () {
 190     this.configLoaded = false
 191     this.configReset = true
 192
 193     // Notify config update
 194     this.getConfig().subscribe(() => {
 195       // empty, to fire a reset config event
 196     })
 197   }
 198
 199   getConfig () {
 200     if (this.configLoaded) return of(this.config)
 201
 202     if (!this.configObservable) {
 203       this.configObservable = this.http.get<ServerConfig>(ServerService.BASE_CONFIG_URL)
 204                                   .pipe(
 205                                     tap(config => this.saveConfigLocally(config)),
 206                                     tap(config => {
 207                                       this.config = config
 208                                       this.configLoaded = true
 209                                     }),
 210                                     tap(config => {
 211                                       if (this.configReset) {
 212                                         this.configReloaded.next(config)
 213                                         this.configReset = false
 214                                       }
 215                                     }),
 216                                     share()
 217                                   )
 218     }
 219
 220     return this.configObservable
 221   }
 222
 223   getTmpConfig () {
 224     return this.config
 225   }
 226
 227   getVideoCategories () {
 228     if (!this.videoCategoriesObservable) {
 229       this.videoCategoriesObservable = this.loadAttributeEnum<number>(ServerService.BASE_VIDEO_URL, 'categories', true)
 230     }
 231
 232     return this.videoCategoriesObservable.pipe(first())
 233   }
 234
 235   getVideoLicences () {
 236     if (!this.videoLicensesObservable) {
 237       this.videoLicensesObservable = this.loadAttributeEnum<number>(ServerService.BASE_VIDEO_URL, 'licences')
 238     }
 239
 240     return this.videoLicensesObservable.pipe(first())
 241   }
 242
 243   getVideoLanguages () {
 244     if (!this.videoLanguagesObservable) {
 245       this.videoLanguagesObservable = this.loadAttributeEnum<string>(ServerService.BASE_VIDEO_URL, 'languages', true)
 246     }
 247
 248     return this.videoLanguagesObservable.pipe(first())
 249   }
 250
 251   getVideoPrivacies () {
 252     if (!this.videoPrivaciesObservable) {
 253       this.videoPrivaciesObservable = this.loadAttributeEnum<number>(ServerService.BASE_VIDEO_URL, 'privacies')
 254     }
 255
 256     return this.videoPrivaciesObservable.pipe(first())
 257   }
 258
 259   getVideoPlaylistPrivacies () {
 260     if (!this.videoPlaylistPrivaciesObservable) {
 261       this.videoPlaylistPrivaciesObservable = this.loadAttributeEnum<number>(ServerService.BASE_VIDEO_PLAYLIST_URL, 'privacies')
 262     }
 263
 264     return this.videoPlaylistPrivaciesObservable.pipe(first())
 265   }
 266
 267   getServerLocale () {
 268     if (!this.localeObservable) {
 269       const completeLocale = isOnDevLocale() ? getDevLocale() : getCompleteLocale(this.localeId)
 270
 271       // Default locale, nothing to translate
 272       if (isDefaultLocale(completeLocale)) {
 273         this.localeObservable = of({}).pipe(shareReplay())
 274       } else {
 275         this.localeObservable = this.http
 276                                     .get(ServerService.BASE_LOCALE_URL + completeLocale + '/server.json')
 277                                     .pipe(shareReplay())
 278       }
 279     }
 280
 281     return this.localeObservable.pipe(first())
 282   }
 283
 284   getServerStats () {
 285     return this.http.get<ServerStats>(ServerService.BASE_STATS_URL)
 286   }
 287
 288   getDefaultSearchTarget (): Promise<SearchTargetType> {
 289     return this.getConfig().pipe(
 290       map(config => {
 291         const searchIndexConfig = config.search.searchIndex
 292
 293         if (searchIndexConfig.enabled && (searchIndexConfig.isDefaultSearch || searchIndexConfig.disableLocalSearch)) {
 294           return 'search-index'
 295         }
 296
 297         return 'local'
 298       })
 299     ).toPromise()
 300   }
 301
 302   private loadAttributeEnum <T extends string | number> (
 303     baseUrl: string,
 304     attributeName: 'categories' | 'licences' | 'languages' | 'privacies',
 305     sort = false
 306   ) {
 307     return this.getServerLocale()
 308                .pipe(
 309                  switchMap(translations => {
 310                    return this.http.get<{ [ id: string ]: string }>(baseUrl + attributeName)
 311                               .pipe(map(data => ({ data, translations })))
 312                  }),
 313                  map(({ data, translations }) => {
 314                    const hashToPopulate: VideoConstant<T>[] = Object.keys(data)
 315                                                                     .map(dataKey => {
 316                                                                       const label = data[ dataKey ]
 317
 318                                                                       const id = attributeName === 'languages'
 319                                                                         ? dataKey as T
 320                                                                         : parseInt(dataKey, 10) as T
 321
 322                                                                       return {
 323                                                                         id,
 324                                                                         label: peertubeTranslate(label, translations)
 325                                                                       }
 326                                                                     })
 327
 328                    if (sort === true) sortBy(hashToPopulate, 'label')
 329
 330                    return hashToPopulate
 331                  }),
 332                  shareReplay()
 333                )
 334   }
 335
 336   private saveConfigLocally (config: ServerConfig) {
 337     peertubeLocalStorage.setItem(ServerService.CONFIG_LOCAL_STORAGE_KEY, JSON.stringify(config))
 338   }
 339
 340   private loadConfigLocally () {
 341     const configString = peertubeLocalStorage.getItem(ServerService.CONFIG_LOCAL_STORAGE_KEY)
 342
 343     if (configString) {
 344       try {
 345         const parsed = JSON.parse(configString)
 346         Object.assign(this.config, parsed)
 347       } catch (err) {
 348         console.error('Cannot parse config saved in local storage.', err)
 349       }
 350     }
 351   }
 352 }