@anantagnanam/lms 0.0.0-stage → 0.2.0

package/astro/pages/certificate.astro

@@ -0,0 +1,57 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import CertificateCard from "../components/CertificateCard.astro";
+import { lmsPublic, lmsLearner, LmsError } from "@anantagnanam/lms/server";
+import type { Certificate } from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+let verification:
+  | {
+      id: string;
+      valid: boolean;
+      shared: boolean;
+      learnerName: string | null;
+      courseTitle: string;
+      issuerName: string;
+      issuedAt: string;
+      courseId?: string;
+    }
+  | undefined;
+let certificate: Certificate | null = null;
+let error = "";
+try {
+  verification = await lmsPublic<typeof verification>(
+    Astro.locals,
+    "certificates/verify",
+    { id: Astro.params.certificateId },
+    Astro.url.origin,
+  );
+  if (Astro.locals.user) {
+    try {
+      certificate = await lmsLearner<Certificate>(
+        Astro.locals,
+        "learner/certificate-by-id",
+        { id: Astro.params.certificateId },
+        Astro.url.origin,
+      );
+    } catch {}
+  }
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "Certificate unavailable.";
+}
+---
+
+<Layout title="Learning certificate" robots="noindex, follow">
+  <LearningShell>
+    {verification ? (
+      <CertificateCard verification={verification} certificate={certificate} />
+    ) : (
+      <section class="lms-gate">
+        <h1>Certificate unavailable</h1>
+        <p>{error}</p>
+      </section>
+    )}
+  </LearningShell>
+</Layout>

package/astro/pages/cohort.astro

@@ -0,0 +1,102 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import { lmsPublic, lmsLearner, loginUrl, courseUrl, LmsError } from "@anantagnanam/lms/server";
+import { basePath, loginPath } from "virtual:anantagnanam-lms/config";
+import type { CohortMembership, CourseCard } from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+let cohort:
+  | {
+      id: string;
+      title: string;
+      startsAt: string | null;
+      endsAt: string | null;
+      courses: CourseCard[];
+    }
+  | undefined;
+let membership: CohortMembership | null = null;
+let error = "";
+try {
+  cohort = await lmsPublic<typeof cohort>(
+    Astro.locals,
+    "cohort",
+    { id: Astro.params.cohortId },
+    Astro.url.origin,
+  );
+  if (Astro.locals.user)
+    membership = await lmsLearner<CohortMembership | null>(
+      Astro.locals,
+      "learner/cohort",
+      { cohortId: Astro.params.cohortId },
+      Astro.url.origin,
+    );
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "Cohort unavailable.";
+}
+---
+
+<Layout title={cohort?.title ?? "Cohort unavailable"} robots="noindex, follow">
+  <LearningShell>
+    {cohort ? (
+      <>
+        <header class="lms-dashboard-header">
+          <p class="lms-eyebrow">LEARN WITH A COHORT</p>
+          <h1>{cohort.title}</h1>
+          <p class="lms-lead">
+            A shared learning journey, with membership approved by an administrator.
+          </p>
+          {cohort.startsAt && (
+            <p>
+              Starts {new Date(cohort.startsAt).toLocaleDateString("en-IN")}
+              {cohort.endsAt
+                ? ` · Ends ${new Date(cohort.endsAt).toLocaleDateString("en-IN")}`
+                : ""}
+            </p>
+          )}
+        </header>
+        {membership ? (
+          <div class="lms-notice">
+            <strong>Membership {membership.status}</strong>
+            {membership.reason && <p>{membership.reason}</p>}
+            {membership.status === "pending" && (
+              <p>Your request is awaiting administrator approval.</p>
+            )}
+          </div>
+        ) : Astro.locals.user ? (
+          <form data-lms-route="learner/cohort/request" data-lms-reload>
+            <input type="hidden" name="cohortId" value={cohort.id} />
+            <button class="lms-btn" type="submit">
+              Request cohort membership →
+            </button>
+            <p data-lms-feedback aria-live="polite"></p>
+          </form>
+        ) : (
+          <a class="lms-btn" href={loginUrl(loginPath, Astro.url.pathname)}>
+            Sign in to request membership →
+          </a>
+        )}
+        <section class="lms-content-section">
+          <h2>Learning paths in this cohort</h2>
+          {cohort.courses.map((course) => (
+            <article class="lms-learning-card">
+              <h3>{course.title}</h3>
+              <p>{course.summary}</p>
+              <a
+                href={`${courseUrl(basePath, course.slug)}?cohort=${encodeURIComponent(cohort.id)}`}
+              >
+                Open course →
+              </a>
+            </article>
+          ))}
+        </section>
+      </>
+    ) : (
+      <section class="lms-gate">
+        <h1>Cohort unavailable</h1>
+        <p>{error}</p>
+      </section>
+    )}
+  </LearningShell>
+</Layout>

