@hed-hog/lms 0.0.304 → 0.0.306

package/hedhog/frontend/app/_components/create-lms-person-sheet.tsx.ejs

@@ -0,0 +1,164 @@
+'use client';
+
+import { PersonFormSheet } from '@/app/(app)/(libraries)/contact/person/_components/person-form-sheet';
+import type {
+  ContactTypeOption,
+  DocumentTypeOption,
+  Person,
+} from '@/app/(app)/(libraries)/contact/person/_components/person-types';
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+import { useMemo } from 'react';
+
+type CreatedInstructor = {
+  id: number;
+  personId: number;
+  name: string;
+  avatarId?: number | null;
+  email?: string | null;
+  phone?: string | null;
+  qualificationSlugs: string[];
+};
+
+type CreateLmsPersonSheetProps = {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  onCreated?: (instructor: CreatedInstructor) => void | Promise<void>;
+  title?: string;
+  description?: string;
+  submitLabel?: string;
+  successMessage?: string;
+  errorMessage?: string;
+  defaultQualificationSlugs?: string[];
+};
+
+function getPrimaryContactValue(
+  person: Person,
+  acceptedCodes: string[],
+  contactTypesById: Map<number, string>
+) {
+  const accepted = new Set(acceptedCodes.map((code) => code.toUpperCase()));
+  const contacts = (person.contact ?? []).filter((contact) => {
+    const code = (
+      contact.contact_type?.code ??
+      contactTypesById.get(contact.contact_type_id) ??
+      ''
+    ).toUpperCase();
+
+    return accepted.has(code);
+  });
+
+  const primaryContact =
+    contacts.find((contact) => contact.is_primary) ?? contacts[0];
+
+  return primaryContact?.value?.trim() || null;
+}
+
+export function CreateLmsPersonSheet({
+  open,
+  onOpenChange,
+  onCreated,
+  title,
+  description,
+  errorMessage,
+  defaultQualificationSlugs,
+}: CreateLmsPersonSheetProps) {
+  const { request, currentLocaleCode } = useApp();
+
+  const qualificationSlugs = useMemo(
+    () =>
+      defaultQualificationSlugs && defaultQualificationSlugs.length > 0
+        ? [...new Set(defaultQualificationSlugs)]
+        : ['course-lessons'],
+    [defaultQualificationSlugs]
+  );
+
+  const { data: contactTypes = [] } = useQuery<ContactTypeOption[]>({
+    queryKey: ['contact-person-contact-types', currentLocaleCode],
+    queryFn: async () => {
+      const response = await request<{ data: ContactTypeOption[] }>({
+        url: '/person-contact-type?pageSize=100',
+        method: 'GET',
+      });
+
+      return response.data.data || [];
+    },
+    placeholderData: (previous) => previous ?? [],
+  });
+
+  const { data: documentTypes = [] } = useQuery<DocumentTypeOption[]>({
+    queryKey: ['contact-person-document-types', currentLocaleCode],
+    queryFn: async () => {
+      const response = await request<{ data: DocumentTypeOption[] }>({
+        url: '/person-document-type?pageSize=100',
+        method: 'GET',
+      });
+
+      return response.data.data || [];
+    },
+    placeholderData: (previous) => previous ?? [],
+  });
+
+  const contactTypesById = useMemo(
+    () =>
+      new Map(
+        contactTypes.map((contactType) => [
+          contactType.contact_type_id,
+          contactType.code,
+        ])
+      ),
+    [contactTypes]
+  );
+
+  const handleSuccess = async (person?: Person) => {
+    if (!person?.id) {
+      throw new Error(
+        errorMessage || 'Nao foi possivel localizar a pessoa cadastrada.'
+      );
+    }
+
+    const email = getPrimaryContactValue(
+      person,
+      ['EMAIL'],
+      contactTypesById
+    );
+    const phone = getPrimaryContactValue(
+      person,
+      ['PHONE', 'MOBILE', 'WHATSAPP'],
+      contactTypesById
+    );
+
+    const response = await request<CreatedInstructor>({
+      url: '/lms/instructors',
+      method: 'POST',
+      data: {
+        personId: person.id,
+        name: person.name.trim(),
+        email: email || undefined,
+        phone: phone || undefined,
+        avatarId: person.avatar_id ?? null,
+        qualificationSlugs,
+        status: 'active',
+      },
+    });
+
+    if (!response.data?.id || !response.data?.name) {
+      throw new Error(errorMessage || 'Nao foi possivel vincular o professor.');
+    }
+
+    await onCreated?.(response.data);
+  };
+
+  return (
+    <PersonFormSheet
+      open={open}
+      person={null}
+      contactTypes={contactTypes}
+      documentTypes={documentTypes}
+      onOpenChange={onOpenChange}
+      onSuccess={handleSuccess}
+      title={title}
+      description={description}
+      allowedTypes={['individual']}
+    />
+  );
+}

