@nomalism-com/api 0.33.83 → 0.34.2

package/src/modules/stock/promotionAssoc.ts

@@ -0,0 +1,75 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindRequest = Nomalism.PromotionAssoc.IFindRequest;
+export import IFindResponse = Nomalism.PromotionAssoc.IFindResponse;
+
+export import IFindPaginatedRequest = Nomalism.PromotionAssoc.IFindPaginatedRequest;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+export import IFindByOwnerIdResponse = Nomalism.PromotionAssoc.IFindByOwnerIdResponse;
+
+export import ICreateRequest = Nomalism.PromotionAssoc.ICreateRequest;
+
+export import IEntity = Nomalism.PromotionAssoc.Entity;
+
+export import IUpdateRequest = Nomalism.PromotionAssoc.IUpdateRequest;
+export type IPaginationResponse =
+  Nomalism.shared.IPaginationResponse<Nomalism.PromotionAssoc.IFindResponse>;
+
+export default class Repository implements Nomalism.PromotionAssoc.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<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, {
+      params,
+    });
+    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;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindByOwnerIdResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IFindByOwnerIdResponse | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<IFindByOwnerIdResponse | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/stock/queryList.ts

@@ -0,0 +1,83 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindResponse = Nomalism.QueryList.IFindResponse;
+export import ICreateRequest = Nomalism.QueryList.ICreateRequest;
+
+export import IEntity = Nomalism.QueryList.Entity;
+
+export import IUpdateRequest = Nomalism.QueryList.IUpdateRequest;
+
+export import IExecuteRequest = Nomalism.QueryList.IExecuteRequest;
+
+export import IExecuteResponse = Nomalism.QueryList.IExecuteResponse;
+
+export import IExecuteOutput = Nomalism.QueryList.IExecuteOutput;
+
+export const { executeOutput } = Nomalism.QueryList;
+
+export default class Repository implements Nomalism.QueryList.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;
+  }
+
+  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 deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async execute(params: IExecuteRequest): Promise<IExecuteResponse> {
+    const response = await this.api.get(`${this.route}execute`, { params });
+    return response.data;
+  }
+
+  getQueryExecuteUrl({ query_id, output, token, ...data }: IExecuteRequest) {
+    const qs = new URLSearchParams();
+
+    qs.set('query_id', query_id);
+    qs.set('output', output);
+    if (token) {
+      qs.set('token', token);
+    }
+
+    Object.entries(data).forEach(([key, value]) => {
+      if (typeof value === 'undefined') return;
+      if (value === null) return;
+      qs.set(key, value.toString());
+    });
+
+    return `${this.route}execute?${qs.toString()}`;
+  }
+}

package/src/modules/stock/queryParameter.ts

@@ -0,0 +1,63 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import ICreateRequest = Nomalism.QueryParameter.ICreateRequest;
+
+export import IEntity = Nomalism.QueryParameter.Entity;
+
+export import IUpdateRequest = Nomalism.QueryParameter.IUpdateRequest;
+
+export import QueryParameterDatatypeEnum = Nomalism.QueryParameter.QueryParameterDatatypeEnum;
+
+export import IQueryParameterDatatype = Nomalism.QueryParameter.IQueryParameterDatatype;
+export import IFindByOwnerIdResponse = Nomalism.QueryParameter.IFindByOwnerIdResponse;
+
+export default class Repository implements Nomalism.QueryParameter.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<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IEntity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async findByOwnerId(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, { params });
+    return response.data;
+  }
+}

package/src/modules/stock/recurrentTasks.ts

@@ -0,0 +1,25 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.RecurrentTasks.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 from_master(): Promise<string> {
+    return this.api.post(`${this.route}from_master`);
+  }
+
+  async from_master_checked(): Promise<string> {
+    return this.api.post(`${this.route}from_master`);
+  }
+}

package/src/modules/stock/returnReason.ts

