ggez-banking-sdk/dist/bank-system/services/verifyAndConfirm.js

A Node.js package to handle GGEZ Banking API endpoints, Simplify the process of managing CRUD operations with this efficient and easy-to-use package.

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.useVerifyAndConfirm = void 0;
const token_1 = require("./token");
const dataStructure_1 = __importDefault(require("../helper/dataStructure"));
const restApi_1 = __importDefault(require("../restApi"));
const helper_1 = __importDefault(require("../helper"));
const useVerifyAndConfirm = (userInfo, tokenData, baseUrl, nodeUrl, programId, geoCoordinates, token, userId, lang) => {
    const { dataValidate, dataSecurity } = (0, dataStructure_1.default)();
    const { dataConfirmEmail, dataConfirmPhone, dataISEmailUsed, dataIsPhoneUsed, dataValidatePhone, dataVerifyEmail, dataVerifyPhone, dataSendOTPEmail, dataSendOTPPhone, dataValidateForgetPassword, dataConfirmForgetPassword, } = dataValidate();
    const { CreateLimitedToken } = (0, token_1.useToken)(userInfo, nodeUrl, programId, "", geoCoordinates);
    const { checkResponse, headerConfig } = (0, helper_1.default)(userInfo);
    const { checkGlobalResponse, errorHandler } = checkResponse();
    const headerConfigVerify = async () => {
        let token;
        let { message, response, status } = await CreateLimitedToken(tokenData);
        if (status == "success") {
            token = response?.data?.access_token;
        }
        else {
            errorHandler(message, "SignUpApi", response);
        }
        let headersData = {
            header: true,
            isUrlEncoded: false,
            token: token,
            lang: lang,
        };
        let headers = headerConfig(headersData);
        return headers;
    };
    const headerConfigUser = async () => {
        let headersData = {
            header: true,
            isUrlEncoded: false,
            token: token,
            lang: lang,
        };
        let headers = headerConfig(headersData);
        return headers;
    };
    const ValidateLimitedPhone = async (values) => {
        let data = dataValidatePhone({ ...values, geoCoordinates: geoCoordinates });
        try {
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/validate`, await headerConfigVerify(), data);
            checkGlobalResponse("verify", response, "ValidateLimitedPhone", "verify");
            return {
                response: response,
                newUser: {},
                message: "",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const VerifyLimitedEmail = async (values) => {
        let data = dataVerifyEmail({ ...values, geoCoordinates: geoCoordinates });
        try {
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/verify`, await headerConfigVerify(), data);
            checkGlobalResponse("verify", response, "VerifyLimitedEmail", "verify");
            return {
                response: response,
                newUser: {},
                message: "Verification Code Message Sent Successfully",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const VerifyLimitedPhone = async (values) => {
        let data = dataVerifyPhone({ ...values, geoCoordinates: geoCoordinates });
        try {
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/verify`, await headerConfigVerify(), data);
            checkGlobalResponse("verify", response, "VerifyLimitedPhone", "verify");
            return {
                response: response,
                newUser: {},
                message: "Verification Code Message Sent Successfully",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const SendOTPEmail = async (values) => {
        let data = dataSendOTPEmail({ ...values, geoCoordinates: geoCoordinates });
        try {
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/user/security/verify/${userId}`, await headerConfigUser(), data);
            checkGlobalResponse("verify", response, "SendOTPEmail", "verify");
            return {
                response: response,
                newUser: null,
                message: response?.data?.result?.message,
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const SendOTPPhone = async (values) => {
        let data = dataSendOTPPhone({ ...values, geoCoordinates: geoCoordinates });
        try {
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/user/security/verify/${userId}`, await headerConfigUser(), data);
            checkGlobalResponse("verify", response, "SendOTPPhone", "verify");
            return {
                response: response,
                newUser: null,
                message: response?.data?.result?.message,
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const ConfirmLimitedEmail = async (values) => {
        let data = dataConfirmEmail({ ...values, geoCoordinates: geoCoordinates });
        try {
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/confirm`, await headerConfigVerify(), data);
            checkGlobalResponse("confirm", response, "ConfirmLimitedEmail", undefined);
            return {
                response: response,
                newUser: {},
                message: response?.data?.result?.message ?? "Email Confirmed Successfully",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const ConfirmLimitedPhone = async (values) => {
        let data = dataConfirmPhone({ ...values, geoCoordinates: geoCoordinates });
        try {
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/confirm`, await headerConfigVerify(), data);
            checkGlobalResponse("confirm", response, "ConfirmLimitedPhone", undefined);
            return {
                response: response,
                newUser: {},
                message: response?.data?.result?.message ?? "Phone Confirmed Successfully",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const IsEmailUsed = async (values) => {
        let data = dataISEmailUsed({ ...values, geoCoordinates: geoCoordinates });
        try {
            let headers = await headerConfigVerify();
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/validate`, headers, data);
            checkGlobalResponse("verify", response, "IsEmailUsed", "verify");
            return {
                response: response,
                newUser: {},
                message: "",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const IsPhoneUsed = async (values) => {
        let data = dataIsPhoneUsed({ ...values, geoCoordinates: geoCoordinates });
        try {
            let headers = await headerConfigVerify();
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/validate`, headers, data);
            checkGlobalResponse("verify", response, "IsPhoneUsed", "verify");
            return {
                response: response,
                newUser: {},
                message: "",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const forgetPasswordValidate = async (values) => {
        let data = dataValidateForgetPassword({
            ...values,
            geoCoordinates: geoCoordinates,
        });
        try {
            let headers = await headerConfigVerify();
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/forget/validate`, headers, data);
            let { newUserInfo } = checkGlobalResponse("forget", response, "forgetPasswordValidate", "forgetValidate");
            return {
                response: response,
                newUser: newUserInfo,
                message: response?.data?.result?.message ??
                    "Forget password validate successfully",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    const forgetPasswordConfirm = async (values) => {
        let data = dataConfirmForgetPassword({
            ...values,
            geoCoordinates: geoCoordinates,
        });
        try {
            let headers = await headerConfigVerify();
            const response = await restApi_1.default.restApi(baseUrl, "POST", `v1/limited/security/forget/confirm`, headers, data);
            let { newUserInfo } = checkGlobalResponse("forget", response, "forgetPasswordConfirm", "forgetConfirm");
            return {
                response: response,
                newUser: newUserInfo,
                message: response?.data?.result?.message ??
                    "Forget password confirm successfully",
                status: "success",
            };
        }
        catch (error) {
            return {
                response: error.response,
                newUser: null,
                message: error.message,
                status: "failed",
            };
        }
    };
    return {
        ValidateLimitedPhone,
        VerifyLimitedEmail,
        VerifyLimitedPhone,
        ConfirmLimitedEmail,
        ConfirmLimitedPhone,
        IsEmailUsed,
        IsPhoneUsed,
        SendOTPEmail,
        SendOTPPhone,
        forgetPasswordValidate,
        forgetPasswordConfirm,
    };
};
exports.useVerifyAndConfirm = useVerifyAndConfirm;