package/hedhog/frontend/app/_components/create-lms-student-person-sheet.tsx.ejs

@@ -0,0 +1,120 @@
+'use client';
+
+import { PersonFormSheet } from '@/app/(app)/(libraries)/contact/person/_components/person-form-sheet';
+import type {
+  ContactTypeOption,
+  DocumentTypeOption,
+  Person,
+} from '@/app/(app)/(libraries)/contact/person/_components/person-types';
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+
+type CreateLmsStudentPersonSheetProps = {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  classGroupId: number | string;
+  onEnrolled?: (person: Person) => void | Promise<void>;
+  title?: string;
+  description?: string;
+  errorMessage?: string;
+  alreadyEnrolledMessage?: string;
+};
+
+function getErrorMessage(error: unknown) {
+  if (error instanceof Error && error.message) {
+    return error.message;
+  }
+
+  if (typeof error === 'object' && error && 'message' in error) {
+    const message = (error as { message?: unknown }).message;
+    if (typeof message === 'string' && message.trim()) {
+      return message;
+    }
+  }
+
+  return null;
+}
+
+export function CreateLmsStudentPersonSheet({
+  open,
+  onOpenChange,
+  classGroupId,
+  onEnrolled,
+  title,
+  description,
+  errorMessage,
+  alreadyEnrolledMessage,
+}: CreateLmsStudentPersonSheetProps) {
+  const { request, currentLocaleCode } = useApp();
+
+  const { data: contactTypes = [] } = useQuery<ContactTypeOption[]>({
+    queryKey: ['contact-person-contact-types', currentLocaleCode],
+    queryFn: async () => {
+      const response = await request<{ data: ContactTypeOption[] }>({
+        url: '/person-contact-type?pageSize=100',
+        method: 'GET',
+      });
+
+      return response.data.data || [];
+    },
+    placeholderData: (previous) => previous ?? [],
+  });
+
+  const { data: documentTypes = [] } = useQuery<DocumentTypeOption[]>({
+    queryKey: ['contact-person-document-types', currentLocaleCode],
+    queryFn: async () => {
+      const response = await request<{ data: DocumentTypeOption[] }>({
+        url: '/person-document-type?pageSize=100',
+        method: 'GET',
+      });
+
+      return response.data.data || [];
+    },
+    placeholderData: (previous) => previous ?? [],
+  });
+
+  const handleSuccess = async (person?: Person) => {
+    if (!person?.id) {
+      throw new Error(
+        errorMessage || 'Nao foi possivel localizar a pessoa cadastrada.'
+      );
+    }
+
+    try {
+      await request({
+        url: `/lms/classes/${classGroupId}/students`,
+        method: 'POST',
+        data: {
+          personId: person.id,
+        },
+      });
+    } catch (error: unknown) {
+      const message = getErrorMessage(error);
+
+      if (message?.toLowerCase().includes('already enrolled')) {
+        throw new Error(
+          alreadyEnrolledMessage || 'Esta pessoa ja esta matriculada na turma.'
+        );
+      }
+
+      throw new Error(
+        message || errorMessage || 'Nao foi possivel matricular o aluno.'
+      );
+    }
+
+    await onEnrolled?.(person);
+  };
+
+  return (
+    <PersonFormSheet
+      open={open}
+      person={null}
+      contactTypes={contactTypes}
+      documentTypes={documentTypes}
+      onOpenChange={onOpenChange}
+      onSuccess={handleSuccess}
+      title={title}
+      description={description}
+      allowedTypes={['individual']}
+    />
+  );
+}

package/hedhog/frontend/app/_components/lms-class-calendar.tsx.ejs

