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

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@plusscommunities/pluss-maintenance-aws-forms",
+  "version": "2.1.7-beta.0",
+  "description": "Extension package to enable maintenance on Pluss Communities Platform",
+  "scripts": {
+    "gc": "node ../../tools/gc ./",
+    "gs": "node ../../tools/gs ./ ../../activity/serverless.yml",
+    "betapatch": "npm version prepatch --preid=beta",
+    "patch": "npm version patch",
+    "deploy": "npm run gc && npm run gs && serverless deploy",
+    "betaupload": "rm -rf .serverless && npm i && npm publish --access public --tag beta",
+    "betaupload:p": "npm run betapatch && npm run betaupload",
+    "upload": "rm -rf .serverless && npm i && npm publish --access public",
+    "upload:p": "npm run patch && npm run upload",
+    "copy:add": "run(){ ext=${1:-default}; test -f values.config.$ext.js || cp values.config.default.js values.config.$ext.js; }; run",
+    "copy:get": "echo $npm_package_name",
+    "copy:set": "run(){ target='\\@plusscommunities\\/pluss-maintenance-aws'; ext=${1:-default}; [ $ext == 'default' ] && replace=$target || replace=$target'-'$ext; echo 'Setting target to '$replace; test -f values.config.$ext.js && cp -f values.config.$ext.js values.config.js; sed -i '' -e 's/'$target'.*\"/'$replace'\"/g' package.json; }; run",
+    "copy:deploy": "for file in `ls ./values.config.*.js`; do dup=`echo $file | sed 's/.*values\\.config\\.\\(.*\\)\\.js/\\1/'`; npm run copy:set $dup; npm run deploy; done; npm run copy:set; npm run gs;",
+    "copy:betaupload": "npm run betapatch; for file in `ls ./values.config.*.js`; do dup=`echo $file | sed 's/.*values\\.config\\.\\(.*\\)\\.js/\\1/'`; npm run copy:set $dup; npm run betaupload; done; npm run copy:set;",
+    "copy:upload": "npm run patch; for file in `ls ./values.config.*.js`; do dup=`echo $file | sed 's/.*values\\.config\\.\\(.*\\)\\.js/\\1/'`; npm run copy:set $dup; npm run upload; done; npm run copy:set;",
+    "test": "jest tests -i"
+  },
+  "author": "Thorbjorn Kappel Davis",
+  "license": "ISC",
+  "dependencies": {
+    "@aws/dynamodb-auto-marshaller": "^0.7.1",
+    "@plusscommunities/pluss-core-aws": "2.0.16-beta.0",
+    "amazon-cognito-identity-js": "^2.0.19",
+    "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",
+    "moment": "^2.30.1",
+    "node-fetch": "^2.2.0",
+    "node-jose": "^1.0.0",
+    "nodemailer": "^6.9.12",
+    "twilio": "^3.18.0",
+    "uuid": "^2.0.3"
+  },
+  "devDependencies": {
+    "@types/jest": "^26.0.23",
+    "eslint-config-rallycoding": "^3.2.0",
+    "jest": "^29.0.0",
+    "jest-aws-sdk-mock": "^1.0.2",
+    "serverless-domain-manager": "^3.3.1",
+    "serverless-prune-plugin": "^1.4.1"
+  },
+  "files": [
+    "db/*",
+    "integration/*",
+    "requests/*",
+    "ticketing/*",
+    "*.js",
+    "package*.json"
+  ],
+  "jest": {
+    "rootDir": "./",
+    "moduleNameMapper": {
+      "^./testing/(.*)$": "<rootDir>/testing/$1"
+    }
+  }
+}

package/requests/assignRequest.js

