dce-reactkit 2.0.6 → 2.0.9

package/src/helpers/parseRequest.ts

@@ -0,0 +1,299 @@
+// Import caccl libs
+import { getLaunchInfo } from 'caccl-lti';
+
+// Import shared types
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+import ParamType from '../types/ParamType';
+
+// Import helpers
+import handleError from './handleError';
+
+/**
+ * Parse express request params and body
+ * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param opts.req express request instance
+ * @param opts.res express response instance
+ * @param opts.params map of parameters that should be parsed out of the request
+ * @returns parsed params + user info from session (if it exists) or undefined
+ *   if an error occurred
+ */
+const parseRequest = (
+  opts: {
+    req: any,
+    res: any,
+    params: {
+      [k in string]: ParamType
+    },
+  },
+): ({ [k in string]: any } | undefined) => {
+  // Output
+
+  const output: { [k in string]: any } = {};
+
+  /*----------------------------------------*/
+  /*              Parse Params              */
+  /*----------------------------------------*/
+
+  // Process items one by one
+  const paramList = Object.entries(opts.params);
+  for (let i = 0; i < paramList.length; i++) {
+    const [name, type] = paramList[i];
+
+    // Find the value as a string
+    const value = (
+      opts.req.params[name]
+      || opts.req.query[name]
+      || opts.req.body[name]
+    );
+
+    // Parse
+    if (type === ParamType.Boolean || type === ParamType.BooleanOptional) {
+      // Boolean
+
+      // Handle case where value doesn't exist
+      if (value === undefined) {
+        if (type === ParamType.BooleanOptional) {
+          output[name] = undefined;
+        } else {
+          return handleError(
+            opts.res,
+            {
+              message: `Parameter ${name} is required, but it was not included.`,
+              code: ReactKitErrorCode.MissingParameter,
+              status: 422,
+            },
+          );
+        }
+      } else {
+        // Value exists
+
+        // Simplify value
+        const simpleVal = (
+          String(value)
+            .trim()
+            .toLowerCase()
+        );
+
+        // Parse
+        output[name] = (
+          [
+            'true',
+            'yes',
+            'y',
+            '1',
+            't',
+          ].indexOf(simpleVal) >= 0
+        );
+      }
+    } else if (type === ParamType.Float || type === ParamType.FloatOptional) {
+      // Float
+
+      // Handle case where value doesn't exist
+      if (value === undefined) {
+        if (type === ParamType.FloatOptional) {
+          output[name] = undefined;
+        } else {
+          return handleError(
+            opts.res,
+            {
+              message: `Parameter ${name} is required, but it was not included.`,
+              code: ReactKitErrorCode.MissingParameter,
+              status: 422,
+            },
+          );
+        }
+      } else if (!Number.isNaN(Number.parseFloat(String(value)))) {
+        // Value is a number
+        output[name] = Number.parseFloat(String(value));
+      } else {
+        // Issue!
+        return handleError(
+          opts.res,
+          {
+            message: `Request data was malformed: ${name} was not a valid float.`,
+            code: ReactKitErrorCode.InvalidParameter,
+            status: 422,
+          },
+        );
+      }
+    } else if (type === ParamType.Int || type === ParamType.IntOptional) {
+      // Int
+
+      // Handle case where value doesn't exist
+      if (value === undefined) {
+        if (type === ParamType.IntOptional) {
+          output[name] = undefined;
+        } else {
+          return handleError(
+            opts.res,
+            {
+              message: `Parameter ${name} is required, but it was not included.`,
+              code: ReactKitErrorCode.MissingParameter,
+              status: 422,
+            },
+          );
+        }
+      } else if (!Number.isNaN(Number.parseInt(String(value), 10))) {
+        // Value is a number
+        output[name] = Number.parseInt(String(value), 10);
+      } else {
+        // Issue!
+        return handleError(
+          opts.res,
+          {
+            message: `Request data was malformed: ${name} was not a valid int.`,
+            code: ReactKitErrorCode.InvalidParameter,
+            status: 422,
+          },
+        );
+      }
+    } else if (type === ParamType.JSON || type === ParamType.JSONOptional) {
+      // Stringified JSON
+
+      // Handle case where value doesn't exist
+      if (value === undefined) {
+        if (type === ParamType.JSONOptional) {
+          output[name] = undefined;
+        } else {
+          return handleError(
+            opts.res,
+            {
+              message: `Parameter ${name} is required, but it was not included.`,
+              code: ReactKitErrorCode.MissingParameter,
+              status: 422,
+            },
+          );
+        }
+      } else {
+        // Value exists
+
+        // Parse
+        try {
+          output[name] = JSON.parse(String(value));
+        } catch (err) {
+          return handleError(
+            opts.res,
+            {
+              message: `Request data was malformed: ${name} was not a valid JSON payload.`,
+              code: ReactKitErrorCode.InvalidParameter,
+              status: 422,
+            },
+          );
+        }
+      }
+    } else if (type === ParamType.String || type === ParamType.StringOptional) {
+      // String
+
+      // Handle case where value doesn't exist
+      if (value === undefined) {
+        if (type === ParamType.StringOptional) {
+          output[name] = undefined;
+        } else {
+          return handleError(
+            opts.res,
+            {
+              message: `Parameter ${name} is required, but it was not included.`,
+              code: ReactKitErrorCode.MissingParameter,
+              status: 422,
+            },
+          );
+        }
+      } else {
+        // Value exists
+
+        // Leave as is
+        output[name] = value;
+      }
+    } else {
+      // No valid data type
+      return handleError(
+        opts.res,
+        {
+          message: `An internal error occurred: we could not determine the type of ${name}.`,
+          code: ReactKitErrorCode.InvalidParameter,
+          status: 422,
+        },
+      );
+    }
+  }
+
+  /*----------------------------------------*/
+  /*               Launch Info              */
+  /*----------------------------------------*/
+
+  // Get launch info
+  const { launched, launchInfo } = getLaunchInfo(opts.req);
+  if (!launched || !launchInfo) {
+    return handleError(
+      opts.res,
+      {
+        message: 'Your session has expired. Please refresh the page and try again.',
+        code: ReactKitErrorCode.SessionExpired,
+        status: 440,
+      },
+    );
+  }
+
+  // Error if user info cannot be found
+  if (
+    !launchInfo.userId
+    || !launchInfo.userFirstName
+    || !launchInfo.userLastName
+    || (
+      launchInfo.notInCourse
+      && !launchInfo.isAdmin
+    )
+    || (
+      !launchInfo.isTTM
+      && !launchInfo.isLearner
+      && !launchInfo.isAdmin
+    )
+  ) {
+    return handleError(
+      opts.res,
+      {
+        message: 'Your session was invalid. Please refresh the page and try again.',
+        code: ReactKitErrorCode.SessionExpired,
+        status: 440,
+      },
+    );
+  }
+
+  // Add launch info to output
+  output.userId = launchInfo.userId;
+  output.userFirstName = launchInfo.userFirstName;
+  output.userLastName = launchInfo.userLastName;
+  output.isLearner = !!launchInfo.isLearner;
+  output.isTTM = !!launchInfo.isTTM;
+  output.isAdmin = !!launchInfo.isAdmin;
+  output.isWatchingInPrivate = !!(opts.req.session.isWatchingInPrivate);
+
+  /*----------------------------------------*/
+  /*       Require Course Consistency       */
+  /*----------------------------------------*/
+
+  // Make sure the user actually launched from the appropriate course
+  if (
+    output.courseId
+    && launchInfo.courseId
+    && output.courseId !== launchInfo.courseId
+    && !output.isTTM
+    && !output.isAdmin
+  ) {
+    // Course of interest is not the launch course
+    return handleError(
+      opts.res,
+      {
+        message: 'You switched sessions by opening Immersive Classroom in another tab. Please refresh the page and try again.',
+        code: ReactKitErrorCode.WrongCourse,
+        status: 401,
+      },
+    );
+  }
+
+  // Return processed params
+  return output;
+};
+
+export default parseRequest;

