dce-reactkit 3.9.4-beta-prompt.2 → 3.9.4-beta-logreviewer.3

package/src/components/Modal/index.tsx

@@ -49,9 +49,6 @@ const modalTypeToModalButtonTypes: {
   [ModalType.Okay]: [
     ModalButtonType.Okay,
   ],
-  [ModalType.Cancel]: [
-    ModalButtonType.Cancel,
-  ],
   [ModalType.OkayCancel]: [
     ModalButtonType.Okay,
     ModalButtonType.Cancel,

package/src/constants/LOG_REVIEW_GET_LOGS_ROUTE.ts

@@ -0,0 +1,9 @@
+import ROUTE_PATH_PREFIX from './ROUTE_PATH_PREFIX';
+
+/**
+ * Path of the route for getting logs for log review
+ * @author Gabe Abrams
+ */
+const LOG_REVIEW_GET_LOGS_ROUTE = `/admin${ROUTE_PATH_PREFIX}/logs`;
+
+export default LOG_REVIEW_GET_LOGS_ROUTE;

package/src/index.ts

@@ -1,7 +1,6 @@
 // Import components
 import AppWrapper, {
   alert,
-  prompt,
   confirm,
   showFatalError,
   addFatalErrorHandler,
@@ -149,7 +148,6 @@ export {
   Dropdown,
   // Global functions
   alert,
-  prompt,
   confirm,
   showFatalError,
   // Errors

package/src/server/initServer.ts

@@ -2,7 +2,7 @@
 import ErrorWithCode from '../errors/ErrorWithCode';
 
 // Import shared constants
-import LOG_REVIEW_ROUTE_PATH_PREFIX from '../constants/LOG_REVIEW_ROUTE_PATH_PREFIX';
+import LOG_REVIEW_ROUTE_PATH_PREFIX from '../constants/LOG_REVIEW_GET_LOGS_ROUTE';
 import LOG_ROUTE_PATH from '../constants/LOG_ROUTE_PATH';
 import LOG_REVIEW_STATUS_ROUTE from '../constants/LOG_REVIEW_STATUS_ROUTE';
 
@@ -10,10 +10,11 @@ import LOG_REVIEW_STATUS_ROUTE from '../constants/LOG_REVIEW_STATUS_ROUTE';
 import genRouteHandler from '../helpers/genRouteHandler';
 
 // Import shared types
-import Log from '../types/Log';
 import LogFunction from '../types/LogFunction';
 import ParamType from '../types/ParamType';
 import ReactKitErrorCode from '../types/ReactKitErrorCode';
+import LogReviewerFilterState from '../types/LogReviewerFilterState';
+import LogType from '../types/LogType';
 
 // Types
 type GetLaunchInfoFunction = (req: any) => {
@@ -234,28 +235,36 @@ const initServer = (
   );
 
   /**
-   * Get all logs for a certain month
-   * @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
-   */
+ * Get filtered logs based on provided filters
+ * @author Gabe Abrams, 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_ROUTE_PATH_PREFIX}`,
     genRouteHandler({
       paramTypes: {
-        year: ParamType.Int,
-        month: ParamType.Int,
+        pageNumber: ParamType.Int,
+        filters: ParamType.JSON,
       },
       handler: async ({ params }) => {
-        // Get user info
+      // Get user info
         const {
-          year,
-          month,
+          pageNumber,
           userId,
           isAdmin,
+          filters,
         } = params;
 
+        const {
+          dateFilterState,
+          contextFilterState,
+          tagFilterState,
+          actionErrorFilterState,
+          advancedFilterState,
+        } = filters as LogReviewerFilterState;
+
         // Validate user
         const canReview = await canReviewLogs(userId, isAdmin);
         if (!canReview) {
@@ -265,14 +274,202 @@ const initServer = (
           );
         }
 
+        // 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.year, startDate.month - 1, startDate.day).getTime();
+        const endTimestamp = new Date(endDate.year, endDate.month - 1, endDate.day + 1).getTime() - 1;
+
+        // Add a date range condition to the query
+        query.timestamp = {
+          $gte: startTimestamp,
+          $lte: endTimestamp,
+        };
+
+        /* ------------ Context Filter ------------ */
+
+        // Process context filters to include selected contexts and subcontexts
+        const selectedContexts: string[] = [];
+        const selectedSubcontexts: string[] = [];
+
+        // Process each context filter
+        Object.keys(contextFilterState).forEach((context) => {
+          const value = contextFilterState[context];
+          if (typeof value === 'boolean') {
+            if (value) {
+              selectedContexts.push(context);
+            }
+          } else {
+            // At least one subcontext is selected
+            const atLeastOneSubcontextSelected = (
+              Object.values(value)
+                .some((subcontextValue) => {
+                  return subcontextValue;
+                })
+            );
+            if (atLeastOneSubcontextSelected) {
+              selectedContexts.push(context);
+            }
+            // Add all selected subcontexts
+            Object.keys(value).forEach((subcontext) => {
+              if (value[subcontext]) {
+                selectedSubcontexts.push(subcontext);
+              }
+            });
+          }
+        });
+
+        // Add context and subcontext conditions to the query if any are selected
+        if (selectedContexts.length > 0) {
+          query.context = { $in: selectedContexts };
+        }
+
+        if (selectedSubcontexts.length > 0) {
+          query.subcontext = { $in: selectedSubcontexts };
+        }
+
+        /* -------------- 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 = [];
+        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 logs: Log[] = await _logCollection.find({
-          year,
-          month,
+        const response = await _logCollection.findPaged({
+          query,
+          perPage: 50,
+          pageNumber,
         });
 
-        // Return logs
-        return logs;
+        // Return response
+        return response;
       },
     }),
   );

package/src/types/LogReviewerFilterState/ActionErrorFilterState.ts

@@ -0,0 +1,21 @@
+import LogType from '../LogType';
+
+// Action filter state (only relevant for action logs)
+type ActionErrorFilterState = {
+  // Required type of log
+  type: LogType | undefined, // If undefined, no filter applied
+  // Query for error message (only relevant if type is error)
+  errorMessage: string, // If empty, no filter applied
+  // Query for error code (only relevant if type is error)
+  errorCode: string, // If empty, no filter applied
+  // Action targets to include (only relevant if type is action)
+  target: {
+    [k: string]: boolean
+  },
+  // Action types to include (only relevant if type is action)
+  action: {
+    [k: string]: boolean
+  },
+};
+
+export default ActionErrorFilterState;

package/src/types/LogReviewerFilterState/AdvancedFilterState.ts

@@ -0,0 +1,33 @@
+import LogSource from '../LogSource';
+
+// Advanced filter state
+type AdvancedFilterState = {
+  // Query for user first name (case insensitive)
+  userFirstName: string, // If empty, no filter applied
+  // Query for user last name (case insensitive)
+  userLastName: string, // If empty, no filter applied
+  // Query for user email (case insensitive)
+  userEmail: string, // If empty, no filter applied
+  // Match for userId (numerical)
+  userId: string, // If empty, no filter applied
+  // If true, include students
+  includeLearners: boolean,
+  // If true, include ttms
+  includeTTMs: boolean,
+  // If true, include admins
+  includeAdmins: boolean,
+  // Match for courseId (numerical)
+  courseId: string, // If empty, no filter applied
+  // Query for course name (case insensitive)
+  courseName: string, // If empty, no filter applied
+  // Required isMobile value
+  isMobile: (true | false | undefined), // If undefined, no filter applied
+  // Required log source value
+  source: LogSource | undefined, // If undefined, no filter applied
+  // Query for route path (only relevant if source is server)
+  routePath: string, // If empty, no filter applied
+  // Query for route template (only relevant if source is server)
+  routeTemplate: string, // If empty, no filter applied
+};
+
+export default AdvancedFilterState;

package/src/types/LogReviewerFilterState/ContextFilterState.ts

@@ -0,0 +1,13 @@
+// Context filter state
+type ContextFilterState = {
+  [k: string]: (
+    // No subcontexts
+    | boolean // True if selected
+    // Includes subcontexts
+    | {
+      [k: string]: boolean // True if selected
+    }
+  )
+};
+
+export default ContextFilterState;

package/src/types/LogReviewerFilterState/DateFilterState.ts

@@ -0,0 +1,23 @@
+// Date filter state
+type DateFilterState = {
+  // Current start date
+  startDate: {
+    // Full year
+    year: number,
+    // 1-indexed month
+    month: number,
+    // 1-indexed day
+    day: number,
+  },
+  // Current end date
+  endDate: {
+    // Full year
+    year: number,
+    // 1-indexed month
+    month: number,
+    // 1-indexed day
+    day: number,
+  },
+};
+
+export default DateFilterState;

package/src/types/LogReviewerFilterState/TagFilterState.ts

@@ -0,0 +1,6 @@
+// Tag filter state
+type TagFilterState = {
+  [k: string]: boolean // tag => true if in the list of tags to show
+};
+
+export default TagFilterState;

package/src/types/LogReviewerFilterState/index.ts

@@ -0,0 +1,24 @@
+import DateFilterState from  './DateFilterState';
+import ContextFilterState from  './ContextFilterState';
+import TagFilterState from  './TagFilterState';
+import ActionErrorFilterState from  './ActionErrorFilterState';
+import AdvancedFilterState from  './AdvancedFilterState';
+
+/**
+ * A bundle of filter state objects for each type of filter
+ * @author Gabe Abrams
+ */
+type LogReviewerFilterState = {
+  // Date filter state
+  dateFilterState: DateFilterState,
+  // Context filter state
+  contextFilterState: ContextFilterState,
+  // Tag filter state
+  tagFilterState: TagFilterState,
+  // Action error filter state
+  actionErrorFilterState: ActionErrorFilterState,
+  // Advanced filter state
+  advancedFilterState: AdvancedFilterState,
+};
+
+export default LogReviewerFilterState;

package/src/types/ModalType.tsx

@@ -4,7 +4,6 @@
  */
 enum ModalType {
   Okay = 'okay', // [Okay]
-  Cancel = 'cancel', // [Cancel]
   OkayCancel = 'okay-cancel', // [Okay] [Cancel]
   YesNo = 'yes-no', // [Yes] [No]
   YesNoCancel = 'yes-no-cancel', // [Yes] [No] [Cancel]

package/dist/cjs/types/constants/LOG_REVIEW_ROUTE_PATH_PREFIX.d.ts

@@ -1,6 +0,0 @@
-/**
- * Path of the route for storing client-side logs
- * @author Gabe Abrams
- */
-declare const LOG_REVIEW_ROUTE_PATH_PREFIX: string;
-export default LOG_REVIEW_ROUTE_PATH_PREFIX;

package/dist/esm/types/constants/LOG_REVIEW_ROUTE_PATH_PREFIX.d.ts

@@ -1,6 +0,0 @@
-/**
- * Path of the route for storing client-side logs
- * @author Gabe Abrams
- */
-declare const LOG_REVIEW_ROUTE_PATH_PREFIX: string;
-export default LOG_REVIEW_ROUTE_PATH_PREFIX;

package/src/constants/LOG_REVIEW_ROUTE_PATH_PREFIX.ts

@@ -1,9 +0,0 @@
-import ROUTE_PATH_PREFIX from './ROUTE_PATH_PREFIX';
-
-/**
- * Path of the route for storing client-side logs
- * @author Gabe Abrams
- */
-const LOG_REVIEW_ROUTE_PATH_PREFIX = `/admin${ROUTE_PATH_PREFIX}/logs`;
-
-export default LOG_REVIEW_ROUTE_PATH_PREFIX;