@nomalism-com/api 0.33.83 → 0.34.1

package/src/modules/supply/payment.ts

@@ -0,0 +1,182 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.Payment.IFindRequest;
+export import IFindResponse = Nomalism.Payment.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.Payment.IFindPaginatedRequest;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+export import IFindByIdRequest = Nomalism.shared.IFindByIdRequest;
+
+export import ICurrentAccountNotes = Nomalism.Payment.ICurrentAccountNotes;
+export import IFindCurrentAccountByOwnerIdResponse = Nomalism.Payment.IFindCurrentAccountByOwnerIdResponse;
+
+export import ICreateForThisDocumentHeaderRequest = Nomalism.Payment.ICreateForThisDocumentHeaderRequest;
+
+export import ICreateRequest = Nomalism.Payment.ICreateRequest;
+
+export import IEntity = Nomalism.Payment.Entity;
+
+export import IExportPaymentsRequest = Nomalism.Payment.IExportPaymentsRequest;
+export import IPaymentsBatchResponse = Nomalism.Payment.IPaymentsBatchResponse;
+
+export import IUnpaidPurchasesRequest = Nomalism.Payment.IUnpaidPurchasesRequest;
+export import IUnpaidPurchasesResponse = Nomalism.Payment.IUnpaidPurchasesResponse;
+export import IUnpaidByDatePurchasesRequest = Nomalism.Payment.IUnpaidByDatePurchasesRequest;
+export import IFindProvidersWithClientIdResponse = Nomalism.Payment.IFindProvidersWithClientIdResponse;
+
+export import IProviderPaymentDocument = Nomalism.Payment.IProviderPaymentDocument;
+export import IProviderPaymentRequest = Nomalism.Payment.IProviderPaymentRequest;
+
+export import IPaymentsNotExportedRequest = Nomalism.Payment.IPaymentsNotExportedRequest;
+export import IPaymentsNotExportedResponse = Nomalism.Payment.IPaymentsNotExportedResponse;
+
+export import IExportCurrentAccountRequest = Nomalism.Payment.IExportCurrentAccountRequest;
+
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.Payment.IFindResponse>;
+
+export default class Repository implements Nomalism.Payment.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findPaginated(params: IFindPaginatedRequest): Promise<IPaginationResponse> {
+    const response = await this.api.get(`${this.route}paginated`, { params });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(selector: IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async deleteBatch(selector: IFindByIdRequest): Promise<void> {
+    const response = await this.api.delete(`${this.route}delete_batch${selector.id}`);
+    return response.data;
+  }
+
+  async findCurrentAccountByOwnerId(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<IFindCurrentAccountByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}current_account`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findBalanceByOwnerId(params: Nomalism.shared.IFindByOwnerIdRequest): Promise<number> {
+    const response = await this.api.get(`${this.route}balance`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findSettledMaterialEntrance(
+    params: IUnpaidPurchasesRequest,
+  ): Promise<IUnpaidPurchasesResponse[]> {
+    const response = await this.api.get(`${this.route}settled_material_entrance`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findSettledMaterialEntranceProviders(): Promise<IFindProvidersWithClientIdResponse[]> {
+    const response = await this.api.get(`${this.route}settled_material_entrance_providers`);
+    return response.data;
+  }
+
+  async createProvidersPayments(body: IProviderPaymentRequest[]): Promise<string[]> {
+    const response = await this.api.post(`${this.route}provider`, body);
+    return response.data;
+  }
+
+  async findPaymentsNotExported(
+    params: IPaymentsNotExportedRequest,
+  ): Promise<IPaymentsNotExportedResponse[]> {
+    const response = await this.api.get(`${this.route}not_exported`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findPaymentBatches(): Promise<IPaymentsBatchResponse[]> {
+    const response = await this.api.get(`${this.route}batches`);
+    return response.data;
+  }
+
+  async updateDownloadedBatchNumber(params: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.put(`${this.route}downloaded_batch_number/${params}`);
+  }
+
+  async exportCurrentAccount(
+    params: IExportCurrentAccountRequest,
+  ): Promise<IFindCurrentAccountByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.publicRoute}export_current_account`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findSettledMaterialEntranceByDate(
+    params: IUnpaidByDatePurchasesRequest,
+  ): Promise<IUnpaidPurchasesResponse[]> {
+    const response = await this.api.get(`${this.route}settled_material_entrance_by_date`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async exportPayments(body: IExportPaymentsRequest[]): Promise<void> {
+    await this.api.post(`${this.route}export_payments`, body);
+  }
+
+  getExportCurrentAccountUrl({
+    owner_id,
+    start_date,
+    end_date,
+    output,
+    token,
+  }: IExportCurrentAccountRequest): string {
+    const qs = new URLSearchParams();
+    qs.set('owner_id', owner_id);
+    qs.set('output', output);
+    if (start_date) qs.set('start_date', start_date.toISOString());
+    if (end_date) qs.set('end_date', end_date.toISOString());
+    qs.set('token', token);
+    return `${this.publicRoute}export_current_account?${qs.toString()}`;
+  }
+
+  async findCurrentAccountPaginated(
+    params: Nomalism.Payment.IFindCurrentAccountPaginatedRequest,
+  ): Promise<
+    Nomalism.shared.IPaginationResponse<Nomalism.Payment.IFindCurrentAccountByOwnerIdResponse>
+  > {
+    const response = await this.api.get(`${this.route}current_account_paginated`, {
+      params,
+    });
+    return response.data;
+  }
+}

package/src/modules/supply/preSale.ts

@@ -0,0 +1,86 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindResponse = Nomalism.PreSale.IFindResponse;
+export import IFindResponseWithCount = Nomalism.PreSale.IFindResponseWithCount;
+
+export import ICreateRequest = Nomalism.PreSale.ICreateRequest;
+
+export import IProductMinified = Nomalism.PreSale.IPreSaleProduct;
+export import IEntityExtended = Nomalism.PreSale.IEntityExtended;
+
+export import IUpdateRequest = Nomalism.PreSale.IUpdateRequest;
+export import IUpdatePreSaleQuantityRequest = Nomalism.PreSale.IUpdatePreSaleQuantityRequest;
+
+export import IRemovePreSaleProductRequest = Nomalism.PreSale.IRemovePreSaleProductRequest;
+
+export import IImportToClientProposalRequest = Nomalism.PreSale.IImportToClientProposalRequest;
+
+export import IPreSaleFindByUser = Nomalism.PreSale.IPreSaleFindByUser;
+
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.PreSale.IFindResponse>;
+
+export default class Repository implements Nomalism.PreSale.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(selector: Nomalism.PreSale.IPreSaleFindByUser): Promise<IFindResponseWithCount[]> {
+    const response = await this.api.get(`${this.route}by_user/${selector.created_by}`);
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntityExtended | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async findPending(): Promise<IEntityExtended[]> {
+    const response = await this.api.get(`${this.route}pending`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IFindResponse | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async updatePreSaleQuantity(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdatePreSaleQuantityRequest,
+  ): Promise<IFindResponse | null> {
+    const response = await this.api.put(`${this.route}${selector.id}/quantity`, body);
+    return response.data;
+  }
+
+  async removeProduct(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IRemovePreSaleProductRequest,
+  ): Promise<void> {
+    const response = await this.api.put(`${this.route}product/${selector.id}`, body);
+    return response.data;
+  }
+
+  async importToClientProposal(data: IImportToClientProposalRequest): Promise<void> {
+    const response = await this.api.post(`${this.route}client_proposal`, data);
+    return response.data;
+  }
+}

package/src/modules/supply/preSaleProduct.ts

@@ -0,0 +1,29 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindResponse = Nomalism.PreSaleProduct.Entity;
+
+export default class Repository implements Nomalism.PreSaleProduct.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(): Promise<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IFindResponse | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/supply/providerCurrentAccount.ts

@@ -0,0 +1,28 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.ProviderCurrentAccount.Entity;
+
+export import IFindRequest = Nomalism.ProviderCurrentAccount.IFindRequest;
+
+export default class Repository implements Nomalism.ProviderCurrentAccount.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findByOwnerId(params: IFindRequest): Promise<Nomalism.shared.IPaginationResponse<IEntity>> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    return response.data;
+  }
+}

package/src/modules/supply/startDocumentHeaderLastUpdate.ts

@@ -0,0 +1,24 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export type IEntity = Nomalism.StartDocumentHeaderLastUpdate.Entity;
+
+export default class Repository implements Nomalism.StartDocumentHeaderLastUpdate.IController {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/supply/vatValidation.ts

@@ -0,0 +1,28 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.VatValidation.Entity;
+
+export default class Repository implements Nomalism.VatValidation.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async findByLatest(nif: string): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}`, {
+      params: {
+        nif,
+      },
+    });
+    return response.data;
+  }
+}

package/src/modules/supply/workflow.ts

@@ -0,0 +1,61 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Workflow.Entity;
+
+export import IFindRequest = Nomalism.Workflow.IFindRequest;
+
+export import IFindByOwnerIdRequest = Nomalism.Workflow.IFindByOwnerIdRequest;
+export import IFindByOwnerIdResponse = Nomalism.Workflow.IFindByOwnerIdResponse;
+
+export import ICreateRequest = Nomalism.Workflow.ICreateRequest;
+
+export import IUpdateRequest = Nomalism.Workflow.IUpdateRequest;
+
+export import IFindByQueryRequest = Nomalism.Workflow.IFindByQueryRequest;
+export type IFindByQueryResponse = Nomalism.shared.IPaginationResponse<IEntity>;
+
+export default class Repository implements Nomalism.Workflow.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async find(params: IFindRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, { params });
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindByOwnerIdResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdNumberRequest,
+    body: IUpdateRequest,
+  ): Promise<IFindByOwnerIdResponse | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdNumberRequest,
+  ): Promise<IFindByOwnerIdResponse | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/tickets/channel.ts

@@ -0,0 +1,55 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Channel.Entity;
+
+export import IChannel = Nomalism.Channel.IChannel;
+
+export import ICreateRequest = Nomalism.Channel.ICreateRequest;
+export import IUpdateRequest = Nomalism.Channel.IUpdateRequest;
+export import IFindMinifiedRequest = Nomalism.Channel.IFindMinifiedRequest;
+
+export default class Repository implements Nomalism.Channel.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(id: Nomalism.shared.IFindByIdNumberRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${id}`);
+    return response.data;
+  }
+
+  async update(id: Nomalism.shared.IFindByIdNumberRequest, body: IUpdateRequest): Promise<void> {
+    await this.api.post(`${this.route}${id}`, body);
+  }
+
+  async deleteOne(id: Nomalism.shared.IFindByIdNumberRequest): Promise<void> {
+    await this.api.delete(`${this.route}${id}`);
+  }
+}