@@ -0,0 +1,106 @@
+const moment = require("moment");
+const editRef = require("@plusscommunities/pluss-core-aws/db/common/editRef");
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const getUserPreviewFromReq = require("@plusscommunities/pluss-core-aws/helper/getUserPreviewFromReq");
+const getRef = require("@plusscommunities/pluss-core-aws/db/common/getRef");
+const isValidAssignee = require("./helper/isValidAssignee");
+const getUserPreview = require("@plusscommunities/pluss-core-aws/helper/getUserPreview");
+const { log } = require("@plusscommunities/pluss-core-aws/helper");
+const publishNotifications = require("@plusscommunities/pluss-core-aws/db/notifications/publishNotifications");
+const { values } = require("../values.config");
+
+module.exports = async (event, data) => {
+  const logId = log("assignRequest", "data", data);
+  // check required data
+  const requiredKeys = ["id", "userId"];
+  if (!data || requiredKeys.some((prop) => !data.hasOwnProperty(prop))) {
+    log("assignRequest", "InsufficientInput", 422, logId);
+    return { status: 422, data: { error: "Insufficient input" } };
+  }
+
+  const request = await getRef(values.tableNameMaintenance, "id", data.id);
+  log("assignRequest", "request", request, logId);
+  log("assignRequest", "site", request.site, logId);
+
+  // validate authorisation
+  const valid = await validateMasterAuth(
+    event,
+    values.permissionMaintenanceTracking,
+    request.site
+  );
+  log("assignRequest", "valid", valid, logId);
+  if (!valid) {
+    const validAssignee = await isValidAssignee(
+      event,
+      request.site,
+      request.AssigneeId
+    );
+    log("assignRequest", "validAssignee", validAssignee, logId);
+    if (!validAssignee) {
+      log("assignRequest", "NotAuthorised", 403, logId);
+      return { status: 403, data: { error: "Not authorised" } };
+    }
+  }
+
+  const user = await getUserPreviewFromReq(event);
+  log("assignRequest", "user", user, logId);
+  const assignedUser = await getUserPreview(data.userId);
+  log("assignRequest", "assignedUser", assignedUser, logId);
+
+  const changes = {
+    history: request.history || [],
+  };
+
+  // Update history
+  changes.history.push({
+    timestamp: moment.utc().valueOf(),
+    EntryType: "assignment",
+    user,
+    assignedUser,
+  });
+
+  changes.AssigneeId = data.userId;
+  changes.Assignee = assignedUser;
+
+  log("assignRequest", "changes", changes, logId);
+
+  const result = await editRef(
+    values.tableNameMaintenance,
+    "id",
+    data.id,
+    changes
+  );
+
+  log("assignRequest", "result", result, logId);
+
+  // send notification to assigned user
+  if (user.id !== assignedUser.id) {
+    await publishNotifications(
+      [assignedUser.id],
+      values.notificationMaintenanceJobAssigned,
+      result.site,
+      result.id,
+      result,
+      true
+    );
+  }
+
+  // send notification to previous assignee
+  if (request.AssigneeId && result.AssigneeId !== request.AssigneeId) {
+    await publishNotifications(
+      [request.AssigneeId],
+      values.notificationMaintenanceJobUnassigned,
+      result.site,
+      result.id,
+      result,
+      true
+    );
+  }
+
+  return {
+    status: 200,
+    data: {
+      job: result,
+    },
+  };
+};

package/requests/getAssignees.js

@@ -0,0 +1,40 @@
+const { log } = require("@plusscommunities/pluss-core-aws/helper");
+const getUsersByPermission = require("@plusscommunities/pluss-core-aws/helper/users/getUsersByPermission");
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const { values } = require("../values.config");
+
+// Define the new function to get assignees
+module.exports = async (event) => {
+  const qParams = event.queryStringParameters || {};
+  const logId = log("getAssignees", "Input", qParams);
+
+  const isAdmin = await validateMasterAuth(
+    event,
+    values.permissionMaintenanceTracking,
+    qParams.site
+  );
+  const isAssignee = await validateMasterAuth(
+    event,
+    values.permissionMaintenanceAssignment,
+    qParams.site
+  );
+
+  const valid = isAdmin || isAssignee;
+  log("getRequests", "valid", valid, logId);
+  if (!valid) {
+    return { status: 403, data: { error: "Not authorised" } };
+  }
+
+  // get assignees
+  const assignees = await getUsersByPermission(qParams.site, [
+    values.permissionMaintenanceTracking,
+    values.permissionMaintenanceAssignment,
+  ]);
+
+  log("getAssignees", "AssigneesLength", assignees.length, logId);
+
+  // compile results
+  const results = { Users: assignees };
+  log("getAssignees", "Done", true, logId);
+  return { status: 200, data: results };
+};

