itrm-tools 1.3.2 → 1.3.5-viio.1

package/src/web3/Coin.ts

@@ -0,0 +1,18 @@
+export enum Coin {
+    APE = "APE",
+    ARTX = "ARTX",
+    ATRI = "ATRI",
+    BTC = "BTC",
+    CUBE = "CUBE",
+    DAI = "DAI",
+    ETH = "ETH",
+    MANA = "MANA",
+    MATIC = "MATIC",
+    RARI = "RARI",
+    SAND = "SAND",
+    SCOTT = "SCOTT",
+    USDC = "USDC",
+    USDT = "USDT",
+    WBTC = "WBTC",
+    WETH = "WETH"
+}

package/src/web3/coingecko/CoingeckoPriceFinder.ts

@@ -0,0 +1,75 @@
+import axios from 'axios';
+import { Coin } from '../Coin';
+
+export class CoingeckoPriceFinder {
+    private prices: any = {};
+    private pair: string;
+
+    constructor(pair?: string) {
+        this.pair = pair ?? "eth";
+    }
+
+    public async getPrice(symbol: Coin, date?: Date) {
+        date = date ?? new Date();
+        let id = this.parseSymbolId(symbol);
+        let key = (10000 * date.getFullYear()) + (100 * (date.getMonth() + 1)) + date.getDate();
+        return await this.findPrice(id, "" + this.adjustDate(symbol, key));
+    }
+
+    private adjustDate(symbol: Coin, date: number) {
+        switch (symbol) {
+            case Coin.APE:   return Math.max(date, 20220317);
+            case Coin.ARTX:  return Math.max(date, 20210404);
+            case Coin.ATRI:  return Math.max(date, 20201102);
+            case Coin.BTC:   return Math.max(date, 20130428);
+            case Coin.CUBE:  return Math.max(date, 20200221);
+            case Coin.DAI:   return Math.max(date, 20191119);
+            case Coin.MANA:  return Math.max(date, 20171028);
+            case Coin.MATIC:  return Math.max(date, 20190427);
+            case Coin.RARI:  return Math.max(date, 20200717);
+            case Coin.SAND:  return Math.max(date, 20200814);
+            case Coin.SCOTT: return Math.max(date, 20211220);
+            case Coin.USDC:  return Math.max(date, 20181005);
+            case Coin.WBTC:  return Math.max(date, 20130428);
+            default: return Math.max(date, 20150807);
+        }
+    }
+
+    private async findPrice(symbol: string, date: string) {
+        let key = symbol + "_" + date;
+        if (!this.prices[key])
+            return new Promise((resolve, reject) => {
+                let url = "https://api.coingecko.com/api/v3/coins/" + symbol + "/history?date="
+		            + date.substring(6) + "-" + date.substring(4, 6) + "-" + date.substring(0, 4);
+                console.log("> url:", url);
+                axios.get(url, { headers: {
+                    'Content-Type': 'application/json'
+                }}).then(response => {
+                    if (response.data.market_data && response.data.market_data.current_price)
+                        this.prices[key] = response.data.market_data.current_price[this.pair];
+                    resolve(this.prices[key]);
+                }).catch(err => { resolve(this.prices[key]); });
+            });
+        return this.prices[key];
+    }
+
+    public parseSymbolId(symbol: Coin) {
+        switch (symbol) {
+            case Coin.APE:   return "apecoin";
+            case Coin.ARTX:  return "artx";
+            case Coin.ATRI:  return "atari";
+            case Coin.BTC:   return "bitcoin";
+            case Coin.CUBE:  return "somnium-space-cubes";
+            case Coin.DAI:   return "dai";
+            case Coin.MANA:  return "decentraland";
+            case Coin.MATIC:  return "matic-network";
+            case Coin.RARI:  return "rarible";
+            case Coin.SAND:  return "the-sandbox";
+            case Coin.SCOTT: return "scotty-beam";
+            case Coin.USDC:  return "usd-coin";
+            case Coin.USDT:  return "tether";
+            case Coin.WBTC:  return "bitcoin";
+            default: return "ethereum";
+        }
+    }
+}