package/src/helpers/roundToNumDecimals.tsx

@@ -0,0 +1,13 @@
+/**
+ * Round a number to a certain number of decimals
+ * @author Gabe Abrams
+ * @param num the number to round
+ * @param numDecimals the number of decimals to round to
+ * @returns rounded number
+ */
+const roundToNumDecimals = (num: number, numDecimals: number): number => {
+  const rounder = 10 ** numDecimals;
+  return (Math.round(num * rounder) / rounder);
+};
+
+export default roundToNumDecimals;

package/src/helpers/showFatalError.tsx

@@ -0,0 +1,3 @@
+import { showFatalError } from '../components/AppWrapper';
+
+export default showFatalError;

package/src/helpers/sum.tsx

@@ -0,0 +1,16 @@
+/**
+ * Sum the numbers in an array
+ * @author Gabe Abrams
+ * @param nums the numbers to sum
+ * @returns the sum of the numbers
+ */
+const sum = (nums: number[]): number => {
+  return nums.reduce(
+    (a: number, b: number) => {
+      return (a + b);
+    },
+    0,
+  );
+};
+
+export default sum;

package/src/helpers/visitServerEndpoint.tsx

@@ -0,0 +1,110 @@
+// Initialize caccl
+import { sendRequest } from 'caccl/client';
+
+// Import custom error
+import ErrorWithCode from '../errors/ErrorWithCode';
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+
+/*------------------------------------------------------------------------*/
+/*                                Listener                                */
+/*------------------------------------------------------------------------*/
+
+// Handler for session expiry
+let sessionExpiryHandler: () => void;
+
+// Keep track of whether or not session expiry has already been handled
+let sessionAlreadyExpired = false;
+
+/**
+ * Set the session expiry handler
+ * @author Gabe Abrams
+ * @param handler new handler to use when session expires
+ */
+export const setSessionExpiryHandler = (handler: () => void) => {
+  sessionExpiryHandler = handler;
+};
+
+/*------------------------------------------------------------------------*/
+/*                                  Main                                  */
+/*------------------------------------------------------------------------*/
+
+/**
+ * Visit an endpoint on the server [for client only]
+ * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param opts.path - the path of the server endpoint
+ * @param [opts.method=GET] - the method of the endpoint
+ * @param [opts.params] - query/body parameters to include
+ * @returns response from server
+ */
+const visitServerEndpoint = async (
+  opts: {
+    path: string,
+    method?: ('GET' | 'POST' | 'DELETE' | 'PUT'),
+    params?: { [key in string]: any },
+  },
+): Promise<any> => {
+  // Send the request
+  const response = await sendRequest({
+    path: opts.path,
+    method: opts.method,
+    params: opts.params,
+  });
+
+  // Check for failure
+  if (!response || !response.body) {
+    throw new ErrorWithCode(
+      'We didn\'t get a response from the server. Please check your internet connection.',
+      ReactKitErrorCode.NoResponse,
+    );
+  }
+  if (!response.body.success) {
+    // Session expired
+    if (response.body.code === ReactKitErrorCode.SessionExpired) {
+      // Skip notice if session was already expired
+      if (sessionAlreadyExpired) {
+        // Never return (browser is already reloading)
+        await new Promise<{ [key in string]: any }>(() => {
+          // Promise that never returns
+        });
+      }
+      sessionAlreadyExpired = true;
+
+      // Show session expiration message
+      if (sessionExpiryHandler) {
+        // Use handler
+        sessionExpiryHandler();
+      } else {
+        // Fallback to alert
+
+        // eslint-disable-next-line no-alert
+        alert('Your session has expired. Please start over.');
+      }
+
+      // Never return (don't continue execution)
+      await new Promise<{ [key in string]: any }>(() => {
+        // Promise that never returns
+      });
+    }
+
+    // Other errors
+    throw new ErrorWithCode(
+      (
+        response.body.message
+        || 'An unknown error occurred. Please contact an admin.'
+      ),
+      (
+        response.body.code
+        || ReactKitErrorCode.NoCode
+      ),
+    );
+  }
+
+  // Success! Extract the body
+  const { body } = response.body;
+
+  // Return
+  return body;
+};
+
+export default visitServerEndpoint;

