@nomalism-com/api 0.33.83 → 0.34.1

package/src/modules/document/upfrontReturn.ts

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

package/src/modules/documentManagement/multimedia.ts

@@ -0,0 +1,41 @@
+import { AxiosRequestHeaders, AxiosInstance } from 'axios';
+import Nomalism from '@nomalism-com/types';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Multimedia.Entity;
+
+export default class Repository implements Nomalism.Multimedia.IApi {
+  public route: string;
+
+  public publicRoute: string;
+
+  private api: AxiosInstance;
+
+  constructor({ api, route, publicRoute }: IModuleConstructor) {
+    this.api = api;
+    this.route = route;
+    this.publicRoute = publicRoute;
+  }
+
+  getUrl(multimediaId: string, download = false) {
+    const qs = new URLSearchParams();
+    if (download) qs.set('download', download.toString());
+    return `${this.publicRoute}${multimediaId}?${qs.toString()}`;
+  }
+
+  async create(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    multipartFormData: any,
+    headers?: AxiosRequestHeaders,
+  ): Promise<Nomalism.Multimedia.Entity> {
+    const response = await this.api.post(`${this.publicRoute}upload`, multipartFormData, {
+      headers: {
+        ...(headers || {}),
+        'content-type': 'multipart/form-data',
+      },
+      maxBodyLength: Infinity,
+      maxContentLength: Infinity,
+    });
+    return response.data;
+  }
+}

package/src/modules/integration/emailLog.ts

@@ -0,0 +1,47 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEmailAttachment = Nomalism.EmailLog.IEmailAttachment;
+export import IEmailAddress = Nomalism.EmailLog.IEmailAddress;
+export import IFindByIdResponse = Nomalism.EmailLog.IFindByIdResponse;
+
+export import IFindRequest = Nomalism.EmailLog.IFindRequest;
+export import IFindResponse = Nomalism.EmailLog.IFindResponse;
+export import ICheckSentResponse = Nomalism.EmailLog.ICheckSentResponse;
+
+export default class Repository implements Nomalism.EmailLog.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<IFindResponse[]> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async findById({ id }: Nomalism.shared.IFindByIdRequest): Promise<IFindByIdResponse> {
+    const response = await this.api.get(`${this.route}${id}`);
+    return response.data;
+  }
+
+  async findByDocumentHeaderId({
+    id,
+  }: Nomalism.shared.IFindByIdRequest): Promise<IFindByIdResponse[]> {
+    const response = await this.api.get(`${this.route}document_header/${id}`);
+    return response.data;
+  }
+
+  async checkSent(body: Nomalism.EmailLog.ICheckSent): Promise<ICheckSentResponse> {
+    const response = await this.api.post(`${this.route}check_sent`, body);
+    return response.data;
+  }
+}

package/src/modules/integration/emailTemplate.ts

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

package/src/modules/integration/emailTemplateAttachment.ts

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

package/src/modules/integration/emailVerification.ts

@@ -0,0 +1,34 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.EmailVerification.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 isVerified(params: Nomalism.EmailVerification.IIsVerifiedRequest): Promise<boolean> {
+    const response = await this.api.get(`${this.route}`, { params });
+    return response.data;
+  }
+
+  async sendVerificationEmail(
+    data: Nomalism.EmailVerification.ISendVerificationRequest,
+  ): Promise<void> {
+    const response = await this.api.post(`${this.route}`, data);
+    return response.data;
+  }
+
+  async markAsVerified(data: Nomalism.EmailVerification.IMarkAsVerifiedRequest): Promise<void> {
+    const response = await this.api.put(`${this.publicRoute}`, data);
+    return response.data;
+  }
+}

package/src/modules/integration/googleFilePermission.ts

@@ -0,0 +1,40 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.GoogleFilePermission.Entity;
+export import ICreateRequest = Nomalism.GoogleFilePermission.ICreateRequest;
+
+export default class Repository implements Nomalism.GoogleFilePermission.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 findById(selector: Nomalism.shared.IFindByIdRequest): Promise<IEntity | null> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    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/integration/googleSheets.ts

