TASK22211: normalize case update and crm task endpoint contracts

pages/api/endpoint/createcrmtask_api.js

@@ -42,35 +42,35 @@
  */
 
 import axios from "axios";
-import CryptoJS from "crypto-js";
-import _ from "lodash";
 import { isNonEmptyString, sanitizeString } from "../../../actions/core/guards";
 import { consoleLogger } from "../../../actions/core/logger";
 import { getToken } from "../../../actions/core/token";
-import { getCaseBlob } from "../../../actions/azurestorage";
 import { hashAPIPath } from "../../../actions/core/hash";
+import { respondError, respondSuccess } from "../middleware/apiResponse";
 
 const WEBAPI_URL =
     process.env.RELAY_ROOT ||
     "https://dev-pedw-ns.servicebus.windows.net/dev-pedw-hc/";
 
 export default async function ApiProxy(req, res) {
-    var createTaskBody = req.body;
+    const createTaskBody = req.body;
 
     const contactEmail = sanitizeString(createTaskBody?.contactEmail);
     const contactSubject = sanitizeString(createTaskBody?.contactSubject);
     const contactBody = sanitizeString(createTaskBody?.contactbody);
 
     if (!isNonEmptyString(contactEmail) || !isNonEmptyString(contactSubject)) {
-        return res.status(400).json({
+        return respondError(res, {
-            error: "contactEmail and contactSubject are required"
+            status: 400,
+            code: "CONTACT_EMAIL_AND_SUBJECT_REQUIRED",
+            message: "contactEmail and contactSubject are required"
         });
     }
 
-    var queryUrl = "tasks";
+    const queryUrl = "tasks";
-    var token = await getToken();
+    const token = await getToken();
 
-    let contactValue = createTaskBody.typeOfContact;
+    const contactValue = createTaskBody.typeOfContact;
 
     const teamMap = {
         plq: "ec48450c-7e26-ec11-a97f-00224800e98c", //PET
@@ -99,7 +99,7 @@ export default async function ApiProxy(req, res) {
 
     //console.log("/////Create Task:\n", payload, "\n//////////////");
 
-    var config = {
+    const config = {
         method: "post",
         url: WEBAPI_URL + queryUrl + hashAPIPath(queryUrl),
         headers: {
@@ -117,11 +117,13 @@ export default async function ApiProxy(req, res) {
 
     try {
         const { data } = await axios(config);
-        return res.status(200).json(data);
+        return respondSuccess(res, data);
     } catch (error) {
         consoleLogger(error);
-        return res
+        return respondError(res, {
-            .status(400)
+            status: 400,
-            .json({ error: "Failed to create CRM task", details: error });
+            code: "CRM_TASK_CREATE_FAILED",
+            message: "Failed to create CRM task"
+        });
     }
 }

pages/api/endpoint/patchcase_api.js

@@ -11,51 +11,54 @@
  */
 
 import axios from "axios";
-import CryptoJS from "crypto-js";
-import _ from "lodash";
 import { consoleLogger } from "../../../actions/core/logger";
 import { getToken } from "../../../actions/core/token";
 import { hashAPIPath } from "../../../actions/core/hash";
+import { respondError, respondSuccess } from "../middleware/apiResponse";
 
 const WEBAPI_URL =
     process.env.RELAY_ROOT ||
     "https://dev-pedw-ns.servicebus.windows.net/dev-pedw-hc/";
 
 export default async function ApiProxy(req, res) {
-    var incidentID = req.query.incidentid;
+    const incidentID = req.query.incidentid;
-    var queryUrl = "incidents(" + incidentID + ")";
-    var token = await getToken();
 
-    var data = JSON.stringify({
+    if (typeof incidentID !== "string" || incidentID.trim().length === 0) {
-        "servicestage": 0
+        return respondError(res, {
-    });
+            status: 400,
+            code: "INCIDENT_ID_REQUIRED",
+            message: "incidentid is required"
+        });
+    }
 
-    //console.log(data, WEBAPI_URL + queryUrl);
+    try {
+        const queryUrl = "incidents(" + incidentID + ")";
+        const token = await getToken();
 
-    var config = {
+        const config = {
-        method: "patch",
+            method: "patch",
-        url: WEBAPI_URL + queryUrl + hashAPIPath(queryUrl),
+            url: WEBAPI_URL + queryUrl + hashAPIPath(queryUrl),
-        headers: {
+            headers: {
-            "OData-MaxVersion": "4.0",
+                "OData-MaxVersion": "4.0",
-            "OData-Version": "4.0",
+                "OData-Version": "4.0",
-            "Accept": "application/json",
+                "Accept": "application/json",
-            "Prefer": 'odata.include-annotations="*",return=representation',
+                "Prefer": 'odata.include-annotations="*",return=representation',
-            "Authorization": "Bearer " + token.access_token,
+                "Authorization": "Bearer " + token.access_token,
-            "Content-Type": "application/json"
+                "Content-Type": "application/json"
-        },
+            },
-        data: data
+            data: JSON.stringify({
-    };
+                "servicestage": 0
+            })
+        };
 
-    var apiResponse = _.isEmpty(req.query)
+        const { data } = await axios(config);
-        ? res.status(400).json()
+        return respondSuccess(res, data);
-        : axios(config)
+    } catch (error) {
-              .then(({ data }) => {
+        consoleLogger(error);
-                  res.status(200).json(data);
+        return respondError(res, {
-              })
+            status: 400,
-              .catch((error) => {
+            code: "CASE_PATCH_FAILED",
-                  consoleLogger(error);
+            message: "Failed to patch case"
-                  res.status(400).json(error);
+        });
-              });
+    }
-
-    return apiResponse;
 }

pages/api/endpoint/updatecase_api.js

@@ -11,45 +11,71 @@
  */
 
 import axios from "axios";
-import CryptoJS from "crypto-js";
+import { consoleLogger } from "../../../actions/core/logger";
 import { getToken } from "../../../actions/core/token";
 import { hashAPIPath } from "../../../actions/core/hash";
+import { respondError, respondSuccess } from "../middleware/apiResponse";
 
 const WEBAPI_URL =
     process.env.RELAY_ROOT ||
     "https://dev-pedw-ns.servicebus.windows.net/dev-pedw-hc/";
 
 export default async function ApiProxy(req, res) {
-    var data = JSON.stringify(req.body);
+    const updatePayload = req.body;
-    var appealObj = req.query.appealObj;
+    const appealObj = req.query.appealObj;
-    var incidentID = req.query.incident;
+    const updateFormCollection = req.query.updateFormCollection;
 
-    var updateFormCollection = req.query.updateFormCollection;
+    if (!updatePayload || typeof updatePayload !== "object") {
-    var queryUrl = updateFormCollection + "(" + appealObj + ")";
+        return respondError(res, {
-
+            status: 400,
-    var token = await getToken();
+            code: "CASE_UPDATE_PAYLOAD_REQUIRED",
-
+            message: "Case update payload is required"
-    var config = {
-        method: "patch",
-        url: WEBAPI_URL + queryUrl + hashAPIPath(queryUrl),
-        headers: {
-            "OData-MaxVersion": "4.0",
-            "OData-Version": "4.0",
-            "Accept": "application/json",
-            "Prefer": 'odata.include-annotations="*",return=representation',
-            "Authorization": "Bearer " + token.access_token,
-            "Content-Type": "application/json"
-        },
-        data: data
-    };
-
-    //console.log("update case:", data);
-
-    return axios(config)
-        .then(({ data }) => {
-            res.status(200).json(data);
-        })
-        .catch((error) => {
-            res.status(400);
         });
+    }
+    if (typeof appealObj !== "string" || appealObj.trim().length === 0) {
+        return respondError(res, {
+            status: 400,
+            code: "APPEAL_OBJECT_ID_REQUIRED",
+            message: "appealObj is required"
+        });
+    }
+    if (
+        typeof updateFormCollection !== "string" ||
+        updateFormCollection.trim().length === 0
+    ) {
+        return respondError(res, {
+            status: 400,
+            code: "UPDATE_FORM_COLLECTION_REQUIRED",
+            message: "updateFormCollection is required"
+        });
+    }
+
+    try {
+        const queryUrl = updateFormCollection + "(" + appealObj + ")";
+        const token = await getToken();
+
+        const config = {
+            method: "patch",
+            url: WEBAPI_URL + queryUrl + hashAPIPath(queryUrl),
+            headers: {
+                "OData-MaxVersion": "4.0",
+                "OData-Version": "4.0",
+                "Accept": "application/json",
+                "Prefer": 'odata.include-annotations="*",return=representation',
+                "Authorization": "Bearer " + token.access_token,
+                "Content-Type": "application/json"
+            },
+            data: JSON.stringify(updatePayload)
+        };
+
+        const { data } = await axios(config);
+        return respondSuccess(res, data);
+    } catch (error) {
+        consoleLogger(error);
+        return respondError(res, {
+            status: 400,
+            code: "CASE_UPDATE_FAILED",
+            message: "Failed to update case"
+        });
+    }
 }

tests/phase21/endpoint-handler-contract.test.cjs

@@ -3320,6 +3320,143 @@ test("createcase catch path returns CASE_CREATE_FAILED", async () => {
     assert.strictEqual(res.state.jsonBody.error.code, "CASE_CREATE_FAILED");
 });
 
+test("updatecase returns CASE_UPDATE_PAYLOAD_REQUIRED when body missing", async () => {
+    const mod = loadModule("pages/api/endpoint/updatecase_api.js", {
+        respondError: respondErrorMock,
+        respondSuccess: respondSuccessMock,
+        getToken: async () => ({ access_token: "token" }),
+        hashAPIPath: () => "&hash=expected",
+        axios: async () => ({ data: {} }),
+        consoleLogger: () => {}
+    });
+
+    const req = {
+        query: { appealObj: "a1", updateFormCollection: "pinswg_x" },
+        body: undefined
+    };
+    const res = createRes();
+    await mod.default(req, res);
+
+    assert.strictEqual(res.state.statusCode, 400);
+    assert.strictEqual(
+        res.state.jsonBody.error.code,
+        "CASE_UPDATE_PAYLOAD_REQUIRED"
+    );
+});
+
+test("updatecase catch path returns CASE_UPDATE_FAILED", async () => {
+    const mod = loadModule("pages/api/endpoint/updatecase_api.js", {
+        respondError: respondErrorMock,
+        respondSuccess: respondSuccessMock,
+        getToken: async () => ({ access_token: "token" }),
+        hashAPIPath: () => "&hash=expected",
+        axios: async () => {
+            throw new Error("update failed");
+        },
+        consoleLogger: () => {}
+    });
+
+    const req = {
+        query: { appealObj: "a1", updateFormCollection: "pinswg_x" },
+        body: { title: "updated" }
+    };
+    const res = createRes();
+    await mod.default(req, res);
+
+    assert.strictEqual(res.state.statusCode, 400);
+    assert.strictEqual(res.state.jsonBody.error.code, "CASE_UPDATE_FAILED");
+});
+
+test("patchcase returns INCIDENT_ID_REQUIRED when incidentid missing", async () => {
+    const mod = loadModule("pages/api/endpoint/patchcase_api.js", {
+        respondError: respondErrorMock,
+        respondSuccess: respondSuccessMock,
+        getToken: async () => ({ access_token: "token" }),
+        hashAPIPath: () => "&hash=expected",
+        axios: async () => ({ data: {} }),
+        consoleLogger: () => {}
+    });
+
+    const req = { query: {} };
+    const res = createRes();
+    await mod.default(req, res);
+
+    assert.strictEqual(res.state.statusCode, 400);
+    assert.strictEqual(res.state.jsonBody.error.code, "INCIDENT_ID_REQUIRED");
+});
+
+test("patchcase catch path returns CASE_PATCH_FAILED", async () => {
+    const mod = loadModule("pages/api/endpoint/patchcase_api.js", {
+        respondError: respondErrorMock,
+        respondSuccess: respondSuccessMock,
+        getToken: async () => ({ access_token: "token" }),
+        hashAPIPath: () => "&hash=expected",
+        axios: async () => {
+            throw new Error("patch failed");
+        },
+        consoleLogger: () => {}
+    });
+
+    const req = { query: { incidentid: "i1" } };
+    const res = createRes();
+    await mod.default(req, res);
+
+    assert.strictEqual(res.state.statusCode, 400);
+    assert.strictEqual(res.state.jsonBody.error.code, "CASE_PATCH_FAILED");
+});
+
+test("createcrmtask returns CONTACT_EMAIL_AND_SUBJECT_REQUIRED when required fields missing", async () => {
+    const mod = loadModule("pages/api/endpoint/createcrmtask_api.js", {
+        respondError: respondErrorMock,
+        respondSuccess: respondSuccessMock,
+        isNonEmptyString: () => false,
+        sanitizeString: (v) => v,
+        getToken: async () => ({ access_token: "token" }),
+        hashAPIPath: () => "&hash=expected",
+        axios: async () => ({ data: {} }),
+        consoleLogger: () => {}
+    });
+
+    const req = { body: {} };
+    const res = createRes();
+    await mod.default(req, res);
+
+    assert.strictEqual(res.state.statusCode, 400);
+    assert.strictEqual(
+        res.state.jsonBody.error.code,
+        "CONTACT_EMAIL_AND_SUBJECT_REQUIRED"
+    );
+});
+
+test("createcrmtask catch path returns CRM_TASK_CREATE_FAILED", async () => {
+    const mod = loadModule("pages/api/endpoint/createcrmtask_api.js", {
+        respondError: respondErrorMock,
+        respondSuccess: respondSuccessMock,
+        isNonEmptyString: () => true,
+        sanitizeString: (v) => v,
+        getToken: async () => ({ access_token: "token" }),
+        hashAPIPath: () => "&hash=expected",
+        axios: async () => {
+            throw new Error("create failed");
+        },
+        consoleLogger: () => {}
+    });
+
+    const req = {
+        body: {
+            contactEmail: "user@test.local",
+            contactSubject: "Need help",
+            contactbody: "Details",
+            typeOfContact: "plq"
+        }
+    };
+    const res = createRes();
+    await mod.default(req, res);
+
+    assert.strictEqual(res.state.statusCode, 400);
+    assert.strictEqual(res.state.jsonBody.error.code, "CRM_TASK_CREATE_FAILED");
+});
+
 test("getsipsmedia returns success contract", async () => {
     const mod = loadModule("pages/api/endpoint/getsipsmedia_api.js", {
         respondSuccess: respondSuccessMock