package/test/api/APIRouter.test.ts

@@ -0,0 +1,78 @@
+import { NextFunction, Request, Response, RouterOptions } from "express";
+import { APIService, SimpleAPIRouter, GetRequest, APIRouter, RequestAxiosCall } from "../../dist";
+import { config } from "./APITestDefinitions";
+
+class TestRequest extends GetRequest {
+    constructor() {
+        super({
+            path: "/test",
+            params: []
+        });
+    }
+
+    public async apply(req: Request, res: Response): Promise<any> {
+        return res.status(200).json({ message: 'Success' });
+    }
+}
+
+class TestRouter extends APIRouter {
+    constructor(path: string, options?: RouterOptions) {
+        super(path, options);
+    }
+
+    protected async runMiddleware(req: Request, res: Response, next: NextFunction): Promise<void | Response> {
+        let { cancel } = req.query;
+        if (cancel)
+            return res.status(400).json({ message: "Cancelled" });
+        return next();
+    }
+}
+
+const service = new APIService(config);
+service.init();
+
+const request = new TestRequest();
+const router1 = new SimpleAPIRouter("/route1");
+router1.init();
+router1.addRequest(request);
+service.addRouter(router1);
+
+const router2 = new TestRouter("/route2");
+router2.init();
+router2.addRequest(request);
+service.addRouter(router2);
+
+describe('testing Router', () => {
+    beforeAll(async () => {
+        await service.run(() => {});
+    });
+    afterAll(async () => {
+        await service.close(() => {})
+    });
+    test("> test route1 request", async() => {
+        expect.assertions(1);
+        await service.addRequest(new TestRequest());
+        return RequestAxiosCall.get(`http://localhost:${config.port}/route1/test`)
+        .then(async (response: any) => {
+            expect(response.message).toMatch("Success");
+        });
+    });
+    test("> test route2 request", async() => {
+        expect.assertions(1);
+        await service.addRequest(new TestRequest());
+        return RequestAxiosCall.get(`http://localhost:${config.port}/route2/test`)
+        .then(async (response: any) => {
+            expect(response.message).toMatch("Success");
+        });
+    });
+    test("> test route2 middleware cancel request", async() => {
+        expect.assertions(3);
+        await service.addRequest(new TestRequest());
+        return RequestAxiosCall.get(`http://localhost:${config.port}/route2/test?cancel=true`)
+        .catch(async err => {
+            expect(err.code).toMatch("ERR_BAD_REQUEST");
+            expect(err.response.status).toBe(400);
+            expect(err.response.data.message).toMatch("Cancelled");
+        });
+    });
+});

package/test/api/APIService.test.ts

@@ -0,0 +1,50 @@
+import { APIService, APIServiceResponse, RequestAxiosCall } from '../../dist';
+import { config } from './APITestDefinitions';
+
+const service = new APIService(config);
+service.init();
+
+describe('testing APIService', () => {
+    test('running OK', async () => {
+        expect.assertions(3);
+        return service.run(() => {}).then((response: APIServiceResponse) => {
+            expect(response.status).toStrictEqual("Ok");
+            expect(response.message).toStrictEqual("Server has been Initialized");
+            expect(response.error).toBeUndefined();
+        });
+    });
+    test('Server working!', async() => {
+        expect.assertions(1);
+        return RequestAxiosCall.get("http://localhost:" + config.port).then(response => {
+            expect(response).toMatch("Server working!");
+        });
+    });
+    test('closing OK', async () => {
+        expect.assertions(3);
+        return service.close(() => {}).then((response: APIServiceResponse) => {
+            expect(response.status).toStrictEqual("Ok");
+            expect(response.message).toStrictEqual("Server has been closed");
+            expect(response.error).toBeUndefined();
+        });
+    });
+    test('running Fail', () => {
+        expect.assertions(3);
+        return service.run(() => { throw "testing failure"; })
+        .catch(async (response: APIServiceResponse) => {
+            expect(response.status).toStrictEqual("Error");
+            expect(response.message).toStrictEqual("An error has ocurred in the initialization function");
+            expect(response.error).toBe("testing failure");
+            await service.close(() => {});
+        });
+    });
+    test('closing Fail', async () => {
+        expect.assertions(3);
+        await service.run(() => {});
+        return service.close(() => { throw "testing failure"; })
+        .catch(async (response: APIServiceResponse) => {
+            expect(response.status).toMatch("Error");
+            expect(response.message).toMatch("An error has ocurred in the closing function");
+            expect(response.error).toMatch("testing failure");
+        });
+    });
+});

