@plusscommunities/pluss-maintenance-aws-forms 2.1.7-beta.0

package/getJobs.js

@@ -0,0 +1,63 @@
+const config = require("./config.json");
+const { init } = require("@plusscommunities/pluss-core-aws/config");
+const { getBody } = require("@plusscommunities/pluss-core-aws/helper");
+const generateJsonResponse = require("@plusscommunities/pluss-core-aws/helper/generateJsonResponse");
+const indexQuery = require("@plusscommunities/pluss-core-aws/db/common/indexQuery");
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const getSessionUser = require("@plusscommunities/pluss-core-aws/helper/auth/getSessionUser");
+const { values } = require("./values.config");
+
+module.exports.getJobs = async (event, context, callback) => {
+  init(config);
+  const data = getBody(event);
+
+  if (!data.site) {
+    return callback(
+      null,
+      generateJsonResponse(422, {
+        error: { message: "User Types fetch -- no site detected." },
+      })
+    );
+  }
+
+  try {
+    const authorised = await validateMasterAuth(
+      event,
+      values.permissionMaintenanceTracking
+    );
+    const userId = authorised
+      ? null
+      : await getSessionUser(event.headers.authkey);
+    console.log("getting jobs for user", userId);
+
+    const query = {
+      IndexName: "MaintenanceSiteIndex",
+      KeyConditionExpression: "site = :site",
+      ExpressionAttributeValues: {
+        ":site": data.site,
+      },
+    };
+
+    try {
+      const res = await indexQuery(values.tableNameMaintenance, query);
+      let jobs = userId
+        ? res.Items.filter((job) => job.userID === userId)
+        : res.Items;
+      if (data.status)
+        jobs = jobs.filter((j) => data.status.includes(j.status));
+      if (data.type) jobs = jobs.filter((j) => data.type.includes(j.type));
+      console.log("jobs count", jobs?.length);
+      return callback(null, generateJsonResponse(200, jobs));
+    } catch (error1) {
+      return callback(
+        null,
+        generateJsonResponse(200, {
+          userFetchFail: true,
+          message: "Fail on user query. Please try again.",
+        })
+      );
+    }
+  } catch (error) {
+    callback(null, generateJsonResponse(422, { fail: true, error }));
+  }
+};

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,463 @@
+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");
+const { values } = require("../../values.config");
+
+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 `${values.serviceKey}_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|1. MAINTENANCE",
+          requestor: "PLUSS",
+          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: "2025", //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(values.tableNameMaintenance, "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);
+      }
+
+      return true;
+    } catch (e) {
+      log("Archibus:CreateRequest", "Error", e, logId);
+    }
+    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(
+        values.tableNameMaintenance,
+        "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(
+          values.tableNameMaintenance,
+          "id",
+          requestId,
+          {
+            status: statusToUse.Status,
+          }
+        );
+        log(
+          "Archibus:RefreshFromSource",
+          "SavedStatus",
+          statusToUse.Status,
+          logId
+        );
+
+        if (statusToUse.Notification) {
+          publishNotifications(
+            [plussRequest.userID],
+            values.activityMaintenanceJobStatusChanged,
+            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, values.serviceKey),
+        },
+      };
+
+      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";
+          if (!_.isEmpty(entry.Attachments)) {
+            entry.Attachments.forEach((att) => {
+              promises.push(this.addFileToRequest(externalId, att.Source));
+            });
+          }
+          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,23 @@
+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");
+const { values } = require("../values.config");
+
+exports.getStrategy = async (site) => {
+  let importConfig;
+  const logId = log("getStrategy", "Site", site);
+  try {
+    importConfig = await getString(
+      getRowId(site, `${values.serviceKey}integration`),
+      "plussSpace"
+    );
+
+    switch (importConfig.Strategy) {
+      case "Archibus":
+        return new ArchibusStrategy(importConfig);
+      default:
+        return new IntegrationStrategy();
+    }
+  } catch (e) {}
+};

package/jobChanged.js

@@ -0,0 +1,73 @@
+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 { values } = require("./values.config");
+
+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);
+
+  event.Records.forEach((record) => {
+    let site;
+    if (record.eventName == "INSERT") {
+      console.log("INSERT");
+      const data = marshaller.unmarshallItem(record.dynamodb.NewImage);
+      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);
+      const previousData = marshaller.unmarshallItem(record.dynamodb.OldImage);
+      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");
+      const previousData = marshaller.unmarshallItem(record.dynamodb.OldImage);
+      console.log("Old record: ", JSON.stringify(previousData));
+
+      site = previousData.site;
+    }
+    logUpdate(site, values.updateKey);
+  });
+};