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

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