codeforlife 2.8.3 → 2.9.0

package/src/api/schemas.ts

@@ -1,243 +0,0 @@
-import * as yup from "yup"
-
-import type {
-  AdminSchoolTeacher,
-  AdminSchoolTeacherUser,
-  AuthFactor,
-  Class,
-  IndependentUser,
-  NonAdminSchoolTeacher,
-  NonAdminSchoolTeacherUser,
-  NonSchoolTeacher,
-  NonSchoolTeacherUser,
-  OtpBypassToken,
-  School,
-  SchoolTeacher,
-  SchoolTeacherUser,
-  Student,
-  StudentUser,
-  Teacher,
-  TeacherUser,
-  User,
-} from "./models"
-import { COUNTRY_ISO_CODES, UK_COUNTIES } from "../utils/general"
-import {
-  lowercaseAsciiAlphanumericString,
-  numericId,
-  unicodeAlphanumericString,
-  uppercaseAsciiAlphanumericString,
-} from "../utils/schema"
-import { type Schemas } from "../utils/api"
-
-// NOTE: do not use .required() here.
-const id = {
-  user: numericId(),
-  teacher: numericId(),
-  student: numericId(),
-  school: numericId(),
-  klass: uppercaseAsciiAlphanumericString().length(5),
-  authFactor: numericId(),
-  otpBypassToken: numericId(),
-}
-
-// -----------------------------------------------------------------------------
-// User Schemas
-// -----------------------------------------------------------------------------
-
-const _userTeacher: Omit<Schemas<Teacher>, "user"> = {
-  id: id.teacher.required(),
-  school: id.school,
-  is_admin: yup.bool().required(),
-}
-
-const _userStudent: Omit<Schemas<Student>, "user"> = {
-  id: id.student.required(),
-  school: id.school.required(),
-  klass: id.klass.required(),
-  auto_gen_password: yup.string().required(),
-}
-
-export const user: Schemas<User> = {
-  id: id.user.required(),
-  requesting_to_join_class: id.klass,
-  first_name: unicodeAlphanumericString({
-    spaces: true,
-    specialChars: "-'",
-  })
-    .required()
-    .max(150),
-  last_name: unicodeAlphanumericString({
-    spaces: true,
-    specialChars: "-'",
-  }).max(150),
-  last_login: yup.date(),
-  email: yup.string().email(),
-  password: yup.string().required(),
-  is_staff: yup.bool().required(),
-  is_active: yup.bool().required(),
-  date_joined: yup.date().required(),
-  teacher: yup.object(_userTeacher).optional(),
-  student: yup.object(_userStudent).optional(),
-}
-
-export const teacherUser: Schemas<TeacherUser> = {
-  ...user,
-  password: user.password
-    .min(10, "must be at least 10 characters long")
-    .matches(/[A-Z]/, "must contain at least one uppercase letter")
-    .matches(/[a-z]/, "must contain at least one lowercase letter")
-    .matches(/[0-9]/, "must contain at least one digit")
-    .matches(
-      /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/,
-      "must contain at least one special character",
-    ),
-  email: user.email.required(),
-  last_name: user.last_name.required(),
-  teacher: user.teacher.required(),
-  student: yup.string().oneOf([undefined]),
-}
-
-const _userSchoolTeacher: Omit<Schemas<SchoolTeacher>, "user"> = {
-  ..._userTeacher,
-  school: _userTeacher.school.required(),
-}
-
-export const schoolTeacherUser: Schemas<SchoolTeacherUser> = {
-  ...teacherUser,
-  teacher: yup.object(_userSchoolTeacher),
-}
-
-const _userAdminSchoolTeacher: Omit<Schemas<AdminSchoolTeacher>, "user"> = {
-  ..._userSchoolTeacher,
-  is_admin: _userSchoolTeacher.is_admin.isTrue(),
-}
-
-export const adminSchoolTeacherUser: Schemas<AdminSchoolTeacherUser> = {
-  ...schoolTeacherUser,
-  teacher: yup.object(_userAdminSchoolTeacher),
-}
-
-const _userNonAdminSchoolTeacher: Omit<
-  Schemas<NonAdminSchoolTeacher>,
-  "user"
-> = {
-  ..._userSchoolTeacher,
-  is_admin: _userSchoolTeacher.is_admin.isFalse(),
-}
-
-export const nonAdminSchoolTeacherUser: Schemas<NonAdminSchoolTeacherUser> = {
-  ...schoolTeacherUser,
-  teacher: yup.object(_userNonAdminSchoolTeacher),
-}
-
-const _userNonSchoolTeacher: Omit<Schemas<NonSchoolTeacher>, "user"> = {
-  ..._userTeacher,
-  school: yup.string().oneOf([undefined]),
-  is_admin: _userTeacher.is_admin.isFalse(),
-}
-
-export const nonSchoolTeacherUser: Schemas<NonSchoolTeacherUser> = {
-  ...teacherUser,
-  teacher: yup.object(_userNonSchoolTeacher),
-}
-
-export const studentUser: Schemas<StudentUser> = {
-  ...user,
-  password: user.password.min(6, "must be at least 6 characters long"),
-  email: user.email.oneOf([undefined]),
-  last_name: user.last_name.oneOf([undefined]),
-  teacher: yup.string().oneOf([undefined]),
-  student: user.student.required(),
-}
-
-export const indyUser: Schemas<IndependentUser> = {
-  ...user,
-  password: user.password
-    .min(8, "must be at least 8 characters long")
-    .matches(/[A-Z]/, "must contain at least one uppercase letter")
-    .matches(/[a-z]/, "must contain at least one lowercase letter")
-    .matches(/[0-9]/, "must contain at least one digit"),
-  email: user.email.required(),
-  last_name: user.last_name.required(),
-  teacher: yup.string().oneOf([undefined]),
-  student: yup.string().oneOf([undefined]),
-}
-
-// -----------------------------------------------------------------------------
-// Teacher Schemas
-// -----------------------------------------------------------------------------
-
-export const teacher: Schemas<Teacher> = {
-  ..._userTeacher,
-  user: id.user.required(),
-}
-
-export const schoolTeacher: Schemas<SchoolTeacher> = {
-  ..._userSchoolTeacher,
-  user: id.user.required(),
-}
-
-export const adminSchoolTeacher: Schemas<AdminSchoolTeacher> = {
-  ..._userAdminSchoolTeacher,
-  user: id.user.required(),
-}
-
-export const nonAdminSchoolTeacher: Schemas<NonAdminSchoolTeacher> = {
-  ..._userNonAdminSchoolTeacher,
-  user: id.user.required(),
-}
-
-export const nonSchoolTeacher: Schemas<NonSchoolTeacher> = {
-  ..._userNonSchoolTeacher,
-  user: id.user.required(),
-}
-
-// -----------------------------------------------------------------------------
-// Other Schemas
-// -----------------------------------------------------------------------------
-
-export const student: Schemas<Student> = {
-  ..._userStudent,
-  user: id.user.required(),
-}
-
-export const school: Schemas<School> = {
-  id: id.school.required(),
-  name: unicodeAlphanumericString({
-    spaces: true,
-    specialChars: "'.",
-  })
-    .required()
-    .max(200),
-  country: yup.string().oneOf(COUNTRY_ISO_CODES),
-  uk_county: yup.string().oneOf(UK_COUNTIES),
-}
-
-export const klass: Schemas<Class> = {
-  id: id.klass.required(),
-  teacher: id.teacher.required(),
-  school: id.school.required(),
-  name: unicodeAlphanumericString({
-    spaces: true,
-    specialChars: "-_",
-  })
-    .required()
-    .max(200),
-  read_classmates_data: yup.bool().required(),
-  receive_requests_until: yup.date(),
-}
-
-export const authFactor: Schemas<AuthFactor> = {
-  id: id.authFactor.required(),
-  user: id.user.required(),
-  type: yup
-    .string()
-    .oneOf(["otp"] as const)
-    .required(),
-}
-
-export const otpBypassToken: Schemas<OtpBypassToken> = {
-  id: id.otpBypassToken.required(),
-  user: id.user.required(),
-  token: lowercaseAsciiAlphanumericString().required().length(8),
-}