package/test/api/APITestDefinitions.ts

@@ -0,0 +1,7 @@
+import { APIServiceConfig, ExpressStandardConfiguration } from "../../dist";
+
+export const config: APIServiceConfig = {
+    name: 'test',
+    port: 8150,
+    express: new ExpressStandardConfiguration()
+};

package/test/api/CORS.test.ts

@@ -0,0 +1,56 @@
+import { APIService, ITRMAPIServiceGlobal, RequestAxiosCall } from "../../dist";
+import { config } from "./APITestDefinitions";
+
+const service = new APIService(config);
+service.init();
+
+describe("Testing CORS", () => {
+    beforeAll(async () => {
+        await service.run(() => {});
+    });
+    afterAll(async () => {
+        await service.close(() => {})
+    });
+    test('Checking invalid route has not been blocked', async() => {
+        expect.assertions(1);
+        return RequestAxiosCall.get("http://localhost:" + config.port, {
+            headers: { 'Content-Type': 'application/json', 'Origin': 'https://invalid.com' }
+        })
+        .then(response => {
+            expect(response).toMatch("Server working!");
+        });
+    });
+    /*test('Checking invalid route was blocked', async() => {
+        ITRMAPIServiceGlobal.whitelist = ["https://valid.com"];
+        try {
+            await RequestAxiosCall.get("http://localhost:" + config.port, {
+                headers: { 'Content-Type': 'application/json', 'Origin': 'https://invalid.com' }
+            })
+        } catch(err: any) {
+            console.log("> err.code:", err.code);
+            expect(err.code).toMatch("ECONNREFUSED");
+            //expect(err.response.status).toBe(500);
+            //expect(err.response.statusText).toMatch("Internal Server Error");
+            //expect(err.response.data).toMatch("Not allowed by CORS");
+        }
+    });*/
+    test('Checking valid route was not blocked', async() => {
+        expect.assertions(1);
+        return RequestAxiosCall.get("http://localhost:" + config.port, {
+            headers: { 'Content-Type': 'application/json', 'Origin': 'https://valid.com' }
+        })
+        .then(response => {
+            expect(response).toMatch("Server working!");
+        });
+    });
+    test('Checking invalid route was released', async() => {
+        expect.assertions(1);
+        ITRMAPIServiceGlobal.whitelist = [];
+        return RequestAxiosCall.get("http://localhost:" + config.port, {
+            headers: { 'Content-Type': 'application/json', 'Origin': 'https://invalid.com' }
+        })
+        .then(response => {
+            expect(response).toMatch("Server working!");
+        });
+    });
+});

package/test/api/alegra/AlegraConnectionManager.test.ts

