Online Courses

interface CourseListItem {
  courseId: string;
  name: string | null;        // localized product name
  slug: string;               // product slug (PDP link)
  imageUrl: string | null;
  totalLessons: number;
  completedLessons: number;
  enrolledAt: number;         // epoch ms
  expiresAt: number | null;   // null = lifetime access
  isExpired: boolean;
  contentAvailableFrom?: number | null; // course start; render a countdown while in the future
}

interface CourseDetail {
  courseId: string;
  name: string | null;
  slug: string;
  imageUrl: string | null;
  welcomeText: string | null; // markdown, show above the content
  contentAvailableFrom?: number | null; // course start; every lesson stays locked until then
  enrolledAt: number;
  expiresAt: number | null;
  totalLessons: number;
  completedLessons: number;
  aiTutorEnabled: boolean;    // render the AI tutor widget only when true
  discussionEnabled: boolean; // render the lesson discussion only when true
  modules: CourseModule[];
  certificate?: { code: string; issuedAt: number } | null; // present at 100 %
}

interface CourseModule {
  id: string;
  title: string;
  lessons: CourseLesson[];
}

interface CourseLesson {
  id: string;
  title: string;
  isPreview: boolean;         // preview lessons ignore drip and are always unlocked
  isUnlocked: boolean;
  unlockAt: number | null;    // when a locked lesson unlocks; null once unlocked
  isCompleted: boolean;
  videoUrl: string | null;    // null while locked
  content: string | null;     // markdown, null while locked
  attachments: CourseAttachment[]; // empty while locked
  quizQuestionCount: number;  // 0 = no quiz; load via getLessonQuiz() once unlocked
}

interface LessonQuiz {
  courseId: string;
  lessonId: string;
  passPercent: number;        // 70, the score that completes the lesson
  questions: { id: string; question: string; options: string[] }[];
}

interface QuizResult {
  courseId: string;
  lessonId: string;
  totalQuestions: number;
  correctCount: number;
  scorePercent: number;
  passPercent: number;
  passed: boolean;
  lessonCompleted: boolean;   // true when the passing score completed the lesson
  results: {                  // correct answers revealed only AFTER submitting
    questionId: string;
    selectedIndex: number | null;
    correctIndex: number;
    correct: boolean;
  }[];
  progress: { totalLessons: number; completedLessons: number } | null;
}

interface CourseCertificate {
  courseId: string;
  courseName: string | null;
  code: string;               // public verification code
  issuedAt: number;
}

interface CertificateVerification {
  valid: boolean;
  code: string;
  courseId: string;
  courseName: string | null;
  studentName: string;        // full name, or a masked e-mail (j***@example.com)
  issuedAt: number;
}

interface CourseAttachment {
  name: string;
  url: string;
  fileSize?: number;          // bytes
}

interface CourseProgress {
  courseId: string;
  lessonId: string;
  totalLessons: number;
  completedLessons: number;
}

const { data, error } = await client.customer.getCourses();
// data: { items: CourseListItem[] }

const { data: course } = await client.customer.getCourse(courseId);
// data: CourseDetail

const { data } = await client.customer.completeLesson(courseId, lessonId);
// data: CourseProgress

const { data: quiz } = await client.customer.getLessonQuiz(courseId, lessonId);
// quiz: LessonQuiz

const { data: result } = await client.customer.submitLessonQuiz(courseId, lessonId, [
  { questionId: quiz.questions[0].id, selectedIndex: 2 },
  // ... one answer per question; unanswered questions count as wrong
]);
// result: QuizResult, reveals correctIndex per question, passed, lessonCompleted

const { data } = await client.customer.getCourseCertificates();
// data: { items: CourseCertificate[] }

const { data, error } = await client.certificates.verify(code);
// data: CertificateVerification

const { data: blob } = await client.certificates.downloadPdf(code);
if (blob) {
  const url = URL.createObjectURL(blob);
  const link = Object.assign(document.createElement("a"), {
    href: url,
    download: `certifikat-${code}.pdf`,
  });
  link.click();
  URL.revokeObjectURL(url);
}

const thread = await behio.customer.getLessonTutorThread(courseId, lessonId);
// { courseId, lessonId, enabled, items: [{ id, question, answer, createdAt }] }

const message = await behio.customer.askLessonTutor(
  courseId,
  lessonId,
  "Jak se liší drip od pevného data?",
);
// { id, question, answer, createdAt }, append it to the thread

