@plusscommunities/pluss-maintenance-aws 2.0.2 → 2.0.3-archibus.1

package/feature.config.js

@@ -149,7 +149,7 @@ exports.serverless = {
       file: "jobChanged",
       function: "jobChanged",
       memorySize: 2048,
-      timeout: 30,
+      timeout: 300,
       table: "maintenance",
     },
   ],
@@ -162,6 +162,14 @@ exports.serverless = {
       timeout: "300",
       rate: "1/5 * * * ? *",
     },
+    {
+      name: "scheduleJobImport",
+      file: "scheduleJobImport",
+      function: "scheduleJobImport",
+      memorySize: "2048",
+      timeout: "300",
+      rate: "2/3 * * * ? *",
+    },
   ],
   tables: [
     {

package/integration/IntegrationStrategy.js

@@ -0,0 +1,35 @@
+class IntegrationStrategy {
+  getEntityType = () => {
+    return "maintenance_null";
+  };
+
+  isValidIntegration = () => {
+    return false;
+  };
+
+  getRefreshInterval = () => {
+    return 15 * 60 * 1000; // 15 minutes
+  };
+
+  // creates a request on the integrated system
+  createRequest = async (request) => {
+    return null;
+  };
+
+  // gets a request from the integrated system
+  getRequest = async (requestId) => {
+    return null;
+  };
+
+  // refreshed a request from the integrated system
+  refreshFromSource = async (requestId) => {
+    return null;
+  };
+
+  // actions taken when a request is marked as completed
+  onCompleteRequest = async (request) => {
+    return null;
+  };
+}
+
+module.exports = IntegrationStrategy;

package/integration/archibus/ArchibusStrategy.js

@@ -0,0 +1,460 @@
+const axios = require("axios");
+const moment = require("moment");
+const _ = require("lodash");
+const { encode } = require("base64-arraybuffer");
+const IntegrationStrategy = require("../IntegrationStrategy");
+const { log, getRowId } = require("@plusscommunities/pluss-core-aws/helper");
+const editRef = require("@plusscommunities/pluss-core-aws/db/common/editRef");
+const updateRef = require("@plusscommunities/pluss-core-aws/db/common/updateRef");
+const indexQuery = require("@plusscommunities/pluss-core-aws/db/common/indexQuery");
+const publishNotifications = require("@plusscommunities/pluss-core-aws/db/notifications/publishNotifications");
+const getRef = require("@plusscommunities/pluss-core-aws/db/common/getRef");
+
+class ArchibusStrategy extends IntegrationStrategy {
+  constructor(config) {
+    super();
+    this.baseUrl = config.BaseUrl; // base URL for the API
+    this.apiKeyHeader = config.APIKeyHeader; // header to use for API key
+    this.apiKey = config.APIKey; // API key
+
+    const url = new URL(this.baseUrl);
+    this.host = url.host;
+
+    this.statusMap = config.StatusMap;
+  }
+
+  /**
+   * Gets the entity type for the integration
+   *
+   * @returns {String} The entity type for the integration
+   */
+  getEntityType = () => {
+    return "maintenance_Archibus";
+  };
+
+  /**
+   * Validates the integration
+   *
+   * @returns {Boolean} Whether the integration is valid
+   */
+  isValidIntegration = () => {
+    return true;
+  };
+
+  /**
+   * Gets the refresh interval for the Archibus system
+   *
+   * @returns {Number} The refresh interval in milliseconds
+   */
+  getRefreshInterval = () => {
+    return 15 * 60 * 1000; // 15 minutes
+  };
+
+  /**
+   * Creates a request from the Archibus system
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @returns {Boolean} Whether the request was created on Archibus
+   */
+  createRequest = async (request) => {
+    const logId = log("Archibus:CreateRequest", "Start", request);
+    try {
+      const response = await axios({
+        method: "PUT",
+        url: `${this.baseUrl}/createWorkRequest`,
+        timeout: 15000,
+        headers: {
+          [this.apiKeyHeader]: this.apiKey,
+          "Content-Type": "application/json",
+          Host: this.host,
+        },
+        data: {
+          prob_type: "1.ON-SITE",
+          requestor: "PLUSSDEV",
+          description: `${request.title}${
+            _.isEmpty(request.description) ? "" : `\n\n${request.description}`
+          }${_.isEmpty(request.room) ? "" : `\n\nLocation: ${request.room}`}${
+            _.isEmpty(request.userName) ? "" : `\n\nName: ${request.userName}`
+          }${_.isEmpty(request.phone) ? "" : `\n\nPhone: ${request.phone}`}${
+            _.isEmpty(request.type) ? "" : `\n\nJob Type: ${request.type}`
+          }${
+            _.isEmpty(request.images)
+              ? ""
+              : `\n\nImages: ${request.images.join("\n")}`
+          }`,
+          site_id: "1001", //TODO need to do site mapping 2025 is WooloowareShores in prod
+        },
+      });
+      log("Archibus:CreateRequest", "Response", response.data, logId);
+
+      // Save the ID to external entities for future reference
+      await updateRef("externalentities", {
+        RowId: `${this.getEntityType()}_${response.data.wrId}`,
+        LastUpdated: moment().valueOf(),
+        EntityType: this.getEntityType(),
+        InternalId: request.id,
+        ExternalId: response.data.wrId,
+        TrackedData: {},
+      });
+
+      // Save the Archibus ID as the job number
+      await editRef("maintenance", "id", request.id, {
+        jobNo: response.data.wrId,
+        jobId: response.data.wrId + "",
+      });
+
+      // add images
+      if (!_.isEmpty(request.images)) {
+        const imagePromises = [];
+        request.images.forEach((url) => {
+          imagePromises.push(this.addFileToRequest(response.data.wrId, url));
+        });
+        await Promise.all(imagePromises);
+      }
+
+      // await this.addCommentToRequest(response.data.wrId, "Some Comment Test");
+
+      await this.addFileToRequest(
+        response.data.wrId,
+        "https://anglicare-prd-uploads.s3.ap-southeast-2.amazonaws.com/uploads/users/05c46825-636e-4397-a043-7a8ebfdb8b8f/public/79975be54c9dad01fd22210b00/serviceimage.jpeg"
+      );
+
+      return true;
+    } catch (e) {
+      log("Archibus:CreateRequest", "Error", e, logId);
+
+      // trigger another attempt
+      // editRef("maintenance", "id", request.id, {
+      //   ExtCreateRetry: moment().valueOf(),
+      // });
+    }
+    return false;
+  };
+
+  /**
+   * Fetches a request from the Archibus system
+   *
+   * @param {String} externalId - Id of the request on the Archibus
+   * @returns {Object} The request as it exists on Archibus
+   */
+  getRequest = async (externalId) => {
+    const logId = log("Archibus:GetRequest", "Start", externalId);
+    try {
+      const response = await axios({
+        method: "GET",
+        url: `${this.baseUrl}/getWorkRequest/${externalId}`,
+        timeout: 15000,
+        headers: {
+          [this.apiKeyHeader]: this.apiKey,
+          "Content-Type": "application/json",
+          Host: this.host,
+        },
+      });
+      log("Archibus:GetRequest", "Response", response.data, logId);
+
+      return response.data;
+    } catch (e) {
+      log("Archibus:GetRequest", "Error", e, logId);
+    }
+    return null;
+  };
+
+  /**
+   * Refreshes a request from the Archibus system
+   *
+   * @param {String} requestId - Id of the request on Pluss.
+   * @param {String} externalId - Id of the request on Archibus.
+   * @param {Object} trackedData - The set of fields tracked.
+   * @returns {Boolean} Whether the request had any changes on Archibus.
+   */
+  refreshFromSource = async (requestId, externalId, trackedData) => {
+    const logId = log("Archibus:RefreshFromSource", "Start", {
+      requestId,
+      externalId,
+      trackedData,
+    });
+    const request = await this.getRequest(externalId);
+    if (!request) {
+      log("Archibus:RefreshFromSource", "Result:NoResponse", false, logId);
+      return false;
+    }
+
+    if (trackedData && trackedData.status === request.status) {
+      log("Archibus:RefreshFromSource", "Result:UnchangedStatus", false, logId);
+      // status has not changed
+      return false;
+    }
+
+    const statusToUse = this.statusMap[request.status];
+    log("Archibus:RefreshFromSource", "UpdatedStatus", statusToUse, logId);
+
+    if (statusToUse) {
+      let plussRequest = await getRef("maintenance", "id", requestId);
+      // check how the new status map to what is saved in Pluss
+
+      if (statusToUse.Status !== plussRequest.status) {
+        // save updated status
+
+        plussRequest = await editRef("maintenance", "id", requestId, {
+          status: statusToUse.Status,
+        });
+        log(
+          "Archibus:RefreshFromSource",
+          "SavedStatus",
+          statusToUse.Status,
+          logId
+        );
+
+        if (statusToUse.Notification) {
+          publishNotifications(
+            [plussRequest.userID],
+            "MaintenanceJobStatusChanged",
+            plussRequest.site,
+            plussRequest.id,
+            plussRequest,
+            true
+          );
+        }
+      }
+    }
+
+    // save tracked data
+    await editRef(
+      "externalentities",
+      "RowId",
+      `${this.getEntityType()}_${externalId}`,
+      {
+        TrackedData: {
+          status: request.status,
+        },
+      }
+    );
+
+    log("Archibus:RefreshFromSource", "Result", true, logId);
+    return true;
+  };
+
+  /**
+   * Adds a comment to a request in Archibus
+   *
+   * @param {Number} externalId - Id of the request on Archibus.
+   * @param {String} comment - Text to add to Archibus request.
+   * @param {moment.Moment} time - The time to save against the comment
+   */
+  addCommentToRequest = async (externalId, comment, time) => {
+    const logId = log("Archibus:AddComment", "Start", {
+      externalId,
+      comment,
+      time,
+    });
+    try {
+      // Format the time
+      const timeToUse = (time || moment()).format("YYYY-MM-DD hh:mm:ss");
+
+      // Generate the POST data
+      const postData = {
+        actionTime: timeToUse,
+        comments: comment,
+        wr_id: externalId,
+      };
+
+      log("Archibus:AddComment", "PostData", postData, logId);
+
+      // Save to Archibus
+      const response = await axios({
+        method: "POST",
+        url: `${this.baseUrl}/addCommentsToWRSteps`,
+        data: postData,
+        timeout: 15000,
+        headers: {
+          [this.apiKeyHeader]: this.apiKey,
+          "Content-Type": "application/json",
+          Host: this.host,
+        },
+      });
+
+      log("Archibus:AddComment", "ResponseStatus", response.status, logId);
+
+      return response;
+    } catch (error) {
+      log("Archibus:AddComment", "Error", error, logId);
+    }
+    return false;
+  };
+
+  /**
+   * Adds a file to a request in Archibus
+   *
+   * @param {Number} externalId - Id of the request on Archibus.
+   * @param {String} fileUrl - URL of the file to attach
+   * @param {moment.Moment} time - The time to save against the file
+   * @returns
+   */
+  addFileToRequest = async (externalId, fileUrl, time) => {
+    const logId = log("Archibus:AddFile", "Start", {
+      externalId,
+      fileUrl,
+      time,
+    });
+
+    // This endpoint is not currently functional. Instead, use the addCommentToRequest method to add a comment with the file URL.
+    return this.addCommentToRequest(externalId, fileUrl, time);
+
+    try {
+      // Download the file content from the URL
+      const fileResponse = await axios.get(fileUrl, {
+        responseType: "arraybuffer",
+      });
+      log("Archibus:AddFile", "GotFileResponse", fileResponse.status, logId);
+
+      // Encode the file content in base64
+      const fileContentBase64 = encode(fileResponse.data);
+      log("Archibus:AddFile", "EncodedFileResponse", true, logId);
+
+      // Extract file name from the URL
+      const fileName = fileUrl.split("/").pop();
+
+      // Format the time
+      const timeToUse = (time || moment()).format("YYYY-MM-DD hh:mm:ss");
+
+      // Generate the POST data
+      const postData = {
+        actionTime: timeToUse,
+        docName: fileName,
+        docUrl: "https://anglicare.plusscommunities.com/",
+        fileContent: fileContentBase64,
+        fileName: fileName,
+        wrId: externalId,
+      };
+
+      log("Archibus:AddFile", "PostData", postData, logId);
+
+      // Save to Archibus
+      const response = await axios({
+        method: "POST",
+        url: `${this.baseUrl}/addDocumentToWorkRequest`,
+        data: postData,
+        timeout: 60000,
+        headers: {
+          [this.apiKeyHeader]: this.apiKey,
+          "Content-Type": "application/json",
+          Host: this.host,
+        },
+      });
+
+      log("Archibus:AddFile", "ResponseStatus", response.status, logId);
+
+      return response;
+    } catch (error) {
+      log("Archibus:AddFile", "Error", error, logId);
+    }
+    return false;
+  };
+
+  /**
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @returns {Boolean} Represents whether the actions were successful
+   */
+  onCompleteRequest = async (request) => {
+    const logId = log("Archibus:OnComplete", "Start", {
+      Id: request.id,
+    });
+    try {
+      // get external id
+      const externalEntityQuery = await indexQuery("externalentities", {
+        IndexName: "InternalIdIndex",
+        KeyConditionExpression:
+          "EntityType = :entityType AND InternalId = :internalId",
+        ExpressionAttributeValues: {
+          ":entityType": this.getEntityType(),
+          ":internalId": request.id,
+        },
+      });
+
+      log(
+        "Archibus:OnComplete",
+        "ExternalLength",
+        externalEntityQuery.Items.length,
+        logId
+      );
+      if (_.isEmpty(externalEntityQuery.Items)) {
+        return true;
+      }
+
+      const externalId = externalEntityQuery.Items[0].ExternalId;
+      log("Archibus:OnComplete", "ExternalId", externalId, logId);
+
+      // get comments
+      const commentsQuery = {
+        IndexName: "CommentsEntityIdIndex",
+        KeyConditionExpression: "EntityId = :groupId",
+        ExpressionAttributeValues: {
+          ":groupId": getRowId(request.id, "maintenance"),
+        },
+      };
+
+      const commentsQueryRes = await indexQuery("comments", commentsQuery);
+      const comments = commentsQueryRes.Items;
+      log("Archibus:OnComplete", "CommentsLength", comments.length, logId);
+
+      const promises = [];
+
+      // save history as a comment
+      if (!_.isEmpty(request.history)) {
+        const historyComment = _.map(request.history, (entry) => {
+          if (entry.EntryType === "assignment") {
+            return "";
+          }
+          const time = moment(Number.parseFloat(entry.timestamp + "")).format(
+            "D MMM YYYY HH:mm:ss"
+          );
+          const user = entry.user ? ` by ${entry.user.displayName}` : "";
+          return `${time}: Marked ${entry.status}${user}`;
+        }).join("\n");
+        promises.push(this.addCommentToRequest(externalId, historyComment));
+      }
+
+      // save history as a comment
+      if (!_.isEmpty(request.Notes)) {
+        // format comment to save
+        const notesComment = _.map(request.Notes, (entry) => {
+          const time = moment(Number.parseFloat(entry.Timestamp + "")).format(
+            "YYYY-MM-DD HH:mm:ss"
+          );
+          const user = entry.User ? entry.User.displayName : "Unknown User";
+          const note = entry.Note ? `Note: ${entry.Note}` : "No Note";
+          const attachments =
+            entry.Attachments && entry.Attachments.length > 0
+              ? `Attachments: ${entry.Attachments.map(
+                  (att) => `${att.Title} (${att.Source})`
+                ).join(", ")}`
+              : "No Attachments";
+          return `${time} by ${user}\n${note}\n${attachments}`;
+        }).join("\n\n");
+        // save comment
+        promises.push(this.addCommentToRequest(externalId, notesComment));
+      }
+
+      // save comments to Archibus
+      comments.forEach((comment) => {
+        const commentText = `${comment.User.displayName}:\n\n${
+          comment.Comment
+        }${!_.isEmpty(comment.Image) ? `\n\nImage: ${comment.Image}` : ""}}`;
+        const commentTime = moment(comment.Timestamp);
+        promises.push(
+          this.addCommentToRequest(externalId, commentText, commentTime)
+        );
+      });
+
+      await Promise.all(promises);
+
+      return true;
+    } catch (error) {
+      log("Archibus:OnComplete", "Error", error.toString(), logId);
+    }
+    return false;
+  };
+}
+
+module.exports = ArchibusStrategy;

package/integration/index.js

@@ -0,0 +1,22 @@
+const getString = require("@plusscommunities/pluss-core-aws/db/strings/getString");
+const { getRowId, log } = require("@plusscommunities/pluss-core-aws/helper");
+const ArchibusStrategy = require("./archibus/ArchibusStrategy");
+const IntegrationStrategy = require("./IntegrationStrategy");
+
+exports.getStrategy = async (site) => {
+  let importConfig;
+  const logId = log("getStrategy", "Site", site);
+  try {
+    importConfig = await getString(
+      getRowId(site, "maintenanceintegration"),
+      "plussSpace"
+    );
+
+    switch (importConfig.Strategy) {
+      case "Archibus":
+        return new ArchibusStrategy(importConfig);
+      default:
+        return new IntegrationStrategy();
+    }
+  } catch (e) {}
+};

package/jobChanged.js

@@ -2,9 +2,41 @@ const { Marshaller } = require("@aws/dynamodb-auto-marshaller");
 const config = require("./config.json");
 const { init } = require("@plusscommunities/pluss-core-aws/config");
 const logUpdate = require("@plusscommunities/pluss-core-aws/db/strings/logUpdate");
+const { getStrategy } = require("./integration");
+const { log } = require("@plusscommunities/pluss-core-aws/helper");
 
 const marshaller = new Marshaller();
 
+const pushRequestToIntegration = async (request) => {
+  const integrationStrategy = await getStrategy(request.site);
+  await integrationStrategy.createRequest(request);
+};
+
+const onCompletedRequest = async (request) => {
+  const integrationStrategy = await getStrategy(request.site);
+  await integrationStrategy.onCompleteRequest(request);
+};
+
+/**
+ * Checks for any necessary integration actions based on the change in the request data
+ * @param {Object} request The new request data
+ * @param {Object} prevRequest The previous request data
+ */
+const checkIntegrationActions = async (request, prevRequest) => {
+  if (
+    request.ExtCreateRetry &&
+    request.ExtCreateRetry !== prevRequest.ExtCreateRetry
+  ) {
+    log("checkIntegrationActions", "Retrying", true);
+    await pushRequestToIntegration(request);
+  }
+
+  if (request.status === "Completed" && prevRequest.status !== "Completed") {
+    log("checkIntegrationActions", "CompletedRequest", true);
+    await onCompletedRequest(request);
+  }
+};
+
 module.exports.jobChanged = (event, context, callback) => {
   init(config);
 
@@ -16,6 +48,8 @@ module.exports.jobChanged = (event, context, callback) => {
       console.log("Record: ", JSON.stringify(data));
 
       site = data.site;
+
+      pushRequestToIntegration(data);
     } else if (record.eventName == "MODIFY") {
       console.log("MODIFY");
       const data = marshaller.unmarshallItem(record.dynamodb.NewImage);
@@ -23,6 +57,8 @@ module.exports.jobChanged = (event, context, callback) => {
       console.log("New record: ", JSON.stringify(data));
       console.log("Old record: ", JSON.stringify(previousData));
 
+      checkIntegrationActions(data, previousData);
+
       site = data.site;
     } else if (record.eventName == "REMOVE") {
       console.log("REMOVE");

package/package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@plusscommunities/pluss-maintenance-aws",
-  "version": "2.0.2",
+  "version": "2.0.3-archibus.1",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -1468,9 +1468,9 @@
       }
     },
     "@plusscommunities/pluss-core-aws": {
-      "version": "2.0.7",
-      "resolved": "https://registry.npmjs.org/@plusscommunities/pluss-core-aws/-/pluss-core-aws-2.0.7.tgz",
-      "integrity": "sha512-YcBbnQbeeGWzR+j2O85Yzdo0n3oxlP9WoitPriXdY8VMnSG0TEAx6wOFHsFhCftJ2kxelm2Gzm3x7G6LeuGBPw==",
+      "version": "2.0.8-beta.0",
+      "resolved": "https://registry.npmjs.org/@plusscommunities/pluss-core-aws/-/pluss-core-aws-2.0.8-beta.0.tgz",
+      "integrity": "sha512-z3ToWOdOnqkOF3w3r8l+kUTQlVWi2763WCyXa7iME0BaIAkPQbf+3M+2AKeu+Nl8lkpNyrKLOu/tH5Gj91WfIQ==",
       "requires": {
         "@aws/dynamodb-auto-marshaller": "^0.7.1",
         "amazon-cognito-identity-js": "^2.0.19",
@@ -2045,6 +2045,11 @@
       "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
       "dev": true
     },
+    "base64-arraybuffer": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/base64-arraybuffer/-/base64-arraybuffer-1.0.2.tgz",
+      "integrity": "sha512-I3yl4r9QB5ZRY3XuJVEPfc2XhZO6YweFPI+UovAzn+8/hb3oJ6lnysaFcjVpkCPfVWFUDvoZ8kmVDP7WyRtYtQ=="
+    },
     "base64-js": {
       "version": "1.5.1",
       "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plusscommunities/pluss-maintenance-aws",
-  "version": "2.0.2",
+  "version": "2.0.3-archibus.1",
   "description": "Extension package to enable maintenance on Pluss Communities Platform",
   "scripts": {
     "gc": "node ../../tools/gc ./",
@@ -18,10 +18,11 @@
   "license": "ISC",
   "dependencies": {
     "@aws/dynamodb-auto-marshaller": "^0.7.1",
-    "@plusscommunities/pluss-core-aws": "2.0.7",
+    "@plusscommunities/pluss-core-aws": "2.0.8-beta.0",
     "amazon-cognito-identity-js": "^2.0.19",
-    "axios": "^1.6.8",
     "aws-sdk": "^2.1591.0",
+    "axios": "^1.6.8",
+    "base64-arraybuffer": "^1.0.2",
     "expo-server-sdk": "^3.0.1",
     "https": "^1.0.0",
     "lodash": "^4.17.10",
@@ -42,6 +43,8 @@
   },
   "files": [
     "db/*",
+    "integration/*",
+    "requests/*",
     "ticketing/*",
     "*.js",
     "package*.json"