package/requests/getRequest.js

@@ -0,0 +1,89 @@
+const { log, getRowId } = require("@plusscommunities/pluss-core-aws/helper");
+const getRef = require("@plusscommunities/pluss-core-aws/db/common/getRef");
+const indexQuery = require("@plusscommunities/pluss-core-aws/db/common/indexQuery");
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const isValidAssignee = require("./helper/isValidAssignee");
+const getSessionUserFromReqAuthKey = require("@plusscommunities/pluss-core-aws/helper/auth/getSessionUserFromReqAuthKey");
+const { values } = require("../values.config");
+
+module.exports = async (event, params) => {
+  const data = params || event.queryStringParameters;
+  const logId = log("getRequest", "Params", data);
+  if (!data.id && (!data.site || !data.jobId)) {
+    return {
+      status: 422,
+      data: {
+        error: "Insufficient input",
+      },
+    };
+  }
+
+  try {
+    let result = null;
+    if (data.jobId) {
+      const query = {
+        IndexName: "MaintenanceSiteJobIdIndex",
+        KeyConditionExpression: "site = :site and jobId = :jobId",
+        ExpressionAttributeValues: {
+          ":site": data.site,
+          ":jobId": data.jobId,
+        },
+      };
+      const { Items } = await indexQuery(values.tableNameMaintenance, query);
+      result = Items[0];
+    }
+    if (!result) {
+      result = await getRef(
+        values.tableNameMaintenance,
+        "id",
+        data.id || data.jobId
+      );
+    }
+
+    const authorised = await validateMasterAuth(
+      event,
+      values.permissionMaintenanceTracking,
+      result.site
+    );
+    const assignAuthorised = await isValidAssignee(
+      event,
+      result.site,
+      result.AssigneeId
+    );
+    if (!authorised && !assignAuthorised) {
+      // Check if the job belongs to the user
+      const userId = await getSessionUserFromReqAuthKey(event);
+      if (userId !== result.userID) {
+        return {
+          status: 403,
+          data: {
+            error: "Not authorised",
+          },
+        };
+      }
+    }
+    if (data.includeComments) {
+      const commentsQuery = {
+        IndexName: "CommentsEntityIdIndex",
+        KeyConditionExpression: "EntityId = :groupId",
+        ExpressionAttributeValues: {
+          ":groupId": getRowId(result.id, values.entityKey),
+        },
+      };
+      const commentsData = await indexQuery("comments", commentsQuery);
+      result.Comments = commentsData.Items;
+    }
+    return {
+      status: 200,
+      data: result,
+    };
+  } catch (error) {
+    log("getRequest", "Error", error.toString(), logId);
+  }
+  return {
+    status: 500,
+    data: {
+      error: "Internal error",
+    },
+  };
+};

package/requests/getRequests.js