package/src/modules/tickets/clt.ts

@@ -0,0 +1,53 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.CLT.Entity;
+
+export import ICreateRequest = Nomalism.CLT.ICreateRequest;
+export import IUpdateRequest = Nomalism.CLT.IUpdateRequest;
+export import IFindMinifiedRequest = Nomalism.CLT.IFindMinifiedRequest;
+
+export default class Repository implements Nomalism.CLT.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(id: Nomalism.shared.IFindByIdNumberRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${id}`);
+    return response.data;
+  }
+
+  async update(id: Nomalism.shared.IFindByIdNumberRequest, body: IUpdateRequest): Promise<void> {
+    await this.api.post(`${this.route}${id}`, body);
+  }
+
+  async deleteOne(id: Nomalism.shared.IFindByIdNumberRequest): Promise<void> {
+    await this.api.delete(`${this.route}${id}`);
+  }
+}

package/src/modules/tickets/language.ts

@@ -0,0 +1,53 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.TicketsLanguage.Entity;
+
+export import ICreateRequest = Nomalism.TicketsLanguage.ICreateRequest;
+export import IUpdateRequest = Nomalism.TicketsLanguage.IUpdateRequest;
+export import IFindMinifiedRequest = Nomalism.TicketsLanguage.IFindMinifiedRequest;
+
+export default class Repository implements Nomalism.TicketsLanguage.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findById(id: Nomalism.shared.IFindByIdNumberRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${id}`);
+    return response.data;
+  }
+
+  async update(id: Nomalism.shared.IFindByIdNumberRequest, body: IUpdateRequest): Promise<void> {
+    await this.api.post(`${this.route}${id}`, body);
+  }
+
+  async deleteOne(id: Nomalism.shared.IFindByIdNumberRequest): Promise<void> {
+    await this.api.delete(`${this.route}${id}`);
+  }
+}