package/src/api/tagTypes.ts

@@ -1,12 +0,0 @@
-const tagTypes = [
-  // These are the tags for the common models used throughout our system.
-  // https://github.com/ocadotechnology/codeforlife-package-python/tree/main/codeforlife/user/models
-  // NOTE: Don't use the "Teacher" and "Student" tags. Use "User" instead.
-  "User",
-  "School",
-  "Class",
-  "AuthFactor",
-] as const
-
-export default tagTypes
-export type TagTypes = (typeof tagTypes)[number]

package/src/api/urls.ts

@@ -1,13 +0,0 @@
-import { modelUrls } from "../utils/api"
-
-const urls = {
-  user: modelUrls("users/", "users/<id>/"),
-  teacher: modelUrls("users/teachers/", "users/teachers/<id>/"),
-  student: modelUrls("users/students/", "users/students/<id>/"),
-  school: modelUrls("schools/", "schools/<id>/"),
-  class: modelUrls("classes/", "classes/<id>/"),
-  otpBypassToken: modelUrls("otp-bypass-tokens/", "otp-bypass-tokens/<id>/"),
-  authFactor: modelUrls("auth-factors/", "auth-factors/<id>/"),
-}
-
-export default urls

package/src/components/App.css

@@ -1,38 +0,0 @@
-@font-face {
-  font-family: "SpaceGrotesk";
-  src:
-    local("SpaceGrotesk"),
-    url("../fonts/ttf/SpaceGrotesk-VariableFont_wght.ttf") format("truetype");
-}
-
-@font-face {
-  font-family: "Inter";
-  src:
-    local("Inter"),
-    url("../fonts/ttf/Inter-VariableFont_slnt,wght.ttf") format("truetype");
-}
-
-html,
-body {
-  box-sizing: border-box;
-  height: 100%;
-  padding: 0;
-  margin: 0;
-}
-
-#root {
-  box-sizing: border-box;
-  min-height: 100%;
-  display: flex;
-  flex-direction: column;
-}
-
-#header,
-#footer {
-  flex-grow: 0;
-  flex-shrink: 0;
-}
-
-#body {
-  flex-grow: 1;
-}

