@nualang/nualang-ui-components 0.1.1305 → 0.1.1307

package/dist/Assignments/AssignmentCard/AssignmentCard.js

@@ -1,12 +1,11 @@
 import { useMemo } from "react";
 import Typography from "@mui/material/Typography";
-import { Card, CardContent, Grid, Box, Divider, Button, LinearProgress, IconButton, Tooltip } from "@mui/material";
+import { Card, CardContent, Grid, Box, Divider, Button, IconButton, Tooltip } from "@mui/material";
 import PropTypes from "prop-types";
 import AssignmentExerciseSelector from "../AssignmentExerciseSelector/AssignmentExerciseSelector";
 import { courses as courseQuerys, ReactQuery } from "@nualang/nualang-api-and-queries/Queries";
 import useConfirm from "../../hooks/useConfirm";
-import { Delete } from "@mui/icons-material";
-import { Edit } from "@mui/icons-material";
+import { Delete, Edit } from "@mui/icons-material";
 import dayjs from "dayjs";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 export default function AssignmentCard({
@@ -41,6 +40,43 @@ export default function AssignmentCard({
       await deleteAssignment(classroomId, assignmentId);
     }
   };
+
+  // 🧠 Helper to format due or available text (adapted from MeetingPromptsList)
+  const formatAssignmentDueText = (availableDate, dueDate, t) => {
+    const now = dayjs();
+    const available = dayjs(availableDate);
+    const due = dayjs(dueDate);
+    const formattedDue = due.format("D MMM YYYY • h:mm A");
+    const formattedAvailable = available.format("D MMM YYYY • h:mm A");
+
+    // Case 1: Not yet available
+    if (available.isAfter(now)) {
+      const diffDays = available.startOf("day").diff(now.startOf("day"), "day");
+      let availableText = "";
+      if (diffDays === 0) {
+        availableText = t("available_today");
+      } else if (diffDays === 1) {
+        availableText = t("available_tomorrow");
+      } else {
+        availableText = `${t("available_in")} ${diffDays} ${t("days")}`;
+      }
+      return `${availableText} - ${formattedAvailable}`;
+    }
+
+    // Case 2: Available, now check due
+    const diffDays = due.startOf("day").diff(now.startOf("day"), "day");
+    let dueText = "";
+    if (diffDays < 0) {
+      dueText = t("past_due");
+    } else if (diffDays === 0) {
+      dueText = t("due_today");
+    } else if (diffDays === 1) {
+      dueText = t("due_tomorrow");
+    } else {
+      dueText = `${t("due_in")} ${diffDays} ${t("days")}`;
+    }
+    return `${dueText} - ${formattedDue}`;
+  };
   const {
     uniqueCourses
   } = useMemo(() => {
@@ -107,7 +143,10 @@ export default function AssignmentCard({
             alignItems: "center",
             children: [/*#__PURE__*/_jsx(Typography, {
               variant: "body1",
-              component: "div",
+              fontWeight: 600,
+              sx: {
+                color: "text.primary"
+              },
               children: assignment.title
             }), isNew && /*#__PURE__*/_jsx(Box, {
               ml: 2,
@@ -126,7 +165,7 @@ export default function AssignmentCard({
           children: /*#__PURE__*/_jsx(Typography, {
             variant: "button",
             color: "text.secondary",
-            children: dayjs(assignment.scheduleDate).isAfter(dayjs()) ? `${t("available_from")} ${dayjs(assignment.scheduleDate).format("DD MMM YYYY • h:mm A")}` : `${t("due")} ${dayjs(assignment.dueDate).format("DD MMM YYYY • h:mm A")}`
+            children: formatAssignmentDueText(assignment.scheduleDate, assignment.dueDate, t)
           })
         }), isCreator && /*#__PURE__*/_jsxs(Grid, {
           children: [/*#__PURE__*/_jsx(Tooltip, {
@@ -151,7 +190,8 @@ export default function AssignmentCard({
         mt: 2,
         children: [/*#__PURE__*/_jsx(Divider, {
           sx: {
-            marginBottom: 1.5
+            marginBottom: "12px",
+            marginTop: "12px"
           }
         }), /*#__PURE__*/_jsxs(Grid, {
           container: true,

package/dist/Assignments/AssignmentCardsList/AssignmentCardsList.js

@@ -1,6 +1,6 @@
 import React, { useState, useEffect } from "react";
 import PropTypes from "prop-types";
-import { Typography, Box, IconButton, Tooltip, Button, Skeleton } from "@mui/material";
+import { Typography, Box, IconButton, Tooltip, Button, Skeleton, Select, MenuItem, FormControl, InputLabel } from "@mui/material";
 import AssignmentCard from "../AssignmentCard/AssignmentCard";
 import Refresh from "@mui/icons-material/Refresh";
 import TeacherCreate from "../../img/teacher-create-2.svg";
@@ -31,6 +31,8 @@ const AssignmentCardsList = ({
   isChallengeModeStudent
 }) => {
   const [lastClickedExerciseId, setLastClickedExerciseId] = useState(null);
+  const [filter, setFilter] = useState("all"); // Filter state
+
   useEffect(() => {
     const stored = localStorage.getItem("lastClickedExercise");
     if (stored) {
@@ -44,6 +46,38 @@ const AssignmentCardsList = ({
       }
     }
   }, []);
+  const now = new Date();
+  const filteredAssignments = assignments.filter(assignment => {
+    if (!isCreator) {
+      if (Array.isArray(assignment.assignedStudents) && !assignment.assignedStudents.includes(memberId)) {
+        return false;
+      }
+      if (assignment.scheduleDate && new Date(assignment.scheduleDate) > now) {
+        return false;
+      }
+    }
+    return true;
+  }).filter(assignment => {
+    if (filter === "all") return true;
+    if (filter === "scheduled") {
+      return assignment.scheduleDate && new Date(assignment.scheduleDate) > now;
+    }
+    if (filter === "pastDue") {
+      return assignment.dueDate && new Date(assignment.dueDate) < now;
+    }
+    if (filter === "dueNext") {
+      return assignment.dueDate && new Date(assignment.dueDate) >= now;
+    }
+    return true;
+  }).sort((a, b) => {
+    if (filter === "dueNext") {
+      return new Date(a.dueDate) - new Date(b.dueDate);
+    }
+    if (filter === "scheduled") {
+      return new Date(a.scheduleDate) - new Date(b.scheduleDate);
+    }
+    return new Date(b.createdAt) - new Date(a.createdAt);
+  });
   if (isLoadingAssignments) {
     return /*#__PURE__*/_jsxs(Box, {
       mb: 1,
@@ -216,14 +250,39 @@ const AssignmentCardsList = ({
     mb: 1,
     children: [/*#__PURE__*/_jsxs(Box, {
       display: "flex",
-      justifyContent: "space-between",
+      justifyContent: isCreator ? "space-between" : "flex-end",
       alignItems: "center",
       sx: {
-        mb: 2
+        mb: 3,
+        mt: "8px"
       },
-      children: [/*#__PURE__*/_jsx(Typography, {
-        variant: "h5",
-        children: t("assignments")
+      children: [isCreator && /*#__PURE__*/_jsxs(FormControl, {
+        size: "large",
+        sx: {
+          minWidth: 140,
+          marginTop: 1
+        },
+        children: [/*#__PURE__*/_jsx(InputLabel, {
+          children: t("view")
+        }), /*#__PURE__*/_jsxs(Select, {
+          value: filter,
+          onChange: e => setFilter(e.target.value),
+          label: t("view"),
+          autoWidth: true,
+          children: [/*#__PURE__*/_jsx(MenuItem, {
+            value: "all",
+            children: t("all")
+          }), /*#__PURE__*/_jsx(MenuItem, {
+            value: "dueNext",
+            children: t("due_next")
+          }), /*#__PURE__*/_jsx(MenuItem, {
+            value: "pastDue",
+            children: t("past_due")
+          }), /*#__PURE__*/_jsx(MenuItem, {
+            value: "scheduled",
+            children: t("scheduled")
+          })]
+        })]
       }), /*#__PURE__*/_jsx(Tooltip, {
         placement: "left",
         title: t("refresh_assignments"),
@@ -231,17 +290,15 @@ const AssignmentCardsList = ({
           onClick: refreshAssignments,
           "aria-label": "refresh",
           size: "large",
-          children: /*#__PURE__*/_jsx(Refresh, {})
+          sx: {
+            size: "large"
+          },
+          children: /*#__PURE__*/_jsx(Refresh, {
+            fontSize: "inherit"
+          })
         })
       })]
-    }), assignments.filter(assignment => {
-      if (isCreator) return true;
-      if (Array.isArray(assignment.assignedStudents) && !assignment.assignedStudents.includes(memberId)) {
-        return false;
-      }
-      if (!assignment.scheduleDate) return true;
-      return new Date(assignment.scheduleDate) <= new Date();
-    }).sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt)).map((assignment, index) => /*#__PURE__*/_jsx(AssignmentCard, {
+    }), filteredAssignments.map((assignment, index) => /*#__PURE__*/_jsx(AssignmentCard, {
       index: index,
       lastAssignmentFetch: lastAssignmentFetch,
       assignment: assignment,

package/dist/Assignments/CreateAssignmentDialog/CreateAssignmentDialog.js

@@ -565,7 +565,18 @@ export default function CreateAssignmentDialog({
                 sx: {
                   width: "45%"
                 },
-                format: "DD MMM YYYY HH:mm"
+                format: "DD MMM YYYY HH:mm",
+                slotProps: {
+                  popper: {
+                    placement: "left-start",
+                    modifiers: [{
+                      name: "preventOverflow",
+                      options: {
+                        boundary: "viewport"
+                      }
+                    }]
+                  }
+                }
               })
             }), /*#__PURE__*/_jsx(Typography, {
               variant: "h4",
@@ -585,7 +596,18 @@ export default function CreateAssignmentDialog({
                 sx: {
                   width: "45%"
                 },
-                format: "DD MMM YYYY HH:mm"
+                format: "DD MMM YYYY HH:mm",
+                slotProps: {
+                  popper: {
+                    placement: "left-start",
+                    modifiers: [{
+                      name: "preventOverflow",
+                      options: {
+                        boundary: "viewport"
+                      }
+                    }]
+                  }
+                }
               })
             })]
           })]

package/dist/Cards/FeedbackCard/FeedbackCard.js

@@ -0,0 +1,411 @@
+import { useState, useEffect, useRef } from "react";
+import { Card, CardContent, CardActions, Typography, Avatar, Box, Button, TextField, Chip, Grid, IconButton, Tooltip } from "@mui/material";
+import { grey, green } from "@mui/material/colors";
+import AutoFixHighIcon from "@mui/icons-material/AutoFixHigh";
+import ErrorOutlineIcon from "@mui/icons-material/ErrorOutline";
+import CheckCircleIcon from "@mui/icons-material/CheckCircle";
+import { Formik } from "formik";
+import * as Yup from "yup";
+import RecordingDialog from "../../Dialogs/RecordingDialog/RecordingDialog";
+import PDFViewer from "../../Dialogs/PDFViewer/PDFViewer";
+import level1Rubric from '../../Dialogs/PDFViewer/rubrics/level1Rubric.pdf';
+import level2Rubric from '../../Dialogs/PDFViewer/rubrics/level2Rubric.pdf';
+import level3Rubric from '../../Dialogs/PDFViewer/rubrics/level3Rubric.pdf';
+import level4Rubric from '../../Dialogs/PDFViewer/rubrics/level4Rubric.pdf';
+import HelpOutlineIcon from "@mui/icons-material/HelpOutline";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+export default function FeedbackCard({
+  t = x => x,
+  discussionData = {},
+  userData = [],
+  hasSubmission = false,
+  aiGrade = {},
+  onGenerateFeedback = () => {},
+  onSubmitFeedback = () => {},
+  setSelectedRecording = () => {},
+  s3Url = "",
+  conversation = {},
+  existingFeedback = {}
+}) {
+  const [isRecordingDialogOpen, setIsRecordingDialogOpen] = useState(false);
+  const [hasBeenEdited, setHasBeenEdited] = useState(false);
+  const [isSubmitted, setIsSubmitted] = useState(false);
+  const [aiJustGenerated, setAiJustGenerated] = useState(false);
+  const formikRef = useRef(null);
+  const initialValuesRef = useRef(null);
+  const [openPDF, setOpenPDF] = useState(false);
+  const [pageNumber, setPageNumber] = useState(1);
+  const [scale, setScale] = useState(1);
+  const rubricMap = {
+    1: level1Rubric,
+    2: level2Rubric,
+    3: level3Rubric,
+    4: level4Rubric
+  };
+  const pdfUrl = rubricMap[discussionData?.level] || level1Rubric;
+  const selectedMembers = userData.filter(u => [discussionData?.meetingMembers || discussionData?.userIds].flat().includes(u?.memberId));
+  const joinedMembers = discussionData?.joinedMembers || [];
+  let attendedMembers = [];
+  let notAttendedMembers = [];
+  if (hasSubmission) {
+    attendedMembers = selectedMembers.filter(m => joinedMembers.includes(m?.memberId));
+    notAttendedMembers = selectedMembers.filter(m => !joinedMembers.includes(m?.memberId));
+  }
+  const hasFeedbackSubmitted = hasSubmission && attendedMembers.every(member => {
+    const feedback = existingFeedback[member.memberId];
+    return feedback && feedback.feedbackText && feedback.feedbackText.trim() !== "";
+  });
+  const getInitialValues = () => {
+    const feedbackData = {};
+    if (hasSubmission) {
+      attendedMembers.forEach(student => {
+        const existingStudentFeedback = existingFeedback[student.memberId];
+        feedbackData[student.memberId] = {
+          feedbackText: existingStudentFeedback?.feedbackText || ""
+        };
+      });
+      notAttendedMembers.forEach(student => {
+        feedbackData[student.memberId] = {
+          feedbackText: existingFeedback[student.memberId]?.feedbackText || t("not_present")
+        };
+      });
+    } else {
+      selectedMembers.forEach(student => {
+        feedbackData[student.memberId] = {
+          feedbackText: existingFeedback[student.memberId]?.feedbackText || ""
+        };
+      });
+    }
+    return {
+      feedbackData
+    };
+  };
+  const attendeesInThisDiscussion = userData.filter(user => [discussionData?.meetingMembers || discussionData?.userIds].flat().includes(user?.memberId));
+  const handleOpenRecordingDialog = () => {
+    if (hasSubmission) {
+      setSelectedRecording({
+        meetingId: discussionData?.meetingId,
+        extMeetingId: discussionData?.extMeetingId,
+        creator: discussionData?.creator || discussionData?.userId,
+        meetingCreator: discussionData?.meetingCreator
+      });
+      setIsRecordingDialogOpen(true);
+    }
+  };
+  useEffect(() => {
+    const initialVals = getInitialValues();
+    const previous = initialValuesRef.current;
+    const hasChanged = JSON.stringify(previous) !== JSON.stringify(initialVals);
+    if (hasChanged) {
+      initialValuesRef.current = initialVals;
+      setIsSubmitted(false);
+    }
+  }, [existingFeedback, hasSubmission, selectedMembers, attendedMembers, notAttendedMembers, t]);
+  useEffect(() => {
+    const formik = formikRef.current;
+    if (!formik) return;
+    if (!hasSubmission || !aiGrade || Object.keys(aiGrade).length === 0) return;
+    if (!aiJustGenerated) return;
+    userData.forEach(student => {
+      const keyVariants = [student.username, `${student.username}Student`, student.username?.replace(/\s+/g, "")];
+      const aiData = keyVariants.map(k => aiGrade?.[k]).find(v => v && typeof v === "object") || null;
+      if (aiData?.Feedback) {
+        formik.setFieldValue(`feedbackData.${student.memberId}.feedbackText`, aiData.Feedback);
+      }
+    });
+    setHasBeenEdited(true);
+    setIsSubmitted(false);
+    setAiJustGenerated(false);
+  }, [aiGrade, hasSubmission, userData, aiJustGenerated]);
+  const handleGenerateAI = async () => {
+    setAiJustGenerated(true);
+    await onGenerateFeedback(discussionData);
+  };
+  const handleOpenPDF = () => {
+    setOpenPDF(true);
+  };
+  const handleClosePDF = () => {
+    setOpenPDF(false);
+  };
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [/*#__PURE__*/_jsx(Formik, {
+      innerRef: formikRef,
+      initialValues: getInitialValues(),
+      validationSchema: getFeedbackValidationSchema(attendedMembers.map(m => m.memberId)),
+      onSubmit: async (values, {
+        setSubmitting
+      }) => {
+        setSubmitting(true);
+        try {
+          const allStudents = selectedMembers.map(m => m.memberId);
+          const feedbackDataWithAbsent = {
+            ...values.feedbackData
+          };
+          notAttendedMembers.forEach(student => {
+            feedbackDataWithAbsent[student.memberId] = {
+              feedbackText: t("not_present")
+            };
+          });
+          await onSubmitFeedback({
+            feedbackData: feedbackDataWithAbsent,
+            selectedAttendee: allStudents,
+            discussionData
+          });
+          initialValuesRef.current = JSON.parse(JSON.stringify(values));
+          setHasBeenEdited(false);
+          setIsSubmitted(true);
+        } catch (error) {
+          console.error("Error submitting feedback:", error);
+        } finally {
+          setSubmitting(false);
+        }
+      },
+      enableReinitialize: false,
+      children: ({
+        values,
+        handleSubmit,
+        setFieldValue,
+        isSubmitting
+      }) => {
+        const isFormValid = () => {
+          if (!hasSubmission) return false;
+          return attendedMembers.every(member => {
+            const feedback = values.feedbackData[member.memberId];
+            return feedback?.feedbackText && feedback.feedbackText.trim() !== "";
+          });
+        };
+        const hasChanges = () => {
+          if (!initialValuesRef.current) return false;
+          return attendedMembers.some(member => {
+            const current = values.feedbackData[member.memberId]?.feedbackText || "";
+            const initial = initialValuesRef.current.feedbackData[member.memberId]?.feedbackText || "";
+            return current !== initial;
+          });
+        };
+        const canSubmit = hasSubmission && !isSubmitting && isFormValid() && (hasChanges() || hasBeenEdited) && !isSubmitted;
+        return /*#__PURE__*/_jsx("form", {
+          onSubmit: handleSubmit,
+          children: /*#__PURE__*/_jsxs(Card, {
+            sx: {
+              mb: 3,
+              borderRadius: 3,
+              boxShadow: 3,
+              overflow: "hidden"
+            },
+            children: [/*#__PURE__*/_jsx(Box, {
+              sx: {
+                px: 3,
+                pt: 2,
+                pb: 1,
+                fontWeight: 600,
+                color: "text.secondary"
+              },
+              children: /*#__PURE__*/_jsxs(Grid, {
+                container: true,
+                alignItems: "center",
+                spacing: 3,
+                children: [/*#__PURE__*/_jsx(Grid, {
+                  size: {
+                    xs: 12,
+                    md: 2.5
+                  },
+                  children: /*#__PURE__*/_jsx(Typography, {
+                    variant: "subtitle2",
+                    children: t("student")
+                  })
+                }), /*#__PURE__*/_jsx(Grid, {
+                  size: {
+                    xs: 12,
+                    md: 9.5
+                  },
+                  children: /*#__PURE__*/_jsxs(Box, {
+                    sx: {
+                      display: "flex",
+                      alignItems: "center"
+                    },
+                    children: [/*#__PURE__*/_jsx(Typography, {
+                      variant: "subtitle2",
+                      children: t("feedback")
+                    }), /*#__PURE__*/_jsx(Tooltip, {
+                      title: t("rubric_info_desc"),
+                      children: /*#__PURE__*/_jsx(IconButton, {
+                        onClick: handleOpenPDF,
+                        color: "primary",
+                        "aria-label": t("rubric_info"),
+                        size: "small",
+                        children: /*#__PURE__*/_jsx(HelpOutlineIcon, {})
+                      })
+                    })]
+                  })
+                })]
+              })
+            }), /*#__PURE__*/_jsx(CardContent, {
+              sx: {
+                px: 3,
+                pt: 1
+              },
+              children: [...selectedMembers].sort((a, b) => {
+                const aJoined = joinedMembers.includes(a.memberId);
+                const bJoined = joinedMembers.includes(b.memberId);
+                return aJoined === bJoined ? 0 : aJoined ? -1 : 1;
+              }).map(student => {
+                const isAbsent = hasSubmission && !joinedMembers.includes(student.memberId);
+                const disabled = !hasSubmission || isAbsent;
+                const studentFeedback = values.feedbackData[student.memberId] || {};
+                return /*#__PURE__*/_jsx(Box, {
+                  sx: {
+                    py: 2
+                  },
+                  children: /*#__PURE__*/_jsxs(Grid, {
+                    container: true,
+                    alignItems: "flex-start",
+                    spacing: 3,
+                    children: [/*#__PURE__*/_jsx(Grid, {
+                      size: {
+                        xs: 12,
+                        md: 2.5
+                      },
+                      children: /*#__PURE__*/_jsxs(Box, {
+                        display: "flex",
+                        alignItems: "center",
+                        gap: 2,
+                        children: [/*#__PURE__*/_jsx(Avatar, {
+                          alt: student.username,
+                          src: student.userImage,
+                          sx: {
+                            width: 48,
+                            height: 48,
+                            filter: isAbsent ? "grayscale(100%)" : "none"
+                          }
+                        }), /*#__PURE__*/_jsx(Typography, {
+                          fontWeight: 600,
+                          sx: {
+                            color: isAbsent ? grey[500] : "text.primary"
+                          },
+                          children: student.username
+                        })]
+                      })
+                    }), /*#__PURE__*/_jsx(Grid, {
+                      size: {
+                        xs: 12,
+                        md: 9.5
+                      },
+                      children: /*#__PURE__*/_jsx(TextField, {
+                        variant: "outlined",
+                        fullWidth: true,
+                        multiline: true,
+                        disabled: disabled,
+                        value: studentFeedback.feedbackText || "",
+                        onChange: e => {
+                          setFieldValue(`feedbackData.${student.memberId}.feedbackText`, e.target.value);
+                          setHasBeenEdited(true);
+                          setIsSubmitted(false);
+                        },
+                        placeholder: t("Write your feedback here")
+                      })
+                    })]
+                  })
+                }, student.memberId);
+              })
+            }), /*#__PURE__*/_jsxs(CardActions, {
+              sx: {
+                px: 3,
+                py: 2,
+                justifyContent: "space-between",
+                alignItems: "center",
+                flexWrap: "wrap",
+                gap: 1.5
+              },
+              children: [/*#__PURE__*/_jsxs(Box, {
+                sx: {
+                  display: "flex",
+                  gap: 1.5
+                },
+                children: [!hasSubmission && /*#__PURE__*/_jsx(Chip, {
+                  label: t("group_not_submitted"),
+                  color: "warning",
+                  variant: "filled",
+                  icon: /*#__PURE__*/_jsx(ErrorOutlineIcon, {}),
+                  sx: {
+                    fontWeight: 500,
+                    borderRadius: "20px"
+                  }
+                }), hasFeedbackSubmitted && /*#__PURE__*/_jsx(Chip, {
+                  label: t("feedback_submitted"),
+                  color: "success",
+                  variant: "filled",
+                  icon: /*#__PURE__*/_jsx(CheckCircleIcon, {}),
+                  sx: {
+                    fontWeight: 500,
+                    borderRadius: "20px",
+                    bgcolor: green[600]
+                  }
+                })]
+              }), /*#__PURE__*/_jsxs(Box, {
+                sx: {
+                  display: "flex",
+                  gap: 1.5,
+                  ml: "auto"
+                },
+                children: [/*#__PURE__*/_jsx(Button, {
+                  variant: "outlined",
+                  disabled: !hasSubmission,
+                  onClick: handleOpenRecordingDialog,
+                  children: t("view_recording")
+                }), /*#__PURE__*/_jsx(Button, {
+                  variant: "contained",
+                  color: "secondary",
+                  disabled: !hasSubmission,
+                  onClick: handleGenerateAI,
+                  endIcon: /*#__PURE__*/_jsx(AutoFixHighIcon, {}),
+                  children: t("generate_feedback")
+                }), /*#__PURE__*/_jsx(Button, {
+                  type: "submit",
+                  variant: "contained",
+                  disabled: !canSubmit,
+                  children: isSubmitting ? t("submitting") : t("submit_feedback")
+                })]
+              })]
+            })]
+          })
+        });
+      }
+    }), /*#__PURE__*/_jsx(RecordingDialog, {
+      t: t,
+      open: isRecordingDialogOpen,
+      handleClose: () => setIsRecordingDialogOpen(false),
+      meetingID: discussionData?.meetingID || discussionData?.meetingId,
+      meetingPrompt: discussionData?.meetingPrompt,
+      meetingTopic: discussionData?.meetingTopic,
+      isTeacher: true,
+      attendeesData: attendeesInThisDiscussion,
+      conversation: conversation,
+      s3Url: s3Url,
+      playerRef: {
+        current: null
+      },
+      aiGrade: aiGrade,
+      hasBadLanguage: discussionData?.hasBadLanguage || false
+    }), /*#__PURE__*/_jsx(PDFViewer, {
+      open: openPDF,
+      handleClose: handleClosePDF,
+      pdfUrl: pdfUrl,
+      pageNumber: pageNumber,
+      setPageNumber: setPageNumber,
+      scale: scale,
+      setScale: setScale,
+      t: t
+    })]
+  });
+}
+const getFeedbackValidationSchema = attendedMemberIds => {
+  return Yup.object().shape({
+    feedbackData: Yup.object().test("all-attended-filled", "All attended students must have feedback", function (value) {
+      if (!attendedMemberIds || attendedMemberIds.length === 0) return true;
+      return attendedMemberIds.every(memberId => {
+        const feedback = value?.[memberId];
+        return feedback?.feedbackText && feedback.feedbackText.trim() !== "";
+      });
+    })
+  });
+};