@@ -0,0 +1,100 @@
+const { log } = require("@plusscommunities/pluss-core-aws/helper");
+const getSessionUserFromReqAuthKey = require("@plusscommunities/pluss-core-aws/helper/auth/getSessionUserFromReqAuthKey");
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const validateSiteAccess = require("@plusscommunities/pluss-core-aws/helper/auth/validateSiteAccess");
+const indexQuery = require("@plusscommunities/pluss-core-aws/db/common/indexQuery");
+const { values } = require("../values.config");
+
+module.exports = async (event) => {
+  const qParams = event.queryStringParameters;
+  const logId = log("getRequests", "Params", qParams);
+
+  // insufficient input
+  if (!qParams.site) {
+    return { status: 422, data: { error: "Insufficient input" } };
+  }
+  log("getRequests", "SufficientInput", true, logId);
+
+  // no access to site
+  const valid = await validateSiteAccess(event, qParams.site);
+  log("getRequests", "valid", valid, logId);
+  if (!valid) {
+    return { status: 403, data: { error: "Not authorised" } };
+  }
+
+  // check auth level to determine whether to fetch all requests or only matching requests
+  const authorised = await validateMasterAuth(
+    event,
+    values.permissionMaintenanceTracking,
+    qParams.site
+  );
+  let assigneeTracking = false;
+  if (!authorised) {
+    assigneeTracking = await validateMasterAuth(
+      event,
+      values.permissionMaintenanceAssignment,
+      qParams.site
+    );
+  }
+
+  log("getRequests", "authorised", authorised, logId);
+  const userId = authorised ? null : await getSessionUserFromReqAuthKey(event);
+
+  log("getRequests", "userId", userId, logId);
+
+  const query =
+    authorised || assigneeTracking
+      ? {
+          IndexName: "MaintenanceSiteIndex",
+          KeyConditionExpression: "site = :site",
+          ExpressionAttributeValues: {
+            ":site": qParams.site,
+          },
+        }
+      : {
+          IndexName: "MaintenanceSiteUserIdIndex",
+          KeyConditionExpression: "site = :site AND userID = :userId",
+          ExpressionAttributeValues: {
+            ":site": qParams.site,
+            ":userId": userId,
+          },
+        };
+  log("getRequests", "query", query, logId);
+
+  // check whether pagination is applied
+  if (qParams.lastKey) {
+    try {
+      query.ExclusiveStartKey = JSON.parse(qParams.lastKey);
+    } catch (e) {}
+  }
+
+  // get jobs
+  const result = await indexQuery(values.tableNameMaintenance, query);
+  let jobs = result.Items;
+
+  log("getRequests", "LastEvaluatedKey", result.LastEvaluatedKey, logId);
+  log("getRequests", "JobsLength", jobs.length, logId);
+
+  // filter on status
+  if (qParams.status) {
+    jobs = jobs.filter((j) => qParams.status.includes(j.status));
+    log("getRequests", "FilteredOnStatus", jobs.length, logId);
+  }
+
+  // filter on type
+  if (qParams.type) {
+    jobs = jobs.filter((j) => qParams.type.includes(j.type));
+    log("getRequests", "FilteredOnType", jobs.length, logId);
+  }
+
+  // filter to assigned jobs
+  if (!authorised && assigneeTracking) {
+    jobs = jobs.filter((j) => j.AssigneeId === userId || j.userID === userId);
+    log("getRequests", "FilteredOnAssignee", jobs.length, logId);
+  }
+
+  // compile results
+  const results = { Items: jobs, LastKey: result.LastEvaluatedKey };
+  log("getRequests", "Done", true, logId);
+  return { status: 200, data: results };
+};

package/requests/helper/hasRequestPermission.js

@@ -0,0 +1,25 @@
+/**
+ * Checks if the request has permission.
+ *
+ * @param {Object} event - The api request object.
+ * @param {Object} job - The job object.
+ * @returns {Promise<boolean>} - A promise that resolves to a boolean indicating if the request has permission.
+ */
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const isValidAssignee = require("./isValidAssignee");
+const { values } = require("../../values.config");
+
+module.exports = async (event, job) => {
+  const valid = await validateMasterAuth(
+    event,
+    values.permissionMaintenanceTracking,
+    job.site
+  );
+  if (valid) {
+    return true;
+  }
+  if (!job.AssigneeId) {
+    return false;
+  }
+  return await isValidAssignee(event, job.site, job.AssigneeId);
+};

package/requests/helper/isValidAssignee.js

@@ -0,0 +1,23 @@
+const getSessionUserFromReqAuthKey = require("@plusscommunities/pluss-core-aws/helper/auth/getSessionUserFromReqAuthKey");
+const validateMasterAuth = require("@plusscommunities/pluss-core-aws/helper/auth/validateMasterAuth");
+const { values } = require("../../values.config");
+
+/**
+ * Checks whether the logged in user is the assignee as has the assignment permission for that site
+ * @param {*} event A request including headers
+ * @param {String} site A site id
+ * @param {String} userId A user id to check for
+ * @returns {Boolean} true if valid
+ */
+module.exports = async (event, site, userId) => {
+  const valid = await validateMasterAuth(
+    event,
+    values.permissionMaintenanceAssignment,
+    site
+  );
+  if (!valid) {
+    return false;
+  }
+  const loggedInUser = await getSessionUserFromReqAuthKey(event);
+  return loggedInUser === userId;
+};