package/src/components/App.tsx

@@ -1,152 +0,0 @@
-import { BrowserRouter, Routes as RouterRoutes } from "react-router-dom"
-import { CssBaseline, ThemeProvider } from "@mui/material"
-import { type FC, type JSX, type ReactNode } from "react"
-import { Provider, type ProviderProps } from "react-redux"
-import { type Action } from "redux"
-import { StaticRouter } from "react-router-dom/server"
-import { type ThemeProviderProps } from "@mui/material/styles/ThemeProvider"
-
-import "./App.css"
-import { SSR } from "../settings"
-import { useLocation } from "../hooks"
-// import { InactiveDialog, ScreenTimeDialog } from "../features"
-// import { useCountdown, useEventListener } from "../hooks"
-// import "../scripts"
-// import {
-//   configureFreshworksWidget,
-//   toggleOneTrustInfoDisplay,
-// } from "../utils/window"
-
-export interface AppProps<A extends Action = Action, S = unknown> {
-  path?: string
-  theme: ThemeProviderProps["theme"]
-  store: ProviderProps<A, S>["store"]
-  routes: ReactNode
-  header?: ReactNode
-  footer?: ReactNode
-  headerExcludePaths?: string[]
-  footerExcludePaths?: string[]
-  maxIdleSeconds?: number
-  maxTotalSeconds?: number
-}
-
-type BaseRoutesProps = Pick<
-  AppProps,
-  "routes" | "header" | "footer" | "headerExcludePaths" | "footerExcludePaths"
->
-
-const Routes: FC<BaseRoutesProps & { path: string }> = ({
-  path,
-  routes,
-  header = <></>, // TODO: "header = <Header />"
-  footer = <></>, // TODO: "footer = <Footer />"
-  headerExcludePaths = [],
-  footerExcludePaths = [],
-}) => (
-  <>
-    {!headerExcludePaths.includes(path) && header}
-    <RouterRoutes>{routes}</RouterRoutes>
-    {!footerExcludePaths.includes(path) && footer}
-  </>
-)
-
-const BrowserRoutes: FC<BaseRoutesProps> = props => {
-  const { pathname } = useLocation()
-
-  return <Routes path={pathname} {...props} />
-}
-
-const App = <A extends Action = Action, S = unknown>({
-  path,
-  theme,
-  store,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  maxIdleSeconds = 60 * 60,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  maxTotalSeconds = 60 * 60,
-  ...routesProps
-}: AppProps<A, S>): JSX.Element => {
-  // TODO: cannot use document during SSR
-  // const root = document.getElementById("root") as HTMLElement
-
-  // const [idleSeconds, setIdleSeconds] = useCountdown(maxIdleSeconds)
-  // const [totalSeconds, setTotalSeconds] = useCountdown(maxTotalSeconds)
-  // const resetIdleSeconds = useCallback(() => {
-  //   setIdleSeconds(maxIdleSeconds)
-  // }, [setIdleSeconds, maxIdleSeconds])
-
-  // const isIdle = idleSeconds === 0
-  // const tooMuchScreenTime = totalSeconds === 0
-
-  // useEventListener(root, "mousemove", resetIdleSeconds)
-  // useEventListener(root, "keypress", resetIdleSeconds)
-
-  // React.useEffect(() => {
-  //   configureFreshworksWidget("hide")
-  // }, [])
-
-  // if (import.meta.env.PROD) {
-  //   toggleOneTrustInfoDisplay()
-  // }
-
-  return (
-    <ThemeProvider theme={theme}>
-      <CssBaseline />
-      <Provider store={store}>
-        {/* <InactiveDialog open={isIdle} onClose={resetIdleSeconds} />
-        <ScreenTimeDialog
-          open={!isIdle && tooMuchScreenTime}
-          onClose={() => {
-            setTotalSeconds(maxTotalSeconds)
-          }}
-        /> */}
-        {SSR ? (
-          <StaticRouter location={path as string}>
-            <Routes path={path as string} {...routesProps} />
-          </StaticRouter>
-        ) : (
-          <BrowserRouter>
-            <BrowserRoutes {...routesProps} />
-          </BrowserRouter>
-        )}
-      </Provider>
-    </ThemeProvider>
-  )
-}
-
-export default App
-
-// TODO: figure out what to do with this
-// function useOneTrustScripts(): void {
-//   const oneTrustEventTypes = [
-//     useExternalScript({
-//       props: {
-//         src: "https://cdn-ukwest.onetrust.com/consent/5da42396-cb12-4493-8d04-5179033cfbad/OtAutoBlock.js",
-//         type: "text/javascript",
-//       },
-//       eventTypes: ["load", "error"],
-//     }),
-//     useExternalScript({
-//       props: {
-//         src: "https://cdn-ukwest.onetrust.com/scripttemplates/otSDKStub.js",
-//         type: "text/javascript",
-//         charset: "UTF-8",
-//       },
-//       attrs: {
-//         "data-domain-script": "5da42396-cb12-4493-8d04-5179033cfbad",
-//       },
-//       eventTypes: ["load", "error"],
-//     }),
-//     useExternalScript({
-//       props: {
-//         src: "https://cdn-ukwest.onetrust.com/scripttemplates/202302.1.0/otBannerSdk.js",
-//         async: true,
-//         type: "text/javascript",
-//       },
-//       eventTypes: ["load", "error"],
-//     }),
-//   ]
-//   if (oneTrustEventTypes.some(t => t === "error")) {
-//     alert("OneTrust failed to load!")
-//   }
-// }