@@ -0,0 +1,56 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import ICloneRequest = Nomalism.GoogleSheets.ICloneRequest;
+export import ICloneResponse = Nomalism.GoogleSheets.ICloneResponse;
+export import IUpdateRequest = Nomalism.GoogleSheets.IUpdateRequest;
+export import IGetDataResponse = Nomalism.GoogleSheets.IGetDataResponse;
+
+export import IGetUserData = Nomalism.GoogleSheets.IGetUserData;
+
+export import IGetProduct = Nomalism.GoogleSheets.IGetProduct;
+
+export import IGetProductGroup = Nomalism.GoogleSheets.IGetProductGroup;
+
+export import IGetProductType = Nomalism.GoogleSheets.IGetProductType;
+export import IExportRequest = Nomalism.GoogleSheets.IExportRequest;
+
+export default class Repository implements Nomalism.GoogleSheets.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 clone(
+    selector: Nomalism.shared.IFindByIdRequest,
+    params?: ICloneRequest,
+  ): Promise<ICloneResponse> {
+    const response = await this.api.get(`${this.route}clone/${selector.id}`, {
+      params,
+    });
+
+    return response.data;
+  }
+
+  async export(params: IExportRequest): Promise<string> {
+    const response = await this.api.get(`${this.route}export`, { params });
+    return response.data;
+  }
+
+  async getData(selector: Nomalism.shared.IFindByIdRequest): Promise<IGetDataResponse> {
+    const response = await this.api.get(`${this.route}${selector.id}`);
+    return response.data;
+  }
+
+  async update(selector: Nomalism.shared.IFindByIdRequest, data: IUpdateRequest): Promise<void> {
+    await this.api.put(`${this.route}${selector.id}`, data);
+  }
+}

package/src/modules/integration/observation.ts

@@ -0,0 +1,57 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindByOwnerRequest = Nomalism.Observation.IFindByOwnerRequest;
+
+export import IFindByOwnersRequest = Nomalism.Observation.IFindByOwnersRequest;
+export import IFindByOwnerResponse = Nomalism.Observation.IFindByOwnerResponse;
+
+export import ICreateRequest = Nomalism.Observation.ICreateRequest;
+export import IEntity = Nomalism.Observation.Entity;
+
+export import IUpdateRequest = Nomalism.Observation.IUpdateRequest;
+
+export default class Repository implements Nomalism.Observation.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: IFindByOwnerRequest): Promise<IFindByOwnerResponse[]> {
+    const response = await this.api.get(`${this.route}`, {
+      params,
+    });
+    return response.data;
+  }
+
+  async findByOwnerIds(body: IFindByOwnersRequest): Promise<IFindByOwnerResponse[]> {
+    const response = await this.api.post(`${this.route}by_owners`, body);
+    return response.data;
+  }
+
+  async create(body: ICreateRequest): Promise<IFindByOwnerResponse> {
+    const response = await this.api.post(`${this.route}`, body);
+    return response.data;
+  }
+
+  async update(
+    selector: Nomalism.shared.IFindByIdRequest,
+    body: IUpdateRequest,
+  ): Promise<IFindByOwnerResponse | null> {
+    const response = await this.api.put(`${this.route}${selector.id}`, body);
+    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/integration/observationType.ts

@@ -0,0 +1,55 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IFindMinifiedRequest = Nomalism.shared.IFindMinifiedRequest;
+export import IFindMinifiedResponse = Nomalism.shared.IFindMinifiedResponse;
+
+export import ICreateRequest = Nomalism.ObservationType.ICreateRequest;
+export import IEntity = Nomalism.ObservationType.Entity;
+
+export import IUpdateRequest = Nomalism.ObservationType.IUpdateRequest;
+
+export default class Repository implements Nomalism.ObservationType.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(): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findMinified(params?: IFindMinifiedRequest): Promise<IFindMinifiedResponse[]> {
+    const response = await this.api.get(`${this.route}minified`, {
+      params,
+    });
+    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<IEntity | null> {
+    const response = await this.api.delete(`${this.route}${selector.id}`);
+    return response.data;
+  }
+}

package/src/modules/integration/projectInfo.ts

@@ -0,0 +1,23 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import ISendEmail = Nomalism.ProjectInfo.ISendEmail;
+
+export default class Repository implements Nomalism.ProjectInfo.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 sendEmail(body: ISendEmail): Promise<void> {
+    await this.api.post(`${this.route}sendEmail`, body);
+  }
+}

