itrm-tools 1.3.2 → 1.3.5-beta.1

package/src/api/APIRequest.ts

@@ -0,0 +1,176 @@
+import { Express, Request, Response, Router } from 'express';
+import { ITRMAPIServiceGlobal } from './APIService';
+import { ServerSentEventsManager } from './channel/ServerSentEventsManager';
+import { DocDetails } from './APIRequestBuilder';
+
+export enum RequestMethod {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE"
+}
+
+export enum RequestContext {
+    BODY = 'body',
+    HEADERS = 'headers',
+    PARAMS = 'params',
+    QUERY = 'query'
+}
+
+export enum RequestParameterType {
+    STRING = 'string',
+    NUMBER = 'number',
+    BOOLEAN = 'boolean',
+    OBJECT = 'object'
+}
+
+export declare interface IProperties {
+    name: string,
+    type: RequestParameterType,
+}
+
+export declare interface IMissing {
+    missing: string[],
+    wrongType: string[]
+}
+
+export declare interface GroupedParameters {
+    context: RequestContext,
+    properties: IProperties[]
+}
+
+export declare interface APIRequestConfig {
+    path: string,
+    params: GroupedParameters[],
+    details?: DocDetails
+}
+
+export abstract class APIRequest {
+    public method: RequestMethod;
+    public path: string;
+    public details?: DocDetails;
+    protected params: GroupedParameters[];
+    protected bodyParams: GroupedParameters[];
+
+    constructor(method: RequestMethod, config: APIRequestConfig) {
+        this.method = method;
+        this.path = config.path;
+        this.params = config.params;
+        this.details = config.details;
+        this.bodyParams = config.params.filter(param => { return param.context === RequestContext.BODY; });
+    }
+
+    public abstract addToApp(app: Express): void;
+    public abstract addToRouter(router: Router): void;
+    public abstract apply(req: Request, res: Response): Promise<any>;
+
+    public getRequestDetails() {
+        return {
+            path: this.path,
+            method: this.method,
+            params: this.params,
+            details: this.details,
+            bodyParams: this.bodyParams
+        }
+    }
+
+    public async process(req: Request, res: Response): Promise<any> {
+        try {
+            let request: APIRequest = ITRMAPIServiceGlobal.requests[APIRequest.buildKey(req)];
+            let check: any = request.checkParameters(req);
+            for (let key of Object.keys(check))
+                if (check[key].status !== 'OK')
+                    return await res.status(400).json(check[key]);
+            return await request.apply(req, res);
+        } catch (error: any) {
+            console.log(">>> error:", error);
+            return await res.status(error?.response?.status ?? 500).json({
+                type: 'InternalRequestError',
+                error: 'An error has ocurred when procesing the request',
+                payload: error?.response?.data ?? error
+            });
+        }
+    }
+
+    public static buildKey(req: Request) {
+        if (req.route.path.includes(req.baseUrl))
+            return req.method + "_" + req.route.path;
+        return req.method + "_" + req.baseUrl + req.route.path;
+    }
+
+    private checkParameters(req: Request): any {
+        let result: any = this.checkItem(req, this.params);
+        if (this.hasValidValuesProperty(req.body))
+            result = this.checkValuesPropertyParameters(req);
+        return result;
+    }
+
+    private checkValuesPropertyParameters(req: Request): any {
+        let result: any = {};
+        for (let i = 0; i < req.body.values.length; i++) {
+            result = this.checkItem({ body: req.body.values[i] }, this.bodyParams);
+            if (result[RequestContext.BODY].status === 'Error') {
+                result[RequestContext.BODY].message += ', item ' + (i + 1);
+                return result;
+            }
+        }
+        return result;
+    }
+
+    private hasValidValuesProperty(context: any) {
+        return context && context.values && Array.isArray(context.values);
+    }
+
+    private checkItem(item: any, params: GroupedParameters[]) {
+        let result: any = {};
+        for (let group of params) {
+            if (item[group.context])
+                result[group.context] = this.buildResponseMessage(result[group.context], group, this.findMissingParameters(item[group.context], group.properties));
+            else
+                return { status: 'Error', message: group.context + " was not found, check your express configuration" };
+        }
+        return result;
+    }
+
+    private buildResponseMessage(response: any, group: GroupedParameters, failures: IMissing): any {
+        if (failures.missing.length > 0 || failures.wrongType.length > 0)
+            return (response && response.blocked) ? response : { status: 'Error', message: this.buildMissingParametersMessage(group.context, failures.missing, failures.wrongType), blocked: group.properties.length > failures.missing.length };
+        return { status: 'OK', blocked: true };
+    }
+
+    private buildMissingParametersMessage(context: RequestContext, missing: string[], wrongType: string[]) {
+        let message = "Parameters";
+        if (missing.length > 0) {
+            message += this.buildMessage(missing)
+            message += " were not found in " + context;
+        }
+        if (wrongType.length > 0) {
+            message += missing.length > 0 ? " and" : "";
+            message += this.buildMessage(wrongType)
+            message += " have invalid type ";
+        }
+        return message;
+    }
+
+    private buildMessage(array: string[]) {
+        let message = "";
+        for (let i = 0; i < array.length; i++)
+            message += (i > 0 ? ", " : " ") + "'" + array[i] + "'";
+        return message;
+    }
+
+    private findMissingParameters(context: any, properties: IProperties[]) {
+        let missing: string[] = [];
+        let wrongType: string[] = [];
+        for (let property of properties)
+            if (context[property.name] === undefined || context[property.name] === null)
+                missing.push(property.name);
+            else if (typeof context[property.name] !== property.type)
+                wrongType.push(property.name);
+        return { missing, wrongType };
+    }
+
+    protected openSentServerEvents(res: Response) {
+        return new ServerSentEventsManager(res);
+    }
+}