@@ -0,0 +1,272 @@
+'use client';
+
+import { Button } from '@/components/ui/button';
+import { format } from 'date-fns';
+import { Plus } from 'lucide-react';
+import { useCallback, useState } from 'react';
+import { EventSummaryPopover } from '../classes/[id]/_components/event-summary-popover';
+import { QuickCreateSessionPopover } from '../classes/[id]/_components/quick-create-session-popover';
+import { MobileCalendar, type MobileCalendarEvent } from './mobile-calendar';
+
+// ── Minimal types ─────────────────────────────────────────────────────────────
+
+interface Aula {
+  id: number;
+  titulo: string;
+  data: string;
+  horaInicio: string;
+  horaFim: string;
+  local: string;
+  meetingUrl: string;
+  tipo: 'presencial' | 'online';
+  status: string;
+  instructorId?: number | null;
+  instructorName?: string;
+  recurrence?: {
+    frequency: 'daily' | 'weekly' | 'monthly' | 'yearly';
+    interval: number;
+    until: string;
+    daysOfWeek?: Array<'MO' | 'TU' | 'WE' | 'TH' | 'FR' | 'SA' | 'SU'>;
+  } | null;
+  recurrenceId?: string | null;
+  occurrenceIndex?: number | null;
+  isException?: boolean;
+  isRecurring?: boolean;
+  cor?: string | null;
+  color?: string | null;
+}
+
+interface PresencaItem {
+  alunoId: number;
+  selecionado: boolean;
+  presente: boolean;
+}
+
+type OpenAulaSheetOptions = {
+  initialTab?: 'aulas' | 'chamada';
+  prefill?: {
+    titulo?: string;
+    data?: string;
+    horaInicio?: string;
+    horaFim?: string;
+    local?: string;
+    tipo?: string;
+    instrutorId?: string;
+    cor?: string;
+    recurrenceFrequency?: 'none' | 'daily' | 'weekly' | 'monthly' | 'yearly';
+    recurrenceUntil?: string;
+    recurrenceDaysOfWeek?: Array<
+      'MO' | 'TU' | 'WE' | 'TH' | 'FR' | 'SA' | 'SU'
+    >;
+    applyScope?: 'single' | 'series';
+  };
+  attendance?: PresencaItem[];
+};
+
+export type AulaCalendarEvent = {
+  id: number;
+  title: string;
+  start: Date;
+  end: Date;
+  resource: Aula;
+};
+
+type CalendarMessages = {
+  today: string;
+  previous: string;
+  next: string;
+  month: string;
+  week: string;
+  day: string;
+  agenda: string;
+  date: string;
+  time: string;
+  event: string;
+  noEventsInRange: string;
+  showMore: (count: number) => string;
+};
+
+interface LmsClassCalendarProps {
+  events: AulaCalendarEvent[];
+  classId: string;
+  alunos: Array<{ id: number; nome: string }>;
+  locale: string;
+  defaultStartTime?: string;
+  defaultEndTime?: string;
+  helperText: string;
+  newLessonLabel: string;
+  calendarMessages: CalendarMessages;
+  mobileCalendarLabels: {
+    previousLabel: string;
+    nextLabel: string;
+    noEventsLabel: string;
+  };
+  onNewLesson: () => void;
+  onOpenAulaSheet: (aula?: Aula, options?: OpenAulaSheetOptions) => void;
+  onSessionSaved: (aula: Aula) => void;
+}
+
+// ── Component ─────────────────────────────────────────────────────────────────
+
+export function LmsClassCalendar({
+  events,
+  classId,
+  alunos,
+  locale,
+  defaultStartTime = '19:00',
+  defaultEndTime = '22:00',
+  helperText,
+  newLessonLabel,
+  calendarMessages,
+  mobileCalendarLabels,
+  onNewLesson,
+  onOpenAulaSheet,
+  onSessionSaved,
+}: LmsClassCalendarProps) {
+  const [calendarDate, setCalendarDate] = useState(new Date());
+
+  const [quickCreateOpen, setQuickCreateOpen] = useState(false);
+  const [quickCreateSlot, setQuickCreateSlot] = useState<{
+    date: string;
+    startTime: string;
+    endTime: string;
+  } | null>(null);
+  const [quickCreateAnchor, setQuickCreateAnchor] = useState<{
+    x: number;
+    y: number;
+  } | null>(null);
+
+  const [eventSummaryOpen, setEventSummaryOpen] = useState(false);
+  const [selectedEventSummary, setSelectedEventSummary] = useState<Aula | null>(
+    null
+  );
+  const [eventSummaryAnchor, setEventSummaryAnchor] = useState<{
+    x: number;
+    y: number;
+  } | null>(null);
+
+  const getEventColor = useCallback((event: MobileCalendarEvent<Aula>) => {
+    const persistedColor = event.resource.cor ?? event.resource.color;
+
+    if (persistedColor) {
+      return persistedColor;
+    }
+
+    return event.resource.tipo === 'presencial' ? '#3b82f6' : '#22c55e';
+  }, []);
+
+  const handleSelectEvent = useCallback(
+    (event: { resource?: Aula }, anchor: { x: number; y: number }) => {
+      if (!event.resource) return;
+      setSelectedEventSummary(event.resource);
+      setEventSummaryAnchor(anchor);
+      setEventSummaryOpen(true);
+    },
+    []
+  );
+
+  const handleOpenSheetFromSummary = useCallback(() => {
+    if (!selectedEventSummary) return;
+    setEventSummaryOpen(false);
+    onOpenAulaSheet(selectedEventSummary);
+  }, [onOpenAulaSheet, selectedEventSummary]);
+
+  const handleOpenAttendanceFromSummary = useCallback(() => {
+    if (!selectedEventSummary) return;
+    setEventSummaryOpen(false);
+    onOpenAulaSheet(selectedEventSummary, { initialTab: 'chamada' });
+  }, [onOpenAulaSheet, selectedEventSummary]);
+
+  const handleSelectDay = useCallback(
+    (date: Date, anchor: { x: number; y: number }) => {
+      setQuickCreateSlot({
+        date: format(date, 'yyyy-MM-dd'),
+        startTime: defaultStartTime,
+        endTime: defaultEndTime,
+      });
+      setQuickCreateAnchor(anchor);
+      setQuickCreateOpen(true);
+    },
+    [defaultStartTime, defaultEndTime]
+  );
+
+  const handleQuickCreateMoreOptions = useCallback(
+    (values: {
+      titulo: string;
+      data: string;
+      horaInicio: string;
+      horaFim: string;
+      cor: string;
+      recurrenceFrequency?: 'none' | 'daily' | 'weekly' | 'monthly' | 'yearly';
+      recurrenceUntil?: string;
+      recurrenceDaysOfWeek?: Array<
+        'MO' | 'TU' | 'WE' | 'TH' | 'FR' | 'SA' | 'SU'
+      >;
+      attendance: PresencaItem[];
+      initialTab: 'aulas' | 'chamada';
+    }) => {
+      onOpenAulaSheet(undefined, {
+        initialTab: values.initialTab,
+        prefill: {
+          titulo: values.titulo,
+          data: values.data,
+          horaInicio: values.horaInicio,
+          horaFim: values.horaFim,
+          cor: values.cor,
+          recurrenceFrequency: values.recurrenceFrequency,
+          recurrenceUntil: values.recurrenceUntil,
+          recurrenceDaysOfWeek: values.recurrenceDaysOfWeek,
+        },
+        attendance: values.attendance,
+      });
+    },
+    [onOpenAulaSheet]
+  );
+
+  return (
+    <>
+      <div className="mb-4 flex items-center justify-between">
+        <p className="text-sm text-muted-foreground">{helperText}</p>
+        <Button size="sm" className="gap-2" onClick={onNewLesson}>
+          <Plus className="size-4" />
+          {newLessonLabel}
+        </Button>
+      </div>
+
+      {/* Unified custom calendar grid — all viewports */}
+      <MobileCalendar
+        events={events}
+        date={calendarDate}
+        locale={locale}
+        previousLabel={mobileCalendarLabels.previousLabel}
+        nextLabel={mobileCalendarLabels.nextLabel}
+        noEventsLabel={mobileCalendarLabels.noEventsLabel}
+        onNavigate={setCalendarDate}
+        onSelectEvent={handleSelectEvent}
+        onSelectDay={handleSelectDay}
+        getEventColor={getEventColor}
+      />
+
+      <QuickCreateSessionPopover
+        open={quickCreateOpen}
+        onOpenChange={setQuickCreateOpen}
+        slot={quickCreateSlot}
+        anchor={quickCreateAnchor}
+        classId={classId}
+        students={alunos}
+        onSaved={onSessionSaved}
+        onMoreOptions={handleQuickCreateMoreOptions}
+      />
+
+      <EventSummaryPopover
+        open={eventSummaryOpen}
+        onOpenChange={setEventSummaryOpen}
+        anchor={eventSummaryAnchor}
+        classId={classId}
+        event={selectedEventSummary}
+        onOpenSheet={handleOpenSheetFromSummary}
+        onRecordAttendance={handleOpenAttendanceFromSummary}
+      />
+    </>
+  );
+}