visorus-erp-core 10.0.2 → 10.1.0

package/fesm2015/visorus-erp-core.js

@@ -1,5 +1,5 @@
+import { HttpHeaders, HttpClient, HttpParams, HTTP_INTERCEPTORS } from '@angular/common/http';
 import { ɵɵinject, ɵɵdefineInjectable, ɵsetClassMetadata, Injectable, ɵɵelementStart, ɵɵtext, ɵɵelementEnd, ɵɵgetCurrentView, ɵɵlistener, ɵɵrestoreView, ɵɵnextContext, ɵɵelement, ɵɵtemplate, ɵɵadvance, ɵɵproperty, ɵɵtextInterpolate1, EventEmitter, ɵɵdirectiveInject, ɵɵdefineComponent, ɵɵstyleMap, ɵɵpureFunction0, Component, Input, Output, ɵɵstaticViewQuery, ɵɵqueryRefresh, ɵɵloadQuery, ɵɵpureFunction1, ViewChild, ɵɵpipe, ɵɵpropertyInterpolate, ɵɵsanitizeUrl, ɵɵpipeBind1, ElementRef, ChangeDetectorRef, ɵɵsanitizeResourceUrl, ɵɵtextInterpolate, ɵɵreference, ɵɵpropertyInterpolate1, ɵɵstyleProp, ɵɵresolveWindow, ɵɵpipeBind2, ɵɵattribute, ɵɵdefineNgModule, ɵɵdefineInjector, ɵɵsetNgModuleScope, NgModule } from '@angular/core';
-import { HttpHeaders, HttpClient, HTTP_INTERCEPTORS } from '@angular/common/http';
 import { DefaultValueAccessor, NgControlStatus, NgModel, ɵangular_packages_forms_forms_y, NgControlStatusGroup, NgForm, RequiredValidator, NumberValueAccessor, SelectControlValueAccessor, NgSelectOption, ɵangular_packages_forms_forms_x, FormsModule } from '@angular/forms';
 import { InputText, InputTextModule } from 'primeng/inputtext';
 import { TreeTable, TreeTableToggler, TreeTableModule } from 'primeng/treetable';
@@ -95,69 +95,110 @@ class GlobalService {
         return this.http.post(this.getUrl() + '/usuario/setModulo', modulo, this.buildAuth());
     }
 }
+/** @nocollapse */ GlobalService.ɵfac = function GlobalService_Factory(t) { return new (t || GlobalService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ GlobalService.ɵprov = ɵɵdefineInjectable({ token: GlobalService, factory: GlobalService.ɵfac, providedIn: 'root' });
+/*@__PURE__*/ (function () { ɵsetClassMetadata(GlobalService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: HttpClient }]; }, null); })();
 