package/src/api/APIRequestBuilder.ts

@@ -0,0 +1,28 @@
+import { GroupedParameters } from "./APIRequest"
+
+export declare interface ISamples {
+    status: number,
+    input: any,
+    output: any
+}
+
+export declare interface DocDetails {
+    description: string,
+    samples: ISamples[]
+}
+
+export abstract class APIRequestBuilder {
+
+    constructor() { }
+
+    public abstract buildParams(): GroupedParameters[];
+    public abstract buildDocDetails(): DocDetails;
+
+    public buildApiRequestConfig(path: string) {
+        return {
+            path: path,
+            params: this.buildParams(),
+            details: this.buildDocDetails()
+        }
+    }
+}

package/src/api/APIRouter.ts

@@ -0,0 +1,26 @@
+import { NextFunction, Router, RouterOptions,Request, Response } from 'express';
+import { APIRequest } from './APIRequest';
+import { ITRMAPIServiceGlobal } from './APIService';
+
+export abstract class APIRouter {
+    public path: string;
+    public router: Router;
+    public linkedRequest: string[] = [];
+
+    constructor(path: string, options?: RouterOptions) {
+        this.path = path;
+        this.router = Router(options);
+    }
+
+    public init() {
+        this.router.use(this.runMiddleware);
+    }
+
+    public addRequest(request: APIRequest) {
+        ITRMAPIServiceGlobal.requests[request.method + "_" + this.path + request.path] = request;
+        request.addToRouter(this.router);
+        this.linkedRequest.push(request.method + "_" + this.path + request.path);
+    }
+
+    protected abstract runMiddleware(req: Request, res: Response, next: NextFunction): Promise<void | Response | any>;
+}

package/src/api/APIService.ts

