dce-expresskit 4.0.0 → 4.2.0

package/src/helpers/genRouteHandler.ts

@@ -19,9 +19,7 @@ import {
 import { getLaunchInfo } from 'caccl/server';
 
 // Import caccl functions
-import {
-  internalGetLogCollection,
-} from './initServer';
+import initExpressKitCollections, { internalGetLogCollection, internalGetSelectAdminCollection } from './initExpressKitCollections';
 
 // Import shared types
 import ExpressKitErrorCode from '../types/ExpressKitErrorCode';
@@ -563,6 +561,32 @@ const genRouteHandler = (
       );
     }
 
+    // Add Select Admin endpoint security
+    if (
+      // This is a select admin endpoint
+      req.path.startsWith('/api/admin/select')
+    ) {
+      // Get select admin collection
+      const selectAdminCollection = await internalGetSelectAdminCollection();
+      const id = output.userId;
+
+      // Find match if exists in select admin collection
+      const [match] = await selectAdminCollection.find({ id });
+
+      // Check that user exists in select admin collection
+      if (!match) {
+        // User does not have access
+        return handleError(
+          res,
+          {
+            message: 'This action is only allowed for select Canvas admins. Please go back to Canvas, log in as a select admin, and try again.',
+            code: ExpressKitErrorCode.NotSelectAdmin,
+            status: 401,
+          },
+        );
+      }
+    }
+
     /*----------------------------------------*/
     /* ------------- Log Handler ------------ */
     /*----------------------------------------*/
@@ -675,7 +699,7 @@ const genRouteHandler = (
         };
 
         // Either print to console or save to db