package/astro/pages/course.astro

@@ -0,0 +1,90 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import CourseOverview from "../components/CourseOverview.astro";
+import { lmsPublic, lmsLearner, LmsError } from "@anantagnanam/lms/server";
+import { basePath } from "virtual:anantagnanam-lms/config";
+import type {
+  CourseDetail,
+  PublicEnrollment,
+  ProgressSummary,
+  Review,
+  Page,
+  CohortMembership,
+} from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+const slug = Astro.params.slug ?? "";
+let course: CourseDetail | undefined;
+let enrollment: PublicEnrollment | null = null;
+let progress: ProgressSummary | undefined;
+let reviews: Page<Review> | undefined;
+let cohortMembership: CohortMembership | null = null;
+const cohortId = Astro.url.searchParams.get("cohort") ?? undefined;
+let error = "";
+try {
+  if (Astro.locals.user) {
+    const result = await lmsLearner<{
+      course: CourseDetail;
+      enrollment: PublicEnrollment | null;
+      progress: ProgressSummary;
+    }>(Astro.locals, "learner/course-by-slug", { slug }, Astro.url.origin);
+    course = result.course;
+    enrollment = result.enrollment;
+    progress = result.progress;
+    if (cohortId)
+      cohortMembership = await lmsLearner<CohortMembership | null>(
+        Astro.locals,
+        "learner/cohort",
+        { cohortId },
+        Astro.url.origin,
+      );
+  } else course = await lmsPublic<CourseDetail>(Astro.locals, "course", { slug }, Astro.url.origin);
+  try {
+    reviews = await lmsPublic<Page<Review>>(
+      Astro.locals,
+      "reviews",
+      { courseId: course.id },
+      Astro.url.origin,
+    );
+  } catch {}
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "Course unavailable.";
+}
+---
+
+<Layout
+  title={course?.title ?? "Course unavailable"}
+  description={course?.summary}
+  robots={course ? undefined : "noindex, follow"}
+>
+  <LearningShell>
+    {course && Astro.locals.user && (
+      <form class="lms-actions" data-lms-route="learner/saved/save">
+        <input type="hidden" name="courseId" value={course.id} />
+        <input type="hidden" name="saved" value="true" />
+        <button class="lms-btn lms-btn-outline" type="submit">
+          Save course to my library
+        </button>
+        <p data-lms-feedback aria-live="polite"></p>
+      </form>
+    )}
+    {course ? (
+      <CourseOverview
+        course={course}
+        enrollment={enrollment}
+        progress={progress}
+        reviews={reviews}
+        cohortId={cohortId}
+        cohortMembership={cohortMembership}
+      />
+    ) : (
+      <section class="lms-gate">
+        <h1>Course unavailable</h1>
+        <p>{error}</p>
+        <a href={basePath}>Explore courses →</a>
+      </section>
+    )}
+  </LearningShell>
+</Layout>

package/astro/pages/dashboard.astro

@@ -0,0 +1,34 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import LearnerDashboard from "../components/LearnerDashboard.astro";
+import { lmsLearner, loginUrl } from "@anantagnanam/lms/server";
+import { loginPath } from "virtual:anantagnanam-lms/config";
+import type { CourseCard, PublicEnrollment, ProgressSummary, Page } from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+if (!Astro.locals.user)
+  return Astro.redirect(loginUrl(loginPath, Astro.url.pathname + Astro.url.search));
+let page: Page<{ course: CourseCard; enrollment: PublicEnrollment; progress: ProgressSummary }> = {
+  items: [],
+  hasMore: false,
+};
+let error = "";
+try {
+  page = await lmsLearner<typeof page>(
+    Astro.locals,
+    "learner/dashboard",
+    { cursor: Astro.url.searchParams.get("cursor") ?? undefined },
+    Astro.url.origin,
+  );
+} catch (cause) {
+  Astro.response.status = 503;
+  error = cause instanceof Error ? cause.message : "Could not load your learning records.";
+}
+---
+
+<Layout title="My learning" robots="noindex, follow">
+  <LearningShell>
+    <LearnerDashboard page={page} error={error} />
+  </LearningShell>
+</Layout>