package/src/modules/tickets/tickets.ts

@@ -0,0 +1,49 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Tickets.Entity;
+
+export import ITicketCreateRequest = Nomalism.Tickets.ITicketCreateRequest;
+export import ITicketCreateResponse = Nomalism.Tickets.ITicketCreateResponse;
+
+export import ITicketUpdateRequest = Nomalism.Tickets.ITicketUpdateRequest;
+export import ITicketUpdateResponse = Nomalism.Tickets.ITicketUpdateResponse;
+
+export import ITicketUndoResponse = Nomalism.Tickets.ITicketUndoResponse;
+
+export import ITicketsFindTodayResponse = Nomalism.Tickets.ITicketsFindTodayResponse;
+
+export default class Repository implements Nomalism.Tickets.IRepository {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  async create(body: ITicketCreateRequest): Promise<ITicketCreateResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async findToday(): Promise<ITicketsFindTodayResponse> {
+    const response = await this.api.get(`${this.route}find_today`);
+    return response.data;
+  }
+
+  async update(body: ITicketUpdateRequest): Promise<ITicketUpdateResponse> {
+    const response = await this.api.put(`${this.route}`, body);
+    return response.data;
+  }
+
+  async undoLastCall(): Promise<ITicketUndoResponse> {
+    const response = await this.api.put(`${this.route}undo_last_call`);
+    return response.data;
+  }
+}