package/src/modules/integration/settings.ts

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

package/src/modules/print/npc.ts

@@ -0,0 +1,43 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Npc.Entity;
+export import IUpdateRequest = Nomalism.Npc.IUpdateRequest;
+export import IFindPrintJobsForComputerIdResponse = Nomalism.Npc.IFindPrintJobsForComputerIdResponse;
+export import IFindPrintJobsForComputerIdRequest = Nomalism.Npc.IFindPrintJobsForComputerIdRequest;
+export default class Repository implements Nomalism.Npc.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 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 findPrintJobsForComputerId(
+    selector: IFindPrintJobsForComputerIdRequest,
+  ): Promise<IFindPrintJobsForComputerIdResponse> {
+    const response = await this.api.get(
+      `${this.route}find_print_jobs_for_computer_id/${selector.computer_id}`,
+    );
+    return response.data;
+  }
+}

package/src/modules/print/printer.ts

@@ -0,0 +1,52 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export import IEntity = Nomalism.Printer.Entity;
+export import IUpdateRequest = Nomalism.Printer.IUpdateRequest;
+export import IUpdateManyRequest = Nomalism.Printer.IUpdateManyRequest;
+
+export type IFindDetailedResponse = Nomalism.Printer.IFindDetailedResponse;
+
+export default class Repository implements Nomalism.Printer.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<IFindDetailedResponse[]> {
+    const response = await this.api.get(`${this.route}`);
+    return response.data;
+  }
+
+  async findByOwnerId(params: Nomalism.shared.IFindByOwnerIdRequest): Promise<IEntity[]> {
+    const response = await this.api.get(`${this.route}by_owner`, { params });
+    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 updateMany(body: IUpdateManyRequest[]): Promise<void> {
+    await this.api.put(`${this.route}update_many`, body);
+  }
+
+  async getOrSetPrinters(
+    body: Nomalism.Printer.IGetOrSetPrintersRequest,
+  ): Promise<Nomalism.Printer.IGetOrSetPrintersResponse> {
+    const response = await this.api.post(`${this.route}get_or_set_printers`, body);
+    return response.data;
+  }
+}

package/src/modules/print/schedulePrintJob.ts

@@ -0,0 +1,45 @@
+import Nomalism from '@nomalism-com/types';
+import { AxiosInstance } from 'axios';
+import { IModuleConstructor } from '../../main';
+
+export default class Repository implements Nomalism.SchedulePrintJob.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.SchedulePrintJob.ICreateSchedulePrintJobRequest): Promise<void> {
+    await this.api.post(`${this.route}`, body);
+  }
+
+  async createMany(
+    body: Nomalism.SchedulePrintJob.ICreateManySchedulePrintJobRequest,
+  ): Promise<void> {
+    await this.api.post(`${this.route}many`, body);
+  }
+
+  async deleteOne(selector: Nomalism.shared.IFindByIdRequest): Promise<void> {
+    await this.api.delete(`${this.route}${selector.id}`);
+  }
+
+  async dispatchSchedulePrintJob(
+    body: Nomalism.SchedulePrintJob.IDispatchSchedulePrintJobRequest,
+  ): Promise<Nomalism.SchedulePrintJob.IDispatchSchedulePrintJobResponse> {
+    const response = await this.api.post(`${this.route}dispatch_schedule_print_job`, body);
+    return response.data;
+  }
+
+  async findByOwner(
+    params: Nomalism.shared.IFindByOwnerIdRequest,
+  ): Promise<Nomalism.SchedulePrintJob.Entity[]> {
+    const response = await this.api.get(`${this.route}by_owner`, { params });
+    return response.data;
+  }
+}