@@ -0,0 +1,117 @@
+import express, { Express, Request, Response } from 'express';
+import { APIRequest } from './APIRequest';
+import { APIRouter } from './APIRouter';
+import { ExpressConfiguration } from './ExpressConfiguration';
+import { DocumentationRequest } from './request/docs/DocumentationRequest';
+
+export namespace ITRMAPIServiceGlobal {
+    export var memory: any = {};
+    export var service: APIService | undefined = undefined;
+    export var requests: any = {};
+    export var routers: any = {};
+    export var whitelist: string[] = [];
+    export var tools: any = {};
+}
+
+export declare interface APIServiceConfig {
+    name: string,
+    port: string | number,
+    express: ExpressConfiguration
+}
+
+export declare interface APIServiceResponse {
+    status: string,
+    message: string,
+    error?: any
+}
+
+export class APIService {
+    protected server: any = undefined;
+    protected app: Express = express();
+    protected name: string;
+    protected port: number | string;
+    protected config: ExpressConfiguration;
+
+    constructor(config: APIServiceConfig) {
+        this.name = config.name;
+        this.port = config.port;
+        this.config = config.express;
+    }
+
+    public init() {
+        ITRMAPIServiceGlobal.service = this;
+        this.config.apply(this.app);
+        this.app.get('/', (req: Request, res: Response | any) => {
+            return res.send('Server working!');
+        });
+    }
+
+    public addRouter(router: APIRouter) {
+        ITRMAPIServiceGlobal.routers[router.path] = router;
+        this.app.use(router.path, router.router);
+    }
+
+    public addRequest(request: APIRequest) {
+        ITRMAPIServiceGlobal.requests[request.method + "_" + request.path] = request;
+        request.addToApp(this.app);
+    }
+
+    public getServerInformation() {
+        return {
+            name: this.name,
+            port: this.port,
+            routers: ITRMAPIServiceGlobal.routers,
+            requests: ITRMAPIServiceGlobal.requests
+        }
+    }
+
+    public enableDocumentation() {
+        const swaggerUi = require('swagger-ui-express');
+        const documentationRequest = new DocumentationRequest();
+        this.app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(documentationRequest.init()));
+    }
+
+    public run(init: Function): Promise<APIServiceResponse> {
+        return new Promise<APIServiceResponse>((resolve, reject) => {
+            this.server = this.app.listen(this.port, async () => {
+                console.log(`⚡️[server]: Server is running at http://localhost:${this.port}`);
+                try {
+                    await init();
+                    resolve({ status: 'Ok', message: 'Server has been Initialized' });
+                } catch (err: any) {
+                    reject({
+                        status: 'Error',
+                        message: 'An error has ocurred in the initialization function',
+                        error: err
+                    });
+                }
+            });
+        });
+    }
+
+    public close(finish: Function): Promise<APIServiceResponse> {
+        return new Promise<APIServiceResponse>((resolve, reject) => {
+            this.server.close(async (err: any) => {
+                if (err)
+                    reject({
+                        status: 'Error',
+                        message: 'An error has ocurred when closing Server',
+                        error: err
+                    });
+                try {
+                    await finish();
+                    resolve({
+                        status: 'Ok',
+                        message: 'Server has been closed'
+                    });
+                } catch (err: any) {
+                    reject({
+                        status: 'Error',
+                        message: 'An error has ocurred in the closing function',
+                        error: err
+                    });
+                }
+            });
+        });
+    }
+}

package/src/api/ExpressConfiguration.ts

@@ -0,0 +1,5 @@
+import { Express } from 'express';
+
+export interface ExpressConfiguration {
+    apply(app: Express): void;
+}

package/src/api/HttpsAPIService.ts

@@ -0,0 +1,35 @@
+import https, { ServerOptions } from 'https';
+import { APIService, APIServiceConfig, APIServiceResponse } from "./APIService";
+
+export class HttpsAPIService extends APIService {
+    private httpsServer: any = undefined;
+    private options: ServerOptions;
+
+    constructor(config: APIServiceConfig, options: ServerOptions) {
+        super(config);
+        this.options = options;
+    }
+
+    public init() {
+        super.init();
+        this.httpsServer = https.createServer(this.options, this.app);
+    }
+
+    public run(init: Function): Promise<APIServiceResponse> {
+        return new Promise<APIServiceResponse>((resolve, reject) => {
+            this.server = this.httpsServer.listen(this.port, async () => {
+                console.log(`⚡️[server]: Server is running at https://localhost:${this.port}`);
+                try {
+                    await init();
+                    resolve({ status: 'Ok', message: 'Server has been Initialized' });
+                } catch (err: any) {
+                    reject({
+                        status: 'Error',
+                        message: 'An error has ocurred in the initialization function',
+                        error: err
+                    });
+                }
+            });
+        });
+    }
+}

package/src/api/alegra/AlegraConnectionManager.ts