-        const logCollection = internalGetLogCollection();
+        const logCollection = await internalGetLogCollection();
         if (logCollection) {
           // Store to the log collection
           await logCollection.insert(log);

package/src/helpers/getLogReviewerLogs.ts

@@ -0,0 +1,260 @@
+// Import dce-mango
+import { Collection } from 'dce-mango';
+
+// Import dce-reactkit
+import {  
+  DAY_IN_MS,
+  Log,
+  LogReviewerFilterState, 
+  LogType 
+} from 'dce-reactkit';
+
+// Import shared types
+import LOG_REVIEW_PAGE_SIZE from '../constants/LOG_REVIEW_PAGE_SIZE';
+
+/**
+ * Get logs for the log reviewer interface
+ * @author Yuen Ler Chow
+ * @param opts object containing all arguments
+ * @param opts.pageNumber the page number to retrieve (1-indexed)
+ * @param opts.filters filter criteria for logs
+ * @param opts.countDocuments if true, count number of documents matching
+ *   filters and return num pages (not always required because if changing pages,
+ *   we don't need to recount documents)
+ * @param opts.logCollection MongoDB collection containing logs
+ * @returns object with logs for the requested page and optionally total number of pages
+ */
+const getLogReviewerLogs = async (
+  opts: {
+    pageNumber: number,
+    filters: LogReviewerFilterState,
+    countDocuments: boolean,
+    logCollection: Collection<Log>,
+  },
+) => {
+  // Destructure opts
+  const {
+    pageNumber,
+    filters,
+    countDocuments,
+    logCollection,
+  } = opts;
+  
+
+  // Destructure filters
+  const {
+    dateFilterState,
+    contextFilterState,
+    tagFilterState,
+    actionErrorFilterState,
+    advancedFilterState,
+  } = filters as LogReviewerFilterState;
+
+  // Build MongoDB query based on filters
+  const query: { [k: string]: any } = {};
+
+  /* -------------- Date Filter ------------- */
+
+  // Convert start and end dates from the dateFilterState into timestamps
+  const { startDate, endDate } = dateFilterState;
+  const startTimestamp = new Date(
+    `${startDate.month}/${startDate.day}/${startDate.year}`,
+  ).getTime();
+  const endTimestamp = (
+    (new Date(`${endDate.month}/${endDate.day}/${endDate.year}`)).getTime()
+    + DAY_IN_MS
+  );
+
+  // Add a date range condition to the query
+  query.timestamp = {
+    $gte: startTimestamp,
+    $lt: endTimestamp,
+  };
+
+  /* ------------ Context Filter ------------ */
+
+  // Process context filters to include selected contexts and subcontexts
+  const contextConditions: { [k: string]: any }[] = [];
+  Object.keys(contextFilterState).forEach((context) => {
+    const value = contextFilterState[context];
+    if (typeof value === 'boolean') {
+      if (value) {
+        // The entire context is selected
+        contextConditions.push({ context });
+      }
+    } else {
+      // The context has subcontexts
+      const subcontexts = Object.keys(value).filter((subcontext) => {
+        return value[subcontext];
+      });
+
+      if (subcontexts.length > 0) {
+        contextConditions.push({
+          context,
+          subcontext: { $in: subcontexts },
+        });
+      }
+    }
+  });
+  if (contextConditions.length > 0) {
+    query.$or = contextConditions;
+  }
+
+  /* -------------- Tag Filter -------------- */
+
+  const selectedTags = Object.keys(tagFilterState).filter((tag) => { return tagFilterState[tag]; });
+  if (selectedTags.length > 0) {
+    query.tags = { $in: selectedTags };
+  }
+
+  /* --------- Action/Error Filter ---------- */
+
+  if (actionErrorFilterState.type) {
+    query.type = actionErrorFilterState.type;
+  }
+
+  if (actionErrorFilterState.type === LogType.Error) {
+    if (actionErrorFilterState.errorMessage) {
+      // Add error message to the query.
+      // $i is used for case-insensitive search, and $regex is used for partial matching
+      query.errorMessage = {
+        $regex: actionErrorFilterState.errorMessage,
+        $options: 'i',
+      };
+    }
+
+    if (actionErrorFilterState.errorCode) {
+      query.errorCode = {
+        $regex: actionErrorFilterState.errorCode,
+        $options: 'i',
+      };
+    }
+  }
+
+  if (actionErrorFilterState.type === LogType.Action) {
+    const selectedTargets = (
+      Object.keys(actionErrorFilterState.target)
+        .filter((target) => {
+          return actionErrorFilterState.target[target];
+        })
+    );
+    const selectedActions = (
+      Object.keys(actionErrorFilterState.action)
+        .filter((action) => {
+          return actionErrorFilterState.action[action];
+        })
+    );
+    if (selectedTargets.length > 0) {
+      query.target = { $in: selectedTargets };
+    }
+    if (selectedActions.length > 0) {
+      query.action = { $in: selectedActions };
+    }
+  }
+
+  /* ------------ Advanced Filter ----------- */
+
+  if (advancedFilterState.userFirstName) {
+    query.userFirstName = {
+      $regex: advancedFilterState.userFirstName,
+      $options: 'i',
+    };
+  }
+
+  if (advancedFilterState.userLastName) {
+    query.userLastName = {
+      $regex: advancedFilterState.userLastName,
+      $options: 'i',
+    };
+  }
+
+  if (advancedFilterState.userEmail) {
+    query.userEmail = {
+      $regex: advancedFilterState.userEmail,
+      $options: 'i',
+    };
+  }
+
+  if (advancedFilterState.userId) {
+    query.userId = Number.parseInt(advancedFilterState.userId, 10);
+  }
+
+  const roles: {
+    isLearner?: boolean,
+    isTTM?: boolean,
+    isAdmin?: boolean,
+  }[] = [];
+  if (advancedFilterState.includeLearners) {
+    roles.push({ isLearner: true });
+  }
+  if (advancedFilterState.includeTTMs) {
+    roles.push({ isTTM: true });
+  }
+  if (advancedFilterState.includeAdmins) {
+    roles.push({ isAdmin: true });
+  }
+  // If any roles are selected, add them to the query
+  if (roles.length > 0) {
+    // The $or operator is used to match any of the roles
+    // The $and operator is to ensure that other conditions in the query are met
+    query.$and = [{ $or: roles }];
+  }
+
+  if (advancedFilterState.courseId) {
+    query.courseId = Number.parseInt(advancedFilterState.courseId, 10);
+  }
+
+  if (advancedFilterState.courseName) {
+    query.courseName = {
+      $regex: advancedFilterState.courseName,
+      $options: 'i',
+    };
+  }
+
+  if (advancedFilterState.isMobile !== undefined) {
+    query['device.isMobile'] = Boolean(advancedFilterState.isMobile);
+  }
+
+  if (advancedFilterState.source) {
+    query.source = advancedFilterState.source;
+  }
+
+  if (advancedFilterState.routePath) {
+    query.routePath = {
+      $regex: advancedFilterState.routePath,
+      $options: 'i',
+    };
+  }
+
+  if (advancedFilterState.routeTemplate) {
+    query.routeTemplate = {
+      $regex: advancedFilterState.routeTemplate,
+      $options: 'i',
+    };
+  }
+
+  // Query for logs
+  const response = await logCollection.findPaged({
+    query,
+    perPage: LOG_REVIEW_PAGE_SIZE,
+    pageNumber,
+    sortDescending: true,
+  });
+
+  // Count documents if requested
+  if (countDocuments) {
+    const numPages = Math.ceil(
+      await logCollection.count(query)
+      / LOG_REVIEW_PAGE_SIZE
+  );
+    return {
+      ...response,
+      numPages,
+    };
+  }
+
+  // Return response
+  return response;
+};
+
+export default getLogReviewerLogs;

package/src/helpers/initExpressKitCollections.ts

@@ -0,0 +1,144 @@
+// Import dce-mango
+import { Collection as MangoCollection } from 'dce-mango';
+
+// Import dce-reactkit
+import { Log } from 'dce-reactkit';
+
+// Import shared types
+import CrossServerCredential from '../types/CrossServerCredential';
+import SelectAdmin from '../types/SelectAdmin';
+import LogReviewerAdmin from '../types/LogReviewerAdmin';
+
+/*------------------------------------------------------------------------*/
+/* ------------------------- Collection Storage ------------------------- */
+/*------------------------------------------------------------------------*/
+
+// Variables to store collections
+let logCollection: MangoCollection<Log>;
+let crossServerCredentialCollection: MangoCollection<CrossServerCredential>;
+let selectAdminCollection: MangoCollection<SelectAdmin>;
+let logReviewerAdminCollection: MangoCollection<LogReviewerAdmin>;
+
+// Promise that resolves when all collections are initialized
+let collectionsInitializedResolve: (v?: unknown) => void;
+let collectionsInitializedReject: (error: Error) => void;
+const collectionsInitialized = new Promise((resolve, reject) => {
+  collectionsInitializedResolve = resolve;
+  collectionsInitializedReject = reject;
+});
+
+/*------------------------------------------------------------------------*/
+/* ------------------------- Collection Getters ------------------------- */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Get the log collection after initialization
+ * @author Gardenia Liu
+ */
+export const internalGetLogCollection = async () => {
+  // Wait for collections to be initialized
+  await collectionsInitialized;
+
+  // Return the log collection
+  return logCollection;
+};
+
+/**
+ * Get the cross server credential collection after initialization
+ * @author Gardenia Liu
+ */
+export const internalGetCrossServerCredentialCollection = async () => {
+  // Wait for collections to be initialized
+  await collectionsInitialized;
+
+  // Return the cross server credential collection
+  return crossServerCredentialCollection;
+};
+
+/**
+ * Get the select admin collection after initialization
+ * @author Gardenia Liu
+ */
+export const internalGetSelectAdminCollection = async () => {
+  // Wait for collections to be initialized
+  await collectionsInitialized;
+
+  // Return the cross server credential collection
+  return selectAdminCollection;
+};
+
+/**
+ * Get the log reviewer admin collection after initialization
+ * @author Yuen Ler Chow
+ */
+export const internalGetLogReviewerAdminCollection = async () => {
+  // Wait for collections to be initialized
+  await collectionsInitialized;
+
+  // Return the log reviewer admin collection
+  return logReviewerAdminCollection;
+};
+
+/*------------------------------------------------------------------------*/
+/* -------------------------------- Main -------------------------------- */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Initialize all collections required for expresskit
+ * @author Gardenia Liu
+ * @author Gabe Abrams
+ * @param Collection the Collection class from dce-mango
+ */
+const initExpressKitCollections = (Collection: typeof MangoCollection) => {
+  try {
+    // Create and store log collection
+    logCollection = new Collection<Log>(
+      'Log',
+      {
+        uniqueIndexKey: 'id',
+        indexKeys: [
+          'courseId',
+          'context',
+          'subcontext',
+          'tags',
+          'year',
+          'month',
+          'day',
+          'hour',
+          'type',
+        ],
+      },
+    );
+
+    // Create and store cross server credential collection
+    crossServerCredentialCollection = new Collection<CrossServerCredential>(
+      'CrossServerCredential',
+      {
+        uniqueIndexKey: 'key',
+      },
+    );
+
+    // Create and store select admin collection
+    selectAdminCollection = new Collection<SelectAdmin>(
+      'SelectAdmin',
+      {
+        uniqueIndexKey: 'id',
+      },
+    );
+
+    // Create and store log reviewer admin collection
+    logReviewerAdminCollection = new Collection<LogReviewerAdmin>(
+      'LogReviewerAdmin',
+      {
+        uniqueIndexKey: 'id',
+      },
+    );
+
+    // Finished! Resolve the promise
+    collectionsInitializedResolve();
+  } catch (err) {
+    return collectionsInitializedReject(err as Error);
+  }
+};
+
+export default initExpressKitCollections;

package/src/helpers/initServer.ts

@@ -6,51 +6,26 @@ import { Collection } from 'dce-mango';
 
 // Import dce-reactkit
 import {
-  ErrorWithCode,
   ParamType,
   LogFunction,
-  LOG_REVIEW_ROUTE_PATH_PREFIX,
   LOG_ROUTE_PATH,
   LOG_REVIEW_STATUS_ROUTE,
-  Log,
+  LOG_REVIEW_GET_LOGS_ROUTE,
+  ErrorWithCode,
 } from 'dce-reactkit';
 
 // Import shared helpers
 import genRouteHandler from './genRouteHandler';
+import getLogReviewerLogs from './getLogReviewerLogs';
 
 // Import shared types
 import ExpressKitErrorCode from '../types/ExpressKitErrorCode';
-import CrossServerCredential from '../types/CrossServerCredential';
-
-// Stored copy of dce-mango log collection
-let _logCollection: Collection<Log>;
-
-// Stored copy of dce-mango cross-server credential collection
-let _crossServerCredentialCollection: Collection<CrossServerCredential>;
 
-/*------------------------------------------------------------------------*/
-/*                                 Helpers                                */
-/*------------------------------------------------------------------------*/
-
-/**
- * Get log collection
- * @author Gabe Abrams
- * @returns log collection if one was included during launch or null if we don't
- *   have a log collection (yet)
- */
-export const internalGetLogCollection = () => {
-  return _logCollection ?? null;
-};
-
-/**
- * Get cross-server credential collection
- * @author Gabe Abrams
- * @return cross-server credential collection if one was included during launch or null
- *   if we don't have a cross-server credential collection (yet)
- */
-export const internalGetCrossServerCredentialCollection = () => {
-  return _crossServerCredentialCollection ?? null;
-};
+// Import shared helpers
+import {
+  internalGetLogCollection,
+  internalGetLogReviewerAdminCollection,
+} from './initExpressKitCollections';
 
 /*------------------------------------------------------------------------*/
 /*                                  Main                                  */
@@ -62,31 +37,12 @@ export const internalGetCrossServerCredentialCollection = () => {
  * @param opts object containing all arguments
  * @param opts.app express app from inside of the postprocessor function that
  *   we will add routes to
- * @param opts.getLaunchInfo CACCL LTI's get launch info function
- * @param [opts.logCollection] mongo collection from dce-mango to use for
- *   storing logs. If none is included, logs are written to the console
- * @param [opts.logReviewAdmins=all] info on which admins can review
- *   logs from the client. If not included, all Canvas admins are allowed to
- *   review logs. If null, no Canvas admins are allowed to review logs.
- *   If an array of Canvas userIds (numbers), only Canvas admins with those
- *   userIds are allowed to review logs. If a dce-mango collection, only
- *   Canvas admins with entries in that collection ({ userId, ...}) are allowed
- *   to review logs
- * @param [opts.crossServerCredentialCollection] mongo collection from dce-mango to use for
- *   storing cross-server credentials. If none is included, cross-server credentials
- *   are not supported
  */
 const initServer = (
   opts: {
     app: express.Application,
-    logReviewAdmins?: (number[] | Collection<any>),
-    logCollection?: Collection<Log>,
-    crossServerCredentialCollection?: Collection<CrossServerCredential>,
   },
 ) => {
-  _logCollection = opts.logCollection;
-  _crossServerCredentialCollection = opts.crossServerCredentialCollection;
-
   /*----------------------------------------*/
   /*                Logging                 */
   /*----------------------------------------*/
@@ -189,22 +145,15 @@ const initServer = (
       return false;
     }
 
-    // If all admins are allowed, we're done
-    if (!opts.logReviewAdmins) {
-      return true;
-    }
+    /* ------- Look Up Credential ------- */
 
-    // Do a dynamic check
-    try {
-      // Array of userIds
-      if (Array.isArray(opts.logReviewAdmins)) {
-        return opts.logReviewAdmins.some((allowedId) => {
-          return (userId === allowedId);
-        });
-      }
+    // Get the log reviewer admin collection
+    const logReviewerAdminCollection = await internalGetLogReviewerAdminCollection();
 
-      // Must be a collection
-      const matches = await opts.logReviewAdmins.find({ userId });
+    // Check if the user is in the log reviewer admin collection
+    try {
+      // Must be in the collection
+      const matches = await logReviewerAdminCollection.find({ id: userId });
 
       // Make sure at least one entry matches
       return matches.length > 0;
@@ -223,36 +172,45 @@ const initServer = (
     LOG_REVIEW_STATUS_ROUTE,
     genRouteHandler({
       handler: async ({ params }) => {
-        const { userId, isAdmin } = params;
+        // Destructure params
+        const {
+          userId,
+          isAdmin,
+        } = params;
+
+        // Check if user can review logs
         const canReview = await canReviewLogs(userId, isAdmin);
+
+        // Return result
         return canReview;
       },
     }),
   );
 
   /**
-   * Get all logs for a certain month
+   * Get filtered logs based on provided filters
    * @author Gabe Abrams
-   * @param {number} year the year to query (e.g. 2022)
-   * @param {number} month the month to query (e.g. 1 = January)
-   * @returns {Log[]} list of logs from the given month
+   * @author Yuen Ler Chow
+   * @param pageNumber the page number to get
+   * @param filters the filters to apply to the logs
+   * @returns {Log[]} list of logs that match the filters
    */
   opts.app.get(
-    `${LOG_REVIEW_ROUTE_PATH_PREFIX}/years/:year/months/:month`,
+    LOG_REVIEW_GET_LOGS_ROUTE,
     genRouteHandler({
       paramTypes: {
-        year: ParamType.Int,
-        month: ParamType.Int,
         pageNumber: ParamType.Int,
+        filters: ParamType.JSON,
+        countDocuments: ParamType.Boolean,
       },
       handler: async ({ params }) => {
-        // Get user info
+        // Destructure params
         const {
-          year,
-          month,
           pageNumber,
           userId,
           isAdmin,
+          filters,
+          countDocuments,
         } = params;
 
         // Validate user
@@ -264,14 +222,15 @@ const initServer = (
           );
         }
 
-        // Query for logs
-        const response = await _logCollection.findPaged({
-          query: {
-            year,
-            month,
-          },
-          perPage: 1000,
+        // Get log collection
+        const logCollection = await internalGetLogCollection();
+
+        // Get logs
+        const response = await getLogReviewerLogs({
           pageNumber,
+          filters,
+          countDocuments,
+          logCollection,
         });
 
         // Return response

package/src/index.ts

@@ -48,14 +48,13 @@ import {
 } from 'dce-reactkit';
 
 // Import helpers
-import initCrossServerCredentialCollection from './helpers/initCrossServerCredentialCollection';
-import initLogCollection from './helpers/initLogCollection';
 import initServer from './helpers/initServer';
 import genRouteHandler from './helpers/genRouteHandler';
 import handleError from './helpers/handleError';
 import handleSuccess from './helpers/handleSuccess';
 import addDBEditorEndpoints from './helpers/addDBEditorEndpoints';
 import visitEndpointOnAnotherServer from './helpers/visitEndpointOnAnotherServer';
+import initExpressKitCollections from './helpers/initExpressKitCollections';
 
 // Import types
 import CrossServerCredential from './types/CrossServerCredential';
@@ -106,8 +105,7 @@ export {
   genRouteHandler,
   handleError,
   handleSuccess,
-  initLogCollection,
-  initCrossServerCredentialCollection,
+  initExpressKitCollections,
   addDBEditorEndpoints,
   visitEndpointOnAnotherServer,
   // Types

package/src/types/ExpressKitErrorCode.ts

@@ -32,6 +32,7 @@ enum ExpressKitErrorCode {
   NoCryptoLib = 'DEK32',
   InvalidCrossServerCredentialsFormat = 'DEK33',
   UnknownCrossServerError = 'DEK34',
+  NotSelectAdmin = 'DEK35',
 }
 
 export default ExpressKitErrorCode;