@plusscommunities/pluss-maintenance-aws-feedback 2.1.15-beta.1

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,50 @@
+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's status has changed
+  onStatusChanged = async (request) => {
+    return null;
+  };
+
+  // actions taken when a comment has been added to a request
+  onCommentAdded = async (request) => {
+    return null;
+  };
+
+  // actions taken when a note has been added to a request
+  onNotesAdded = async (request) => {
+    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,591 @@
+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 getString = require("@plusscommunities/pluss-core-aws/db/strings/getString");
+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;
+    this.siteMap = config.SiteMap ?? {};
+    this.buildingCodes = [];
+  }
+
+  /**
+   * 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
+   * @param {Object} mockResponse - Mock response from Archibus to simulate response
+   * @returns {Boolean} Whether the request was created on Archibus
+   */
+  createRequest = async (request, mockResponse = null) => {
+    const logId = log("Archibus:CreateRequest", "Start", request);
+
+    let siteId = this.siteMap[request.site];
+    let buildingCode = null;
+    if (request.room) {
+      if (this.buildingCodes.length === 0) {
+        this.buildingCodes = await getString(
+          getRowId(request.site, `${values.serviceKey}buildingcodes`),
+          "plussSpace"
+        );
+      }
+      const building = this.buildingCodes.find((b) => {
+        const address = request.room.toLowerCase();
+        const search = b.SearchString.toLowerCase();
+        const name = b.BuildingName.toLowerCase();
+        return address.includes(search) || address.includes(name);
+      });
+
+      if (building?.SiteCode) siteId = building.SiteCode.toString();
+      buildingCode = building?.BuildingCode;
+    }
+    if (!siteId) return false;
+
+    try {
+      const 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: siteId,
+      };
+      if (buildingCode) data.bl_id = buildingCode;
+      log("Archibus:CreateRequest", "Request", data, logId);
+
+      const response =
+        mockResponse ??
+        (await axios({
+          method: "PUT",
+          url: `${this.baseUrl}/createWorkRequest`,
+          timeout: 30000,
+          headers: {
+            [this.apiKeyHeader]: this.apiKey,
+            "Content-Type": "application/json",
+            Host: this.host,
+          },
+          data,
+        }));
+      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 (!mockResponse && !_.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: 30000,
+        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: 30000,
+        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;
+  };
+
+  /**
+   * Get Archibus Id of the request
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @returns {Number} Id of the request on Archibus (null if not exists)
+   */
+  getExternalId = async (request) => {
+    const logId = log("Archibus:GetExternalId", "Start", { Id: request.id });
+
+    // 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:GetExternalId",
+      "ExternalLength",
+      externalEntityQuery.Items.length,
+      logId
+    );
+    if (_.isEmpty(externalEntityQuery.Items)) {
+      return null;
+    }
+
+    const externalId = externalEntityQuery.Items[0].ExternalId;
+    log("Archibus:GetExternalId", "ExternalId", externalId, logId);
+
+    return externalId;
+  };
+
+  /**
+   * Get latest comment for a request
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @param {String} entityKey - Request entity key (e.g. maintenancerequest)
+   * @returns {Object} Latest comment (null if not exists)
+   */
+  getLatestComment = async (request, entityKey) => {
+    const logId = log("Archibus:GetLatestComment", "Start", { Id: request.id });
+
+    // get comments
+    const commentsQuery = {
+      IndexName: "CommentsEntityIdIndex",
+      KeyConditionExpression: "EntityId = :groupId",
+      ExpressionAttributeValues: {
+        ":groupId": getRowId(request.id, entityKey),
+      },
+    };
+
+    const commentsQueryRes = await indexQuery("comments", commentsQuery);
+    const comments = _.orderBy(commentsQueryRes.Items, "Timestamp", "desc");
+    log(
+      "Archibus:GetLatestComment",
+      `CommentsLength - ${entityKey}`,
+      comments.length,
+      logId
+    );
+
+    return comments.length > 0 ? comments[0] : null;
+  };
+
+  /**
+   * Perform actions when a task's status has changed
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @returns {Boolean} Represents whether the actions were successful
+   */
+  onStatusChanged = async (request) => {
+    const logId = log("Archibus:OnStatusChanged", "Start", { Id: request.id });
+
+    try {
+      const externalId = await this.getExternalId(request);
+      if (_.isNil(externalId)) return true;
+
+      const statues = _.orderBy(
+        (request.history ?? []).filter(
+          (entry) => entry.EntryType !== "assignment"
+        ),
+        "timestamp",
+        "desc"
+      );
+      const latest = statues.length > 0 ? statues[0] : null;
+
+      if (latest) {
+        const time = moment(Number.parseFloat(latest.timestamp + "")).format(
+          "D MMM YYYY HH:mm:ss"
+        );
+        const user = latest.user ? ` by ${latest.user.displayName}` : "";
+        const comment = `${time}: Marked ${latest.status}${user}`;
+        await this.addCommentToRequest(externalId, comment);
+      }
+
+      return true;
+    } catch (error) {
+      log("Archibus:OnStatusChanged", "Error", error.toString(), logId);
+    }
+    return false;
+  };
+
+  /**
+   * Perform actions when a a comment has been added to a task
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @returns {Boolean} Represents whether the actions were successful
+   */
+  onCommentAdded = async (request) => {
+    const logId = log("Archibus:OnCommentAdded", "Start", {
+      Id: request.id,
+    });
+
+    try {
+      const externalId = await this.getExternalId(request);
+      if (_.isNil(externalId)) return true;
+
+      let comment = await this.getLatestComment(request, values.serviceKey);
+      if (!comment)
+        comment = await this.getLatestComment(request, values.entityKey);
+
+      if (comment) {
+        const commentText = `${comment.User.displayName}:\n\n${
+          comment.Comment
+        }${!_.isEmpty(comment.Image) ? `\n\nImage: ${comment.Image}` : ""}}`;
+        const commentTime = moment(comment.Timestamp);
+        await this.addCommentToRequest(externalId, commentText, commentTime);
+      }
+
+      return true;
+    } catch (error) {
+      log("Archibus:OnCommentAdded", "Error", error.toString(), logId);
+    }
+    return false;
+  };
+
+  /**
+   * Perform actions when a note has been added to a task
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @returns {Boolean} Represents whether the actions were successful
+   */
+  onNotesAdded = async (request) => {
+    const logId = log("Archibus:OnNotesAdded", "Start", { Id: request.id });
+
+    try {
+      const externalId = await this.getExternalId(request);
+      if (_.isNil(externalId)) return true;
+
+      const notes = _.orderBy(request.Notes ?? [], "Timestamp", "desc");
+      const latest = notes.length > 0 ? notes[0] : null;
+
+      if (latest) {
+        const promises = [];
+
+        const time = moment(Number.parseFloat(latest.Timestamp + "")).format(
+          "YYYY-MM-DD HH:mm:ss"
+        );
+        const user = latest.User ? latest.User.displayName : "Unknown User";
+        const note = latest.Note ? `Note: ${latest.Note}` : "No Note";
+        if (!_.isEmpty(latest.Attachments)) {
+          latest.Attachments.forEach((att) => {
+            promises.push(this.addFileToRequest(externalId, att.Source));
+          });
+        }
+        const attachments =
+          latest.Attachments && latest.Attachments.length > 0
+            ? `Attachments: ${latest.Attachments.map(
+                (att) => `${att.Title} (${att.Source})`
+              ).join(", ")}`
+            : "No Attachments";
+        if (!_.isEmpty(latest.Images)) {
+          latest.Images.forEach((image) => {
+            promises.push(this.addFileToRequest(externalId, image));
+          });
+        }
+        const images =
+          latest.Images && latest.Images.length > 0
+            ? `Images: ${latest.Images.map((image) => image).join(", ")}`
+            : "No Images";
+        const comment = `${time} by ${user}\n${note}\n${attachments}\n${images}`;
+        promises.push(this.addCommentToRequest(externalId, comment));
+
+        await Promise.all(promises);
+      }
+
+      return true;
+    } catch (error) {
+      log("Archibus:OnNotesAdded", "Error", error.toString(), logId);
+    }
+    return false;
+  };
+
+  /**
+   * Perform completion actions when a task is completed
+   *
+   * @param {Object} request - Request definition on Pluss
+   * @returns {Boolean} Represents whether the actions were successful
+   */
+  onCompleteRequest = async (request) => {
+    return true;
+  };
+}
+
+module.exports = ArchibusStrategy;