jade-integration-utils
Version:
A tool made for any type of http requisitions and to manage localstorage. This package works into Angular and Ionic projects (maybe you can run this in ReactNative, MAYBE!).
156 lines • 16.5 kB
JavaScript
import { __decorate } from "tslib";
import { Injectable } from '@angular/core';
import { HttpStatusService } from './http-status.service';
import { Router } from '@angular/router';
import { StorageService } from './storage.service';
import * as i0 from "@angular/core";
import * as i1 from "./http-status.service";
import * as i2 from "@angular/router";
var GenericService = /** @class */ (function () {
function GenericService(http, router) {
this.http = http;
this.router = router;
this._auth = "Authentication";
}
/**
* configureHttp
*/
GenericService.prototype.configureHttp = function (url) {
this.http.configure(url);
};
/**
*
* @param endpoint end point to access
* @param queryParams = null; a string for example: name=Ronaldo&type=2 doesn't write ? \n(In case send GET without queryParams, just pass null end use endpoint to do it. Ex: cars/example)
*/
GenericService.prototype.get = function (endpoint, queryParams) {
var new_endpoint = '';
if (queryParams) {
console.log(queryParams);
new_endpoint = '/' + endpoint + '?' + queryParams;
}
else {
new_endpoint = '/' + endpoint;
}
this.default_options();
this.auth = this.auth;
return this.http.get(new_endpoint);
};
/**
*
* @param endpoint end point to access
* @param queryParams = null; a string for example: name=Ronaldo&type=2 doesn't write ? \n(In case send GET without queryParams, just pass null end use endpoint to do it. Ex: cars/example)
*/
GenericService.prototype.get_file = function (endpoint, queryParams) {
var new_endpoint = '';
if (queryParams) {
console.log(queryParams);
new_endpoint = '/' + endpoint + '?' + queryParams;
}
else {
new_endpoint = '/' + endpoint;
}
return this.http.get_file(new_endpoint);
};
/**
*
* @param endpoint end point to access
* @param queryParams = null; a string for example: name=Ronaldo&type=2 doesn't write ? \n(In case send GET without queryParams, just pass null end use endpoint to do it. Ex: cars/example)
*/
GenericService.prototype.get_any = function (endpoint, queryParams) {
var new_endpoint = '';
if (queryParams) {
console.log(queryParams);
new_endpoint = '/' + endpoint + '?' + queryParams;
}
else {
new_endpoint = '/' + endpoint;
}
this.default_options();
this.auth = this.auth;
return this.http.get(new_endpoint);
};
GenericService.prototype.getById = function (id, endpoint) {
this.default_options();
this.auth = this.auth;
return this.http.get('/' + endpoint + '/' + id);
};
/**
* Use to request POST.
* @param body K -> K is the model dto to pass with body
* @param endpoint String -> string to be pass with endpoint access
*/
GenericService.prototype.post = function (body, endpoint) {
this.default_options();
this.auth = this.auth;
return this.http.post('/' + endpoint, body);
};
/**
* Use to request formData with files
* Don't forget.to call default_options
* @param body K -> K is the model dto to pass with body
* @param endpoint String -> string to be pass with endpoint access
*/
GenericService.prototype.formData = function (body, endpoint) {
return this.http.formData('/' + endpoint, body);
};
/**
* Use to request POST.
* @param body K -> K is the model dto to pass with body
* @param endpoint String -> string to be pass with endpoint access
*/
GenericService.prototype.put = function (body, endpoint) {
return this.http.put('/' + endpoint, body);
};
GenericService.prototype.delete = function (id, endpoint) {
return this.http.delete('/' + endpoint + '/' + id);
};
GenericService.prototype.set_token = function (auth) {
this.http.set_token(auth);
};
GenericService.prototype.get_token = function () {
return this.http.get_token();
};
Object.defineProperty(GenericService.prototype, "options", {
get: function () {
return this.http.options;
},
set: function (options) {
this.http.options = options;
},
enumerable: true,
configurable: true
});
GenericService.prototype.default_options = function () {
this.http.default_options();
};
Object.defineProperty(GenericService.prototype, "auth", {
get: function () {
return StorageService.get(this._auth);
},
set: function (auth) {
StorageService.set(this._auth, auth);
this.set_token(auth);
},
enumerable: true,
configurable: true
});
GenericService.prototype.downloadFile = function (data) {
var blob = new Blob([data]);
var url = window.URL.createObjectURL(blob);
window.open(url);
};
GenericService.ctorParameters = function () { return [
{ type: HttpStatusService },
{ type: Router }
]; };
GenericService.ɵprov = i0.ɵɵdefineInjectable({ factory: function GenericService_Factory() { return new GenericService(i0.ɵɵinject(i1.HttpStatusService), i0.ɵɵinject(i2.Router)); }, token: GenericService, providedIn: "root" });
GenericService = __decorate([
Injectable({
providedIn: 'root'
})
], GenericService);
return GenericService;
}());
export { GenericService };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic.service.js","sourceRoot":"ng://jade-integration-utils/","sources":["lib/services/generic.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpStatusService } from './http-status.service';\nimport { Result } from '../Models/Paginator';\nimport { Router } from '@angular/router';\nimport { StorageService } from './storage.service';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class GenericService {\n  private _auth: string = \"Authentication\";\n\n  constructor(\n    public http: HttpStatusService,\n    public router:Router\n  ) {  }\n\n  /**\n   * configureHttp\n   */\n  public configureHttp(url: string) {\n    this.http.configure(url);\n  }\n\n  /**\n   *\n   * @param endpoint end point to access\n   * @param queryParams = null; a string for example: name=Ronaldo&type=2 doesn't write ? \\n(In case send GET without queryParams, just pass null end use endpoint to do it. Ex: cars/example)\n   */\n  get<T>(endpoint?: string, queryParams?: string): Promise<Result<T>> {\n    let new_endpoint = '';\n\n    if(queryParams){\n      console.log(queryParams);\n      new_endpoint = '/' +endpoint+'?'+queryParams;\n    }else{\n      new_endpoint = '/'+ endpoint;\n    }\n    this.default_options();\n    this.auth = this.auth;\n\n    return this.http.get<Result<T>>(new_endpoint);\n  }\n\n  /**\n   *\n   * @param endpoint end point to access\n   * @param queryParams = null; a string for example: name=Ronaldo&type=2 doesn't write ? \\n(In case send GET without queryParams, just pass null end use endpoint to do it. Ex: cars/example)\n   */\n  get_file(endpoint?: string, queryParams?: string): Promise<any> {\n    let new_endpoint = '';\n\n    if(queryParams){\n      console.log(queryParams);\n      new_endpoint = '/' +endpoint+'?'+queryParams;\n    }else{\n      new_endpoint = '/'+ endpoint;\n    }\n\n    return this.http.get_file(new_endpoint);\n  }\n  /**\n   *\n   * @param endpoint end point to access\n   * @param queryParams = null; a string for example: name=Ronaldo&type=2 doesn't write ? \\n(In case send GET without queryParams, just pass null end use endpoint to do it. Ex: cars/example)\n   */\n  get_any(endpoint?: string, queryParams?: string): Promise<any> {\n    let new_endpoint = '';\n\n    if(queryParams){\n      console.log(queryParams);\n      new_endpoint = '/' +endpoint+'?'+queryParams;\n    }else{\n      new_endpoint = '/'+ endpoint;\n    }\n    this.default_options();\n    this.auth = this.auth;\n\n    return this.http.get<any>(new_endpoint);\n  }\n\n  getById<T>(id: number, endpoint?: string): Promise<Result<T>> {\n    this.default_options();\n    this.auth = this.auth;\n\n    return this.http.get<Result<T>>('/' + endpoint + '/' + id);\n  }\n\n  /**\n   * Use to request POST.\n   * @param body K -> K is the model dto to pass with body\n   * @param endpoint String -> string to be pass with endpoint access\n   */\n  post<T,K>(body: K, endpoint?: string): Promise<Result<T>> {\n    this.default_options();\n    this.auth = this.auth;\n\n    return this.http.post<Result<T>>('/' + endpoint, body);\n  }\n\n  /**\n   * Use to request formData with files\n   * Don't forget.to call default_options\n   * @param body K -> K is the model dto to pass with body\n   * @param endpoint String -> string to be pass with endpoint access\n   */\n  formData<T,K>(body: K, endpoint?: string): Promise<Result<T>> {\n    return this.http.formData<Result<T>>('/' + endpoint, body);\n  }\n\n  /**\n   * Use to request POST.\n   * @param body K -> K is the model dto to pass with body\n   * @param endpoint String -> string to be pass with endpoint access\n   */\n  put<T,K>(body: K, endpoint?: string): Promise<Result<T>> {\n    return this.http.put<Result<T>>('/' + endpoint, body);\n  }\n\n  delete<T>(id: number, endpoint?: string): Promise<Result<T>> {\n    return this.http.delete<Result<T>>('/' + endpoint + '/' + id);\n  }\n\n  public set_token(auth: string): void {\n    this.http.set_token(auth);\n  }\n  public get_token(): string {\n    return this.http.get_token();\n  }\n\n  public get options(){\n    return this.http.options;\n  }\n  public set options(options:any){\n    this.http.options = options;\n  }\n  public default_options(){\n    this.http.default_options();\n  }\n\n\n  public set auth(auth: string) {\n    StorageService.set(this._auth,auth);\n    this.set_token(auth);\n  }\n  public get auth() {\n    return StorageService.get(this._auth);\n  }\n\n  public downloadFile(data: any) {\n    const blob = new Blob([data]);\n    const url= window.URL.createObjectURL(blob);\n    window.open(url);\n  }\n}\n"]}