@@ -0,0 +1,32 @@
+import { AlegraConnectionManager } from "../../../dist";
+
+const ALEGRA_URL = "https://api.alegra.com/api";
+const TOKEN = "aXRybWFjaGluZXMuY29udGFiaWxpZGFkQGdtYWlsLmNvbTphZDYwNWEwMzI4ZDk2NjcyYmVhNw==";
+
+const connection = new AlegraConnectionManager(ALEGRA_URL, TOKEN);
+
+describe('testing Checkable Router', () => {
+    beforeAll(async () => { });
+    afterAll(async () => { });
+    test("> test not found contact", async() => {
+        let contact = await connection.findContact('103244436ABC');
+        expect(contact).toBeUndefined();
+    });
+    test("> test find contact", async() => {
+        let contact = await connection.findContact('1032444365');
+        expect(contact).toBeDefined();
+        if (contact) {
+            expect(contact.name).toMatch("CAMILO ALEJANDRO ALAGUNA");
+            expect(contact.identification).toMatch("1032444365");
+        }
+    });
+    test("> test find payment", async() => {
+        let payment = await connection.findPayment(3248);
+        expect(payment).toBeDefined();
+    });
+    test("> test find journal", async() => {
+        let journal: any = await connection.findJournal(3248);
+        console.log("> journal:", journal);
+        console.log("> entries:", journal.entries);
+    });
+});

package/test/api/check/CheckDefinitions.ts

@@ -0,0 +1,47 @@
+import { Request } from 'express';
+import { APICheck, APICheckResult, APICheckConfig } from '../../../dist';
+
+export interface TestCheckerConfig extends APICheckConfig {
+    key: string
+}
+
+export class TestCheck implements APICheck {
+    
+    public getConfig(): TestCheckerConfig {
+        return {
+            check: 'test',
+            key: 'valid'
+        };
+    }
+
+    public async apply(config: TestCheckerConfig, req: Request): Promise<APICheckResult> {
+        const { key } = req.query;
+        if (config.key === key)
+            return { approved: true, payload: { message: 'Accepted' } };
+        if (key === 'unknown')
+            return { approved: false };
+        return {
+            approved: false,
+            rejection: {
+                code: 401,
+                payload: { message: 'key does not match' }
+            }
+        };
+    }
+}
+
+export class UnexpectedErrorTestCheck implements APICheck {
+    
+    public getConfig(): APICheckConfig {
+        return {
+            check: 'unexpectedError'
+        };
+    }
+
+    public async apply(config: TestCheckerConfig, req: Request): Promise<APICheckResult> {
+        throw 'Unexpected error';
+    }
+}
+
+export const check = new TestCheck();
+export const unexpectedErrorCheck = new UnexpectedErrorTestCheck();

package/test/api/check/CheckableAPIRouter.test.ts

@@ -0,0 +1,67 @@
+import { Request, Response } from "express";
+import { APIService, SimpleCheckableAPIRouter, GetRequest, RequestAxiosCall } from "../../../dist";
+import { config } from "../APITestDefinitions";
+import { check, unexpectedErrorCheck } from './CheckDefinitions';
+
+class TestRequest extends GetRequest {
+    constructor() {
+        super({
+            path: "/test",
+            params: []
+        });
+    }
+
+    public async apply(req: Request, res: Response): Promise<any> {
+        console.log("> checkResults:", req.body.checkResults);
+        return res.status(200).json({ message: 'Success', checkResults: req.body.checkResults });
+    }
+}
+
+const service = new APIService(config);
+service.init();
+
+const request = new TestRequest();
+const router = new SimpleCheckableAPIRouter("/route");
+router.init();
+router.addCheck(check);
+router.addRequest(request);
+service.addRouter(router);
+
+describe('testing Checkable Router', () => {
+    beforeAll(async () => {
+        await service.run(() => {});
+    });
+    afterAll(async () => {
+        await service.close(() => {})
+    });
+    test("> test valid route request", async() => {
+        expect.assertions(3);
+        await service.addRequest(new TestRequest());
+        return RequestAxiosCall.get(`http://localhost:${config.port}/route/test?key=valid`)
+        .then(async (response: any) => {
+            expect(response.message).toMatch("Success");
+            expect(response.checkResults).toBeDefined();
+            expect(response.checkResults[check.getConfig().check]).toMatchObject({ message: 'Accepted' });
+        });
+    });
+    test('> test invalid route request', async () => {
+        expect.assertions(4);
+        return RequestAxiosCall.get(`http://localhost:${config.port}/route/test?key=invalid`)
+        .catch(err => {
+            expect(err.code).toMatch("ERR_BAD_REQUEST");
+            expect(err.response.status).toBe(401);
+            expect(err.response.statusText).toMatch("Unauthorized");
+            expect(err.response.data.message).toMatch("key does not match");
+        });
+    });
+    test('Checking invalid route request with no unauthorization reason', async () => {
+        expect.assertions(4);
+        return RequestAxiosCall.get(`http://localhost:${config.port}/route/test?key=unknown`)
+        .catch(err => {
+            expect(err.code).toMatch("ERR_BAD_REQUEST");
+            expect(err.response.status).toBe(401);
+            expect(err.response.statusText).toMatch("Unauthorized");
+            expect(err.response.data.message).toMatch("Unknown reason");
+        });
+    });
+});