package/src/components/ClickableTooltip.tsx

@@ -1,43 +0,0 @@
-import { Tooltip, type TooltipProps } from "@mui/material"
-import React from "react"
-
-import { wrap } from "../utils/general"
-
-export interface ClickableTooltipProps extends TooltipProps {}
-
-const ClickableTooltip: React.FC<ClickableTooltipProps> = ({
-  open = false,
-  onClick,
-  ...otherTooltipProps
-}) => {
-  const [_open, _setOpen] = React.useState(open)
-
-  React.useEffect(() => {
-    _setOpen(open)
-  }, [open])
-
-  return (
-    <Tooltip
-      open={_open}
-      onMouseOver={() => {
-        if (!_open) {
-          _setOpen(true)
-        }
-      }}
-      onMouseLeave={() => {
-        _setOpen(false)
-      }}
-      onClick={wrap(
-        {
-          after: () => {
-            _setOpen(!_open)
-          },
-        },
-        onClick,
-      )}
-      {...otherTooltipProps}
-    />
-  )
-}
-
-export default ClickableTooltip

package/src/components/CopyIconButton.test.tsx

@@ -1,16 +0,0 @@
-import { screen } from "@testing-library/react"
-
-import CopyIconButton from "./CopyIconButton"
-import { renderWithUser } from "../utils/test"
-
-test("Clicking button should copy content", async () => {
-  const content = "Example string to be copied."
-
-  const { user } = renderWithUser(<CopyIconButton content={content} />)
-
-  expect(await navigator.clipboard.readText()).toEqual("")
-
-  await user.click(screen.getByTestId("copy-icon-button"))
-
-  expect(await navigator.clipboard.readText()).toEqual(content)
-})

package/src/components/CopyIconButton.tsx

@@ -1,27 +0,0 @@
-import { IconButton, type IconButtonProps } from "@mui/material"
-import { ContentCopy as ContentCopyIcon } from "@mui/icons-material"
-import type { FC } from "react"
-
-export interface CopyIconButtonProps extends Omit<IconButtonProps, "onClick"> {
-  content: string
-}
-
-const CopyIconButton: FC<CopyIconButtonProps> = ({
-  content,
-  children = <ContentCopyIcon />,
-  ...otherIconButtonProps
-}) => {
-  return (
-    <IconButton
-      data-testid="copy-icon-button"
-      onClick={() => {
-        void navigator.clipboard.writeText(content)
-      }}
-      {...otherIconButtonProps}
-    >
-      {children}
-    </IconButton>
-  )
-}
-
-export default CopyIconButton

