dce-reactkit 3.0.0-beta.4 → 3.0.0-beta.40

package/src/components/TabBox.tsx

@@ -15,6 +15,8 @@ type Props = {
   title: React.ReactNode,
   // Children/contents inside the box
   children: React.ReactNode,
+  // If true, don't add padding below the tab box
+  noBottomPadding?: boolean,
 };
 
 /*------------------------------------------------------------------------*/
@@ -22,63 +24,67 @@ type Props = {
 /*------------------------------------------------------------------------*/
 
 const style = `
-/* Tab Box */
-.TabBox-box {
-  /* Light Border */
-  border: 2px solid #dedede;
-  
-  /* Rounded Corners (except top-left) */
-  border-bottom-right-radius: 5px;
-  border-bottom-left-radius: 5px;
-  border-top-right-radius: 5px;
-
-  /* Very Light Gray Border */
-  background: #fdfdfd;
-
-  /* Align Contents on Left */
-  text-align: left;
-}
-
-/* Container for Title */
-.TabBox-title-container {
-  /* Place on Left */
-  position: relative;
-  left: 0;
-  text-align: left;
-}
-
-/* Tab-style Title */
-.TabBox-title {
-  /* Place so it Barely Overlaps the Box Border */
-  display: inline-block;
-  position: relative;
-  top: 2px; /* Gives Illusion that Border Doesn't Exist Below Tab */
-
-  /* Title-sized Font */
-  font-size: 25px;
-
-  /* Add Border on Top and Sides */
-  border-top: 2px solid #dedede;
-  border-left: 2px solid #dedede;
-  border-right: 2px solid #dedede;
-
-  /* Round the Top Corners */
-  border-top-left-radius: 5px;
-  border-top-right-radius: 5px;
-
-  /* Add Text Padding */
-  padding-left: 12px;
-  padding-right: 12px;
-
-  /* Match Background Color of Box */
-  background: #fdfdfd;
-}
-
-/* Make the TabBox's Children Appear Above Title if Overlap Occurs */
-.TabBox-children {
-  position: relative;
-  z-index: 1;
-}
+  /* Tab Box */
+  .TabBox-box {
+    /* Light Border */
+    border: 0.15rem solid #dedede;
+    
+    /* Rounded Corners (except top-left) */
+    border-bottom-right-radius: 0.3rem;
+    border-bottom-left-radius: 0.3rem;
+    border-top-right-radius: 0.3rem;
+
+    /* Very Light Gray Border */
+    background: #fdfdfd;
+
+    /* Align Contents on Left */
+    text-align: left;
+
+    /* Add Text Padding */
+    padding-left: 0.3rem;
+    padding-right: 0.3rem;
+  }
+
+  /* Container for Title */
+  .TabBox-title-container {
+    /* Place on Left */
+    position: relative;
+    left: 0;
+    text-align: left;
+  }
+
+  /* Tab-style Title */
+  .TabBox-title {
+    /* Place so it Barely Overlaps the Box Border */
+    display: inline-block;
+    position: relative;
+    top: 0.15rem; /* Gives Illusion that Border Doesn't Exist Below Tab */
+
+    /* Title-sized Font */
+    font-size: 1.5rem;
+
+    /* Add Border on Top and Sides */
+    border-top: 0.15rem solid #dedede;
+    border-left: 0.15rem solid #dedede;
+    border-right: 0.15rem solid #dedede;
+
+    /* Round the Top Corners */
+    border-top-left-radius: 0.3rem;
+    border-top-right-radius: 0.3rem;
+
+    /* Add Text Padding */
+    padding-left: 0.5rem;
+    padding-right: 0.5rem;
+
+    /* Match Background Color of Box */
+    background: #fdfdfd;
+  }
+
+  /* Make the TabBox's Children Appear Above Title if Overlap Occurs */
+  .TabBox-children {
+    position: relative;
+    z-index: 1;
+  }
 `;
 
 /*------------------------------------------------------------------------*/
@@ -95,6 +101,7 @@ const TabBox: React.FC<Props> = (props) => {
   const {
     title,
     children,
+    noBottomPadding,
   } = props;
 
   /*------------------------------------------------------------------------*/
@@ -107,7 +114,7 @@ const TabBox: React.FC<Props> = (props) => {
 
   // Full UI
   return (
-    <div>
+    <div className={`TabBox-container ${noBottomPadding ? '' : 'mb-2'}`}>
       {/* Style */}
       <style>{style}</style>
 

package/src/helpers/genRouteHandler.ts

@@ -0,0 +1,326 @@
+// Import caccl functions
+import { cacclGetLaunchInfo } from '../server/initServer';
+
+// Import shared types
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+import ParamType from '../types/ParamType';
+
+// Import helpers
+import handleError from './handleError';
+import handleSuccess from './handleSuccess';
+
+/**
+ * Generate an express API route handler
+ * @author Gabe Abrams
+ * @param opts object containing all arguments
+ * @param opts.paramTypes map containing the types for each parameter that is
+ *   included in the request (map: param name => type)
+ * @param opts.handler function that processes the request
+ * @returns express route handler that takes the following arguments:
+ *   params (map: param name => value), handleSuccess (function for handling
+ *   successful requests), handleError (function for handling failed requests),
+ *   req (express request object), res (express response object)
+ */
+const genRouteHandler = (
+  opts: {
+    paramTypes?: {
+      [k: string]: ParamType
+    },
+    handler: (
+      opts: {
+        params: {
+          [k: string]: any
+        },
+        handleSuccess: (body: any) => void,
+        handleError: (error: any) => void,
+        req: any,
+        res: any,
+      },
+    ) => void,
+  },
+) => {
+  // Return a route handler
+  return async (req: any, res: any) => {
+    // Output params
+    const output: { [k in string]: any } = {};
+
+    /*----------------------------------------*/
+    /*              Parse Params              */
+    /*----------------------------------------*/
+
+    // Process items one by one
+    const paramList = Object.entries(opts.paramTypes ?? {});
+    for (let i = 0; i < paramList.length; i++) {
+      const [name, type] = paramList[i];
+
+      // Find the value as a string
+      const value = (
+        req.params[name]
+        || req.query[name]
+        || 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(
+              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(
+              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(
+            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(
+              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(
+            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(
+              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(
+              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(
+              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(
+          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 } = cacclGetLaunchInfo(req);
+    if (!launched || !launchInfo) {
+      return handleError(
+        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(
+        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 = !!(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(
+        res,
+        {
+          message: 'You switched sessions by opening Immersive Classroom in another tab. Please refresh the page and try again.',
+          code: ReactKitErrorCode.WrongCourse,
+          status: 401,
+        },
+      );
+    }
+
+    /*------------------------------------------------------------------------*/
+    /*                              Call handler                              */
+    /*------------------------------------------------------------------------*/
+
+    opts.handler({
+      params: output,
+      handleSuccess: (body: any) => {
+        return handleSuccess(res, body);
+      },
+      handleError: (error: any) => {
+        return handleError(res, error);
+      },
+      req,
+      res,
+    });
+  };
+};
+
+export default genRouteHandler;

package/src/helpers/getOrdinal.tsx

@@ -0,0 +1,13 @@
+const ORDINALS = ['th', 'st', 'nd', 'rd'];
+
+/**
+ * Get a number's ordinal
+ * @author Gabe Abrams
+ * @param num the number being analyzed
+ * @returns ordinal
+ */
+const getOrdinal = (num: number): string => {
+  return (ORDINALS[(num - 20) % 10] ?? ORDINALS[num] ?? ORDINALS[0]);
+};
+
+export default getOrdinal;

package/src/helpers/getTimeInfoInET.tsx

@@ -0,0 +1,56 @@
+/**
+ * Get current time info in US Boston Eastern Time, independent of machine
+ *   timezone
+ * @author Gabe Abrams
+ * @param {Date} [date=now] the date to get info on
+ * @returns object with timestamp (ms since epoch) and numbers
+ *   corresponding to ET time values for year, month, day, hour, minute
+ */
+const getTimeInfoInET = (date?: Date): {
+  timestamp: number,
+  year: number,
+  month: number,
+  day: number,
+  hour: number,
+  minute: number,
+} => {
+  // Create a time string
+  const d = (date || new Date());
+  const str = d.toLocaleString(
+    'en-US', // Using US encoding (it's the only one installed on containers)
+    { timeZone: 'America/New_York' } // Force EST timezone
+  );
+
+  // Parse the string for the date/time info
+  const [dateStr, timeStr] = str.split(', '); // Format: MM/DD/YYYY, HH:MM:SS AM
+  const [monthStr, dayStr, yearStr] = dateStr.split('/'); // Format: MM/DD/YYYY
+  const [hourStr, minStr, ending] = timeStr.split(':'); // Format: HH:MM:SS AM
+
+  // Create all time numbers
+  const timestamp = d.getTime();
+  const year = Number.parseInt(yearStr, 10);
+  const month = Number.parseInt(monthStr, 10);
+  const day = Number.parseInt(dayStr, 10);
+  const minute = Number.parseInt(minStr, 10);
+  let hour = Number.parseInt(hourStr, 10);
+  // Convert from am/pm to 24hr
+  const isAM = ending.toLowerCase().includes('am');
+  const isPM = !isAM;
+  if (isPM && hour !== 12) {
+    hour += 12;
+  } else if (isAM && hour === 12) {
+    hour = 0;
+  }
+
+  // Return
+  return {
+    timestamp,
+    year,
+    month,
+    day,
+    hour,
+    minute,
+  };
+};
+
+export default getTimeInfoInET;

package/src/helpers/handleError.ts

@@ -0,0 +1,65 @@
+// Import shared types
+import ReactKitErrorCode from '../types/ReactKitErrorCode';
+
+/**
+ * Handle an error and respond to the client
+ * @author Gabe Abrams
+ * @param res express response
+ * @param error error info
+ * @param opts.err the error to send to the client
+ *   or the error message
+ * @param [opts.code] an error code (only used if err.code is not
+ *   included)
+ * @param [opts.status=500] the https status code to use
+ *   defined)
+ */
+const handleError = (
+  res: any,
+  error: (
+    | {
+      message: any,
+      code?: string,
+      status?: number,
+    }
+    | Error
+    | string
+    | any
+  ),
+): undefined => {
+  // Get the error message
+  let message;
+  if (error && (error as any).message) {
+    message = (error.message || 'An unknown error occurred.');
+  } else if (typeof error === 'string') {
+    message = (
+      error.trim().length > 0
+        ? error
+        : 'An unknown error occurred.'
+    );
+  } else {
+    message = 'An unknown error occurred.';
+  }
+
+  // Get the error code
+  const code = (error.code || ReactKitErrorCode.NoCode);
+
+  // Get the status code
+  const status = (error.status || 500);
+
+  // Respond to user
+  res
+    // Set the http status code
+    .status(status)
+    // Send a JSON response
+    .json({
+      // Error message
+      message,
+      // Error code
+      code,
+      // Success = false flag so client can detect server-side errors
+      success: false,
+    });
+  return undefined;
+};
+
+export default handleError;

package/src/helpers/handleSuccess.ts

@@ -0,0 +1,18 @@
+/**
+ * Send successful API response
+ * @author Gabe Abrams
+ * @param res express response
+ * @param body the body of the response to send to the client
+ */
+const handleSuccess = (res: any, body: any): undefined => {
+  // Send a http 200 json response
+  res.json({
+    // Include the body as a parameter
+    body,
+    // Success = true flag so client can detect successful responses
+    success: true,
+  });
+  return undefined;
+};
+
+export default handleSuccess;