moh-common-lib
Version:
A library of Angular components, services, and styles for B.C. Government Ministry of Health (MoH).
144 lines • 12 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { catchError, tap } from 'rxjs/operators';
import { UUID } from 'angular2-uuid';
/**
* Abstract class for HTTP Service
* @abstract
*/
export class AbstractHttpService {
/**
* @param {?} http
*/
constructor(http) {
this.http = http;
this.logHTTPRequestsToConsole = false;
}
/**
* Makes a GET request to the specified URL, using headers and HTTP options specified in their respective methods.
* @protected
* @template T
* @param {?} url Target URL to make the GET request
* @param {?=} queryParams
* @return {?}
*/
get(url, queryParams) {
/**
* The HTTP request observer with always on error handling
* @type {?}
*/
const httpOpts = this.httpOptions;
httpOpts.params = queryParams ? queryParams : undefined;
/** @type {?} */
const observable = this.http.get(url, httpOpts);
return this.setupRequest(observable);
}
/**
* @protected
* @template T
* @param {?} url
* @param {?} body
* @return {?}
*/
post(url, body) {
if (this.logHTTPRequestsToConsole) {
console.log('Post Request: ', body);
}
/** @type {?} */
const observable = this.http.post(url, body, this.httpOptions);
return this.setupRequest(observable);
}
/**
* @protected
* @template T
* @param {?} observable
* @return {?}
*/
setupRequest(observable) {
// All failed requests should trigger the abstract method handleError
observable = observable.pipe(catchError(this.handleError.bind(this)));
// Optionally add console logging
if (this.logHTTPRequestsToConsole) {
observable = observable.pipe(tap((/**
* @param {?} data
* @return {?}
*/
data => console.log('HTTP Success: ', data)), (/**
* @param {?} error
* @return {?}
*/
error => console.log('HTTP Error: ', error))));
}
return observable;
}
/**
* The HttpOptions object that Angular takes for GET and POST requests. Used in every HTTP request from this service.
* @protected
* @return {?}
*/
get httpOptions() {
return {
headers: this._headers
};
}
/* Helper function for generating a unique UUID per request for logging. */
/**
* @protected
* @return {?}
*/
generateUUID() {
return UUID.UUID();
}
/**
* Uploads an individual attachment. All you need to do is set the url.
* Note: urls often include UUIDs, so this must be an application decision.
*
* @protected
* @param {?} relativeUrl URL to hit, must include UUIDs of application and CommonImage
* @param {?} attachment CommonImage to upload
* @return {?}
*/
uploadAttachment(relativeUrl, attachment) {
/** @type {?} */
const options = { headers: this._headers, responseType: (/** @type {?} */ ('text')) };
/** @type {?} */
const binary = atob(attachment.fileContent.split(',')[1]);
/** @type {?} */
const array = [];
for (let i = 0; i < binary.length; i++) {
array.push(binary.charCodeAt(i));
}
/** @type {?} */
const blob = new Blob([new Uint8Array(array)], { type: attachment.contentType });
return this.http.post(relativeUrl, blob, options);
}
}
if (false) {
/**
* @type {?}
* @protected
*/
AbstractHttpService.prototype.logHTTPRequestsToConsole;
/**
* The headers to send along with every GET and POST.
* @type {?}
* @protected
*/
AbstractHttpService.prototype._headers;
/**
* @type {?}
* @protected
*/
AbstractHttpService.prototype.http;
/**
* Handles all failed requests that throw either a server error (400/500) or a client error (e.g. lost internet).
* @abstract
* @protected
* @param {?} error
* @return {?}
*/
AbstractHttpService.prototype.handleError = function (error) { };
}
//# sourceMappingURL=data:application/json;base64,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