package/src/helpers/waitMs.tsx

@@ -0,0 +1,12 @@
+/**
+ * Wait for a certain number of ms
+ * @author Gabe Abrams
+ * @param ms number of ms to wait
+ */
+const waitMs = async (ms = 0) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+
+export default waitMs;

package/src/types/ParamType.ts

@@ -0,0 +1,18 @@
+/**
+ * API param types
+ * @author Gabe Abrams
+ */
+enum ParamType {
+  Boolean = 'boolean', // Boolean
+  BooleanOptional = 'boolean-optional', // Optional boolean
+  Float = 'float', // Float Number
+  FloatOptional = 'float-optional', // Optional Float Number
+  Int = 'int', // Integer Number
+  IntOptional = 'int-optional', // Optional Integer Number
+  JSON = 'json', // JSONified object
+  JSONOptional = 'json-optional', // Optional JSONified object
+  String = 'string', // String
+  StringOptional = 'string-optional', // Optional string
+}
+
+export default ParamType;

package/src/types/ReactKitErrorCode.tsx

@@ -0,0 +1,16 @@
+// Highest error code = DRK2
+
+/**
+ * List of error codes built into the react kit
+ * @author Gabe Abrams
+ */
+enum ReactKitErrorCode {
+  NoResponse = 'DRK1',
+  NoCode = 'DRK2',
+  SessionExpired = 'DRK3',
+  MissingParameter = 'DRK4',
+  InvalidParameter = 'DRK5',
+  WrongCourse = 'DRK6',
+}
+
+export default ReactKitErrorCode;

package/src/types/Variant.tsx

@@ -0,0 +1,16 @@
+/**
+ * Bootstrap variants
+ * @author Gabe Abrams
+ */
+enum Variant {
+  Primary = 'primary',
+  Secondary = 'secondary',
+  Success = 'success',
+  Warning = 'warning',
+  Info = 'info',
+  Danger = 'danger',
+  Light = 'light',
+  Dark = 'dark',
+}
+
+export default Variant;