@experteam-mx/ngx-services 15.0.0 → 16.0.0

package/{esm2020 → esm2022}/lib/apis/api-companies.service.mjs

@@ -1,255 +1,255 @@
-import { Inject, Injectable } from '@angular/core';
-import { forkJoin, map, mergeMap } from 'rxjs';
-import { httpParams } from '../helpers/http';
-import * as i0 from "@angular/core";
-import * as i1 from "@angular/common/http";
-export class ApiCompaniesService {
-    constructor(environments, http) {
-        this.environments = environments;
-        this.http = http;
-    }
-    /**
-     * Retrieves the URL for the companies API from the environment configurations.
-     *
-     * @return {string} The URL of the companies API.
-     */
-    get url() {
-        return this.environments.apiCompaniesUrl;
-    }
-    /**
-     * Fetches the installations based on the provided query parameters.
-     *
-     * @param {QueryParams} params - The parameters used to filter the installations query.
-     * @return {Observable<InstallationsData>} An observable that emits the installations data.
-     */
-    getInstallations(params) {
-        return this.http.get(`${this.url}/installations`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves the installation details based on the given installation ID.
-     *
-     * @param {number} id - The unique identifier of the installation to retrieve.
-     * @returns {Observable<InstallationData>} An observable of the installation details.
-     */
-    getInstallation(id) {
-        return this.http.get(`${this.url}/installations/${id}`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves a list of locations based on the provided query parameters.
-     *
-     * @param {QueryParams} params - The parameters to use for querying locations.
-     * @return {Observable<LocationsData>} An observable that emits the locations data.
-     */
-    getLocations(params) {
-        return this.http.get(`${this.url}/locations`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Fetches the location details for a given location ID.
-     *
-     * @param {number} id - The unique identifier of the location.
-     * @return {Observable<LocationData>} An Observable containing the location details.
-     */
-    getLocation(id) {
-        return this.http.get(`${this.url}/locations/${id}`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves a list of active supply entities.
-     *
-     * @param {QueryParams} params - The query parameters to filter supply entities.
-     * @return {Observable<SupplyEntitiesData>} Observable emitting supply entities data.
-     */
-    getSupplyEntitiesActive(params) {
-        return this.http.get(`${this.url}/supply-entities/actives`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Fetches a list of employees based on the specified query parameters.
-     *
-     * @param {QueryParams} params - The parameters to filter and sort the employees.
-     * @return {Observable<EmployeesData>} An observable that emits the list of employees.
-     */
-    getEmployees(params) {
-        return this.http.get(`${this.url}/employees`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Fetches an employee's details based on the provided employee ID.
-     *
-     * @param {number} id - The unique identifier of the employee.
-     * @return {Observable<EmployeeData>} An observable that emits the employee's details.
-     */
-    getEmployee(id) {
-        return this.http.get(`${this.url}/employees/${id}`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves the list of employees for a specified location based on provided query parameters.
-     *
-     * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.
-     * @returns {Observable<LocationEmployeesData>} An observable that emits the list of employees for the specified location.
-     */
-    getLocationEmployees(params) {
-        return this.http.get(`${this.url}/location-employees`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves a list of countries where the company operates.
-     *
-     * @param {QueryParams} params - The query parameters for the API request.
-     * @return {Observable<CompanyCountriesData>} An observable containing the list of company countries.
-     */
-    getCompanyCountries(params) {
-        return this.http.get(`${this.url}/company-countries`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves the country information for a specified company by its ID.
-     *
-     * @param {number} id - The unique identifier of the company.
-     * @return {Observable<CompanyCountryData>} An observable containing the country information of the company.
-     */
-    getCompanyCountry(id) {
-        return this.http.get(`${this.url}/company-countries/${id}`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Fetches the reference currencies for a given country.
-     *
-     * @param {QueryParams} params - The query parameters to include in the request.
-     * @return {Observable<CountryReferenceCurrenciesData>} The observable containing the country reference currencies data.
-     */
-    getCountryReferenceCurrencies(params) {
-        return this.http.get(`${this.url}/country-reference-currencies`, { params }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves a list of currencies for different countries along with their current exchange rates.
-     *
-     * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.
-     * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.
-     */
-    getCountryCurrenciesWithRate(params) {
-        return this.getCountryReferenceCurrencies(params)
-            .pipe(mergeMap((currenciesData) => {
-            const $observables = currenciesData.country_reference_currencies
-                .map((country_reference_currency) => this.getCurrentExchanges({
-                currency_id: country_reference_currency.currency.id,
-            }).pipe(map((exchangesData) => ({
-                ...country_reference_currency,
-                rate: exchangesData.exchanges[0]?.value ?? 1.00,
-            }))));
-            return forkJoin($observables);
-        }));
-    }
-    /**
-     * Retrieves the current exchanges based on the given query parameters.
-     *
-     * @param {QueryParams} params - The query parameters to filter the exchanges.
-     *
-     * @returns {Observable<ExchangesData>} - An observable that emits the API response data containing the current exchanges.
-     */
-    getCurrentExchanges(params) {
-        return this.http.get(`${this.url}/exchanges/current`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Fetches the country-specific tax information for a company.
-     *
-     * @param {QueryParams} params - The parameters used to filter and query the taxes.
-     * @return {Observable<CompanyCountryTaxesData>} An observable that emits the tax information.
-     */
-    getCompanyCountryTaxes(params) {
-        return this.http.get(`${this.url}/company-country-taxes`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves the list of active account entities based on the provided query parameters.
-     *
-     * @param {QueryParams} params - The parameters to filter and query active account entities.
-     * @return {Observable<AccountEntitiesData>} An observable that emits the list of active account entities.
-     */
-    getActiveAccountEntities(params) {
-        return this.http.get(`${this.url}/account-entities/actives`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves the parameter values based on the provided parameter names.
-     *
-     * @param {Object} params - An object containing the required parameters.
-     * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.
-     * @return {Observable<ParametersData>} An observable that emits the fetched parameter values.
-     */
-    getParameters({ paramNames, }) {
-        const parameters = paramNames.map((p) => ({ name: p }));
-        return this.http.post(`${this.url}/parameters-values`, {
-            parameters
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves the value of a specified parameter.
-     *
-     * @param {Object} input - The input object containing the parameter details.
-     * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.
-     * @return {Observable<ParameterValueData>} An observable emitting the value of the specified parameter.
-     */
-    getParameterValue({ paramName, }) {
-        return this.http.get(`${this.url}/parameters-values/${paramName}`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Retrieves a list of country references based on the given query parameters.
-     *
-     * @param {QueryParams} params - The query parameters for retrieving country references.
-     * @return {Observable<CountryReferencesData>} An observable containing the country reference data.
-     */
-    getCountryReferences(params) {
-        return this.http.get(`${this.url}/country-references`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-    /**
-     * Fetches the country reference data for a given country ID.
-     *
-     * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.
-     * @return {Observable<CountryReferenceData>} An observable containing the country reference data.
-     */
-    getCountryReference(id) {
-        return this.http.get(`${this.url}/country-references/${id}`)
-            .pipe(map(({ data }) => data));
-    }
-    /**
-     * Fetches the list of workflows based on the provided query parameters.
-     *
-     * @param {QueryParams} params - The query parameters used to filter workflows.
-     * @return {Observable<WorkflowsData>} An observable containing the workflow data.
-     */
-    getWorkflows(params) {
-        return this.http.get(`${this.url}/workflows`, {
-            params: httpParams(params),
-        }).pipe(map(({ data }) => data));
-    }
-}
-ApiCompaniesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiCompaniesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
-ApiCompaniesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiCompaniesService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ApiCompaniesService, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root'
-                }]
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['env']
-                }] }, { type: i1.HttpClient }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam/ngx-services/src/lib/apis/api-companies.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport {\r\n  AccountEntitiesData,\r\n  CompanyCountriesData,\r\n  CompanyCountryData,\r\n  CompanyCountryTaxesData,\r\n  CountryReferenceCurrenciesData,\r\n  CountryReferenceData,\r\n  CountryReferencesData,\r\n  EmployeeData,\r\n  EmployeesData,\r\n  ExchangesData,\r\n  InstallationData,\r\n  InstallationsData,\r\n  LocationData,\r\n  LocationEmployeesData,\r\n  LocationsData,\r\n  ParametersData,\r\n  ParametersProps,\r\n  ParameterValueData,\r\n  ParameterValueProps,\r\n  SupplyEntitiesData,\r\n  WorkflowsData\r\n} from './models/api-companies.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { forkJoin, map, mergeMap, Observable } from 'rxjs'\r\nimport { httpParams } from '../helpers/http'\r\nimport { CountryCurrencyRate } from './models/api-companies.interfaces'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCompaniesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient,\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the URL for the companies API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the companies API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCompaniesUrl\r\n  }\r\n\r\n  /**\r\n   * Fetches the installations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter the installations query.\r\n   * @return {Observable<InstallationsData>} An observable that emits the installations data.\r\n   */\r\n  getInstallations (params: QueryParams): Observable<InstallationsData> {\r\n    return this.http.get<ApiSuccess<InstallationsData>>(`${this.url}/installations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the installation details based on the given installation ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the installation to retrieve.\r\n   * @returns {Observable<InstallationData>} An observable of the installation details.\r\n   */\r\n  getInstallation (id: number): Observable<InstallationData> {\r\n    return this.http.get<ApiSuccess<InstallationData>>(`${this.url}/installations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of locations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to use for querying locations.\r\n   * @return {Observable<LocationsData>} An observable that emits the locations data.\r\n   */\r\n  getLocations (params: QueryParams): Observable<LocationsData> {\r\n    return this.http.get<ApiSuccess<LocationsData>>(`${this.url}/locations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the location details for a given location ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the location.\r\n   * @return {Observable<LocationData>} An Observable containing the location details.\r\n   */\r\n  getLocation (id: number): Observable<LocationData> {\r\n    return this.http.get<ApiSuccess<LocationData>>(`${this.url}/locations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of active supply entities.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter supply entities.\r\n   * @return {Observable<SupplyEntitiesData>} Observable emitting supply entities data.\r\n   */\r\n  getSupplyEntitiesActive (params: QueryParams): Observable<SupplyEntitiesData> {\r\n    return this.http.get<ApiSuccess<SupplyEntitiesData>>(`${this.url}/supply-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of employees based on the specified query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and sort the employees.\r\n   * @return {Observable<EmployeesData>} An observable that emits the list of employees.\r\n   */\r\n  getEmployees (params: QueryParams): Observable<EmployeesData> {\r\n    return this.http.get<ApiSuccess<EmployeesData>>(`${this.url}/employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches an employee's details based on the provided employee ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee.\r\n   * @return {Observable<EmployeeData>} An observable that emits the employee's details.\r\n   */\r\n  getEmployee (id: number): Observable<EmployeeData> {\r\n    return this.http.get<ApiSuccess<EmployeeData>>(`${this.url}/employees/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of employees for a specified location based on provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.\r\n   * @returns {Observable<LocationEmployeesData>} An observable that emits the list of employees for the specified location.\r\n   */\r\n  getLocationEmployees (params: QueryParams): Observable<LocationEmployeesData> {\r\n    return this.http.get<ApiSuccess<LocationEmployeesData>>(`${this.url}/location-employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of countries where the company operates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for the API request.\r\n   * @return {Observable<CompanyCountriesData>} An observable containing the list of company countries.\r\n   */\r\n  getCompanyCountries (params: QueryParams): Observable<CompanyCountriesData> {\r\n    return this.http.get<ApiSuccess<CompanyCountriesData>>(`${this.url}/company-countries`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n\r\n  /**\r\n   * Retrieves the country information for a specified company by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the company.\r\n   * @return {Observable<CompanyCountryData>} An observable containing the country information of the company.\r\n   */\r\n  getCompanyCountry (id: number): Observable<CompanyCountryData> {\r\n    return this.http.get<ApiSuccess<CompanyCountryData>>(`${this.url}/company-countries/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the reference currencies for a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to include in the request.\r\n   * @return {Observable<CountryReferenceCurrenciesData>} The observable containing the country reference currencies data.\r\n   */\r\n  getCountryReferenceCurrencies (params: QueryParams): Observable<CountryReferenceCurrenciesData> {\r\n    return this.http.get<ApiSuccess<CountryReferenceCurrenciesData>>(\r\n      `${this.url}/country-reference-currencies`,\r\n      { params }\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of currencies for different countries along with their current exchange rates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.\r\n   * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.\r\n   */\r\n  getCountryCurrenciesWithRate (params: QueryParams): Observable<CountryCurrencyRate[]> {\r\n    return this.getCountryReferenceCurrencies(params)\r\n      .pipe(mergeMap((currenciesData) => {\r\n        const $observables = currenciesData.country_reference_currencies\r\n          .map((country_reference_currency) =>\r\n            this.getCurrentExchanges({\r\n              currency_id: country_reference_currency.currency.id,\r\n            }).pipe(\r\n              map((exchangesData) => ({\r\n                ...country_reference_currency,\r\n                rate: exchangesData.exchanges[0]?.value ?? 1.00,\r\n              }))\r\n            )\r\n          )\r\n\r\n        return forkJoin($observables)\r\n      }))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the current exchanges based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the exchanges.\r\n   *\r\n   * @returns {Observable<ExchangesData>} - An observable that emits the API response data containing the current exchanges.\r\n   */\r\n  getCurrentExchanges (params: QueryParams): Observable<ExchangesData> {\r\n    return this.http.get<ApiSuccess<ExchangesData>>(`${this.url}/exchanges/current`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country-specific tax information for a company.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter and query the taxes.\r\n   * @return {Observable<CompanyCountryTaxesData>} An observable that emits the tax information.\r\n   */\r\n  getCompanyCountryTaxes (params: QueryParams): Observable<CompanyCountryTaxesData> {\r\n    return this.http.get<ApiSuccess<CompanyCountryTaxesData>>(`${this.url}/company-country-taxes`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of active account entities based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and query active account entities.\r\n   * @return {Observable<AccountEntitiesData>} An observable that emits the list of active account entities.\r\n   */\r\n  getActiveAccountEntities (params: QueryParams): Observable<AccountEntitiesData> {\r\n    return this.http.get<ApiSuccess<AccountEntitiesData>>(`${this.url}/account-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the parameter values based on the provided parameter names.\r\n   *\r\n   * @param {Object} params - An object containing the required parameters.\r\n   * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.\r\n   * @return {Observable<ParametersData>} An observable that emits the fetched parameter values.\r\n   */\r\n  getParameters ({\r\n    paramNames,\r\n  }: ParametersProps): Observable<ParametersData> {\r\n    const parameters = paramNames.map((p) => ({ name: p }))\r\n\r\n    return this.http.post<ApiSuccess<ParametersData>>(`${this.url}/parameters-values`, {\r\n      parameters\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the value of a specified parameter.\r\n   *\r\n   * @param {Object} input - The input object containing the parameter details.\r\n   * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.\r\n   * @return {Observable<ParameterValueData>} An observable emitting the value of the specified parameter.\r\n   */\r\n  getParameterValue ({\r\n    paramName,\r\n  }: ParameterValueProps): Observable<ParameterValueData> {\r\n    return this.http.get<ApiSuccess<ParameterValueData>>(`${this.url}/parameters-values/${paramName}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of country references based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for retrieving country references.\r\n   * @return {Observable<CountryReferencesData>} An observable containing the country reference data.\r\n   */\r\n  getCountryReferences (params: QueryParams): Observable<CountryReferencesData> {\r\n    return this.http.get<ApiSuccess<CountryReferencesData>>(`${this.url}/country-references`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country reference data for a given country ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.\r\n   * @return {Observable<CountryReferenceData>} An observable containing the country reference data.\r\n   */\r\n  getCountryReference (id: number): Observable<CountryReferenceData> {\r\n    return this.http.get<ApiSuccess<CountryReferenceData>>(`${this.url}/country-references/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of workflows based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter workflows.\r\n   * @return {Observable<WorkflowsData>} An observable containing the workflow data.\r\n   */\r\n  getWorkflows (params: QueryParams): Observable<WorkflowsData> {\r\n    return this.http.get<ApiSuccess<WorkflowsData>>(`${this.url}/workflows`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}
+import { Inject, Injectable } from '@angular/core';
+import { forkJoin, map, mergeMap } from 'rxjs';
+import { httpParams } from '../helpers/http';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiCompaniesService {
+    constructor(environments, http) {
+        this.environments = environments;
+        this.http = http;
+    }
+    /**
+     * Retrieves the URL for the companies API from the environment configurations.
+     *
+     * @return {string} The URL of the companies API.
+     */
+    get url() {
+        return this.environments.apiCompaniesUrl;
+    }
+    /**
+     * Fetches the installations based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters used to filter the installations query.
+     * @return {Observable<InstallationsData>} An observable that emits the installations data.
+     */
+    getInstallations(params) {
+        return this.http.get(`${this.url}/installations`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the installation details based on the given installation ID.
+     *
+     * @param {number} id - The unique identifier of the installation to retrieve.
+     * @returns {Observable<InstallationData>} An observable of the installation details.
+     */
+    getInstallation(id) {
+        return this.http.get(`${this.url}/installations/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of locations based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters to use for querying locations.
+     * @return {Observable<LocationsData>} An observable that emits the locations data.
+     */
+    getLocations(params) {
+        return this.http.get(`${this.url}/locations`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the location details for a given location ID.
+     *
+     * @param {number} id - The unique identifier of the location.
+     * @return {Observable<LocationData>} An Observable containing the location details.
+     */
+    getLocation(id) {
+        return this.http.get(`${this.url}/locations/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of active supply entities.
+     *
+     * @param {QueryParams} params - The query parameters to filter supply entities.
+     * @return {Observable<SupplyEntitiesData>} Observable emitting supply entities data.
+     */
+    getSupplyEntitiesActive(params) {
+        return this.http.get(`${this.url}/supply-entities/actives`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches a list of employees based on the specified query parameters.
+     *
+     * @param {QueryParams} params - The parameters to filter and sort the employees.
+     * @return {Observable<EmployeesData>} An observable that emits the list of employees.
+     */
+    getEmployees(params) {
+        return this.http.get(`${this.url}/employees`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches an employee's details based on the provided employee ID.
+     *
+     * @param {number} id - The unique identifier of the employee.
+     * @return {Observable<EmployeeData>} An observable that emits the employee's details.
+     */
+    getEmployee(id) {
+        return this.http.get(`${this.url}/employees/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the list of employees for a specified location based on provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.
+     * @returns {Observable<LocationEmployeesData>} An observable that emits the list of employees for the specified location.
+     */
+    getLocationEmployees(params) {
+        return this.http.get(`${this.url}/location-employees`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of countries where the company operates.
+     *
+     * @param {QueryParams} params - The query parameters for the API request.
+     * @return {Observable<CompanyCountriesData>} An observable containing the list of company countries.
+     */
+    getCompanyCountries(params) {
+        return this.http.get(`${this.url}/company-countries`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the country information for a specified company by its ID.
+     *
+     * @param {number} id - The unique identifier of the company.
+     * @return {Observable<CompanyCountryData>} An observable containing the country information of the company.
+     */
+    getCompanyCountry(id) {
+        return this.http.get(`${this.url}/company-countries/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the reference currencies for a given country.
+     *
+     * @param {QueryParams} params - The query parameters to include in the request.
+     * @return {Observable<CountryReferenceCurrenciesData>} The observable containing the country reference currencies data.
+     */
+    getCountryReferenceCurrencies(params) {
+        return this.http.get(`${this.url}/country-reference-currencies`, { params }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of currencies for different countries along with their current exchange rates.
+     *
+     * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.
+     * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.
+     */
+    getCountryCurrenciesWithRate(params) {
+        return this.getCountryReferenceCurrencies(params)
+            .pipe(mergeMap((currenciesData) => {
+            const $observables = currenciesData.country_reference_currencies
+                .map((country_reference_currency) => this.getCurrentExchanges({
+                currency_id: country_reference_currency.currency.id,
+            }).pipe(map((exchangesData) => ({
+                ...country_reference_currency,
+                rate: exchangesData.exchanges[0]?.value ?? 1.00,
+            }))));
+            return forkJoin($observables);
+        }));
+    }
+    /**
+     * Retrieves the current exchanges based on the given query parameters.
+     *
+     * @param {QueryParams} params - The query parameters to filter the exchanges.
+     *
+     * @returns {Observable<ExchangesData>} - An observable that emits the API response data containing the current exchanges.
+     */
+    getCurrentExchanges(params) {
+        return this.http.get(`${this.url}/exchanges/current`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the country-specific tax information for a company.
+     *
+     * @param {QueryParams} params - The parameters used to filter and query the taxes.
+     * @return {Observable<CompanyCountryTaxesData>} An observable that emits the tax information.
+     */
+    getCompanyCountryTaxes(params) {
+        return this.http.get(`${this.url}/company-country-taxes`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the list of active account entities based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The parameters to filter and query active account entities.
+     * @return {Observable<AccountEntitiesData>} An observable that emits the list of active account entities.
+     */
+    getActiveAccountEntities(params) {
+        return this.http.get(`${this.url}/account-entities/actives`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the parameter values based on the provided parameter names.
+     *
+     * @param {Object} params - An object containing the required parameters.
+     * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.
+     * @return {Observable<ParametersData>} An observable that emits the fetched parameter values.
+     */
+    getParameters({ paramNames, }) {
+        const parameters = paramNames.map((p) => ({ name: p }));
+        return this.http.post(`${this.url}/parameters-values`, {
+            parameters
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves the value of a specified parameter.
+     *
+     * @param {Object} input - The input object containing the parameter details.
+     * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.
+     * @return {Observable<ParameterValueData>} An observable emitting the value of the specified parameter.
+     */
+    getParameterValue({ paramName, }) {
+        return this.http.get(`${this.url}/parameters-values/${paramName}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Retrieves a list of country references based on the given query parameters.
+     *
+     * @param {QueryParams} params - The query parameters for retrieving country references.
+     * @return {Observable<CountryReferencesData>} An observable containing the country reference data.
+     */
+    getCountryReferences(params) {
+        return this.http.get(`${this.url}/country-references`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the country reference data for a given country ID.
+     *
+     * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.
+     * @return {Observable<CountryReferenceData>} An observable containing the country reference data.
+     */
+    getCountryReference(id) {
+        return this.http.get(`${this.url}/country-references/${id}`)
+            .pipe(map(({ data }) => data));
+    }
+    /**
+     * Fetches the list of workflows based on the provided query parameters.
+     *
+     * @param {QueryParams} params - The query parameters used to filter workflows.
+     * @return {Observable<WorkflowsData>} An observable containing the workflow data.
+     */
+    getWorkflows(params) {
+        return this.http.get(`${this.url}/workflows`, {
+            params: httpParams(params),
+        }).pipe(map(({ data }) => data));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiCompaniesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiCompaniesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ApiCompaniesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['env']
+                }] }, { type: i1.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api-companies.service.js","sourceRoot":"","sources":["../../../../../../projects/experteam/ngx-services/src/lib/apis/api-companies.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core'\r\nimport { Environment } from '../ngx-services.models'\r\nimport { HttpClient } from '@angular/common/http'\r\nimport {\r\n  AccountEntitiesData,\r\n  CompanyCountriesData,\r\n  CompanyCountryData,\r\n  CompanyCountryTaxesData,\r\n  CountryReferenceCurrenciesData,\r\n  CountryReferenceData,\r\n  CountryReferencesData,\r\n  EmployeeData,\r\n  EmployeesData,\r\n  ExchangesData,\r\n  InstallationData,\r\n  InstallationsData,\r\n  LocationData,\r\n  LocationEmployeesData,\r\n  LocationsData,\r\n  ParametersData,\r\n  ParametersProps,\r\n  ParameterValueData,\r\n  ParameterValueProps,\r\n  SupplyEntitiesData,\r\n  WorkflowsData\r\n} from './models/api-companies.types'\r\nimport { ApiSuccess, QueryParams } from './models/api.models'\r\nimport { forkJoin, map, mergeMap, Observable } from 'rxjs'\r\nimport { httpParams } from '../helpers/http'\r\nimport { CountryCurrencyRate } from './models/api-companies.interfaces'\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ApiCompaniesService {\r\n  constructor (\r\n    @Inject('env') private environments: Environment,\r\n    private http: HttpClient,\r\n  ) { }\r\n\r\n  /**\r\n   * Retrieves the URL for the companies API from the environment configurations.\r\n   *\r\n   * @return {string} The URL of the companies API.\r\n   */\r\n  get url (): string {\r\n    return this.environments.apiCompaniesUrl\r\n  }\r\n\r\n  /**\r\n   * Fetches the installations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter the installations query.\r\n   * @return {Observable<InstallationsData>} An observable that emits the installations data.\r\n   */\r\n  getInstallations (params: QueryParams): Observable<InstallationsData> {\r\n    return this.http.get<ApiSuccess<InstallationsData>>(`${this.url}/installations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the installation details based on the given installation ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the installation to retrieve.\r\n   * @returns {Observable<InstallationData>} An observable of the installation details.\r\n   */\r\n  getInstallation (id: number): Observable<InstallationData> {\r\n    return this.http.get<ApiSuccess<InstallationData>>(`${this.url}/installations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of locations based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to use for querying locations.\r\n   * @return {Observable<LocationsData>} An observable that emits the locations data.\r\n   */\r\n  getLocations (params: QueryParams): Observable<LocationsData> {\r\n    return this.http.get<ApiSuccess<LocationsData>>(`${this.url}/locations`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the location details for a given location ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the location.\r\n   * @return {Observable<LocationData>} An Observable containing the location details.\r\n   */\r\n  getLocation (id: number): Observable<LocationData> {\r\n    return this.http.get<ApiSuccess<LocationData>>(`${this.url}/locations/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of active supply entities.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter supply entities.\r\n   * @return {Observable<SupplyEntitiesData>} Observable emitting supply entities data.\r\n   */\r\n  getSupplyEntitiesActive (params: QueryParams): Observable<SupplyEntitiesData> {\r\n    return this.http.get<ApiSuccess<SupplyEntitiesData>>(`${this.url}/supply-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches a list of employees based on the specified query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and sort the employees.\r\n   * @return {Observable<EmployeesData>} An observable that emits the list of employees.\r\n   */\r\n  getEmployees (params: QueryParams): Observable<EmployeesData> {\r\n    return this.http.get<ApiSuccess<EmployeesData>>(`${this.url}/employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches an employee's details based on the provided employee ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the employee.\r\n   * @return {Observable<EmployeeData>} An observable that emits the employee's details.\r\n   */\r\n  getEmployee (id: number): Observable<EmployeeData> {\r\n    return this.http.get<ApiSuccess<EmployeeData>>(`${this.url}/employees/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of employees for a specified location based on provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter and retrieve the location employees.\r\n   * @returns {Observable<LocationEmployeesData>} An observable that emits the list of employees for the specified location.\r\n   */\r\n  getLocationEmployees (params: QueryParams): Observable<LocationEmployeesData> {\r\n    return this.http.get<ApiSuccess<LocationEmployeesData>>(`${this.url}/location-employees`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of countries where the company operates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for the API request.\r\n   * @return {Observable<CompanyCountriesData>} An observable containing the list of company countries.\r\n   */\r\n  getCompanyCountries (params: QueryParams): Observable<CompanyCountriesData> {\r\n    return this.http.get<ApiSuccess<CompanyCountriesData>>(`${this.url}/company-countries`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n\r\n  /**\r\n   * Retrieves the country information for a specified company by its ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the company.\r\n   * @return {Observable<CompanyCountryData>} An observable containing the country information of the company.\r\n   */\r\n  getCompanyCountry (id: number): Observable<CompanyCountryData> {\r\n    return this.http.get<ApiSuccess<CompanyCountryData>>(`${this.url}/company-countries/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the reference currencies for a given country.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to include in the request.\r\n   * @return {Observable<CountryReferenceCurrenciesData>} The observable containing the country reference currencies data.\r\n   */\r\n  getCountryReferenceCurrencies (params: QueryParams): Observable<CountryReferenceCurrenciesData> {\r\n    return this.http.get<ApiSuccess<CountryReferenceCurrenciesData>>(\r\n      `${this.url}/country-reference-currencies`,\r\n      { params }\r\n    ).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of currencies for different countries along with their current exchange rates.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to fetch the country reference currencies.\r\n   * @return {Observable<CountryCurrencyRate[]>} An observable that emits an array of country currency rates.\r\n   */\r\n  getCountryCurrenciesWithRate (params: QueryParams): Observable<CountryCurrencyRate[]> {\r\n    return this.getCountryReferenceCurrencies(params)\r\n      .pipe(mergeMap((currenciesData) => {\r\n        const $observables = currenciesData.country_reference_currencies\r\n          .map((country_reference_currency) =>\r\n            this.getCurrentExchanges({\r\n              currency_id: country_reference_currency.currency.id,\r\n            }).pipe(\r\n              map((exchangesData) => ({\r\n                ...country_reference_currency,\r\n                rate: exchangesData.exchanges[0]?.value ?? 1.00,\r\n              }))\r\n            )\r\n          )\r\n\r\n        return forkJoin($observables)\r\n      }))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the current exchanges based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters to filter the exchanges.\r\n   *\r\n   * @returns {Observable<ExchangesData>} - An observable that emits the API response data containing the current exchanges.\r\n   */\r\n  getCurrentExchanges (params: QueryParams): Observable<ExchangesData> {\r\n    return this.http.get<ApiSuccess<ExchangesData>>(`${this.url}/exchanges/current`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country-specific tax information for a company.\r\n   *\r\n   * @param {QueryParams} params - The parameters used to filter and query the taxes.\r\n   * @return {Observable<CompanyCountryTaxesData>} An observable that emits the tax information.\r\n   */\r\n  getCompanyCountryTaxes (params: QueryParams): Observable<CompanyCountryTaxesData> {\r\n    return this.http.get<ApiSuccess<CompanyCountryTaxesData>>(`${this.url}/company-country-taxes`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the list of active account entities based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The parameters to filter and query active account entities.\r\n   * @return {Observable<AccountEntitiesData>} An observable that emits the list of active account entities.\r\n   */\r\n  getActiveAccountEntities (params: QueryParams): Observable<AccountEntitiesData> {\r\n    return this.http.get<ApiSuccess<AccountEntitiesData>>(`${this.url}/account-entities/actives`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the parameter values based on the provided parameter names.\r\n   *\r\n   * @param {Object} params - An object containing the required parameters.\r\n   * @param {string[]} params.paramNames - An array of parameter names for which the values need to be fetched.\r\n   * @return {Observable<ParametersData>} An observable that emits the fetched parameter values.\r\n   */\r\n  getParameters ({\r\n    paramNames,\r\n  }: ParametersProps): Observable<ParametersData> {\r\n    const parameters = paramNames.map((p) => ({ name: p }))\r\n\r\n    return this.http.post<ApiSuccess<ParametersData>>(`${this.url}/parameters-values`, {\r\n      parameters\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves the value of a specified parameter.\r\n   *\r\n   * @param {Object} input - The input object containing the parameter details.\r\n   * @param {string} input.paramName - The name of the parameter whose value is to be retrieved.\r\n   * @return {Observable<ParameterValueData>} An observable emitting the value of the specified parameter.\r\n   */\r\n  getParameterValue ({\r\n    paramName,\r\n  }: ParameterValueProps): Observable<ParameterValueData> {\r\n    return this.http.get<ApiSuccess<ParameterValueData>>(`${this.url}/parameters-values/${paramName}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Retrieves a list of country references based on the given query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters for retrieving country references.\r\n   * @return {Observable<CountryReferencesData>} An observable containing the country reference data.\r\n   */\r\n  getCountryReferences (params: QueryParams): Observable<CountryReferencesData> {\r\n    return this.http.get<ApiSuccess<CountryReferencesData>>(`${this.url}/country-references`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the country reference data for a given country ID.\r\n   *\r\n   * @param {number} id - The unique identifier of the country for which the reference data is to be retrieved.\r\n   * @return {Observable<CountryReferenceData>} An observable containing the country reference data.\r\n   */\r\n  getCountryReference (id: number): Observable<CountryReferenceData> {\r\n    return this.http.get<ApiSuccess<CountryReferenceData>>(`${this.url}/country-references/${id}`)\r\n      .pipe(map(({ data }) => data))\r\n  }\r\n\r\n  /**\r\n   * Fetches the list of workflows based on the provided query parameters.\r\n   *\r\n   * @param {QueryParams} params - The query parameters used to filter workflows.\r\n   * @return {Observable<WorkflowsData>} An observable containing the workflow data.\r\n   */\r\n  getWorkflows (params: QueryParams): Observable<WorkflowsData> {\r\n    return this.http.get<ApiSuccess<WorkflowsData>>(`${this.url}/workflows`, {\r\n      params: httpParams(params),\r\n    }).pipe(map(({ data }) => data))\r\n  }\r\n}\r\n"]}