package/astro/pages/index.astro

@@ -0,0 +1,40 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import CourseCatalog from "../components/CourseCatalog.astro";
+import { lmsPublic, LmsError } from "@anantagnanam/lms/server";
+import type { Page, CourseCard } from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+let page: Page<CourseCard> = { items: [], hasMore: false };
+let academy = {
+  title: "Ananta Gnanam Academy",
+  description: "Build knowledge, one lesson at a time.",
+};
+let error = "";
+try {
+  [page, academy] = await Promise.all([
+    lmsPublic<Page<CourseCard>>(
+      Astro.locals,
+      "catalog",
+      Object.fromEntries(Astro.url.searchParams),
+      Astro.url.origin,
+    ),
+    lmsPublic<typeof academy>(Astro.locals, "academy", {}, Astro.url.origin),
+  ]);
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "The academy is temporarily unavailable.";
+}
+---
+
+<Layout title={academy.title} description={academy.description}>
+  <LearningShell>
+    <CourseCatalog
+      page={page}
+      title={academy.title}
+      description={academy.description}
+      error={error}
+    />
+  </LearningShell>
+</Layout>

package/astro/pages/lesson.astro

@@ -0,0 +1,103 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import LessonPlayer from "../components/LessonPlayer.astro";
+import LessonAvailabilityNote from "../components/LessonAvailabilityNote.astro";
+import { lmsPublic, lmsLearner, courseUrl, loginUrl, LmsError } from "@anantagnanam/lms/server";
+import { basePath, loginPath } from "virtual:anantagnanam-lms/config";
+import type {
+  CourseDetail,
+  PublicLesson,
+  PublicEnrollment,
+  ProgressSummary,
+} from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+let course: CourseDetail | undefined;
+let lesson: PublicLesson | undefined;
+let enrollment: PublicEnrollment | null = null;
+let progress: ProgressSummary | undefined;
+let error = "";
+let preview = false;
+try {
+  if (Astro.locals.user) {
+    const result = await lmsLearner<{
+      course: CourseDetail;
+      enrollment: PublicEnrollment | null;
+      progress: ProgressSummary;
+    }>(Astro.locals, "learner/course-by-slug", { slug: Astro.params.slug }, Astro.url.origin);
+    course = result.course;
+    enrollment = result.enrollment;
+    progress = result.progress;
+  } else
+    course = await lmsPublic<CourseDetail>(
+      Astro.locals,
+      "course",
+      { slug: Astro.params.slug },
+      Astro.url.origin,
+    );
+  if (enrollment && ["active", "completed"].includes(enrollment.status)) {
+    const result = await lmsLearner<{
+      course: CourseDetail;
+      lesson: PublicLesson;
+      enrollment: PublicEnrollment;
+      progress: ProgressSummary;
+    }>(
+      Astro.locals,
+      "learner/lesson",
+      { courseId: course.id, lessonId: Astro.params.lessonId },
+      Astro.url.origin,
+    );
+    lesson = result.lesson;
+    enrollment = result.enrollment;
+    progress = result.progress;
+  } else {
+    const result = await lmsPublic<{ course: CourseDetail; lesson: PublicLesson }>(
+      Astro.locals,
+      "preview",
+      { courseId: course.id, lessonId: Astro.params.lessonId },
+      Astro.url.origin,
+    );
+    lesson = result.lesson;
+    preview = true;
+  }
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "This lesson is unavailable.";
+}
+---
+
+<Layout
+  title={lesson?.title ?? "Continue your learning"}
+  description={lesson?.summary}
+  robots="noindex, follow"
+>
+  <LearningShell>
+    {course && lesson ? (
+      <LessonPlayer
+        course={course}
+        lesson={lesson}
+        enrollment={enrollment}
+        progress={progress}
+        preview={preview}
+      />
+    ) : (
+      <section class="lms-gate">
+        <p class="lms-eyebrow">ONE STEP AT A TIME</p>
+        <h1>Continue your learning</h1>
+        <p>{error}</p>
+        <LessonAvailabilityNote availability={progress?.availability[Astro.params.lessonId!]} />
+        {!Astro.locals.user && (
+          <a class="lms-btn" href={loginUrl(loginPath, Astro.url.pathname)}>
+            Sign in →
+          </a>
+        )}
+        {course && (
+          <p>
+            <a href={courseUrl(basePath, course.slug)}>Return to course overview →</a>
+          </p>
+        )}
+      </section>
+    )}
+  </LearningShell>
+</Layout>