@@ -0,0 +1,46 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.ReturnReason.Entity;
+
+export import ICreateRequest = Nomalism.ReturnReason.ICreateRequest;
+
+export import IUpdateRequest = Nomalism.ReturnReason.IUpdateRequest;
+
+export default class Repository implements Nomalism.ReturnReason.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 update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IEntity | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async find(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/stock/savedEmPicking.ts

@@ -0,0 +1,35 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.SavedEmPicking.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: Nomalism.SavedEmPicking.ICreateRequest): Promise<string> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async createMany(body: Nomalism.SavedEmPicking.ICreateManyRequest): Promise<string[]> {
+    const response = await this.api.post(`${this.route}many`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.delete(`${this.route}${selector.id}`);
+  }
+
+  async deleteMany(body: Nomalism.SavedEmPicking.IDeleteManyRequest): Promise<void> {
+    await this.api.post(`${this.route}delete_many`, body);
+  }
+}

package/src/modules/stock/savedProviderProposal.ts

@@ -0,0 +1,44 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.SavedProviderProposal.Entity;
+
+export import ICreateRequest = Nomalism.SavedProviderProposal.ICreateRequest;
+export import IUpdateRequest = Nomalism.SavedProviderProposal.IUpdateRequest;
+
+export default class Repository implements Nomalism.SavedProviderProposal.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 findByProviderId(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.SavedProviderProposal.IFindManyResponse[]> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<void> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(selector: Nomalism.shared.IFindByIdRequest, body: IUpdateRequest): Promise<void> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    return response.data;
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/stock/schedule.ts

@@ -0,0 +1,27 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IScheduleType = Nomalism.Schedule.IScheduleType;
+
+export import IRunImmediatelyRequest = Nomalism.Schedule.IRunImmediatelyRequest;
+
+export const { ScheduleTypeEnum, scheduleTypes, ScheduleTypeLabel } = Nomalism.Schedule;
+
+export default class Repository implements Nomalism.Schedule.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 runImmediately(selector: IRunImmediatelyRequest): Promise<void> {
+    await this.api.post(`${this.route}${selector.scheduleType}`);
+  }
+}

package/src/modules/stock/sideMenu.ts