@@ -0,0 +1,54 @@
+import { AxiosRequestConfig } from "axios";
+import { RequestAxiosCall } from "../request/RequestAxiosCall";
+import { IAlegraContact, IAlegraJournal, IAlegraPayment, IAlegraResult } from "./AlegraTypes";
+
+export class AlegraConnectionManager {
+    private alegraUrl: string;
+    private headers: AxiosRequestConfig;
+
+    constructor(alegraUrl: string, token: string) {
+        this.alegraUrl = alegraUrl;
+        this.headers = { headers: { Authorization: `Basic ${token}` } };
+    }
+
+    public async createContact(contact: IAlegraContact) {
+        return (await RequestAxiosCall.post(`${this.alegraUrl}/v1/contacts`, contact, this.headers)) as IAlegraContact;
+    }
+
+    public async findContact(document: string): Promise<IAlegraContact | undefined> {
+        let response: any = await RequestAxiosCall.get(`${this.alegraUrl}/v1/contacts?order_direction=ASC&identification=${document}`, this.headers);
+        return response.length > 0 ? response[0] : undefined;
+    }
+    
+    public async createJournal(body: IAlegraJournal) {
+        return (await RequestAxiosCall.post(`${this.alegraUrl}/v1/journals`, body, this.headers)) as IAlegraJournal;
+    }
+
+    public async findJournal(journalId: string | number) {
+        return (await RequestAxiosCall.get(`${this.alegraUrl}/v1/journals/${journalId}`, this.headers) as IAlegraJournal);
+    }
+
+    public async updateJournal(journalId: string | number, body: IAlegraJournal) {
+        return await RequestAxiosCall.put(`${this.alegraUrl}/v1/journals/${journalId}`, body, this.headers);
+    }
+
+    public async deleteJournal(journalId: string | number) {
+        return (await RequestAxiosCall.delete(`${this.alegraUrl}/v1/journals/${journalId}`, this.headers)) as IAlegraResult;
+    }
+
+    public async createPayment(body: IAlegraPayment) {
+        return (await RequestAxiosCall.post(`${this.alegraUrl}/v1/payments`, body, this.headers)) as IAlegraPayment;
+    }
+    
+    public async findPayment(paymentId: string | number) {
+        return (await RequestAxiosCall.get(`${this.alegraUrl}/v1/payments/${paymentId}`, this.headers) as IAlegraPayment);
+    }
+    
+    public async updatePayment(paymentId: string | number, body: IAlegraPayment) {
+        return await RequestAxiosCall.put(`${this.alegraUrl}/v1/payments/${paymentId}`, body, this.headers);
+    }
+
+    public async deletePayment(paymentId: string | number) {
+        return (await RequestAxiosCall.delete(`${this.alegraUrl}/v1/payments/${paymentId}`, this.headers)) as IAlegraResult;
+    }
+}

package/src/api/alegra/AlegraTypes.ts