package/astro/pages/library.astro

@@ -0,0 +1,173 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import { lmsLearner, loginUrl, courseUrl, LmsError } from "@anantagnanam/lms/server";
+import { basePath, loginPath } from "virtual:anantagnanam-lms/config";
+import type { Page, CourseCard, LearnerPath, LearnerPreferences } from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+if (!Astro.locals.user)
+  return Astro.redirect(loginUrl(loginPath, Astro.url.pathname + Astro.url.search));
+let saved: Page<{ courseId: string; course: CourseCard | null }> = { items: [], hasMore: false };
+let paths: Page<LearnerPath> = { items: [], hasMore: false };
+let preferences: { value: LearnerPreferences; revision: string | null } | undefined;
+let error = "";
+try {
+  [saved, paths, preferences] = await Promise.all([
+    lmsLearner<typeof saved>(
+      Astro.locals,
+      "learner/saved",
+      { cursor: Astro.url.searchParams.get("saved") ?? undefined },
+      Astro.url.origin,
+    ),
+    lmsLearner<typeof paths>(
+      Astro.locals,
+      "learner/paths",
+      { cursor: Astro.url.searchParams.get("paths") ?? undefined },
+      Astro.url.origin,
+    ),
+    lmsLearner<NonNullable<typeof preferences>>(
+      Astro.locals,
+      "learner/preferences",
+      {},
+      Astro.url.origin,
+    ),
+  ]);
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "Your library is unavailable.";
+}
+const more = (key: string, cursor: string) => {
+  const url = new URL(Astro.url);
+  url.searchParams.set(key, cursor);
+  return url.href;
+};
+---
+
+<Layout title="My library and preferences" robots="noindex, follow">
+  <LearningShell>
+    <h1>My library &amp; preferences</h1>
+    {error && <p role="alert">{error}</p>}
+    <section>
+      <h2>Saved courses</h2>
+      {!error && !saved.items.length && (
+        <p>Save a course from its overview to find it here later.</p>
+      )}
+      {saved.items.map(({ courseId, course }) => (
+        <article class="lms-learning-card">
+          <h3>
+            {course ? (
+              <a href={courseUrl(basePath, course.slug)}>{course.title}</a>
+            ) : (
+              "Course currently unavailable"
+            )}
+          </h3>
+          <form data-lms-route="learner/saved/save" data-lms-reload>
+            <input type="hidden" name="courseId" value={courseId} />
+            <input type="hidden" name="saved" value="false" />
+            <button class="lms-text-button" type="submit">
+              Remove from saved courses
+            </button>
+            <p data-lms-feedback aria-live="polite"></p>
+          </form>
+        </article>
+      ))}
+      {saved.hasMore && saved.cursor && (
+        <a href={more("saved", saved.cursor)}>More saved courses →</a>
+      )}
+    </section>
+    <section>
+      <h2>My learning paths</h2>
+      <p>
+        Your joined paths keep their original course lists when administrators edit the program.
+      </p>
+      {!error && !paths.items.length && <a href={`${basePath}/paths`}>Explore learning paths</a>}
+      {paths.items.map((path) => (
+        <article class="lms-learning-card">
+          <h3>{path.title}</h3>
+          <p>
+            {path.completed} of {path.total} courses completed
+          </p>
+          <progress value={path.completed} max={path.total} aria-label={`${path.title} progress`}>
+            {path.completed}/{path.total}
+          </progress>
+          <ol>
+            {path.courses.map(({ course, completed }) => (
+              <li>
+                {course ? (
+                  <a href={courseUrl(basePath, course.slug)}>{course.title}</a>
+                ) : (
+                  "Course currently unavailable"
+                )}
+                {completed && " · Completed"}
+              </li>
+            ))}
+          </ol>
+        </article>
+      ))}
+      {paths.hasMore && paths.cursor && (
+        <a href={more("paths", paths.cursor)}>More joined paths →</a>
+      )}
+    </section>
+    {preferences && (
+      <section class="lms-learning-card">
+        <h2>Learning preferences</h2>
+        <form class="lms-form" data-lms-route="learner/preferences/save" data-lms-reload>
+          <input type="hidden" name="expectedRevision" value={preferences.revision ?? ""} />
+          <label>
+            <span>Email updates</span>
+            <select name="emailNotifications">
+              <option value="true" selected={preferences.value.emailNotifications}>
+                Enabled when the academy sends email
+              </option>
+              <option value="false" selected={!preferences.value.emailNotifications}>
+                Off
+              </option>
+            </select>
+          </label>
+          <label>
+            <span>Weekly lesson goal</span>
+            <input
+              type="number"
+              name="weeklyGoalLessons"
+              min="0"
+              max="100"
+              value={preferences.value.weeklyGoalLessons}
+            />
+          </label>
+          <p>
+            Set 0 for no goal. Your goal is a personal target; it does not change deadlines or
+            completion requirements.
+          </p>
+          <button class="lms-btn" type="submit">
+            Save preferences
+          </button>
+          <p data-lms-feedback aria-live="polite"></p>
+        </form>
+      </section>
+    )}
+    <section class="lms-learning-card" data-lms-export>
+      <h2>Download my learning data</h2>
+      <p>
+        Download each section as JSON, five records per page. Continue until all pages are
+        downloaded. Exports include only your records and omit quiz answer keys.
+      </p>
+      <label>
+        Data section{" "}
+        <select data-lms-export-section>
+          <option value="enrollments">Learning history, notes and assessments</option>
+          <option value="discussions">Discussion contributions</option>
+          <option value="reviews">Course reviews</option>
+          <option value="notifications">Notifications</option>
+          <option value="saved_courses">Saved courses</option>
+          <option value="path_enrollments">Joined paths</option>
+          <option value="cohort_enrollments">Cohort membership</option>
+        </select>
+      </label>
+      <button type="button" class="lms-btn" data-lms-export-download>
+        Download first page
+      </button>
+      <p data-lms-feedback aria-live="polite"></p>
+    </section>
+  </LearningShell>
+</Layout>