const list = await behio.customer.getLessonComments(courseId, lessonId, 1);
// { enabled, page, pageSize, totalCount,
//   items: [{ id, body, authorName, isMine, createdAt, replies: [...] }] }

const comment = await behio.customer.postLessonComment(courseId, lessonId, "Super lekce!");
const reply = await behio.customer.postLessonComment(courseId, lessonId, "Souhlasím", comment.id);

await behio.customer.deleteLessonComment(courseId, lessonId, comment.id);
// only the customer's OWN comments; anything else returns 404

const note = await behio.customer.getLessonNote(courseId, lessonId);
// { courseId, lessonId, body, updatedAt }

await behio.customer.saveLessonNote(courseId, lessonId, "Timestamp 12:30 - skvělý příklad");

import { useCourses } from "@behio/storefront-sdk/react";

const { courses, isLoading, error, refetch } = useCourses();
// courses: CourseListItem[]

import { useCourse } from "@behio/storefront-sdk/react";

const { course, isLoading, completeLesson, isCompleting } = useCourse(courseId);
// course: CourseDetail | undefined

await completeLesson(lesson.id);

import { useLessonQuiz } from "@behio/storefront-sdk/react";

const { quiz, submitQuiz, isSubmitting, result } = useLessonQuiz(courseId, lessonId);

const outcome = await submitQuiz(answers); // QuizResult

import { useCourseCertificates } from "@behio/storefront-sdk/react";

const { certificates } = useCourseCertificates();
// certificates: CourseCertificate[]

import { useCertificateVerification } from "@behio/storefront-sdk/react";

const { verification, isLoading, error } = useCertificateVerification(code);
// error with code NOT_FOUND = invalid certificate

import { useLessonTutor } from "@behio/storefront-sdk/react";

const { messages, enabled, ask, isAsking } = useLessonTutor(courseId, lessonId);
// messages: CourseTutorMessage[] (oldest first); hide the widget when !enabled

await ask("Můžete mi vysvětlit ten příklad jinak?");
// the answer is appended to `messages` automatically

import { useLessonComments } from "@behio/storefront-sdk/react";

const { comments, totalCount, enabled, postComment, deleteComment } =
  useLessonComments(courseId, lessonId, { page: 1 });

await postComment("Super lekce!");
await postComment("Souhlasím", parentCommentId); // one-level reply
await deleteComment(myCommentId); // own comments only

import { useLessonNote } from "@behio/storefront-sdk/react";

const { body, updatedAt, save, isSaving } = useLessonNote(courseId, lessonId);
// render a textarea with defaultValue={body}, call save(value) on blur

const { courses } = useCourses();

return courses.map((c) => (
  <a key={c.courseId} href={`/account/courses/${c.courseId}`}>
    <img src={c.imageUrl ?? "/placeholder.png"} alt="" />
    <h3>{c.name}</h3>
    <progress value={c.completedLessons} max={c.totalLessons} />
    {c.isExpired && <span>Přístup vypršel</span>}
  </a>
));

const { course, completeLesson } = useCourse(courseId);
const [activeId, setActiveId] = useState<string | null>(null);

const lessons = course?.modules.flatMap((m) => m.lessons) ?? [];
const active = lessons.find((l) => l.id === activeId) ?? lessons.find((l) => l.isUnlocked);

return (
  <div className="grid grid-cols-[280px_1fr]">
    <nav>
      {course?.modules.map((m) => (
        <section key={m.id}>
          <h4>{m.title}</h4>
          {m.lessons.map((l) => (
            <button key={l.id} disabled={!l.isUnlocked} onClick={() => setActiveId(l.id)}>
              {l.isCompleted ? "✓" : l.isUnlocked ? "▶" : "🔒"} {l.title}
              {!l.isUnlocked && l.unlockAt && (
                <time>{new Date(l.unlockAt).toLocaleDateString()}</time>
              )}
            </button>
          ))}
        </section>
      ))}
    </nav>
    <main>
      {active?.videoUrl && <iframe src={active.videoUrl} allowFullScreen />}
      {active?.content && <Markdown>{active.content}</Markdown>}
      {active?.attachments.map((a) => (
        <a key={a.url} href={a.url} download>{a.name}</a>
      ))}
      {active && !active.isCompleted && (
        <button onClick={() => completeLesson(active.id)}>Označit jako dokončené</button>
      )}
    </main>
  </div>
);