@plusscommunities/pluss-maintenance-aws-forms 2.1.31 → 2.1.32

package/jobChanged.js

@@ -43,7 +43,7 @@ const onNotesAdded = async (request) => {
 const checkIntegrationActions = async (request, prevRequest) => {
   if (
     request.ExtCreateRetry &&
-    request.ExtCreateRetry !== prevRequest.ExtCreateRetry
+    request.ExtCreateRetry > prevRequest.ExtCreateRetry
   ) {
     log("checkIntegrationActions", "Retrying", true);
     await pushRequestToIntegration(request);

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@plusscommunities/pluss-maintenance-aws-forms",
-  "version": "2.1.31",
+  "version": "2.1.32",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plusscommunities/pluss-maintenance-aws-forms",
-  "version": "2.1.31",
+  "version": "2.1.32",
   "description": "Extension package to enable maintenance on Pluss Communities Platform",
   "scripts": {
     "gc": "node ../../tools/gc ./",

package/requests/retrySync.js

@@ -0,0 +1,161 @@
+const moment = require("moment");
+const getRef = require("@plusscommunities/pluss-core-aws/db/common/getRef");
+const editRef = require("@plusscommunities/pluss-core-aws/db/common/editRef");
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const { log } = require("@plusscommunities/pluss-core-aws/helper");
+const { values } = require("../values.config");
+const { getStrategy } = require("../integration");
+
+/**
+ * Checks if a job has already been successfully synced to an external system.
+ * Uses two methods to determine sync status:
+ * 1. Checks job history for an "ExternalIDSet" entry
+ * 2. Queries the integration strategy's getExternalId method if available
+ *
+ * @param {Object} job - The maintenance job record
+ * @param {string} job.id - The job's internal ID
+ * @param {string} job.site - The site the job belongs to
+ * @param {Array} [job.history] - The job's history entries
+ * @param {string} logId - The log ID for tracing
+ * @returns {Promise<boolean>} True if the job has already been synced
+ */
+const isAlreadySynced = async (job, logId) => {
+  const history = job.history || [];
+  const hasSuccessfulSync = history.some(
+    (entry) => entry.EntryType === "ExternalIDSet"
+  );
+
+  if (hasSuccessfulSync) {
+    log("isAlreadySynced", "FoundInHistory", true, logId);
+    return true;
+  }
+
+  try {
+    const integrationStrategy = await getStrategy(job.site);
+    if (integrationStrategy.getExternalId) {
+      const externalId = await integrationStrategy.getExternalId(job);
+      if (externalId) {
+        log("isAlreadySynced", "FoundViaStrategy", externalId, logId);
+        return true;
+      }
+    }
+  } catch (error) {
+    log("isAlreadySynced", "StrategyCheckError", error.message, logId);
+  }
+
+  return false;
+};
+
+/**
+ * Initiates a retry of the external system sync for a maintenance job.
+ * This endpoint sets the ExtCreateRetry field on the job, which triggers
+ * the jobChanged stream handler to attempt pushing the request to the
+ * external integration system again.
+ *
+ * @param {Object} event - The Lambda event object
+ * @param {Object} event.headers - Request headers containing auth credentials
+ * @param {Object} data - The request body
+ * @param {string} data.id - The ID of the job to retry sync for
+ * @returns {Promise<Object>} Response object with status and data
+ * @returns {number} returns.status - HTTP status code
+ * @returns {Object} returns.data - Response payload
+ *
+ * @example
+ * // Request
+ * POST /maintenance/update/retrysync
+ * { "id": "job-uuid-here" }
+ *
+ * // Success Response (200)
+ * {
+ *   "success": true,
+ *   "message": "Sync retry initiated. Check back shortly for results.",
+ *   "job": { ... }
+ * }
+ *
+ * // Error Responses
+ * // 400 - Job already synced to external system
+ * // 403 - Not authorised
+ * // 404 - Job not found
+ * // 422 - Missing required field: id
+ * // 500 - Internal error
+ */
+module.exports = async (event, data) => {
+  const action = "retrySync";
+  const logId = log(action, "Input", data);
+
+  try {
+    // Validate required fields
+    if (!data.id) {
+      return {
+        status: 422,
+        data: { error: "Missing required field: id" },
+      };
+    }
+
+    // Fetch the job record
+    let job;
+    try {
+      job = await getRef(values.tableNameMaintenance, "id", data.id);
+    } catch (error) {
+      log(action, "Error:JobNotFound", { error: error.message }, logId);
+      return { status: 404, data: { error: "Job not found" } };
+    }
+
+    if (!job) {
+      log(action, "JobNotFound", { id: data.id }, logId);
+      return { status: 404, data: { error: "Job not found" } };
+    }
+
+    // Validate user has permission to manage maintenance for this site
+    const authorised = await validateMasterAuth(
+      event,
+      values.permissionMaintenanceTracking,
+      job.site
+    );
+
+    if (!authorised) {
+      log(action, "NotAuthorised", { site: job.site }, logId);
+      return { status: 403, data: { error: "Not authorised" } };
+    }
+
+    // Prevent duplicate syncs - check if already synced via history or external entity
+    const alreadySynced = await isAlreadySynced(job, logId);
+    if (alreadySynced) {
+      log(action, "AlreadySynced", { id: job.id }, logId);
+      return {
+        status: 400,
+        data: { error: "Job already synced to external system" },
+      };
+    }
+
+    // Set ExtCreateRetry to a new timestamp value.
+    // The jobChanged stream handler detects this field change and
+    // triggers pushRequestToIntegration() to retry the external sync.
+    const retryTimestamp = moment.utc().valueOf();
+    const updatedJob = await editRef(
+      values.tableNameMaintenance,
+      "id",
+      job.id,
+      {
+        ExtCreateRetry: retryTimestamp,
+      }
+    );
+
+    log(action, "RetryTriggered", { ExtCreateRetry: retryTimestamp }, logId);
+
+    return {
+      status: 200,
+      data: {
+        success: true,
+        message: "Sync retry initiated. Check back shortly for results.",
+        job: updatedJob,
+      },
+    };
+  } catch (error) {
+    log(action, "InternalError", error, logId);
+    return {
+      status: 500,
+      data: { error: "Internal error", message: error.message },
+    };
+  }
+};

package/updateData.js

@@ -5,6 +5,7 @@ const config = require("./config.json");
 const assignRequest = require("./requests/assignRequest");
 const updatePriority = require("./requests/updatePriority");
 const setExternalJobId = require("./requests/setExternalJobId");
+const retrySync = require("./requests/retrySync");
 
 module.exports.updateData = async (event, context, callback) => {
   init(config);
@@ -25,6 +26,9 @@ module.exports.updateData = async (event, context, callback) => {
       case "externalid":
         response = await setExternalJobId(event, data);
         break;
+      case "retrysync":
+        response = await retrySync(event, data);
+        break;
       default:
         response = { status: 404, data: { error: "Action not found" } };
         break;