package/astro/pages/paths.astro

@@ -0,0 +1,73 @@
+---
+import Layout from "virtual:anantagnanam-lms/layout";
+import LearningShell from "../components/LearningShell.astro";
+import { lmsPublic, courseUrl, loginUrl, LmsError } from "@anantagnanam/lms/server";
+import { basePath, loginPath } from "virtual:anantagnanam-lms/config";
+import type { Page, PublicPath } from "@anantagnanam/lms/types";
+export const prerender = false;
+Astro.response.headers.set("Cache-Control", "private, no-store");
+let page: Page<PublicPath> = { items: [], hasMore: false };
+let error = "";
+try {
+  page = await lmsPublic<typeof page>(
+    Astro.locals,
+    "paths",
+    { cursor: Astro.url.searchParams.get("cursor") ?? undefined },
+    Astro.url.origin,
+  );
+} catch (cause) {
+  Astro.response.status = cause instanceof LmsError ? cause.status : 503;
+  error = cause instanceof Error ? cause.message : "Learning paths unavailable.";
+}
+const next = new URL(Astro.url);
+next.searchParams.set("cursor", page.cursor ?? "");
+---
+
+<Layout title="Learning paths">
+  <LearningShell>
+    <h1>Learning paths</h1>
+    <p class="lms-lead">
+      Follow an ordered program of courses and track your progress in your library.
+    </p>
+    <p>
+      Join a path to save its course list. Enroll in each course separately; approval and
+      prerequisites still apply.
+    </p>
+    {error && <p role="alert">{error}</p>}
+    {!error && !page.items.length && <p>No learning paths have been published yet.</p>}
+    {page.items.map((path) => (
+      <article class="lms-learning-card">
+        <h2>{path.title}</h2>
+        <p class="lms-text">{path.description}</p>
+        <ol>
+          {path.courses.map((course) => (
+            <li>
+              {course ? (
+                <a href={courseUrl(basePath, course.slug)}>{course.title}</a>
+              ) : (
+                "Course currently unavailable"
+              )}
+            </li>
+          ))}
+        </ol>
+        {Astro.locals.user ? (
+          <form data-lms-route="learner/path/join">
+            <input type="hidden" name="pathId" value={path.id} />
+            <button class="lms-btn" type="submit">
+              Join path
+            </button>
+            <a class="lms-btn lms-btn-outline" href={`${basePath}/my-learning/library`}>
+              View my paths
+            </a>
+            <p data-lms-feedback aria-live="polite"></p>
+          </form>
+        ) : (
+          <a class="lms-btn" href={loginUrl(loginPath, Astro.url.pathname)}>
+            Sign in to join
+          </a>
+        )}
+      </article>
+    ))}
+    {page.hasMore && page.cursor && <a href={next.href}>More learning paths →</a>}
+  </LearningShell>
+</Layout>