-class CrudService extends GlobalService {
-    constructor(httpCliente, url) {
-        super(httpCliente);
-        this.httpCliente = httpCliente;
-        this.url = url;
-        this.urlComponente = this.url;
-    }
-    //Functions for ResourcesCrud [{ param: "max", value: 10}]
-    serializeParams(params) {
-        let serializeString = '';
-        params.map((e, index) => {
-            if (e.value !== undefined)
-                serializeString += ((index == 0) ? '?' : '&') + e.param + '=' + e.value;
-        });
-        return serializeString;
-    }
-    getHttp() {
-        return this.httpCliente;
-    }
-    geturl() {
-        return this.getUrl(this.urlComponente);
-    }
-    getBaseUrl() {
-        return this.getUrl('');
+// projects/erp-core/src/lib/services/api.service.ts
+class ApiService {
+    constructor(http, 
+    // Inyectamos GlobalService para usar sus métodos de ayuda (construir URL y cabeceras)
+    global) {
+        this.http = http;
+        this.global = global;
+    }
+    /**
+    * Realiza una petición GET genérica y autenticada usando HttpParams.
+    * @param endpoint El endpoint del API (ej. '/FormaDePago')
+    * @param queryParams Un objeto clave-valor para los parámetros de la URL.
+    */
+    get(endpoint, queryParams) {
+        // 1. Construye HttpParams de forma segura. Se encarga del URL encoding.
+        const params = new HttpParams({ fromObject: queryParams });
+        // 2. Combina las opciones: cabeceras de GlobalService y los nuevos params.
+        const options = Object.assign(Object.assign({}, this.global.buildAuth()), { params: params // Añade los HttpParams
+         });
+        const url = this.global.getUrl(endpoint);
+        return this.http.get(url, options);
+    }
+    /**
+     * Realiza una petición POST genérica y autenticada.
+     * @param endpoint El endpoint del API
+     * @param body El cuerpo de la petición
+     */
+    post(endpoint, body) {
+        const url = this.global.getUrl(endpoint);
+        const options = this.global.buildAuth();
+        return this.http.post(url, body, options);
+    }
+    /**
+     * Realiza una petición PUT genérica y autenticada.
+     * @param endpoint El endpoint del API
+     * @param id El ID del recurso a actualizar
+     * @param body El cuerpo de la petición
+     */
+    put(endpoint, id, body) {
+        const url = `<span class="math-inline">\{this\.global\.getUrl\(endpoint\)\}/</span>{id}`;
+        const options = this.global.buildAuth();
+        return this.http.put(url, body, options);
+    }
+    /**
+     * Realiza una petición DELETE genérica y autenticada.
+     * @param endpoint El endpoint del API
+     * @param id El ID del recurso a eliminar
+     */
+    delete(endpoint, id) {
+        const url = `<span class="math-inline">\{this\.global\.getUrl\(endpoint\)\}/</span>{id}`;
+        const options = this.global.buildAuth();
+        return this.http.delete(url, options);
     }
-    getByUrl(url, params) {
-        return this.httpCliente.get(this.getUrl(url) + this.serializeParams(params), this.buildAuth());
+}
+/** @nocollapse */ ApiService.ɵfac = function ApiService_Factory(t) { return new (t || ApiService)(ɵɵinject(HttpClient), ɵɵinject(GlobalService)); };
+/** @nocollapse */ ApiService.ɵprov = ɵɵdefineInjectable({ token: ApiService, factory: ApiService.ɵfac, providedIn: 'root' });
+/*@__PURE__*/ (function () { ɵsetClassMetadata(ApiService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root'
+            }]
+    }], function () { return [{ type: HttpClient }, { type: GlobalService }]; }, null); })();
+
+class CuentaContableService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'cuentaContable';
     }
     getAll(params) {
-        return this.httpCliente.get(this.getUrl(this.urlComponente) + (params ? (this.serializeParams(params)) : ('')), this.buildAuth());
+        return this.api.get(this.endpoint, params);
+    }
+    obtieneCuentasContablesRecursivo() {
+        return this.api.get(`${this.endpoint}/obtieneCuentasContablesRecursivo`);
     }
     get(id) {
-        return this.httpCliente.get(this.getUrl(this.urlComponente) + '/' + id, this.buildAuth());
+        return this.api.get(`${this.endpoint}/${id}`);
     }
     save(obj) {
-        return this.httpCliente.post(this.getUrl(this.urlComponente), obj, this.buildAuth());
+        return this.api.post(this.endpoint, obj);
     }
     update(obj) {
-        return this.httpCliente.put(this.getUrl(this.urlComponente) + '/' + obj.id, obj, this.buildAuth());
+        return this.api.put(this.endpoint, obj.id, obj);
     }
     delete(id) {
-        return this.httpCliente.delete(this.getUrl(this.urlComponente) + '/' + id, this.buildAuth());
-    }
-}
-
-class CuentaContableService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'cuentaContable');
-        this.httpClient = httpClient;
-    }
-    obtieneCuentasContablesRecursivo() {
-        return this.httpClient.get(this.getUrl('cuentaContable') + '/obtieneCuentasContablesRecursivo', this.buildAuth());
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ CuentaContableService.ɵfac = function CuentaContableService_Factory(t) { return new (t || CuentaContableService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ CuentaContableService.ɵfac = function CuentaContableService_Factory(t) { return new (t || CuentaContableService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ CuentaContableService.ɵprov = ɵɵdefineInjectable({ token: CuentaContableService, factory: CuentaContableService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(CuentaContableService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 function CclistaComponent_ng_template_3_Template(rf, ctx) { if (rf & 1) {
     ɵɵelementStart(0, "tr");
@@ -1352,20 +1393,35 @@ class LoginModalComponent {
             }]
     }], function () { return [{ type: LoginModalService }, { type: AuthService }]; }, null); })();
 
-class SessionCajaService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'sessionCaja');
-        this.httpClient = httpClient;
+class SessionCajaService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'sessionCaja';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ SessionCajaService.ɵfac = function SessionCajaService_Factory(t) { return new (t || SessionCajaService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ SessionCajaService.ɵfac = function SessionCajaService_Factory(t) { return new (t || SessionCajaService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ SessionCajaService.ɵprov = ɵɵdefineInjectable({ token: SessionCajaService, factory: SessionCajaService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(SessionCajaService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 function SessionCreateComponent_ng_template_1_Template(rf, ctx) { if (rf & 1) {
     ɵɵelementStart(0, "a", 4);
@@ -1589,22 +1645,38 @@ class Cliente {
     }
 }
 
-class ClienteService extends CrudService {
-    constructor(httpCliente) {
-        super(httpCliente, '/cliente');
+class ClienteService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'cliente';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
     validar_archivos_bss(id) {
-        return this.getHttp().get(this.getUrl('/cliente/validarClienteBss/') + id, this.buildAuth());
+        return this.api.get(`${this.endpoint}/validarClienteBss/${id}`);
     }
 }
-/** @nocollapse */ ClienteService.ɵfac = function ClienteService_Factory(t) { return new (t || ClienteService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ClienteService.ɵfac = function ClienteService_Factory(t) { return new (t || ClienteService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ClienteService.ɵprov = ɵɵdefineInjectable({ token: ClienteService, factory: ClienteService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ClienteService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class PaginateService {
     constructor(translate) {
@@ -1885,20 +1957,35 @@ class Proveedor {
     }
 }
 
-class ProveedorService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/proveedor');
-        this.httpClient = httpClient;
+class ProveedorService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'proveedor';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ ProveedorService.ɵfac = function ProveedorService_Factory(t) { return new (t || ProveedorService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ProveedorService.ɵfac = function ProveedorService_Factory(t) { return new (t || ProveedorService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ProveedorService.ɵprov = ɵɵdefineInjectable({ token: ProveedorService, factory: ProveedorService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ProveedorService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 function SelectProveedorComponent_ng_template_7_Template(rf, ctx) { if (rf & 1) {
     ɵɵelementStart(0, "tr");
@@ -2032,34 +2119,51 @@ class SelectProveedorComponent {
             type: Output
         }] }); })();
 
-class AlmacenService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/almacen');
-        this.httpClient = httpClient;
+class AlmacenService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'almacen';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
     }
     obtenerAlmacenEmpresa() {
-        let url = this.geturl() + '/obtenerAlmacenEmpresa';
-        return this.getHttp().get(url, this.buildAuth());
+        return this.api.get(`${this.endpoint}/obtenerAlmacenEmpresa`);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ AlmacenService.ɵfac = function AlmacenService_Factory(t) { return new (t || AlmacenService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ AlmacenService.ɵfac = function AlmacenService_Factory(t) { return new (t || AlmacenService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ AlmacenService.ɵprov = ɵɵdefineInjectable({ token: AlmacenService, factory: AlmacenService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(AlmacenService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class StockService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'stock');
-        this.httpClient = httpClient;
+class StockService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'stock';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
     }
     obtenerExistenciasArticulosDescripcion(parametros, params) {
-        const url = this.getBaseUrl() + '/stock/obtenerExistenciasArticulos';
+        const url = `${this.endpoint}/obtenerExistenciasArticulos`;
         let promesa = new Promise((resolve, reject) => {
-            this.httpClient.post(url + this.serializeParams(params), parametros, this.buildAuth()).subscribe((data) => {
+            this.api.post(url, parametros).subscribe((data) => {
                 resolve(data);
             }, (err) => {
                 reject(err);
@@ -2068,33 +2172,48 @@ class StockService extends CrudService {
         return promesa;
     }
 }
-/** @nocollapse */ StockService.ɵfac = function StockService_Factory(t) { return new (t || StockService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ StockService.ɵfac = function StockService_Factory(t) { return new (t || StockService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ StockService.ɵprov = ɵɵdefineInjectable({ token: StockService, factory: StockService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(StockService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class ArticuloInformacionService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'articulo');
-        this.httpClient = httpClient;
+class ArticuloInformacionService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'articulo';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
     }
     obtenerExistencias(articulo) {
         let uRL = "/existenciasArticulo/" + articulo;
-        return this.httpClient.get(this.geturl() + uRL, this.buildAuth());
+        return this.api.get(`${this.endpoint}${uRL}`);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ ArticuloInformacionService.ɵfac = function ArticuloInformacionService_Factory(t) { return new (t || ArticuloInformacionService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ArticuloInformacionService.ɵfac = function ArticuloInformacionService_Factory(t) { return new (t || ArticuloInformacionService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ArticuloInformacionService.ɵprov = ɵɵdefineInjectable({ token: ArticuloInformacionService, factory: ArticuloInformacionService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ArticuloInformacionService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 function SeleccionArticuloInformacionComponent_ng_template_2_col_1_Template(rf, ctx) { if (rf & 1) {
     ɵɵelement(0, "col");
@@ -2745,20 +2864,35 @@ class SeleccionaArticuloComponent {
             type: Output
         }] }); })();
 
-class AcreedorService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'acreedor');
-        this.httpClient = httpClient;
+class AcreedorService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'acreedor';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ AcreedorService.ɵfac = function AcreedorService_Factory(t) { return new (t || AcreedorService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ AcreedorService.ɵfac = function AcreedorService_Factory(t) { return new (t || AcreedorService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ AcreedorService.ɵprov = ɵɵdefineInjectable({ token: AcreedorService, factory: AcreedorService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(AcreedorService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 function SelectAcreedorComponent_ng_template_6_Template(rf, ctx) { if (rf & 1) {
     ɵɵelementStart(0, "tr");
@@ -3222,19 +3356,35 @@ class MessageService {
             }]
     }], function () { return [{ type: ToastrService }]; }, null); })();
 
-class PersonaMoralService extends CrudService {
-    constructor(http) {
-        super(http, '/personaMoral');
+class PersonaMoralService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'personaMoral';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ PersonaMoralService.ɵfac = function PersonaMoralService_Factory(t) { return new (t || PersonaMoralService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ PersonaMoralService.ɵfac = function PersonaMoralService_Factory(t) { return new (t || PersonaMoralService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ PersonaMoralService.ɵprov = ɵɵdefineInjectable({ token: PersonaMoralService, factory: PersonaMoralService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(PersonaMoralService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class CanActivateGuard {
     constructor(controlAccesoService) {
@@ -3258,20 +3408,35 @@ class CanActivateGuard {
             }]
     }], function () { return [{ type: ControlAccesoService }]; }, null); })();
 
-class CatalogoAdicionalService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'catalogoAdicional');
-        this.httpClient = httpClient;
+class CatalogoAdicionalService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'catalogoAdicional';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ CatalogoAdicionalService.ɵfac = function CatalogoAdicionalService_Factory(t) { return new (t || CatalogoAdicionalService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ CatalogoAdicionalService.ɵfac = function CatalogoAdicionalService_Factory(t) { return new (t || CatalogoAdicionalService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ CatalogoAdicionalService.ɵprov = ɵɵdefineInjectable({ token: CatalogoAdicionalService, factory: CatalogoAdicionalService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(CatalogoAdicionalService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class Authenticated {
     constructor(authService, controlAccesoService, router) {
@@ -3390,32 +3555,41 @@ class VersionCheckService {
             }]
     }], function () { return [{ type: HttpClient }]; }, null); })();
 
-class AgenteService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'agente');
-        this.httpClient = httpClient;
+class AgenteService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'agente';
     }
     saveUsuarioAgente(usuario) {
-        let url = this.getUrl('agente') + '/usuario';
-        return this.getHttp().post(url, usuario, this.buildAuth());
+        return this.api.post(`${this.endpoint}/usuario`, usuario);
     }
     getUsuarioAgente(id) {
-        let url = this.getUrl('agente') + '/usuario/' + id;
-        return this.getHttp().get(url, this.buildAuth());
+        return this.api.get(`${this.endpoint}/usuario/${id}`);
     }
     obtenerAgenteEmpresa() {
-        let url = this.geturl() + '/obtenerAgenteEmpresa';
-        return this.getHttp().get(url, this.buildAuth());
+        return this.api.get(`${this.endpoint}/obtenerAgenteEmpresa`);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ AgenteService.ɵfac = function AgenteService_Factory(t) { return new (t || AgenteService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ AgenteService.ɵfac = function AgenteService_Factory(t) { return new (t || AgenteService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ AgenteService.ɵprov = ɵɵdefineInjectable({ token: AgenteService, factory: AgenteService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(AgenteService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class Almacen {
     constructor() { }
@@ -3432,69 +3606,133 @@ class Banco {
     }
 }
 
-class BancoService extends CrudService {
-    constructor(http) {
-        super(http, '/banco');
+class BancoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'banco';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ BancoService.ɵfac = function BancoService_Factory(t) { return new (t || BancoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ BancoService.ɵfac = function BancoService_Factory(t) { return new (t || BancoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ BancoService.ɵprov = ɵɵdefineInjectable({ token: BancoService, factory: BancoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(BancoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class CatalogoTipo {
     constructor() { }
 }
 
-class CatalogoTipoService extends CrudService {
-    constructor(htt) {
-        super(htt, '/catalogoTipo');
+class CatalogoTipoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'catalogoTipo';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ CatalogoTipoService.ɵfac = function CatalogoTipoService_Factory(t) { return new (t || CatalogoTipoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ CatalogoTipoService.ɵfac = function CatalogoTipoService_Factory(t) { return new (t || CatalogoTipoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ CatalogoTipoService.ɵprov = ɵɵdefineInjectable({ token: CatalogoTipoService, factory: CatalogoTipoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(CatalogoTipoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class ClasificadorTipoService extends CrudService {
-    constructor(http) {
-        super(http, '/clasificadorTipo');
+class ClasificadorTipoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'clasificadorTipo';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ ClasificadorTipoService.ɵfac = function ClasificadorTipoService_Factory(t) { return new (t || ClasificadorTipoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ClasificadorTipoService.ɵfac = function ClasificadorTipoService_Factory(t) { return new (t || ClasificadorTipoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ClasificadorTipoService.ɵprov = ɵɵdefineInjectable({ token: ClasificadorTipoService, factory: ClasificadorTipoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ClasificadorTipoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class ClaveMovimiento {
     constructor() { }
 }
 
-class ClaveMovimientoService extends CrudService {
-    constructor(http) {
-        super(http, 'claveMovimiento');
+class ClaveMovimientoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'claveMovimiento';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ ClaveMovimientoService.ɵfac = function ClaveMovimientoService_Factory(t) { return new (t || ClaveMovimientoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ClaveMovimientoService.ɵfac = function ClaveMovimientoService_Factory(t) { return new (t || ClaveMovimientoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ClaveMovimientoService.ɵprov = ɵɵdefineInjectable({ token: ClaveMovimientoService, factory: ClaveMovimientoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ClaveMovimientoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class ClienteCuentaBanco {
     constructor() {
@@ -3515,43 +3753,73 @@ class ClienteFlete {
     }
 }
 
-class ClienteCuentaBancoService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/clienteCuentaBanco');
-        this.httpClient = httpClient;
+class ClienteCuentaBancoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'clienteCuentaBanco';
     }
     saveAll(params) {
         let p = { 'cuentas': params };
-        return this.httpClient.post(this.geturl(), p, this.buildAuth());
+        return this.api.post(this.endpoint, p);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
     }
 }
-/** @nocollapse */ ClienteCuentaBancoService.ɵfac = function ClienteCuentaBancoService_Factory(t) { return new (t || ClienteCuentaBancoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ClienteCuentaBancoService.ɵfac = function ClienteCuentaBancoService_Factory(t) { return new (t || ClienteCuentaBancoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ClienteCuentaBancoService.ɵprov = ɵɵdefineInjectable({ token: ClienteCuentaBancoService, factory: ClienteCuentaBancoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ClienteCuentaBancoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class ClienteFleteService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/clienteFlete');
-        this.httpClient = httpClient;
+class ClienteFleteService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'clienteFlete';
     }
     saveAll(p) {
         let params = { fletes: p };
-        return this.save(params);
+        return this.api.post(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
     }
 }
-/** @nocollapse */ ClienteFleteService.ɵfac = function ClienteFleteService_Factory(t) { return new (t || ClienteFleteService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ClienteFleteService.ɵfac = function ClienteFleteService_Factory(t) { return new (t || ClienteFleteService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ClienteFleteService.ɵprov = ɵɵdefineInjectable({ token: ClienteFleteService, factory: ClienteFleteService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ClienteFleteService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class TipoContacto {
     constructor() {
@@ -3565,52 +3833,100 @@ class DatoContacto {
     }
 }
 
-class DatoContactoService extends CrudService {
-    constructor(http) {
-        super(http, '/contacto');
+class DatoContactoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'contacto';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ DatoContactoService.ɵfac = function DatoContactoService_Factory(t) { return new (t || DatoContactoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ DatoContactoService.ɵfac = function DatoContactoService_Factory(t) { return new (t || DatoContactoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ DatoContactoService.ɵprov = ɵɵdefineInjectable({ token: DatoContactoService, factory: DatoContactoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(DatoContactoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class DatoDireccionService extends CrudService {
-    constructor(http) {
-        super(http, '/datoDireccion');
+class DatoDireccionService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'datoDireccion';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ DatoDireccionService.ɵfac = function DatoDireccionService_Factory(t) { return new (t || DatoDireccionService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ DatoDireccionService.ɵfac = function DatoDireccionService_Factory(t) { return new (t || DatoDireccionService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ DatoDireccionService.ɵprov = ɵɵdefineInjectable({ token: DatoDireccionService, factory: DatoDireccionService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(DatoDireccionService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class Departamento {
     constructor() {
     }
 }
 
-class DepartamentoService extends CrudService {
-    constructor(http) {
-        super(http, '/departamento');
+class DepartamentoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'departamento';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ DepartamentoService.ɵfac = function DepartamentoService_Factory(t) { return new (t || DepartamentoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ DepartamentoService.ɵfac = function DepartamentoService_Factory(t) { return new (t || DepartamentoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ DepartamentoService.ɵprov = ɵɵdefineInjectable({ token: DepartamentoService, factory: DepartamentoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(DepartamentoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class FormaPago {
     constructor() { }
@@ -3630,72 +3946,132 @@ class ConfiguracionEmpresaAdministrativa {
     }
 }
 
-class EmpresaService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/empresa');
-        this.httpClient = httpClient;
+class EmpresaService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'empresa';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
     }
     get() {
-        // return super.get(1);
-        return this.httpClient.get(this.getBaseUrl() + '/configuracionEmpresaAdministrativo/configuracionUsuario', this.buildAuth());
+        return this.api.get(`${this.endpoint}/configuracionEmpresaAdministrativo/configuracionUsuario`);
+    }
+    getByEmpresa(id) {
+        return this.api.get(`${this.endpoint}/configuracionEmpresaAdministrativo/configuracionUsuario/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ EmpresaService.ɵfac = function EmpresaService_Factory(t) { return new (t || EmpresaService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ EmpresaService.ɵfac = function EmpresaService_Factory(t) { return new (t || EmpresaService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ EmpresaService.ɵprov = ɵɵdefineInjectable({ token: EmpresaService, factory: EmpresaService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(EmpresaService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class FleteService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/flete');
-        this.httpClient = httpClient;
+class FleteService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'flete';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ FleteService.ɵfac = function FleteService_Factory(t) { return new (t || FleteService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ FleteService.ɵfac = function FleteService_Factory(t) { return new (t || FleteService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ FleteService.ɵprov = ɵɵdefineInjectable({ token: FleteService, factory: FleteService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(FleteService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class FormaPagoService extends CrudService {
-    constructor(http) {
-        super(http, '/FormaDePago');
+class FormaPagoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'FormaDePago';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ FormaPagoService.ɵfac = function FormaPagoService_Factory(t) { return new (t || FormaPagoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ FormaPagoService.ɵfac = function FormaPagoService_Factory(t) { return new (t || FormaPagoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ FormaPagoService.ɵprov = ɵɵdefineInjectable({ token: FormaPagoService, factory: FormaPagoService.ɵfac, providedIn: "root" });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(FormaPagoService, [{
         type: Injectable,
         args: [{
                 providedIn: "root"
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class Moneda {
     constructor() { }
 }
 
-class MonedaService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/moneda');
-        this.httpClient = httpClient;
+class MonedaService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'moneda';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ MonedaService.ɵfac = function MonedaService_Factory(t) { return new (t || MonedaService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ MonedaService.ɵfac = function MonedaService_Factory(t) { return new (t || MonedaService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ MonedaService.ɵprov = ɵɵdefineInjectable({ token: MonedaService, factory: MonedaService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(MonedaService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class EstadoCivil {
     constructor() { }
@@ -3705,26 +4081,26 @@ class Genero {
     constructor() { }
 }
 
-class PersonaFisicaService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/PersonaFisica');
-        this.httpClient = httpClient;
+class PersonaFisicaService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'PersonaFisica';
     }
     getGeneros() {
-        return this.httpClient.get(this.getBaseUrl() + '/genero', this.buildAuth());
+        return this.api.get(`${this.endpoint}/genero`);
     }
     getEstadoCivil() {
-        return this.httpClient.get(this.getBaseUrl() + '/estadoCivil', this.buildAuth());
+        return this.api.get(`${this.endpoint}/estadoCivil`);
     }
 }
-/** @nocollapse */ PersonaFisicaService.ɵfac = function PersonaFisicaService_Factory(t) { return new (t || PersonaFisicaService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ PersonaFisicaService.ɵfac = function PersonaFisicaService_Factory(t) { return new (t || PersonaFisicaService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ PersonaFisicaService.ɵprov = ɵɵdefineInjectable({ token: PersonaFisicaService, factory: PersonaFisicaService.ɵfac, providedIn: "root" });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(PersonaFisicaService, [{
         type: Injectable,
         args: [{
                 providedIn: "root"
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class ProveedorCuentaBanco {
     constructor() {
@@ -3741,138 +4117,224 @@ class ProveedorFlete {
     }
 }
 
-class ProveedorCuentaBancoService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/proveedorCuentaBanco');
-        this.httpClient = httpClient;
+class ProveedorCuentaBancoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'proveedorCuentaBanco';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
     }
     saveAll(params) {
         let p = { 'cuentas': params };
-        return this.httpClient.post(this.geturl(), p, this.buildAuth());
+        return this.api.post(this.endpoint, p);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
     }
 }
-/** @nocollapse */ ProveedorCuentaBancoService.ɵfac = function ProveedorCuentaBancoService_Factory(t) { return new (t || ProveedorCuentaBancoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ProveedorCuentaBancoService.ɵfac = function ProveedorCuentaBancoService_Factory(t) { return new (t || ProveedorCuentaBancoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ProveedorCuentaBancoService.ɵprov = ɵɵdefineInjectable({ token: ProveedorCuentaBancoService, factory: ProveedorCuentaBancoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ProveedorCuentaBancoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class ProveedorFleteService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, '/proveedorFlete');
-        this.httpClient = httpClient;
+class ProveedorFleteService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'proveedorFlete';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
     }
     saveAll(p) {
         let params = { fletes: p };
         return this.save(params);
     }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
+    }
 }
-/** @nocollapse */ ProveedorFleteService.ɵfac = function ProveedorFleteService_Factory(t) { return new (t || ProveedorFleteService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ProveedorFleteService.ɵfac = function ProveedorFleteService_Factory(t) { return new (t || ProveedorFleteService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ProveedorFleteService.ɵprov = ɵɵdefineInjectable({ token: ProveedorFleteService, factory: ProveedorFleteService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ProveedorFleteService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class ClaveAumentoDisminucionService extends CrudService {
-    constructor(http) {
-        super(http, 'claveAumentoDisminucion');
+class ClaveAumentoDisminucionService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'claveAumentoDisminucion';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ ClaveAumentoDisminucionService.ɵfac = function ClaveAumentoDisminucionService_Factory(t) { return new (t || ClaveAumentoDisminucionService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ ClaveAumentoDisminucionService.ɵfac = function ClaveAumentoDisminucionService_Factory(t) { return new (t || ClaveAumentoDisminucionService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ ClaveAumentoDisminucionService.ɵprov = ɵɵdefineInjectable({ token: ClaveAumentoDisminucionService, factory: ClaveAumentoDisminucionService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(ClaveAumentoDisminucionService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
-class SerieDocumentoService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'serieDocumento');
-        this.httpClient = httpClient;
+class SerieDocumentoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'serieDocumento';
     }
     getTipos() {
-        return this.httpClient.get(this.getUrl('serieDocumento') + '/tipoSerie', this.buildAuth());
+        return this.api.get(`${this.endpoint}/tipoSerie`);
     }
     getReporte(params) {
-        return this.httpClient.get(this.getUrl('serieDocumento') + '/descargaFormatoReporte' + this.serializeParams(params), this.buildAuth());
+        return this.api.get(`${this.endpoint}/descargaFormatoReporte`, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ SerieDocumentoService.ɵfac = function SerieDocumentoService_Factory(t) { return new (t || SerieDocumentoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ SerieDocumentoService.ɵfac = function SerieDocumentoService_Factory(t) { return new (t || SerieDocumentoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ SerieDocumentoService.ɵprov = ɵɵdefineInjectable({ token: SerieDocumentoService, factory: SerieDocumentoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(SerieDocumentoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class SerieDocumento {
     constructor() { }
 }
 
-class TipoContactoService extends CrudService {
-    constructor(http) {
-        super(http, '/tipoContacto');
+class TipoContactoService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'tipoContacto';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ TipoContactoService.ɵfac = function TipoContactoService_Factory(t) { return new (t || TipoContactoService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ TipoContactoService.ɵfac = function TipoContactoService_Factory(t) { return new (t || TipoContactoService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ TipoContactoService.ɵprov = ɵɵdefineInjectable({ token: TipoContactoService, factory: TipoContactoService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(TipoContactoService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class Ubicacion {
     constructor() { }
 }
 
-class UbicacionService extends CrudService {
-    constructor(http) {
-        super(http, 'ubicacion');
+class UbicacionService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'ubicacion';
+    }
+    getAll(params) {
+        return this.api.get(this.endpoint, params);
+    }
+    get(id) {
+        return this.api.get(`${this.endpoint}/${id}`);
+    }
+    save(obj) {
+        return this.api.post(this.endpoint, obj);
+    }
+    update(obj) {
+        return this.api.put(this.endpoint, obj.id, obj);
+    }
+    delete(id) {
+        return this.api.delete(this.endpoint, id);
     }
 }
-/** @nocollapse */ UbicacionService.ɵfac = function UbicacionService_Factory(t) { return new (t || UbicacionService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ UbicacionService.ɵfac = function UbicacionService_Factory(t) { return new (t || UbicacionService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ UbicacionService.ɵprov = ɵɵdefineInjectable({ token: UbicacionService, factory: UbicacionService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(UbicacionService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class TipoCatalogo {
 }
 TipoCatalogo.ARTICULO = 2;
 TipoCatalogo.USO_CFDI = 11;
 
-class AcreedorCuentaContableService extends CrudService {
-    constructor(httpClient) {
-        super(httpClient, 'acreedorCuentaContable');
-        this.httpClient = httpClient;
+class AcreedorCuentaContableService {
+    constructor(api) {
+        this.api = api;
+        this.endpoint = 'acreedorCuentaContable';
     }
     cuentasContables() {
-        let uRL = "/cuentaContable/obtieneCuentasContablesRecursivo/";
-        return this.httpClient.get(this.getUrl() + uRL, this.buildAuth());
+        return this.api.get(`${this.endpoint}/obtieneCuentasContablesRecursivo`);
     }
 }
-/** @nocollapse */ AcreedorCuentaContableService.ɵfac = function AcreedorCuentaContableService_Factory(t) { return new (t || AcreedorCuentaContableService)(ɵɵinject(HttpClient)); };
+/** @nocollapse */ AcreedorCuentaContableService.ɵfac = function AcreedorCuentaContableService_Factory(t) { return new (t || AcreedorCuentaContableService)(ɵɵinject(ApiService)); };
 /** @nocollapse */ AcreedorCuentaContableService.ɵprov = ɵɵdefineInjectable({ token: AcreedorCuentaContableService, factory: AcreedorCuentaContableService.ɵfac, providedIn: 'root' });
 /*@__PURE__*/ (function () { ɵsetClassMetadata(AcreedorCuentaContableService, [{
         type: Injectable,
         args: [{
                 providedIn: 'root'
             }]
-    }], function () { return [{ type: HttpClient }]; }, null); })();
+    }], function () { return [{ type: ApiService }]; }, null); })();
 
 class CuentaContableModel {
     constructor() {
@@ -3893,5 +4355,5 @@ class NormaInformacionFinancieraModel {
  * Generated bundle index. Do not edit.
  */
 
-export { AcreedorCuentaContableService, AcreedorService, Agente, AgenteService, Almacen, AlmacenService, Auth, AuthService, Authenticated, Banco, BancoService, CanActivateGuard, CatalogoAdicionalService, CatalogoTipo, CatalogoTipoService, CclistaComponent, CcseleccionDialogComponent, ClasificadorTipo, ClasificadorTipoService, ClaveAumentoDisminucionService, ClaveMovimiento, ClaveMovimientoService, Cliente, ClienteCuentaBanco, ClienteCuentaBancoService, ClienteFlete, ClienteFleteService, ClienteService, ConfiguracionEmpresaAdministrativa, ControlAccesoService, CoreLibModule, CrudService, CuentaContableModel, DatoContacto, DatoContactoService, DatoDireccion, DatoDireccionService, Departamento, DepartamentoService, Empresa, EmpresaService, Error404Component, EstadoCivil, FileService, Flete, FleteService, FormaPago, FormaPagoService, Genero, GlobalService, HttpLoaderFactory, InitService, LoadingComponent, LoadingScreenComponent, LoadingScreenService, LoadingService, LoginModalComponent, LoginModalService, MessageService, Moneda, MonedaService, NormaInformacionFinancieraModel, PaginateService, PdfModalComponent, PdfModalService, Persona, PersonaFisica, PersonaFisicaService, PersonaMoral, PersonaMoralService, Proveedor, ProveedorCuentaBanco, ProveedorCuentaBancoService, ProveedorFlete, ProveedorFleteService, ProveedorService, SeleccionaArticuloComponent, SelectAcreedorComponent, SelectClienteComponent, SelectProveedorComponent, SerieDocumento, SerieDocumentoService, SessionCajaService, SessionCreateComponent, StockService, TipoCatalogo, TipoContacto, TipoContactoService, Ubicacion, UbicacionService, Usuario, VersionCheckService, httpInterceptor };
+export { AcreedorCuentaContableService, AcreedorService, Agente, AgenteService, Almacen, AlmacenService, ApiService, Auth, AuthService, Authenticated, Banco, BancoService, CanActivateGuard, CatalogoAdicionalService, CatalogoTipo, CatalogoTipoService, CclistaComponent, CcseleccionDialogComponent, ClasificadorTipo, ClasificadorTipoService, ClaveAumentoDisminucionService, ClaveMovimiento, ClaveMovimientoService, Cliente, ClienteCuentaBanco, ClienteCuentaBancoService, ClienteFlete, ClienteFleteService, ClienteService, ConfiguracionEmpresaAdministrativa, ControlAccesoService, CoreLibModule, CuentaContableModel, DatoContacto, DatoContactoService, DatoDireccion, DatoDireccionService, Departamento, DepartamentoService, Empresa, EmpresaService, Error404Component, EstadoCivil, FileService, Flete, FleteService, FormaPago, FormaPagoService, Genero, GlobalService, HttpLoaderFactory, InitService, LoadingComponent, LoadingScreenComponent, LoadingScreenService, LoadingService, LoginModalComponent, LoginModalService, MessageService, Moneda, MonedaService, NormaInformacionFinancieraModel, PaginateService, PdfModalComponent, PdfModalService, Persona, PersonaFisica, PersonaFisicaService, PersonaMoral, PersonaMoralService, Proveedor, ProveedorCuentaBanco, ProveedorCuentaBancoService, ProveedorFlete, ProveedorFleteService, ProveedorService, SeleccionaArticuloComponent, SelectAcreedorComponent, SelectClienteComponent, SelectProveedorComponent, SerieDocumento, SerieDocumentoService, SessionCajaService, SessionCreateComponent, StockService, TipoCatalogo, TipoContacto, TipoContactoService, Ubicacion, UbicacionService, Usuario, VersionCheckService, httpInterceptor };
 //# sourceMappingURL=visorus-erp-core.js.map