@@ -0,0 +1,49 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindByDocumentLineStateRequest = Nomalism.SideMenu.IFindByDocumentLineStateRequest;
+export import IFindByDocumentLineStateResponse = Nomalism.SideMenu.IFindByDocumentLineStateResponse;
+export import IFindByStateRequest = Nomalism.SideMenu.IFindByStateRequest;
+export import IFindByStateResponse = Nomalism.SideMenu.IFindByStateResponse;
+export import IFindSideMenuCountersResponse = Nomalism.SideMenu.IFindSideMenuCountersResponse;
+
+export default class Repository implements Nomalism.SideMenu.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 findSideMenuStoreOperators(): Promise<string[]> {
+    const response = await this.api.get(`${this.route}side_menu_store_operators`);
+    return response.data;
+  }
+
+  async findByDocumentLineState(
+    params: IFindByDocumentLineStateRequest,
+  ): Promise<IFindByDocumentLineStateResponse[]> {
+    const response = await this.api.get(`${this.route}by_document_line_state`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByState(params: IFindByStateRequest): Promise<IFindByStateResponse[]> {
+    const response = await this.api.get(`${this.route}find_by_state`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findSideMenuCounters(): Promise<IFindSideMenuCountersResponse> {
+    const response = await this.api.get(`${this.route}counters`);
+    return response.data;
+  }
+}

package/src/modules/stock/stockMovement.ts

@@ -0,0 +1,63 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindByIdNumberRequest = Nomalism.shared.IFindByIdNumberRequest;
+export import IFindByProviderResponse = Nomalism.StockMovement.IFindByProviderResponse;
+
+export import IFindByOwnerIdRequest = Nomalism.shared.IFindByOwnerIdRequest;
+export import IFindByOwnerIdResponse = Nomalism.StockMovement.IFindByOwnerIdResponse;
+
+export import ExportFormatEnum = Nomalism.StockMovement.ExportFormatEnum;
+export import IExportFormat = Nomalism.StockMovement.IExportFormat;
+export import exportFormats = Nomalism.StockMovement.exportFormats;
+export import ExportVersionEnum = Nomalism.StockMovement.ExportVersionEnum;
+export import IExportVersion = Nomalism.StockMovement.IExportVersion;
+export import exportVersions = Nomalism.StockMovement.exportVersions;
+export import IExportRequest = Nomalism.StockMovement.IExportRequest;
+export import IExportCsvResponse = Nomalism.StockMovement.IExportCsvResponse;
+
+export default class Repository implements Nomalism.StockMovement.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 findByProvider({ id }: IFindByIdNumberRequest): Promise<IFindByProviderResponse[]> {
+    const response = await this.api.get(`${this.route}${id}`);
+    return response.data;
+  }
+
+  async findByOwnerId(params: IFindByOwnerIdRequest): Promise<IFindByOwnerIdResponse[]> {
+    const response = await this.api.get(`${this.route}by_owner`, { params });
+    return response.data;
+  }
+
+  async exportCsv(params: IExportRequest): Promise<IExportCsvResponse[]> {
+    const response = await this.api.get(`${this.route}csv`, { params });
+    return response.data;
+  }
+
+  getStockCsvUrl({ date, version, format, token }: IExportRequest): string {
+    const qs = new URLSearchParams();
+    qs.set('date', date.toISOString());
+    qs.set('version', version);
+    qs.set('format', format);
+    qs.set('token', token);
+    return `${this.publicRoute}csv?${qs.toString()}`;
+  }
+
+  async findStockMovementPaginated(
+    params: Nomalism.StockMovement.IFindStockMovementPaginatedRequest,
+  ): Promise<Nomalism.shared.IPaginationResponse<IFindByOwnerIdResponse>> {
+    const response = await this.api.get(`${this.route}stock_movement_paginated`, { params });
+    return response.data;
+  }
+}

package/src/modules/stock/task.ts

@@ -0,0 +1,50 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.Task.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.Task.IFindTasksRequest): Promise<Nomalism.Task.IFindResponse[]> {
+    return this.api.get(`${this.route}${selector}`);
+  }
+
+  async findWithMessages(
+    selector: Nomalism.shared.IFindByIdRequest,
+  ): Promise<Nomalism.Task.IFindWithMessagesResponse> {
+    return this.api.get(`${this.route}with_messages`, {
+      params: selector,
+    });
+  }
+
+  async create(body: Nomalism.Task.ICreateRequest): Promise<Nomalism.Task.Entity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: Nomalism.Task.IUpdateRequest,
+  ): Promise<void> {
+    await this.api.put(`${this.route}${selector.id}`, body);
+  }
+
+  async delete(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.delete(`${this.route}${selector.id}`);
+  }
+  async findByOwnerId(
+    selector: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<Nomalism.Task.IFindByOwnerResponse[]> {
+    const response = await this.api.delete(`${this.route}by_owner/${selector.owner_id}`);
+    return response.data;
+  }
+}

package/src/modules/stock/taskMessage.ts

@@ -0,0 +1,33 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.TaskMessage.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: Nomalism.TaskMessage.ICreateRequest): Promise<Nomalism.TaskMessage.Entity> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: Nomalism.TaskMessage.IUpdateRequest,
+  ): Promise<void> {
+    await this.api.put(`${this.route}${selector.id}`, body);
+  }
+
+  async delete(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.delete(`${this.route}${selector.id}`);
+  }
+}

package/src/modules/stock/taskRead.ts

@@ -0,0 +1,25 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.TaskRead.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: Nomalism.TaskRead.ICreateRequest): Promise<void> {
+    await this.api.post(`${this.route}`, body);
+  }
+
+  async delete(params: Nomalism.TaskRead.IDeleteRequest): Promise<void> {
+    await this.api.delete(`${this.route}`, { data: params });
+  }
+}