@@ -0,0 +1,150 @@
+export interface IAlegraContact {
+    id?: string | number;
+    name?: string;
+    identification?: string;
+    email?: string;
+    phonePrimary?: string;
+    phoneSecondary?: string;
+    fax?: string;
+    mobile?: string;
+    observations?: string;
+    status?: 'active' | 'inactive';
+    kindOfPerson?: 'PERSON_ENTITY' | 'LEGAL_ENTITY ' | 'OTHER_ENTITY ';
+    regime?: 'COMMON_REGIME' | 'SIMPLIFIED_REGIME' | 'NATIONAL_CONSUMPTION_TAX' | 'NOT_REPONSIBLE_FOR_CONSUMPTION' | 'INC_IVA_RESPONSIBLE' | 'SPECIAL_REGIME';
+    nameObject?: {
+        firstName: string;
+        secondName: string;
+        lastName: string;
+        secondLastName?: string;
+    };
+    identificationObject?: {
+        type: 'CC' | 'TI' | 'NIT' | 'DIE' | 'PP' | 'CE' | 'TE' | 'RC' | 'FOREIGN_NIT' | 'NUIP';
+        number: string;
+        dv?: string;
+    };
+    fiscalResidence?: 'RESIDENT' | 'NON_RESIDENT';
+    enableHealthSector?: boolean;
+    healthPatients?: any;
+    address?: {
+        address: string;
+        city: string;
+        department?: string;
+        country?: 'Colombia';
+        zipCode?: string;
+    };
+    type?: string[];
+    seller?: any;
+    term?: {
+        id: number;
+        name: string;
+        days: string;
+    };
+    priceList?: {
+        id: number;
+        name: string;
+    };
+    internalContacts?: string[];
+    settings?: { sendElectronicDocuments: boolean; };
+    statementAttached?: boolean;
+    accounting?: {
+        accountReceivable: {
+          id: string;
+          idParent: string;
+          name: string;
+          text: string;
+          code: string;
+          description: string;
+          type: string;
+          readOnly: boolean;
+          nature: string;
+          blocked: string;
+          status: string;
+          categoryRule: any;
+          use: string;
+          showThirdPartyBalance: boolean
+        };
+        debtToPay: {
+          id: string;
+          idParent: string;
+          name: string;
+          text: string;
+          code: string;
+          description: string;
+          type: string;
+          readOnly: boolean;
+          nature: string;
+          blocked: string;
+          status: string;
+          categoryRule?: any;
+          use: string;
+          showThirdPartyBalance: boolean
+        }
+    }
+}
+
+export interface IAlegraPayment {
+    id?: string | number;
+    date: string;
+    bankAccount: {
+        id: string | number;
+    };
+    client: IAlegraContact,
+    paymentMethod: 'transfer' | 'cash' | 'deposit' | 'check' | 'credit-card' | 'debit-card';
+    observations: string;
+    anotation: string;
+    type: 'in' | 'out';
+    categories: IAlegraCategory[];
+    costCenter?: any;
+    numberTemplate?: {
+        id: string;
+        prefix: any,
+        number: string;
+        fullNumber: string;
+        formattedNumber:string;
+    }
+}
+
+export interface IAlegraCategory {
+    id: string | number;
+    name?: string;
+    price: number;
+    quantity: number;
+    observations: string;
+    total?: number;
+    behavior?: string;
+    tax?: any[]
+}
+
+export interface IAlegraJournal {
+    id?: string | number;
+    date: string;
+    observations: string;
+    entries: IAlegraEntry[];
+    client?: IAlegraContact;
+    reference?: string;
+    status?: string;
+    total?: number;
+}
+
+export interface IAlegraEntry {
+    id: string | number;
+    client: IAlegraContact;
+    description: string;
+    debit: number;
+    credit: number;
+    name?: string;
+    type?: string;
+    line?: string;
+    lineParent?: any;
+    costCenter?: any;
+    associatedDocument?: {
+        idResource: any;
+        resourceType: any;
+        resource: any;
+    }
+}
+
+export interface IAlegraResult {
+    code: number;
+    message: string;
+}

package/src/api/builder/StandardGetRequestBuilder.ts

@@ -0,0 +1,34 @@
+import { GroupedParameters, RequestContext, RequestParameterType } from "../APIRequest";
+import { APIRequestBuilder } from "../APIRequestBuilder";
+
+export abstract class StandardGetRequestBuilder extends APIRequestBuilder {
+  protected buildDefaultParams(): GroupedParameters[] {
+    return [
+      {
+        context: RequestContext.QUERY,
+        properties: [{ name: "id", type: RequestParameterType.STRING }],
+      },
+      {
+        context: RequestContext.QUERY,
+        properties: [{ name: "limit", type: RequestParameterType.STRING }],
+      },
+      {
+        context: RequestContext.QUERY,
+        properties: [{ name: "count", type: RequestParameterType.STRING }],
+      },
+      {
+        context: RequestContext.QUERY,
+        properties: [
+          { name: "limit", type: RequestParameterType.STRING },
+          { name: "offset", type: RequestParameterType.STRING },
+        ],
+      },
+    ];
+  }
+
+  public abstract buildSpecificParams(): GroupedParameters[];
+
+  public buildParams(): GroupedParameters[] {
+    return this.buildDefaultParams().concat(this.buildSpecificParams());
+  }
+}

package/src/api/channel/ServerSentEventsManager.ts

@@ -0,0 +1,28 @@
+import { Response } from 'express';
+
+export class ServerSentEventsManager {
+    private res: Response;
+
+    constructor(res: Response, config?: any) {
+        config = config ?? {
+            'Cache-control': 'no-cahe',
+            'Content-Type': 'text/event-stream',
+            'Connection': 'keep-alive'
+        };
+        res.set(config);
+        res.flushHeaders();
+        this.res = res;
+    }
+
+    public write(status: number, payload: string) {
+        this.res.status(status).write(payload);
+    }
+
+    public writeObject(status: number, payload: any) {
+        this.res.status(status).write(JSON.stringify(payload));
+    }
+
+    public end(status: number, payload: string) {
+        this.res.status(200).end(payload);
+    }
+}