@experteam-mx/ngx-services
Version:
Angular common services for Experteam apps
353 lines • 50.6 kB
JavaScript
import { Inject, Injectable } from '@angular/core';
import { forkJoin, map, mergeMap } from 'rxjs';
import * as i0 from "@angular/core";
import * as i1 from "@angular/common/http";
export class ApiCompaniesService {
environments;
http;
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<InstallationsOut>} An observable that emits the installation's data.
*/
getInstallations(params) {
return this.http.get(`${this.url}/installations`, {
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<InstallationOut>} 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<LocationsOut>} An observable that emits the location's data.
*/
getLocations(params) {
return this.http.get(`${this.url}/locations`, {
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<LocationOut>} 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<SupplyEntitiesActivesOut>} Observable emitting supply entities data.
*/
getSupplyEntitiesActives(params) {
return this.http.get(`${this.url}/supply-entities/actives`, {
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<EmployeesOut>} An observable that emits the list of employees.
*/
getEmployees(params) {
return this.http.get(`${this.url}/employees`, {
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<EmployeeOut>} 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<LocationEmployeesOut>} An observable that emits the list of employees for the specified location.
*/
getLocationEmployees(params) {
return this.http.get(`${this.url}/location-employees`, {
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<CompanyCountriesOut>} An observable containing the list of company countries.
*/
getCompanyCountries(params) {
return this.http.get(`${this.url}/company-countries`, {
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<CompanyCountryOut>} 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<CountryReferenceCurrenciesOut>} 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((item) => this.getCurrentExchanges({
currency_id: item.currency.id,
}).pipe(map((exchangesData) => ({
...item,
rate: exchangesData.exchanges[0]?.value,
}))));
return forkJoin($observables);
}));
}
/**
* Fetches exchange data based on the provided query parameters.
*
* @param {QueryParams} params - The query parameters for retrieving exchange data.
* @return {Observable<ExchangesOut>} An observable containing the exchange data.
*/
getExchanges(params) {
return this.http.get(`${this.url}/exchanges`, {
params,
}).pipe(map(({ data }) => data));
}
/**
* Retrieves the current exchanges based on the given query parameters.
*
* @param {QueryParams} params - The query parameters to filter the exchanges.
*
* @returns {Observable<ExchangesOut>} - An observable that emits the API response data containing the current exchanges.
*/
getCurrentExchanges(params) {
return this.http.get(`${this.url}/exchanges/current`, {
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<CompanyCountryTaxesOut>} An observable that emits the tax information.
*/
getCompanyCountryTaxes(params) {
return this.http.get(`${this.url}/company-country-taxes`, {
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<AccountEntitiesActivesOut>} An observable that emits the list of active account entities.
*/
getAccountEntitiesActives(params) {
return this.http.get(`${this.url}/account-entities/actives`, {
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<ParametersValuesOut>} An observable that emits the fetched parameter values.
*/
getParametersValues({ 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<ParameterValueOut>} 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<CountryReferencesOut>} An observable containing the country reference data.
*/
getCountryReferences(params) {
return this.http.get(`${this.url}/country-references`, {
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<CountryReferenceOut>} 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<WorkflowsOut>} An observable containing the workflow data.
*/
getWorkflows(params) {
return this.http.get(`${this.url}/workflows`, {
params,
}).pipe(map(({ data }) => data));
}
/**
* Fetches the list of employee customer
*
* @param {QueryParams} params - The query parameters used to filter employee customers.
* @return {Observable<EmployeeCustomersOut>} An observable containing the employee customer data.
*/
getEmployeesCustomers(params) {
return this.http.get(`${this.url}/employee-customers`, {
params,
}).pipe(map(({ data }) => data));
}
/**
* Sends a POST request to create or update employee customer records and processes the server response.
*
* @param {EmployeeCustomersIn} body - The request payload containing employee customer data to be sent to the server.
* @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee customer data on successful response.
*/
postEmployeeCustomers(body) {
return this.http.post(`${this.url}/employee-customers`, body).pipe(map(({ data }) => data));
}
/**
* Updates the employee-customer association record identified by the given ID with the provided data.
*
* @param {number} id - The identifier of the employee-customer record to update.
* @param {EmployeeCustomersIn} body - The data to update the employee-customer record with.
* @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.
*/
putEmployeeCustomers(id, body) {
return this.http.put(`${this.url}/employee-customers/${id}`, body).pipe(map(({ data }) => data));
}
/**
* Fetches the employee-customer details based on the provided employee customer ID.
*
* @param {number} id - The identifier of the employee-customer record to update.
* @return {Observable<EmployeeCustomersOut>} An observable that emits the updated employee-customer data.
*/
getEmployeeCustomer(id) {
return this.http.get(`${this.url}/employee-customers/${id}`).pipe(map(({ data }) => data));
}
/**
* Enables or disables an employee customer's active state.
*
* @param {EmployeeCustomerDhl} employee - The employee customer object to be updated.
* @param {boolean} [isActive] - Optional parameter to explicitly set the active state.
* If null or undefined, the active state will be toggled.
* @return {Observable<EmployeeCustomersOut>} An observable containing the updated employee customer output.
*/
enableDisableEmployeeCustomers(employee, isActive) {
return this.http.patch(`${this.url}/employee-customers/${employee.id}`, {
is_active: isActive ?? !employee.is_active
}).pipe(map(({ data }) => data));
}
/**
* Submits a file containing employee customer data for a specific country to the server.
*
* @param {number} countryId - The identifier of the country for which the data is being uploaded.
* @param {File} file - The file containing employee customer data to be uploaded.
* @return {Observable<BoardingProcessIdIn>} Observable that emits the processed boarding process ID on success.
*/
postEmployeeCustomersLoad(countryId, file) {
const formData = new FormData();
formData.append('file', file);
formData.append('country_id', countryId.toString());
return this.http.post(`${this.url}/employee-customers/load`, formData).pipe(map(({ data }) => data));
}
/**
* Downloads a file containing customer data for a specific employee based on the provided country ID.
*
* @param {number} id - The ID of the country used as a filter for fetching the employee's customers.
* @return {Observable<Blob>} An observable that emits the file blob containing the customer data.
*/
getEmployeeCustomersDownload(id) {
return this.http.get(`${this.url}/employee-customers/download`, {
params: { country_id: id },
responseType: 'blob'
});
}
/**
* Retrieves the boarding process details for a given ID.
*
* @param {number} id - The unique identifier of the boarding process to retrieve.
* @return {Observable<BoardingProcessIn>} An observable containing the boarding process details.
*/
getBoardingProcess(id) {
return this.http.get(`${this.url}/boarding-process/${id}`).pipe(map(({ data }) => data));
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompaniesService, deps: [{ token: 'env' }, { token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompaniesService, providedIn: 'root' });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ApiCompaniesService, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: undefined, decorators: [{
type: Inject,
args: ['env']
}] }, { type: i1.HttpClient }] });
//# sourceMappingURL=data:application/json;base64,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