@fdot/angular-dotcodes
Version:
`npm install @fdot/angular-dotcodes --save`
413 lines (402 loc) • 38.8 kB
JavaScript
import { Inject, Injectable, Pipe, Component, Input, defineInjectable, inject, NgModule, EventEmitter, Output } from '@angular/core';
import { HttpClient, HttpHeaders, HttpParams, HttpClientModule } from '@angular/common/http';
import { Observable, BehaviorSubject } from 'rxjs';
import { map } from 'rxjs/operators';
import { CommonModule } from '@angular/common';
import { FormsModule } from '@angular/forms';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class Config {
/**
* @param {?} host
* @param {?} apiKey
* @param {?} useDefaultSelect
* @param {?} defaultSelectText
*/
constructor(host, apiKey, useDefaultSelect, defaultSelectText) {
this.host = host;
this.apiKey = apiKey;
this.useDefaultSelect = useDefaultSelect;
this.defaultSelectText = defaultSelectText;
}
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class AngularDotcodesService {
/**
* @param {?} http
* @param {?} config
*/
constructor(http, config) {
this.http = http;
this.config = config;
this.codesCache = new Map();
this.codeCache = new Map();
if (!config) {
throw Error('Call AngularDotcodesService with for root passing in the config object');
}
}
/**
* Method GetCode
* @param {?} column Column name to get Dotcode from
* @param {?} codeValue The code value to retrieve
* @return {?} Full HTTP response as Observable
*/
GetCode(column, codeValue) {
const /** @type {?} */ key = `${column}-${codeValue}`;
if (this.codeCache.get(key)) {
this.codeCache.get(`${column}-${codeValue}`);
}
else if (this.codesCache.get(column)) {
const /** @type {?} */ codes = this.codesCache.get(column).value;
if (codes) {
const /** @type {?} */ code = codes.filter(c => c.value === codeValue);
if (code && code.length === 1) {
if (!this.codeCache.get(key)) {
this.codeCache.set(key, new BehaviorSubject(null));
}
this.codeCache.get(key).next(code[0]);
}
else {
this.loadCodes(key, column, codeValue);
}
}
else {
this.loadCodes(key, column, codeValue);
}
}
else {
this.loadCodes(key, column, codeValue);
}
return this.codeCache.get(key);
}
/**
* @param {?} key
* @param {?} column
* @param {?} codeValue
* @return {?}
*/
loadCodes(key, column, codeValue) {
this.codeCache.set(key, new BehaviorSubject(null));
const /** @type {?} */ uri = `/GetCode`;
const /** @type {?} */ headers = new HttpHeaders();
let /** @type {?} */ params = new HttpParams();
if (column !== undefined && column !== null) {
params = params.set('column', column + '');
}
if (codeValue !== undefined && codeValue !== null) {
params = params.set('codeValue', codeValue + '');
}
this.sendRequest('get', uri, headers, params, null).toPromise().then(b => {
if (b && b.body) {
this.codeCache.get(key).next(b.body);
}
});
}
/**
* Method GetCodes
* @param {?} column Column name to get Dotcode from
* @return {?} Full HTTP response as Observable
*/
GetCodes(column) {
if (this.codesCache.get(column)) {
this.codesCache.get(column);
}
else {
this.codesCache.set(column, new BehaviorSubject(null));
const /** @type {?} */ uri = `/GetCodes`;
const /** @type {?} */ headers = new HttpHeaders();
let /** @type {?} */ params = new HttpParams();
if (column !== undefined && column !== null) {
params = params.set('column', column + '');
}
this.sendRequest('get', uri, headers, params, null).toPromise().then(b => {
if (b && b.body) {
this.codesCache.get(column).next(b.body);
}
});
}
return this.codesCache.get(column);
}
/**
* Method GetRelatedCodes
* @param {?} column Column name for dotcode
* @param {?} codeValue DotCode value to get related codes for
* @param {?} relatedCode Related Column name to get Related Codes from
* @return {?} Full HTTP response as Observable
*/
GetRelatedCodes(column, codeValue, relatedCode) {
const /** @type {?} */ uri = `/GetRelatedCodes`;
const /** @type {?} */ headers = new HttpHeaders();
let /** @type {?} */ params = new HttpParams();
if (column !== undefined && column !== null) {
params = params.set('column', column + '');
}
if (codeValue !== undefined && codeValue !== null) {
params = params.set('codeValue', codeValue + '');
}
if (relatedCode !== undefined && relatedCode !== null) {
params = params.set('relatedCode', relatedCode + '');
}
return this.sendRequest('get', uri, headers, params, null).pipe(map(b => {
if (b && b.body) {
return b.body;
}
}));
}
/**
* @template T
* @param {?} method
* @param {?} uri
* @param {?} headers
* @param {?} params
* @param {?} body
* @return {?}
*/
sendRequest(method, uri, headers, params, body) {
headers = headers.set('Ocp-Apim-Subscription-Key', this.config.apiKey);
if (method === 'get') {
return this.http.get(this.config.host + uri, { headers: headers.set('Accept', 'application/json'), params: params, observe: 'response' });
}
else if (method === 'put') {
return this.http.put(this.config.host + uri, body, { headers: headers.set('Content-Type', 'application/json'), params: params, observe: 'response' });
}
else if (method === 'post') {
return this.http.post(this.config.host + uri, body, { headers: headers.set('Content-Type', 'application/json'), params: params, observe: 'response' });
}
else if (method === 'delete') {
return this.http.delete(this.config.host + uri, { headers: headers, params: params, observe: 'response' });
}
else {
console.error('Unsupported request: ' + method);
return Observable.throw('Unsupported request: ' + method);
}
}
}
AngularDotcodesService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] },
];
/** @nocollapse */
AngularDotcodesService.ctorParameters = () => [
{ type: HttpClient, },
{ type: Config, decorators: [{ type: Inject, args: ['config',] },] },
];
/** @nocollapse */ AngularDotcodesService.ngInjectableDef = defineInjectable({ factory: function AngularDotcodesService_Factory() { return new AngularDotcodesService(inject(HttpClient), inject("config")); }, token: AngularDotcodesService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class AngularDotcodesComponent {
/**
* @param {?} dotcodeService
*/
constructor(dotcodeService) {
this.dotcodeService = dotcodeService;
}
/**
* @return {?}
*/
ngOnInit() {
console.log('init');
this.dotcodeService.GetCode(this.column, this.value).subscribe(code => {
console.log(code);
this.code = code;
});
}
}
AngularDotcodesComponent.decorators = [
{ type: Component, args: [{
selector: 'fdot-angular-dotcodes',
template: `
<span *ngIf="code">
{{code.description}}
</span>
`,
styles: []
},] },
];
/** @nocollapse */
AngularDotcodesComponent.ctorParameters = () => [
{ type: AngularDotcodesService, },
];
AngularDotcodesComponent.propDecorators = {
"column": [{ type: Input },],
"value": [{ type: Input },],
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class DotcodesSelectComponent {
/**
* @param {?} dotCodeService
* @param {?} config
*/
constructor(dotCodeService, config) {
this.dotCodeService = dotCodeService;
this.config = config;
this.selectedDotcode = new EventEmitter();
}
/**
* @param {?} value
* @return {?}
*/
set value(value) {
this._value = value;
this.setSelectedCode();
}
/**
* @return {?}
*/
get value() {
return this._value;
}
/**
* @return {?}
*/
ngOnInit() {
// tslint:disable-next-line:triple-equals
if (!(this.useDefaultSelect === false || /** @type {?} */ (this.useDefaultSelect) === 'false')
&& this.config != null && this.config.useDefaultSelect) {
this.useDefaultSelect = true;
}
else {
this.useDefaultSelect = false;
}
if (!this.defaultSelectText && this.config != null && this.config.defaultSelectText) {
this.defaultSelectText = this.config.defaultSelectText;
}
this.dotCodeService.GetCodes(this.column).subscribe(codes => {
this.codes = codes;
this.setSelectedCode();
});
}
/**
* @return {?}
*/
setSelectedCode() {
if (!this.codes) {
return;
}
if (this.value) {
const /** @type {?} */ code = this.codes.find(c => c.value === this.value);
if (code) {
this.selectedCode = code;
this.codeChanged();
}
}
}
/**
* @return {?}
*/
codeChanged() {
this.selectedDotcode.emit(this.selectedCode);
}
}
DotcodesSelectComponent.decorators = [
{ type: Component, args: [{
selector: 'fdot-dotcodes-select',
template: `<select [(ngModel)]="selectedCode" (change)="codeChanged()" class="form-control" [disabled]="disabled">
<option *ngIf="useDefaultSelect" value="">
{{defaultSelectText}}
</option>
<option *ngFor="let code of codes" [ngValue]="code">
{{code.description}}
</option>
</select>
`,
styles: [``]
},] },
];
/** @nocollapse */
DotcodesSelectComponent.ctorParameters = () => [
{ type: AngularDotcodesService, },
{ type: Config, decorators: [{ type: Inject, args: ['config',] },] },
];
DotcodesSelectComponent.propDecorators = {
"column": [{ type: Input },],
"value": [{ type: Input },],
"disabled": [{ type: Input },],
"selectedDotcode": [{ type: Output },],
"useDefaultSelect": [{ type: Input },],
"defaultSelectText": [{ type: Input },],
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class DotcodePipe {
/**
* @param {?} dotcodeService
*/
constructor(dotcodeService) {
this.dotcodeService = dotcodeService;
}
/**
* @param {?} value
* @param {?} column
* @return {?}
*/
transform(value, column) {
return this.dotcodeService.GetCode(column, value).pipe(map(c => {
if (c) {
return c.description;
}
}));
}
}
DotcodePipe.decorators = [
{ type: Pipe, args: [{
name: 'dotcode',
},] },
];
/** @nocollapse */
DotcodePipe.ctorParameters = () => [
{ type: AngularDotcodesService, },
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class AngularDotcodesModule {
/**
* @param {?} config
* @return {?}
*/
static forRoot(config) {
return {
ngModule: AngularDotcodesModule,
providers: [AngularDotcodesService,
{ provide: 'config', useValue: config }
]
};
}
}
AngularDotcodesModule.decorators = [
{ type: NgModule, args: [{
imports: [HttpClientModule, CommonModule, FormsModule
],
declarations: [AngularDotcodesComponent, DotcodesSelectComponent, DotcodePipe],
exports: [AngularDotcodesComponent, DotcodesSelectComponent, DotcodePipe]
},] },
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
export { AngularDotcodesService, AngularDotcodesComponent, Config, DotcodesSelectComponent, AngularDotcodesModule, DotcodePipe as ɵa };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"fdot-angular-dotcodes.js.map","sources":["ng://@fdot/angular-dotcodes/lib/models/config.ts","ng://@fdot/angular-dotcodes/lib/angular-dotcodes.service.ts","ng://@fdot/angular-dotcodes/lib/angular-dotcodes.component.ts","ng://@fdot/angular-dotcodes/lib/dotcodes-select/dotcodes-select.component.ts","ng://@fdot/angular-dotcodes/lib/dotcode.pipe.ts","ng://@fdot/angular-dotcodes/lib/angular-dotcodes.module.ts"],"sourcesContent":["export class Config {\r\n    constructor(public host: string, public apiKey: string, public useDefaultSelect: boolean,\r\n        public defaultSelectText: string) {\r\n\r\n    }\r\n}\r\n","import { Inject, Injectable, Optional } from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams, HttpResponse } from '@angular/common/http';\r\nimport { Observable, BehaviorSubject } from 'rxjs';\r\nimport { map } from 'rxjs/operators';\r\n\r\nimport {\r\n  DotCode,\r\n  RelatedCode\r\n} from './models';\r\nimport { Config } from './models/config';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AngularDotcodesService {\r\n  private codesCache = new Map<string, BehaviorSubject<DotCode[]>>();\r\n  private codeCache = new Map<string, BehaviorSubject<DotCode>>();\r\n\r\n  constructor(private http: HttpClient, @Inject('config') private config: Config) {\r\n    if (!config) {\r\n      throw Error('Call AngularDotcodesService with for root passing in the config object');\r\n    }\r\n  }\r\n\r\n  /**\r\n  * Method GetCode\r\n  * @param column Column name to get Dotcode from\r\n  * @param codeValue The code value to retrieve\r\n  * @return Full HTTP response as Observable\r\n  */\r\n  public GetCode(column: string, codeValue: string): Observable<DotCode> {\r\n    const key = `${column}-${codeValue}`;\r\n\r\n    if (this.codeCache.get(key)) {\r\n      this.codeCache.get(`${column}-${codeValue}`);\r\n    } else if (this.codesCache.get(column)) {\r\n      const codes = this.codesCache.get(column).value;\r\n      if (codes) {\r\n        const code = codes.filter(c => c.value === codeValue);\r\n\r\n        if (code && code.length === 1) {\r\n          if (!this.codeCache.get(key)) {\r\n            this.codeCache.set(key, new BehaviorSubject<DotCode>(null));\r\n          }\r\n\r\n          this.codeCache.get(key).next(code[0]);\r\n        } else {\r\n          this.loadCodes(key, column, codeValue);\r\n        }\r\n      } else {\r\n        this.loadCodes(key, column, codeValue);\r\n      }\r\n    } else {\r\n      this.loadCodes(key, column, codeValue);\r\n    }\r\n\r\n    return this.codeCache.get(key);\r\n  }\r\n\r\n  private loadCodes(key: string, column: string, codeValue: string) {\r\n    this.codeCache.set(key, new BehaviorSubject<DotCode>(null));\r\n\r\n    const uri = `/GetCode`;\r\n    const headers = new HttpHeaders();\r\n    let params = new HttpParams();\r\n\r\n    if (column !== undefined && column !== null) {\r\n      params = params.set('column', column + '');\r\n    }\r\n    if (codeValue !== undefined && codeValue !== null) {\r\n      params = params.set('codeValue', codeValue + '');\r\n    }\r\n\r\n    this.sendRequest<DotCode>('get', uri, headers, params, null).toPromise().then(b => {\r\n      if (b && b.body) {\r\n        this.codeCache.get(key).next(b.body);\r\n      }\r\n    });\r\n  }\r\n  /**\r\n  * Method GetCodes\r\n  * @param column Column name to get Dotcode from\r\n  * @return Full HTTP response as Observable\r\n  */\r\n  public GetCodes(column: string): Observable<DotCode[]> {\r\n    if (this.codesCache.get(column)) {\r\n      this.codesCache.get(column);\r\n    } else {\r\n      this.codesCache.set(column, new BehaviorSubject<DotCode[]>(null));\r\n\r\n      const uri = `/GetCodes`;\r\n      const headers = new HttpHeaders();\r\n      let params = new HttpParams();\r\n      if (column !== undefined && column !== null) {\r\n        params = params.set('column', column + '');\r\n      }\r\n      this.sendRequest<DotCode[]>('get', uri, headers, params, null).toPromise().then(b => {\r\n        if (b && b.body) {\r\n          this.codesCache.get(column).next(b.body);\r\n        }\r\n      });\r\n    }\r\n\r\n    return this.codesCache.get(column);\r\n  }\r\n\r\n  /**\r\n  * Method GetRelatedCodes\r\n  * @param column Column name for dotcode\r\n  * @param codeValue DotCode value to get related codes for\r\n  * @param relatedCode Related Column name to get Related Codes from\r\n  * @return Full HTTP response as Observable\r\n  */\r\n  public GetRelatedCodes(column: string, codeValue: string, relatedCode: string): Observable<RelatedCode[]> {\r\n    const uri = `/GetRelatedCodes`;\r\n    const headers = new HttpHeaders();\r\n    let params = new HttpParams();\r\n    if (column !== undefined && column !== null) {\r\n      params = params.set('column', column + '');\r\n    }\r\n    if (codeValue !== undefined && codeValue !== null) {\r\n      params = params.set('codeValue', codeValue + '');\r\n    }\r\n    if (relatedCode !== undefined && relatedCode !== null) {\r\n      params = params.set('relatedCode', relatedCode + '');\r\n    }\r\n\r\n    return this.sendRequest<RelatedCode[]>('get', uri, headers, params, null).pipe(\r\n      map(b => {\r\n        if (b && b.body) {\r\n          return b.body;\r\n        }\r\n      }));\r\n  }\r\n\r\n  private sendRequest<T>(method: string, uri: string, headers: HttpHeaders, params: HttpParams, body: any): Observable<HttpResponse<T>> {\r\n    headers = headers.set('Ocp-Apim-Subscription-Key', this.config.apiKey);\r\n    if (method === 'get') {\r\n      return this.http.get<T>(this.config.host + uri,\r\n        { headers: headers.set('Accept', 'application/json'), params: params, observe: 'response' });\r\n    } else if (method === 'put') {\r\n      return this.http.put<T>(this.config.host + uri, body,\r\n        { headers: headers.set('Content-Type', 'application/json'), params: params, observe: 'response' });\r\n    } else if (method === 'post') {\r\n      return this.http.post<T>(this.config.host + uri, body,\r\n        { headers: headers.set('Content-Type', 'application/json'), params: params, observe: 'response' });\r\n    } else if (method === 'delete') {\r\n      return this.http.delete<T>(this.config.host + uri, { headers: headers, params: params, observe: 'response' });\r\n    } else {\r\n      console.error('Unsupported request: ' + method);\r\n      return Observable.throw('Unsupported request: ' + method);\r\n    }\r\n  }\r\n}\r\n","import { DotCode } from './models/dotcode.model';\r\nimport { AngularDotcodesService } from './angular-dotcodes.service';\r\nimport { Component, OnInit, Input } from '@angular/core';\r\n\r\n@Component({\r\n  selector: 'fdot-angular-dotcodes',\r\n  template: `\r\n    <span *ngIf=\"code\">\r\n    {{code.description}}\r\n    </span>\r\n  `,\r\n  styles: []\r\n})\r\nexport class AngularDotcodesComponent implements OnInit {\r\n\r\n  code: DotCode;\r\n\r\n  @Input()\r\n  column: string;\r\n  @Input()\r\n  value: string;\r\n\r\n\r\n  constructor(private dotcodeService: AngularDotcodesService) { }\r\n\r\n  ngOnInit() {\r\n    console.log('init');\r\n    this.dotcodeService.GetCode(this.column, this.value).subscribe(code => {\r\n      console.log(code);\r\n      this.code = code;\r\n    });\r\n  }\r\n\r\n}\r\n","import { Config } from './../models/config';\r\nimport { AngularDotcodesService } from './../angular-dotcodes.service';\r\nimport { DotCode } from './../models/dotcode.model';\r\nimport { Component, OnInit, Input, EventEmitter, Output, Optional, Inject } from '@angular/core';\r\n\r\n@Component({\r\n  selector: 'fdot-dotcodes-select',\r\n  template: `<select [(ngModel)]=\"selectedCode\" (change)=\"codeChanged()\" class=\"form-control\" [disabled]=\"disabled\">\r\n  <option *ngIf=\"useDefaultSelect\" value=\"\">\r\n    {{defaultSelectText}}\r\n  </option>\r\n  <option *ngFor=\"let code of codes\" [ngValue]=\"code\">\r\n    {{code.description}}\r\n  </option>\r\n</select>\r\n`,\r\n  styles: [``]\r\n})\r\nexport class DotcodesSelectComponent implements OnInit {\r\n\r\n  private _value: string;\r\n  codes: DotCode[];\r\n\r\n  @Input()\r\n  column: string;\r\n\r\n  @Input()\r\n  set value(value) {\r\n    this._value = value;\r\n    this.setSelectedCode();\r\n  }\r\n\r\n  get value(): string {\r\n    return this._value;\r\n  }\r\n\r\n  @Input()\r\n  disabled?: boolean;\r\n\r\n  @Output()\r\n  selectedDotcode = new EventEmitter<DotCode>();\r\n  selectedCode: DotCode;\r\n\r\n  @Input()\r\n  useDefaultSelect?: boolean;\r\n  @Input()\r\n  defaultSelectText?: string;\r\n\r\n  constructor(private dotCodeService: AngularDotcodesService, @Inject('config') private config: Config) {\r\n  }\r\n\r\n  ngOnInit() {\r\n\r\n    // tslint:disable-next-line:triple-equals\r\n    if (!(this.useDefaultSelect === false || <any>this.useDefaultSelect === 'false')\r\n      && this.config != null && this.config.useDefaultSelect) {\r\n      this.useDefaultSelect = true;\r\n    } else {\r\n      this.useDefaultSelect = false;\r\n    }\r\n    if (!this.defaultSelectText && this.config != null && this.config.defaultSelectText) {\r\n      this.defaultSelectText = this.config.defaultSelectText;\r\n    }\r\n    this.dotCodeService.GetCodes(this.column).subscribe(codes => {\r\n      this.codes = codes;\r\n\r\n      this.setSelectedCode();\r\n    });\r\n  }\r\n\r\n  private setSelectedCode() {\r\n    if (!this.codes) {\r\n      return;\r\n    }\r\n    if (this.value) {\r\n      const code = this.codes.find(c => c.value === this.value);\r\n\r\n      if (code) {\r\n        this.selectedCode = code;\r\n        this.codeChanged();\r\n      }\r\n    }\r\n  }\r\n\r\n  public codeChanged() {\r\n    this.selectedDotcode.emit(this.selectedCode);\r\n  }\r\n\r\n}\r\n","import { Pipe, PipeTransform } from '@angular/core';\r\nimport { AngularDotcodesService } from './angular-dotcodes.service';\r\nimport { map } from 'rxjs/operators';\r\n\r\n@Pipe({\r\n  name: 'dotcode',\r\n})\r\nexport class DotcodePipe implements PipeTransform {\r\n  constructor(private dotcodeService: AngularDotcodesService) { }\r\n\r\n  transform(value: string, column: string): any {\r\n    return this.dotcodeService.GetCode(column, value).pipe(map(c => {\r\n      if (c) {\r\n        return c.description;\r\n      }\r\n    }));\r\n  }\r\n\r\n}\r\n","import { AngularDotcodesService } from './angular-dotcodes.service';\r\nimport { NgModule, ModuleWithProviders } from '@angular/core';\r\nimport { AngularDotcodesComponent } from './angular-dotcodes.component';\r\nimport { HttpClientModule, HttpClient } from '@angular/common/http';\r\nimport { DotcodesSelectComponent } from './dotcodes-select/dotcodes-select.component';\r\nimport { CommonModule } from '@angular/common';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { DotcodePipe } from './dotcode.pipe';\r\nimport { Config } from './models/config';\r\n\r\n@NgModule({\r\n  imports: [HttpClientModule, CommonModule, FormsModule\r\n  ],\r\n  declarations: [AngularDotcodesComponent, DotcodesSelectComponent, DotcodePipe],\r\n  exports: [AngularDotcodesComponent, DotcodesSelectComponent, DotcodePipe]\r\n})\r\nexport class AngularDotcodesModule {\r\n  static forRoot(config: Config): ModuleWithProviders {\r\n    return {\r\n      ngModule: AngularDotcodesModule,\r\n      providers: [AngularDotcodesService,\r\n        { provide: 'config', useValue: config }\r\n      ]\r\n    };\r\n  }\r\n}\r\n"],"names":[],"mappings":"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"}