package/scheduleJobImport.js

@@ -0,0 +1,81 @@
+const indexQuery = require("@plusscommunities/pluss-core-aws/db/common/indexQuery");
+const editRef = require("@plusscommunities/pluss-core-aws/db/common/editRef");
+const moment = require("moment");
+const { getStrategy } = require("./integration");
+const { log } = require("@plusscommunities/pluss-core-aws/helper");
+
+const processSingle = async (strategy, item) => {
+  // use IDs to refresh request data
+  const logId = log("processSingle", "RefreshFromSource", item.ExternalId);
+
+  // refresh from external source
+  await strategy.refreshFromSource(
+    item.InternalId,
+    item.ExternalId,
+    item.TrackedData
+  );
+
+  // save updated timestamp
+  await editRef("externalentities", "RowId", item.RowId, {
+    LastUpdated: moment().valueOf(),
+  });
+
+  log("processBatch", "Refreshed", item.ExternalId, logId);
+  return true;
+};
+
+const processBatch = async (strategy, startTime) => {
+  const logId = log("processBatch", "StartTime", moment().valueOf());
+
+  // use index query to fetch IDs of requests
+  const query = {
+    IndexName: "EntityTypeIndex",
+    KeyConditionExpression:
+      "EntityType = :entityType AND LastUpdated < :lastUpdate", // only fetch items that haven't been updated in this scan
+    ExpressionAttributeValues: {
+      ":entityType": strategy.getEntityType(),
+      ":lastUpdate": startTime - strategy.getRefreshInterval(),
+    },
+    Limit: 10,
+    ScanIndexForward: false,
+  };
+  const { Items } = await indexQuery("externalentities", query);
+
+  const promises = [];
+
+  Items.forEach((item) => {
+    log("processBatch", "ProcessSingle", JSON.stringify(item), logId);
+    promises.push(processSingle(strategy, JSON.parse(JSON.stringify(item))));
+  });
+
+  await Promise.all(promises);
+  log("processBatch", "EndOfBatch", Items.length, logId);
+  return Items.length;
+};
+
+module.exports.scheduleJobImport = async (event, context, callback) => {
+  const logId = log("scheduleJobImport", "Start", true);
+  // get active integration
+  const integrationStrategy = await getStrategy("plussSpace");
+  if (!integrationStrategy.isValidIntegration()) {
+    log("scheduleJobImport", "Exit", "No valid integration", logId);
+    return;
+  }
+
+  const startTime = moment().valueOf();
+  const timeout = 3 * 60 * 1000; // 3 minutes
+  let noneToProcess = false;
+  log("scheduleJobImport", "StartTime", startTime, logId);
+
+  while (!noneToProcess && moment().valueOf() < startTime + timeout) {
+    const logId = log("scheduleJobImport", "StartLoop", moment().valueOf());
+    const count = await processBatch(integrationStrategy, startTime);
+    log("scheduleJobImport", "Count", count, logId);
+    if (!count) {
+      log("scheduleJobImport", "noneToProcess", true, logId);
+      noneToProcess = true;
+    }
+    log("scheduleJobImport", "EndLoop", moment().valueOf(), logId);
+  }
+  log("scheduleJobImport", "End", moment().valueOf(), logId);
+};

package/sendJobEmail.js