package/test/api/check/CheckableDeleteRequest.test.ts

@@ -0,0 +1,92 @@
+import { Request, Response } from "express";
+import { APIService, CheckableDeleteRequest, RequestContext, RequestAxiosCall, RequestParameterType } from "../../../dist";
+import { config } from "../APITestDefinitions";
+import { check, unexpectedErrorCheck } from "./CheckDefinitions";
+
+const service = new APIService(config);
+service.init();
+
+export class TestRequest extends CheckableDeleteRequest {
+    constructor() {
+        super({
+            path: "/check",
+            params: [{
+                context: RequestContext.QUERY,
+                properties: [{ name: "key", type: RequestParameterType.STRING }]
+            }]
+        });
+    }
+
+    public async apply(req: Request, res: Response): Promise<any> {
+        return res.status(200).json({ message: 'Success' });
+    }
+}
+
+export class InvalidCheckConfigurationTestRequest extends CheckableDeleteRequest {
+    constructor() {
+        super({
+            path: "/invalid-check",
+            params: [{
+                context: RequestContext.QUERY,
+                properties: [{ name: "key", type: RequestParameterType.STRING }]
+            }]
+        });
+    }
+
+    public async apply(req: Request, res: Response): Promise<any> {
+        return res.status(200).json({ message: 'Success' });
+    }
+}
+
+const validKeyUrl = `http://localhost:${config.port}/check?key=valid`;
+const invalidKeyUrl = `http://localhost:${config.port}/check?key=invalid`;
+const invalidUnknownKeyUrl = `http://localhost:${config.port}/check?key=unknown`;
+
+describe('testing Checkable DELETE Request', () => {
+    let request = new TestRequest();
+    beforeAll(async () => {
+        await service.run(() => { });
+    });
+    afterAll(async () => {
+        await service.close(() => { })
+    });
+    test('Refuse request when API Request does not exist', async () => {
+        expect.assertions(3);
+        return RequestAxiosCall.delete(validKeyUrl)
+            .catch(err => {
+                expect(err.code).toMatch("ERR_BAD_REQUEST");
+                expect(err.response.status).toBe(404);
+                expect(err.response.statusText).toMatch("Not Found");
+            });
+    });
+    test('Checking valid', async () => {
+        try {
+        request.addCheck(check);
+        await service.addRequest(request);
+        let response: any = await RequestAxiosCall.delete(validKeyUrl);
+        expect(response.message).toMatch("Success");
+    } catch (err) {
+        console.log("> err:", err);
+    }
+    });
+    test('Checking invalid', async () => {
+        expect.assertions(4);
+        return RequestAxiosCall.delete(invalidKeyUrl)
+            .catch(err => {
+                expect(err.code).toMatch("ERR_BAD_REQUEST");
+                expect(err.response.status).toBe(401);
+                expect(err.response.statusText).toMatch("Unauthorized");
+                expect(err.response.data.message).toMatch("key does not match");
+            });
+    });
+    test('Checking invalid with no unauthorization reason', async () => {
+        expect.assertions(4);
+        return RequestAxiosCall.delete(invalidUnknownKeyUrl)
+            .catch(err => {
+                expect(err.code).toMatch("ERR_BAD_REQUEST");
+                expect(err.response.status).toBe(401);
+                expect(err.response.statusText).toMatch("Unauthorized");
+                expect(err.response.data.message).toMatch("Unknown reason");
+            });
+    });
+});

