File

src/app/modules/shared/services/resource/resource.service.ts

Description

Service to fetch resource bundle

Constructor

constructor(config: ConfigService, http: HttpClient, _cacheService: CacheService, cacheService: CacheService, browserCacheTtlService: BrowserCacheTtlService)

constructor

Parameters :
  • config : ConfigService

    ConfigService reference

  • http : HttpClient

    LearnerService reference

Methods

Public initialize
initialize()
Returns: void
Public getResource
getResource(language: string, range: any)

method to fetch resource bundle

Returns: void
get
get(requestParam: RequestParam)
Returns: Observable<any>
Private getHeader
getHeader()
Returns: HttpHeaders | { [header: string]: any; }
getLanguageChange
getLanguageChange(language: any)
Returns: void

Properties

Private _instance
_instance: string

Contains instance name

Private _languageSelected
_languageSelected: BehaviorSubject<any>
Public baseUrl
baseUrl: string
Public config
config: ConfigService

reference of config service.

frmelmnts
frmelmnts: any

frmelmnts bundle

Public http
http: HttpClient
instance
instance: string

get method to fetch instance.

languageSelected$
languageSelected$: Observable<any>
messages
messages: any

messages bundle

Static singletonInstance
singletonInstance: ResourceService
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
import {of as observableOf, throwError as observableThrowError,  Observable, BehaviorSubject } from 'rxjs';

import {mergeMap} from 'rxjs/operators';
import { BrowserCacheTtlService } from './../browser-cache-ttl/browser-cache-ttl.service';
import { HttpOptions, RequestParam, ServerResponse } from './../../interfaces';
import { ConfigService } from './../config/config.service';
import { Injectable, EventEmitter } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { v4 as UUID } from 'uuid';
import * as moment from 'moment';
import { CacheService } from '../../../shared/services/cache-service/cache.service';
import * as _ from 'lodash-es';
/**
 * Service to fetch resource bundle
 */
@Injectable()
export class ResourceService {
  // Workaround for issue https://github.com/angular/angular/issues/12889
  // Dependency injection creates new instance each time if used in router sub-modules
  static singletonInstance: ResourceService;
  /**
  * messages bundle
  */
  messages: any = {};
  /**
  * frmelmnts bundle
  */
  frmelmnts: any = {};
  /**
   * reference of config service.
   */
  public config: ConfigService;
  public baseUrl: string;
  public http: HttpClient;

  /**
   * Contains instance name
   */
  private _instance: string;
  // Observable navItem source
  private _languageSelected = new BehaviorSubject<any>({});
  // Observable navItem stream
  languageSelected$ = this._languageSelected.asObservable();

  /**
   * constructor
   * @param {ConfigService} config ConfigService reference
   * @param {HttpClient} http LearnerService reference
   */
  constructor(config: ConfigService, http: HttpClient, private _cacheService: CacheService,
    private cacheService: CacheService, private browserCacheTtlService: BrowserCacheTtlService) {
    if (!ResourceService.singletonInstance) {
      this.http = http;
      this.config = config;
      this.baseUrl = this.config.urlConFig.URLS.RESOURCEBUNDLES_PREFIX;
      try {
        this._instance = (<HTMLInputElement>document.getElementById('instance')).value;
      } catch (error) {
      }
      ResourceService.singletonInstance = this;
    }
    return ResourceService.singletonInstance;
  }
  public initialize() {
    const range  = {value: 'en', label: 'English', dir: 'ltr'};
    this.getResource(this._cacheService.get('portalLanguage') || 'en', range);
  }
  /**
   * method to fetch resource bundle
  */
  public getResource(language = 'en', range: any = {}): void {
    const resourcebundles: any | null = this.cacheService.get('resourcebundles' + language);
    if (resourcebundles) {
      this.messages = resourcebundles.messages;
      this.frmelmnts = resourcebundles.frmelmnts;
      this.getLanguageChange(range);
    } else {
      const option = {
        url: this.config.urlConFig.URLS.RESOURCEBUNDLES.ENG + '/' + language
      };
      this.get(option).subscribe(
        (data: ServerResponse) => {
          this.messages = _.merge({},  data.result.creation.messages, data.result.consumption.messages);
          this.frmelmnts = _.merge({}, data.result.creation.frmelmnts, data.result.consumption.frmelmnts);
          this.cacheService.set('resourcebundles' + language, {
            messages: this.messages,
            frmelmnts: this.frmelmnts
          }, {
              maxAge: this.browserCacheTtlService.browserCacheTtl
            });
          this.getLanguageChange(range);
        },
        (err: ServerResponse) => {
        }
      );
    }
  }
  get(requestParam: RequestParam): Observable<any> {
    const httpOptions: HttpOptions = {
      headers: requestParam.header ? requestParam.header : this.getHeader(),
      params: requestParam.param
    };
    return this.http.get(this.baseUrl + requestParam.url, httpOptions).pipe(
      mergeMap((data: ServerResponse) => {
        if (data.responseCode !== 'OK') {
          return observableThrowError(data);
        }
        return observableOf(data);
      }));
  }
  private getHeader(): HttpOptions['headers'] {
    return {
      'Content-Type': 'application/json',
      'Accept': 'application/json',
      'X-Consumer-ID': 'X-Consumer-ID',
      'X-Device-ID': 'X-Device-ID',
      'X-Org-code': '',
      'X-Source': 'web',
      'ts': moment().format(),
      'X-msgid': UUID(),
      'X-Request-ID': UUID()
    };
  }
  /**
 * get method to fetch instance.
 */
  get instance(): string {
    return _.upperCase(this._instance);
  }

  getLanguageChange(language) {
    this._languageSelected.next(language);
  }
}

results matching ""

    No results matching ""