pedwfrontend/pages/api/proxy/[...route].js

import axios from "axios";
import https from "https";
import CryptoJS from "crypto-js";
import HmacSHA256 from "crypto-js/hmac-sha256";
import { rest } from "lodash";

const PROXY_RELAY_URL =
    "https://" +
    (process.env.RELAYURI || "dev-pedw-ns.servicebus.windows.net") +
    "/" +
    (process.env.RELAYPATH || "dev-pedw-hc") +
    "/";

const accessTokenEndpoint = process.env.ACCESS_TOKEN_ENDPOINT;
const tenantId = process.env.TENANT;

const tokenBody =
    "grant_type=" +
    process.env.GRANT_TYPE +
    "&client_id=" +
    process.env.CLIENT_ID +
    "&client_secret=" +
    process.env.CLIENT_SECRET +
    "&scope=" +
    "https://" +
    process.env.RELAYURI +
    "/.default";

const tokenConfig = {
    headers: {
        "Content-Type": "application/x-www-form-urlencoded",
        "Cache-Control": "no-cache",
    },
};

export const getToken = () => {
    return axios
        .post(
            `${accessTokenEndpoint}${tenantId}/oauth2/v2.0/token`,
            tokenBody,
            tokenConfig
        )
        .then((res) => res.data)
        .then((data) => {
            return data;
        })
        .catch((error) => {
            console.log("error :", error.response);
            // return error;
        });
};

function checkProxyPath(queryPath) {
    const WORDKEY = process.env.NEXT_PUBLIC_HASHKEY;

    var hashPath =
        queryPath.indexOf("/api/proxy/") == -1
            ? queryPath
            : queryPath.split("/api/proxy/")[1];

    const wordKey = WORDKEY;
    var hashlink = CryptoJS.HmacSHA256(
        decodeURI(hashPath),
        CryptoJS.enc.Hex.parse(wordKey)
    );

    hashlink = hashlink.toString(CryptoJS.enc.Hex);

    return hashlink;
}

export default async function ApiProxy(req, res) {
    var data = JSON.stringify(req.body);
    var accessToken = await getToken();
    accessToken = accessToken.access_token;

    const isDocument = req.url.indexOf("/documents/download") > -1;

    let hashCheckPath = isDocument
        ? req.url.split("?hash=")[0]
        : req.url.split("&hash=")[0];
    let hashCheckValue = isDocument
        ? req.url.split("?hash=")[1]
        : req.url.split("&hash=")[1];
    let hashFromRequest = checkProxyPath(hashCheckPath);

    var configNoData = {
        method: req.method,
        //url: PROXY_RELAY_URL + updateFormCollection + "(" + incidentId + ")",
        url:
            PROXY_RELAY_URL +
            req.url.split("&hash=")[0].split("/api/proxy/")[1] +
            "&hash=" +
            req.url.split("&hash=")[1],
        headers: {
            "OData-MaxVersion": "4.0",
            "OData-Version": "4.0",
            "Accept": "application/json",
            "Prefer":
                'odata.include-annotations="*",return=representation,odata.maxpagesize=10',
            "Authorization": "Bearer " + accessToken,
            "Content-Type": "application/json",
        },
    };

    var config = {
        method: req.method,
        url:
            PROXY_RELAY_URL +
            req.query.route[0] +
            "&hash=" +
            req.url.split("&hash=")[1],
        headers: {
            "OData-MaxVersion": "4.0",
            "OData-Version": "4.0",
            "Accept": "application/json",
            "Prefer": 'odata.include-annotations="*",return=representation',
            "Authorization": "Bearer " + accessToken,
            "Content-Type": "application/json",
        },
        data: data,
    };

    var configDocument = {
        method: req.method,
        url:
            PROXY_RELAY_URL +
            req.url.split("?hash=")[0].split("/api/proxy/")[1] +
            "?hash=" +
            req.url.split("?hash=")[1],
        headers: {
            "OData-MaxVersion": "4.0",
            "OData-Version": "4.0",
            "Accept": "application/json",
            "Prefer": 'odata.include-annotations="*",return=representation',
            "Authorization": "Bearer " + accessToken,
            "Content-Type": "application/json",
        },
        responseType: "arraybuffer",
    };

    if (hashCheckValue == hashFromRequest) {
        return new Promise((resolve, reject) => {
            let hasDocument =
                hashCheckPath.indexOf("/download") > 0 ? true : false;

            axios(
                req.method == "GET"
                    ? hasDocument
                        ? configDocument
                        : configNoData
                    : config
            )
                .then((response) => {
                    res.statusCode = 200;
                    if (hasDocument) {
                        res.setHeader(
                            "Content-disposition",
                            "attachment; filename=" +
                                response.headers["content-disposition"].split(
                                    "filename="
                                )[1]
                        );
                        res.end(response.data);
                    } else {
                        res.setHeader("Content-Type", "application/json");
                        // res.setHeader("Cache-Control", "max-age=1800000");
                        res.end(JSON.stringify(response.data));
                    }
                    resolve();
                })
                .catch((error) => {
                    console.log("proxy response error", error);
                    //res.json(error);
                    res.status(405).end();
                    return resolve();
                });
        });
    } else {
        res.status(405).end();
        return resolve();
    }
}