package/test/api/check/CheckableGetRequest.test.ts

@@ -0,0 +1,99 @@
+import { Request, Response } from "express";
+import { APIService, CheckableGetRequest, RequestContext, RequestAxiosCall, RequestParameterType } from "../../../dist";
+import { config } from "../APITestDefinitions";
+import { check, unexpectedErrorCheck } from "./CheckDefinitions";
+
+const service = new APIService(config);
+service.init();
+
+export class TestRequest extends CheckableGetRequest {
+    constructor() {
+        super({
+            path: "/check",
+            params: [{
+                context: RequestContext.QUERY,
+                properties: [{ name: "key", type: RequestParameterType.STRING }]
+            }]
+        });
+    }
+
+    public getCheckConfiguration() {
+        return {
+            key: 'valid'
+        };
+    }
+
+    public async apply(req: Request, res: Response): Promise<any> {
+        return res.status(200).json({ message: 'Success' });
+    }
+}
+
+export class InvalidCheckConfigurationTestRequest extends CheckableGetRequest {
+    constructor() {
+        super({
+            path: "/invalid-check",
+            params: [{
+                context: RequestContext.QUERY,
+                properties: [{ name: "key", type: RequestParameterType.STRING }]
+            }]
+        });
+    }
+
+    public getCheckConfiguration() { // invalid configuration
+        return {
+            password: 'valid'
+        };
+    }
+
+    public async apply(req: Request, res: Response): Promise<any> {
+        return res.status(200).json({ message: 'Success' });
+    }
+}
+
+const validKeyUrl = `http://localhost:${config.port}/check?key=valid`;
+const invalidKeyUrl = `http://localhost:${config.port}/check?key=invalid`;
+const invalidUnknownKeyUrl = `http://localhost:${config.port}/check?key=unknown`;
+
+describe('testing Checkable GET Request', () => {
+    let request = new TestRequest();
+    beforeAll(async () => {
+        await service.run(() => { });
+    });
+    afterAll(async () => {
+        await service.close(() => { })
+    });
+    test('Refuse request when API Request does not exist', async () => {
+        expect.assertions(3);
+        return RequestAxiosCall.get(validKeyUrl).catch(err => {
+            expect(err.code).toMatch("ERR_BAD_REQUEST");
+            expect(err.response.status).toBe(404);
+            expect(err.response.statusText).toMatch("Not Found");
+        });
+    });
+    test('Checking valid', async () => {
+        expect.assertions(1);
+        request.addCheck(check);
+        await service.addRequest(request);
+        return RequestAxiosCall.get(validKeyUrl).then(async (response: any) => {
+            expect(response.message).toMatch("Success");
+        });
+    });
+    test('Checking invalid', async () => {
+        expect.assertions(4);
+        return RequestAxiosCall.get(invalidKeyUrl).catch(err => {
+            expect(err.code).toMatch("ERR_BAD_REQUEST");
+            expect(err.response.status).toBe(401);
+            expect(err.response.statusText).toMatch("Unauthorized");
+            expect(err.response.data.message).toMatch("key does not match");
+        });
+    });
+    test('Checking invalid with no unauthorization reason', async () => {
+        expect.assertions(4);
+        return RequestAxiosCall.get(invalidUnknownKeyUrl).catch(err => {
+            expect(err.code).toMatch("ERR_BAD_REQUEST");
+            expect(err.response.status).toBe(401);
+            expect(err.response.statusText).toMatch("Unauthorized");
+            expect(err.response.data.message).toMatch("Unknown reason");
+        });
+    });
+});