@nathapp/na-cli 1.0.8 → 1.0.10

package/dist/templates/k8s-deployment/services/charts/tests/charts/e2e-test-js/tests/individual-contract.ts

@@ -0,0 +1,328 @@
+'use strict';
+
+import { describe, it } from 'mocha';
+import chai, { expect } from 'chai';
+import chaihttp from 'chai-http';
+
+import HubService, { User, goodRet, mxwServiceUrl, serviceUrl, challengeIt, badRet } from "./hub";
+import { toUtf8Bytes, sortObject, hexlify } from 'mxw-libs-utils';
+import { utils, Wallet, auth } from 'mxw-sdk-js';
+import { JsonRpcProvider } from 'mxw-sdk-js/dist/providers';
+import moment from "moment";
+import { throwError, errors } from 'mxw-libs-errors';
+
+chai.use(chaihttp);
+
+let indent = "     ";
+let silent = false;
+
+export function createContract(user: User, wallet: Wallet, others: User[], challenge: boolean) {
+    describe('Suite: Contract: ' + user.code, function () {
+        let contract: {
+            objId?: number,
+            parentId?: number,
+            category: string,
+            name: string,
+            refNo: string,
+            validFrom: string,
+            validTo: string,
+            reminder: string
+        } = {
+            parentId: 0,
+            category: "1",
+            name: "CTR" + hexlify(utils.randomBytes(4)).substr(2),
+            refNo: "BOT/" + hexlify(utils.randomBytes(2)).substr(2) + "/" +
+                hexlify(utils.randomBytes(2)).substr(2) + "/" +
+                hexlify(utils.randomBytes(2)).substr(2) + "/" +
+                hexlify(utils.randomBytes(2)).substr(2),
+            validFrom: moment().utc().format("YYYY-MM-DD HH:mm:ss"),
+            validTo: moment().utc().add(3, "days").format("YYYY-MM-DD HH:mm:ss"),
+            reminder: moment().utc().add(2, "days").format("YYYY-MM-DD HH:mm:ss")
+        }
+
+        // challenge = true; // TODO
+
+        it("Query contract template", function () {
+            return chai.request(serviceUrl("/contract/api")).get("/getContract")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .query({
+                    listType: 4
+                })
+                .then((res) => {
+                    console.log(res.body)
+                    goodRet(res);
+                });
+        });
+
+        challengeIt("Create contract", function (params) {
+            return chai.request(serviceUrl("/contract/api")).post("/initContract")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send(params)
+                .then((res) => {
+                    badRet(res);
+                });
+        }, {
+            orgId: null,
+            category: null,
+            name: null,
+            parentId: null
+        }, challenge);
+
+        if (challenge) {
+            it("Create contract - challenge without JWT", function () {
+                return chai.request(serviceUrl("/contract/api")).post("/initContract")
+                    .type("application/json")
+                    .send({
+                        orgId: 0,
+                        category: contract.category,
+                        name: contract.name,
+                        parentId: contract.parentId
+                    })
+                    .then((res) => {
+                        badRet(res, "Unauthorised");
+                    });
+            });
+        }
+
+        it("Create contract", function () {
+            return chai.request(serviceUrl("/contract/api")).post("/initContract")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send({
+                    orgId: 0,
+                    category: contract.category,
+                    name: contract.name,
+                    parentId: contract.parentId
+                })
+                .then((res) => {
+                    console.log(res.body)
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("objId").is.a("number").greaterThan(0);
+
+                    contract.objId = res.body.data.objId;
+                    if (!HubService.Instance.silent || !silent) { console.log(indent, "Created contract", contract.objId + ":", contract.name) }
+                });
+        });
+
+        if (challenge) {
+            it("Update contract - challenge without JWT", function () {
+                return chai.request(serviceUrl("/contract/api")).post("/setContract")
+                    .type("application/json")
+                    .send({
+                        objId: contract.objId,
+                        orgId: 0,
+                        category: contract.category,
+                        name: contract.name,
+                        parentId: contract.parentId,
+                        refNo: contract.refNo,
+                        header: null,
+                        title: null,
+                        content: null,
+                        footer: null,
+                        validFrom: contract.validFrom,
+                        validTo: contract.validTo,
+                        mint: "1",
+                        amendable: "1000000",
+                        view: "0",
+                        notes: "Believe me I am very honest " + user.username,
+                        renewal: 1,
+                        reminder: contract.reminder,
+                        submitFlag: "1"
+                    })
+                    .then((res) => {
+                        badRet(res, "Unauthorised");
+                    });
+            });
+
+            it("Update contract - challenge contract not belong to me", function () {
+                return chai.request(serviceUrl("/contract/api")).post("/setContract")
+                    .type("application/json")
+                    .set("Authorization", "Bearer " + user.jwt)
+                    .send({
+                        objId: 0,
+                        orgId: 0,
+                        category: contract.category,
+                        name: contract.name,
+                        parentId: contract.parentId,
+                        refNo: contract.refNo,
+                        header: null,
+                        title: null,
+                        content: null,
+                        footer: null,
+                        validFrom: contract.validFrom,
+                        validTo: contract.validTo,
+                        mint: "1",
+                        amendable: "1000000",
+                        view: "0",
+                        notes: "Believe me I am very honest " + user.username,
+                        renewal: 1,
+                        reminder: contract.reminder,
+                        submitFlag: "1"
+                    })
+                    .then((res) => {
+                        badRet(res, "1002");
+
+                        if ("1002" == res.body.ret) {
+                            console.log("\x1b[33m%s", indent, "WARNING: This error handler is required to patch.", "\x1b[0m");
+                        }
+                        else {
+                            console.log("\x1b[33m%s", indent, "WARNING: Special error handler is required to remove.", "\x1b[0m");
+                        }
+                    });
+            });
+        }
+
+        it("Update draft contract", function () {
+            return chai.request(serviceUrl("/contract/api")).post("/setContract")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send({
+                    objId: contract.objId,
+                    orgId: 0,
+                    category: contract.category,
+                    name: contract.name,
+                    parentId: contract.parentId,
+                    refNo: contract.refNo,
+                    header: null,
+                    title: null,
+                    content: null,
+                    footer: null,
+                    validFrom: contract.validFrom,
+                    validTo: contract.validTo,
+                    mint: "1",
+                    amendable: "1000000",
+                    view: "0",
+                    notes: "Hello, I am testBot " + user.username,
+                    renewal: 1,
+                    reminder: contract.reminder,
+                    tags: [],
+                    submitFlag: "0"
+                })
+                .then((res) => {
+                    goodRet(res);
+                });
+        });
+
+        it("Verify draft contract info", function () {
+            return chai.request(serviceUrl("/contract/api")).get("/getContract")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .query({
+                    objId: contract.objId,
+                })
+                .then((res) => {
+                    console.log(res.body)
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("objId").is.a("number").eq(contract.objId);
+                    expect(res.body).have.property("data").property("name").is.a("string").eq(contract.name);
+                    expect(res.body).have.property("data").property("refNo").is.a("string").eq(contract.refNo);
+                    expect(res.body).have.property("data").property("validFrom").is.a("string").lengthOf.greaterThan(0);
+                    expect(res.body).have.property("data").property("validTo").is.a("string").lengthOf.greaterThan(0);
+                    expect(res.body).have.property("data").property("reminder").is.a("string").satisfy(function (value) {
+                        let dt = moment.utc(value).format("YYYY-MM-DD HH:mm:ss");
+                        if (dt == contract.reminder) {
+                            return true;
+                        }
+                        throwError(errors.MISMATCHED, "Mismatched reminder date " + dt, { expected: contract.reminder, value: dt });
+                    });
+                });
+        });
+
+        it("Set contract user role", function () {
+            let parties = [];
+
+            for (let party of others) {
+                parties.push({
+                    access: 255,
+                    flag: 1,
+                    orgId: 0,
+                    role: 12, // 12: signer
+                    email: party.email
+                });
+            }
+
+            parties.push({
+                access: 255,
+                flag: 1,
+                orgId: 0,
+                role: 12, // 12: signer
+                email: user.email
+            });
+
+            return chai.request(serviceUrl("/contract/api")).post("/setUserRole")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send({
+                    objId: contract.objId,
+                    orgId: 0,
+                    order: 1, // 1 = sequence or 2 = parallel
+                    signerData: parties
+                })
+                .then((res) => {
+                    console.log(res.body)
+                    goodRet(res);
+
+                    if (!HubService.Instance.silent || !silent) { console.log(indent, "Contract user role", contract.objId + ":", JSON.stringify(parties)) }
+                });
+        });
+
+        it("Verify contract user role", function () {
+            return chai.request(serviceUrl("/contract/api")).get("/getContract")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .query({
+                    objId: contract.objId,
+                })
+                .then((res) => {
+                    console.log(res.body)
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("objId").is.a("number").eq(contract.objId);
+                    expect(res.body).have.property("data").property("name").is.a("string").eq(contract.name);
+                    expect(res.body).have.property("data").property("refNo").is.a("string").eq(contract.refNo);
+                    expect(res.body).have.property("data").property("validFrom").is.a("string").lengthOf.greaterThan(0);
+                    expect(res.body).have.property("data").property("validTo").is.a("string").lengthOf.greaterThan(0);
+                    expect(res.body).have.property("data").property("reminder").is.a("string").satisfy(function (value) {
+                        let dt = moment.utc(value).format("YYYY-MM-DD HH:mm:ss");
+                        if (dt == contract.reminder) {
+                            return true;
+                        }
+                        throwError(errors.MISMATCHED, "Mismatched reminder date " + dt, { expected: contract.reminder, value: dt });
+                    });
+                });
+        });
+
+        it("Submit contract", function () {
+            return chai.request(serviceUrl("/contract/api")).post("/setContract")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.jwt)
+                .send({
+                    objId: contract.objId,
+                    orgId: 0,
+                    category: contract.category,
+                    name: contract.name,
+                    parentId: contract.parentId,
+                    refNo: contract.refNo,
+                    header: null,
+                    title: null,
+                    content: null,
+                    footer: null,
+                    validFrom: contract.validFrom,
+                    validTo: contract.validTo,
+                    mint: "1",
+                    amendable: "1000000",
+                    view: "0",
+                    notes: "Hello, I am testBot " + user.username,
+                    renewal: 1,
+                    reminder: contract.reminder,
+                    tags: [],
+                    submitFlag: "1"
+                })
+                .then((res) => {
+                    console.log(res.body)
+                    goodRet(res);
+                });
+        });
+    });
+}

