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!).
147 lines • 15.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";
let GenericService = class GenericService {
constructor(http, router) {
this.http = http;
this.router = router;
this._auth = "Authentication";
}
/**
* configureHttp
*/
configureHttp(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)
*/
get(endpoint, queryParams) {
let 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)
*/
get_file(endpoint, queryParams) {
let 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)
*/
get_any(endpoint, queryParams) {
let 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);
}
getById(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
*/
post(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
*/
formData(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
*/
put(body, endpoint) {
return this.http.put('/' + endpoint, body);
}
delete(id, endpoint) {
return this.http.delete('/' + endpoint + '/' + id);
}
set_token(auth) {
this.http.set_token(auth);
}
get_token() {
return this.http.get_token();
}
get options() {
return this.http.options;
}
set options(options) {
this.http.options = options;
}
default_options() {
this.http.default_options();
}
set auth(auth) {
StorageService.set(this._auth, auth);
this.set_token(auth);
}
get auth() {
return StorageService.get(this._auth);
}
downloadFile(data) {
const blob = new Blob([data]);
const url = window.URL.createObjectURL(blob);
window.open(url);
}
};
GenericService.ctorParameters = () => [
{ 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);
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":";AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE1D,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;;;;AAKnD,IAAa,cAAc,GAA3B,MAAa,cAAc;IAGzB,YACS,IAAuB,EACvB,MAAa;QADb,SAAI,GAAJ,IAAI,CAAmB;QACvB,WAAM,GAAN,MAAM,CAAO;QAJd,UAAK,GAAW,gBAAgB,CAAC;IAKpC,CAAC;IAEN;;OAEG;IACI,aAAa,CAAC,GAAW;QAC9B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAI,QAAiB,EAAE,WAAoB;QAC5C,IAAI,YAAY,GAAG,EAAE,CAAC;QAEtB,IAAG,WAAW,EAAC;YACb,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACzB,YAAY,GAAG,GAAG,GAAE,QAAQ,GAAC,GAAG,GAAC,WAAW,CAAC;SAC9C;aAAI;YACH,YAAY,GAAG,GAAG,GAAE,QAAQ,CAAC;SAC9B;QACD,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAEtB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAY,YAAY,CAAC,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,QAAiB,EAAE,WAAoB;QAC9C,IAAI,YAAY,GAAG,EAAE,CAAC;QAEtB,IAAG,WAAW,EAAC;YACb,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACzB,YAAY,GAAG,GAAG,GAAE,QAAQ,GAAC,GAAG,GAAC,WAAW,CAAC;SAC9C;aAAI;YACH,YAAY,GAAG,GAAG,GAAE,QAAQ,CAAC;SAC9B;QAED,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC1C,CAAC;IACD;;;;OAIG;IACH,OAAO,CAAC,QAAiB,EAAE,WAAoB;QAC7C,IAAI,YAAY,GAAG,EAAE,CAAC;QAEtB,IAAG,WAAW,EAAC;YACb,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;YACzB,YAAY,GAAG,GAAG,GAAE,QAAQ,GAAC,GAAG,GAAC,WAAW,CAAC;SAC9C;aAAI;YACH,YAAY,GAAG,GAAG,GAAE,QAAQ,CAAC;SAC9B;QACD,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAEtB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAM,YAAY,CAAC,CAAC;IAC1C,CAAC;IAED,OAAO,CAAI,EAAU,EAAE,QAAiB;QACtC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAEtB,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAY,GAAG,GAAG,QAAQ,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAM,IAAO,EAAE,QAAiB;QAClC,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QAEtB,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAY,GAAG,GAAG,QAAQ,EAAE,IAAI,CAAC,CAAC;IACzD,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAM,IAAO,EAAE,QAAiB;QACtC,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAY,GAAG,GAAG,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACH,GAAG,CAAM,IAAO,EAAE,QAAiB;QACjC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAY,GAAG,GAAG,QAAQ,EAAE,IAAI,CAAC,CAAC;IACxD,CAAC;IAED,MAAM,CAAI,EAAU,EAAE,QAAiB;QACrC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAY,GAAG,GAAG,QAAQ,GAAG,GAAG,GAAG,EAAE,CAAC,CAAC;IAChE,CAAC;IAEM,SAAS,CAAC,IAAY;QAC3B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;IACM,SAAS;QACd,OAAO,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;IAC/B,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;IAC3B,CAAC;IACD,IAAW,OAAO,CAAC,OAAW;QAC5B,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAC9B,CAAC;IACM,eAAe;QACpB,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;IAC9B,CAAC;IAGD,IAAW,IAAI,CAAC,IAAY;QAC1B,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,EAAC,IAAI,CAAC,CAAC;QACpC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IACD,IAAW,IAAI;QACb,OAAO,cAAc,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAEM,YAAY,CAAC,IAAS;QAC3B,MAAM,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;QAC9B,MAAM,GAAG,GAAE,MAAM,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAC5C,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACnB,CAAC;CACF,CAAA;;YA7IgB,iBAAiB;YAChB,MAAM;;;AALX,cAAc;IAH1B,UAAU,CAAC;QACV,UAAU,EAAE,MAAM;KACnB,CAAC;GACW,cAAc,CAiJ1B;SAjJY,cAAc","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"]}