@@ -0,0 +1,153 @@
+const _ = require("lodash");
+const moment = require("moment");
+const getJobEmail = require("./db/maintenance/getJobEmail");
+const sendEmail = require("@plusscommunities/pluss-core-aws/helper/sendEmail");
+const getRef = require("@plusscommunities/pluss-core-aws/db/common/getRef");
+const { values } = require("./values.config");
+
+module.exports = function (job, updated) {
+  const whenEvs = job.isHome
+    ? "Yes - I would like to be present"
+    : "No - Work may be done while I am not home.";
+
+  getRef("sites", "Id", job.site || job.location)
+    .then((site) => {
+      const siteToUse = site ? site.siteName : job.site || job.location;
+      const { customFields } = job;
+      const hasCustomFields = customFields && customFields.length > 0;
+
+      const renderCommon = () => `
+        <p>
+          <b>${values.textJobEmailTitle} ${job.id != null ? `#${job.id}` : ""}${
+        updated ? "-DETAILS EDITED- " : " "
+      }(${job.type}):</b> ${job.room}
+        </p>
+        <div>
+            <b>Title: </b>${job.title}
+        </div>  
+        <p>Client Details:</p>
+        <div>
+            <b>Name: </b>${job.userName}
+        </div>  
+        <div>
+            <b>Phone: </b>${job.phone || ""}
+        </div> 
+        <div>
+            <b>Location: </b>${siteToUse} <br /><br />
+        </div>   
+        <div>
+            <b>Address: </b>${job.room} <br /><br />
+        </div>
+      `;
+      const renderImages = () => {
+        let inner = "";
+        if (!_.isNil(job.images)) {
+          inner = job.images.map(
+            (image) => `<img style="max-height: 400px" src="${image}" />`
+          );
+        } else if (!_.isNil(job.image)) {
+          inner = `<img style="max-height: 400px" src="${job.image}" />`;
+        }
+        return _.isEmpty(inner) ? "" : `<div>${inner}</div>`;
+      };
+      const renderNonCustom = () => `
+          <div>
+              <b>Person Present During Service: </b>${whenEvs} 
+              <div>
+                  ${job.isHome ? job.homeText : ""}
+                  <br /><br />
+              </div>
+          </div>  
+          <div>
+              <b>${job.type} Description: </b>
+          </div>
+          <div>
+              ${job.description || ""}
+          </div>
+          ${renderImages()}
+      `;
+      const renderCustom = () => {
+        const renderAnswer = (field) => {
+          switch (field.type) {
+            case "date":
+              return field.answer
+                ? moment(field.answer, "YYYY-MM-DD").format("DD MMM YYYY")
+                : "";
+            case "time":
+              return field.answer
+                ? moment(field.answer, "HH:mm").format("h:mm a")
+                : "";
+            case "yn":
+              return field.answer ? "Yes" : "No";
+            case "checkbox":
+              return field.answer && Array.isArray(field.answer)
+                ? field.answer.join(", ")
+                : "";
+            case "image":
+              return field.answer && Array.isArray(field.answer)
+                ? `<br>${field.answer.map(
+                    (image) =>
+                      `<img style="max-height: 400px" src="${image}" />`
+                  )}`
+                : "";
+            default:
+              return field.answer;
+          }
+        };
+
+        return customFields
+          .filter((f) => !["staticTitle", "staticText"].includes(f.type))
+          .map((field) => {
+            return `
+            <div>
+              <b>${field.label}: </b>${renderAnswer(field)}
+            </div>
+          `;
+          })
+          .join("\n");
+      };
+
+      const htmlString = `
+        <div>
+          ${renderCommon()}
+          ${hasCustomFields ? renderCustom() : renderNonCustom()}          
+        </div>
+      `;
+
+      getJobEmail(job.site || job.location, job.type)
+        .then((obj) => {
+          const email = obj.email;
+          if (_.isEmpty(email)) {
+            return;
+          }
+
+          sendEmail(
+            email,
+            `${values.textJobEmailTitle} #${job.id}${
+              updated ? " -DETAILS EDITED" : ""
+            }- (${job.type}) - ${job.room}`,
+            htmlString
+          )
+            .then((result) => {
+              console.log(
+                `SUCCESS - Maintenance email --> ${job.type}, ${job.userName}`
+              );
+            })
+            .catch((error) => {
+              console.log(
+                `FAIL - Maintenance email --> ${job.type}, ${job.userName}`
+              );
+            });
+        })
+        .catch(() => {
+          console.log(
+            `FAIL - Maintenance email - fetch email address --> ${job.type}, ${job.userName}`
+          );
+        });
+    })
+    .catch(() => {
+      console.log(
+        `FAIL - Maintenance email - fetch site --> ${job.site || job.location}`
+      );
+    });
+};