package/dist/templates/k8s-deployment/services/charts/tests/charts/e2e-test-js/tests/individual-kyc.ts

@@ -0,0 +1,304 @@
+'use strict';
+
+import { describe, it } from 'mocha';
+import chai, { expect } from 'chai';
+import chaihttp from 'chai-http';
+import request from "request";
+
+import HubService, { User, challengeIt, goodRet, badRet, getActivationToken, goodRes, mxwServiceUrl, uploadOSS, mxwV1ServiceUrl } from "./hub";
+import { hexlify, isUndefinedOrNullOrEmpty } from 'mxw-libs-utils';
+import { utils } from 'mxw-sdk-js';
+
+chai.use(chaihttp);
+
+let indent = "     ";
+
+export enum KYC_PROVIDER_ID {
+    MANUAL = 0,
+    E_KYC = 1
+};
+
+export enum KYC_FLOW_ID {
+    MANUAL = "Manual",
+    AUTO = "Auto"
+};
+
+export enum KYC_STATUS {
+    PENDING = 0,
+    APPROVED = 1,
+    SUSPENDED = 2,
+    TERMINATED = 3,
+    REJECTED = 4,
+    BLACKLISTED = 7,
+    EXPIRED = 9,
+    SUBMITTED = 10,
+    VERIFIED = 11,
+    PENDING_PAYMENT = 13,
+    IN_REVIEW = 18,
+    ALERT = 19,
+    REVOKED = 21,
+    REVOKE_APPROVED = 23,
+    RELEASED = 31,
+    RELEASE_VERIFIED = 32,
+    RELEASE_APPROVED = 33,
+    ERROR = 99
+};
+
+export enum KYC_TYPE_ID {
+    NATIONAL_ID = 1,
+    MILITARY_OFFICER_CARD = 2,
+    PASSPORT = 3,
+    RESIDENT_PASS = 4,
+    DRIVING_LICENCE = 9,
+    COMPANY_REGISTRATION = 11,
+    OTHERS = 99
+};
+
+let kycType: {
+    [id: string]: {
+        typeId: KYC_TYPE_ID,
+        typeName: string
+    }
+} = {
+    "1": { typeId: KYC_TYPE_ID.NATIONAL_ID, typeName: "National ID" },
+    "2": { typeId: KYC_TYPE_ID.MILITARY_OFFICER_CARD, typeName: "Military Officer Card" },
+    "3": { typeId: KYC_TYPE_ID.PASSPORT, typeName: "Passport" },
+    "4": { typeId: KYC_TYPE_ID.RESIDENT_PASS, typeName: "Resident Pass" },
+    "9": { typeId: KYC_TYPE_ID.DRIVING_LICENCE, typeName: "Driving Licence" },
+    "11": { typeId: KYC_TYPE_ID.COMPANY_REGISTRATION, typeName: "Company Registration" },
+    "99": { typeId: KYC_TYPE_ID.OTHERS, typeName: "Others" }
+}
+
+export function kycByType(user: User, idType: KYC_TYPE_ID, flow: KYC_FLOW_ID, challenge: boolean) {
+    describe('Suite: Individual ' + flow + " KYC: " + user.code + " (" + user.email + ")", function () {
+        let kycProviderUrl: string;
+        let kycProviderId: number;
+        let idImgFrontUrl: string;
+        let imgLiveUrl: string;
+        let alertFlag: number;
+
+        it("Get KYC provider id", function () {
+            let url = mxwServiceUrl("/provider/kyc/v2");
+
+            return chai.request(url).get("/getProviderId")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .query({
+                    country: user.profile.country,
+                    identityType: idType
+                })
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("providerId").is.a("number").to.be.oneOf([
+                        KYC_PROVIDER_ID.MANUAL,
+                        KYC_PROVIDER_ID.E_KYC
+                    ]);
+                    kycProviderId = res.body.data.providerId as number;
+
+                    expect(res.body).have.property("data").property("config").property("url").is.a("string").lengthOf.greaterThan(0);
+                    kycProviderUrl = res.body.data.config.url;
+
+                    if (KYC_PROVIDER_ID.E_KYC == kycProviderId) {
+                        expect(res.body).have.property("data").property("idAuto").is.a("number").is.gte(0).and.is.lte(1);
+                        expect(res.body).have.property("data").property("idReject").is.a("number").is.gte(0).and.is.lte(1);
+                        expect(res.body).have.property("data").property("idLiveness").is.a("number").is.gte(0).and.is.lte(1);
+                    }
+
+                    if (!HubService.Instance.silent) { console.log(indent, "KYC provider id:", kycProviderId, "@", kycProviderUrl) }
+                });
+        });
+
+        it("Get supported document id type", function () {
+            return chai.request(kycProviderUrl).get("/getIdType")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").is.an("array").lengthOf.greaterThan(0);
+                    expect(res.body).have.property("data").to.include.deep.members([
+                        kycType[idType]
+                    ]);
+                });
+        });
+
+        it("Get KYC info", function () {
+            return chai.request(kycProviderUrl).get("/getKycInfo")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .query({
+                    kycId: user.kyc.kycId
+                })
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("kycId").is.a("number").is.eq(user.kyc.kycId);
+                });
+        });
+
+        it("Pre-check", function () {
+            let url = mxwV1ServiceUrl("/provider/kyc-proxy/v1");
+
+            return chai.request(url).post("/precheckEx")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .set("app-id", String(HubService.Instance.appId))
+                .send({
+                    kycId: user.kyc.kycId,
+                    idType,
+                    country: user.profile.country,
+                    idNo: user.username
+                })
+                .then((res) => {
+                    goodRet(res);
+                });
+        });
+
+        it("Upload document front image", function () {
+            let params = {
+                actionType: "FRONT",
+                kycId: user.kyc.kycId
+            };
+
+            return uploadOSS(user, kycProviderUrl, "/preupload", params, __dirname + "/resources/mykad_front.jpg", "image/png").then((readUrl) => {
+                idImgFrontUrl = readUrl;
+                if (!HubService.Instance.silent) { console.log(indent, "KYC uploaded document front image:", idImgFrontUrl) }
+            });
+        });
+
+        it("Process OCR document front image", function () {
+            this.timeout(60000);
+
+            let params = {
+                providerId: kycProviderId,
+                kycId: user.kyc.kycId,
+                country: user.profile.country,
+                idType,
+                userData: {
+                    dob: user.profile.dob,
+                    gender: user.profile.gender,
+                    idName: user.username,
+                    idNo: user.username,
+                    religion: user.profile.religion,
+                    address: user.profile.address.value,
+                    street: user.profile.address.street,
+                    postcode: user.profile.address.postcode,
+                    city: user.profile.address.city,
+                    state: user.profile.address.state,
+                    province: user.profile.address.province,
+                    country: user.profile.address.country
+                },
+                ocrData: null
+            }
+
+            if (KYC_FLOW_ID.AUTO == flow) {
+                params.ocrData = {
+                    dob: user.profile.dob,
+                    gender: user.profile.gender,
+                    idName: user.username + (user.kyc.ocrAlter ? "X" : ""),
+                    idNo: user.username,
+                    religion: user.profile.religion,
+                    address: user.profile.address.value,
+                    street: user.profile.address.street,
+                    postcode: user.profile.address.postcode,
+                    city: user.profile.address.city,
+                    state: user.profile.address.state,
+                    province: user.profile.address.province,
+                    country: user.profile.address.country
+                }
+            }
+
+            return chai.request(kycProviderUrl).post("/iDVerifyOcr")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .set("app-id", String(HubService.Instance.appId))
+                .send(params)
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("userData");
+                    expect(res.body).have.property("data").property("ocrFlag").is.a("number");
+                    expect(res.body).have.property("data").property("alertFlag").is.a("number");
+
+                    alertFlag = res.body.data.alertFlag;
+                });
+        });
+
+        it("Upload live image", function () {
+            let params = {
+                actionType: "LIVE",
+                kycId: user.kyc.kycId
+            };
+
+            return uploadOSS(user, kycProviderUrl, "/preupload", params, __dirname + "/resources/live.jpg", "image/png").then((readUrl) => {
+                imgLiveUrl = readUrl;
+                if (!HubService.Instance.silent) { console.log(indent, "KYC uploaded live image:", imgLiveUrl) }
+            });
+        });
+
+        it("Submission", function () {
+            this.timeout(60000);
+
+            return chai.request(kycProviderUrl).post("/kycSubmit")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .set("app-id", String(HubService.Instance.appId))
+                .send({
+                    providerId: kycProviderId,
+                    kycId: user.kyc.kycId,
+                    alertFlag
+                })
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("kycStatus").is.a("number");
+
+                    user.kyc.status = res.body.data.kycStatus;
+                    if (!HubService.Instance.silent) { console.log(indent, "KYC status:", user.kyc.status) }
+                });
+        });
+
+        it("Verify KYC info", function () {
+            return chai.request(kycProviderUrl).get("/getKycInfo")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .query({
+                    kycId: user.kyc.kycId
+                })
+                .then((res) => {
+                    goodRet(res);
+                    expect(res.body).have.property("data").property("kycId").is.a("number").is.eq(user.kyc.kycId);
+                    expect(res.body).have.property("data").property("country").is.a("string").is.eq(user.profile.country);
+                    expect(res.body).have.property("data").property("gender").is.a("string").is.eq(user.profile.gender);
+                    expect(res.body).have.property("data").property("idType").is.a("number").is.eq(user.kyc.idType);
+                    expect(res.body).have.property("data").property("fullName").is.a("string").is.eq(user.username);
+                    expect(res.body).have.property("data").property("idNo").is.a("string").is.eq(user.username);
+                    expect(res.body).have.property("data").property("dob").is.a("number").is.eq(user.profile.dob);
+                    expect(res.body).have.property("data").property("providerId").is.a("number").is.eq(kycProviderId);
+                    expect(res.body).have.property("data").property("kycStatus").is.a("number").is.eq(user.kyc.status);
+                    expect(res.body).have.property("data").property("frontId").is.a("string").is.not.empty;
+                    expect(res.body).have.property("data").property("liveness").is.a("string").is.not.empty;
+                    expect(res.body).have.property("data").property("address").is.a("string").is.eq(user.profile.address.value);
+                    expect(res.body).have.property("data").property("postcode").is.a("string").is.eq(user.profile.address.postcode);
+                    expect(res.body).have.property("data").property("province").is.a("string").is.eq(user.profile.address.province);
+                    expect(res.body).have.property("data").property("city").is.a("string").is.eq(user.profile.address.city);
+                    expect(res.body).have.property("data").property("frontIdImg").is.a("string").is.not.empty;
+                    expect(res.body).have.property("data").property("liveImg").is.a("string").is.not.empty;
+                });
+        });
+
+        it("re-submission", function () {
+            this.timeout(60000);
+
+            return chai.request(kycProviderUrl).post("/kycSubmit")
+                .type("application/json")
+                .set("Authorization", "Bearer " + user.mxwJwt)
+                .set("app-id", String(HubService.Instance.appId))
+                .send({
+                    providerId: kycProviderId,
+                    kycId: user.kyc.kycId,
+                    alertFlag
+                })
+                .then((res) => {
+                    badRet(res);
+                });
+        });
+
+    });
+}