package/src/components/Countdown.tsx

@@ -1,42 +0,0 @@
-import { type FC, useState } from "react"
-import { Typography, type TypographyProps } from "@mui/material"
-
-import { useCountdown } from "../hooks"
-
-export interface CountdownProps extends Omit<TypographyProps, "children"> {
-  seconds: number
-  start?: boolean
-  onEnd: () => void
-}
-
-const Countdown: FC<CountdownProps> = ({
-  seconds,
-  start = true,
-  onEnd,
-  ...typographyProps
-}) => {
-  seconds = Math.floor(seconds)
-  const _seconds = useCountdown(seconds)[0]
-  const [end, setEnd] = useState(!start)
-
-  if (_seconds === 0 && !end) {
-    setEnd(true)
-    onEnd()
-  }
-
-  seconds = Math.floor(_seconds % 60)
-  const minutes = Math.floor(_seconds / 60)
-
-  return (
-    <>
-      {_seconds > 0 && (
-        <Typography {...typographyProps}>
-          {minutes > 0 && `${minutes} ${minutes > 1 ? "mins" : "min"} `}
-          {seconds > 0 && `${seconds} ${seconds > 1 ? "secs" : "sec"}`}
-        </Typography>
-      )}
-    </>
-  )
-}
-
-export default Countdown

package/src/components/DownloadFileButton.tsx

@@ -1,55 +0,0 @@
-import { Button, type ButtonProps } from "@mui/material"
-import { type FC, useEffect } from "react"
-import { Download as DownloadIcon } from "@mui/icons-material"
-
-export type DownloadFileButtonProps = ButtonProps & {
-  file:
-    | Blob
-    | MediaSource
-    | {
-        text: string
-        mimeType: "plain" | "csv"
-        name: string
-        charset?: string
-        extension?: string
-      }
-}
-
-const DownloadFileButton: FC<DownloadFileButtonProps> = ({
-  children = "Download",
-  endIcon = <DownloadIcon />,
-  file,
-  ...otherButtonProps
-}) => {
-  let url: undefined | string = undefined
-  let anchorProps: undefined | { download?: string; href: string } = undefined
-  if ("mimeType" in file) {
-    const { text, mimeType, name, charset = "utf-8" } = file
-    let { extension } = file
-
-    if (!extension) extension = "." + { plain: "txt", csv: "csv" }[mimeType]
-
-    anchorProps = {
-      download: name + extension,
-      href: `data:text/${mimeType};charset=${charset},${encodeURIComponent(text)}`,
-    }
-  } else {
-    url = URL.createObjectURL(file)
-
-    anchorProps = { href: url }
-  }
-
-  useEffect(() => {
-    return () => {
-      if (url) URL.revokeObjectURL(url)
-    }
-  }, [url])
-
-  return (
-    <Button endIcon={endIcon} {...otherButtonProps} {...anchorProps}>
-      {children}
-    </Button>
-  )
-}
-
-export default DownloadFileButton

package/src/components/ElevatedAppBar.tsx

@@ -1,41 +0,0 @@
-import {
-  AppBar,
-  type AppBarProps,
-  Container,
-  type ContainerProps,
-  Toolbar,
-  type ToolbarProps,
-  useScrollTrigger,
-} from "@mui/material"
-import { type FC, cloneElement } from "react"
-
-export interface ElevatedAppBarProps extends Omit<AppBarProps, "position"> {
-  containerProps: ContainerProps
-  toolbarProps?: ToolbarProps
-}
-
-const ElevatedAppBar: FC<ElevatedAppBarProps> = ({
-  containerProps,
-  toolbarProps,
-  elevation = 4,
-  children,
-  ...otherProps
-}) => {
-  const trigger = useScrollTrigger({
-    disableHysteresis: true,
-    threshold: 0,
-  })
-
-  return cloneElement(
-    <AppBar elevation={elevation} {...otherProps}>
-      <Container {...containerProps}>
-        <Toolbar {...toolbarProps}>{children}</Toolbar>
-      </Container>
-    </AppBar>,
-    {
-      position: trigger ? "fixed" : "sticky",
-    },
-  )
-}
-
-export default ElevatedAppBar