@hed-hog/lms 0.0.361 → 0.0.365

package/hedhog/frontend/app/courses/[id]/structure/_data/use-course-content-overview.ts.ejs

@@ -0,0 +1,53 @@
+'use client';
+
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+
+export type CourseContentOverview = {
+  structure: {
+    moduleCount: number;
+    lessonCount: number;
+    publishedLessonCount: number;
+    lessonsByType: {
+      video: number;
+      questao: number;
+      post: number;
+    };
+  };
+  videos: {
+    lessonCount: number;
+    withTranscription: number;
+    withXp: number;
+  };
+  media: {
+    extractedImageCount: number;
+  };
+  resources: {
+    fileCount: number;
+  };
+  storage: {
+    totalBytes: number;
+    totalFileCount: number;
+    categories: Array<{
+      key: string;
+      fileCount: number;
+      totalBytes: number;
+    }>;
+  };
+};
+
+export function useCourseContentOverviewQuery(courseId: string | null) {
+  const { request } = useApp();
+
+  return useQuery<CourseContentOverview | null>({
+    queryKey: ['course-content-overview', courseId],
+    enabled: Boolean(courseId),
+    queryFn: async () => {
+      const res = await request<CourseContentOverview>({
+        url: `/lms/courses/${courseId}/overview`,
+        method: 'GET',
+      });
+      return res.data ?? null;
+    },
+    initialData: null,
+  });
+}

package/hedhog/frontend/app/courses/[id]/structure/_data/use-course-exports.ts.ejs

@@ -0,0 +1,106 @@
+'use client';
+
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+
+export type ScormVisualSettings = {
+  primaryColor?: string;
+  fontFamily?: string;
+  fontSize?: string;
+  sidebarWidth?: number;
+  sidebarPosition?: string;
+  progressStyle?: string;
+  sidebarTheme?: string;
+};
+
+export type CourseExportRecord = {
+  id: number;
+  format: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  settings: Record<string, unknown> | null;
+  duration_seconds: number | null;
+  error_message: string | null;
+  created_at: string;
+  finished_at: string | null;
+  file_id: number | null;
+  notification_id: number | null;
+  file: {
+    id: number;
+    path: string;
+    filename: string;
+    size: number | null;
+  } | null;
+  user: {
+    id: number;
+    name: string;
+    photo_id: number | null;
+  };
+};
+
+export function courseExportsQueryKey(courseId: string) {
+  return ['course-exports', courseId] as const;
+}
+
+export function useCourseExportsQuery(courseId: string | null) {
+  const { request } = useApp();
+
+  return useQuery<CourseExportRecord[]>({
+    queryKey: courseExportsQueryKey(courseId ?? ''),
+    enabled: Boolean(courseId),
+    queryFn: async () => {
+      const res = await request<CourseExportRecord[]>({
+        url: `/lms/courses/${courseId}/exports`,
+        method: 'GET',
+      });
+      return res.data ?? [];
+    },
+    initialData: [],
+  });
+}
+
+export function useCreateCourseExportMutation(courseId: string | null) {
+  const { request } = useApp();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (payload: {
+      format: 'scorm_1_2';
+      visualSettings?: ScormVisualSettings;
+    }) => {
+      const res = await request<{
+        exportId: number;
+        queueJobId: number;
+        notificationId: number;
+      }>({
+        url: `/lms/courses/${courseId}/exports`,
+        method: 'POST',
+        data: payload,
+      });
+      return res.data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: courseExportsQueryKey(courseId ?? ''),
+      });
+    },
+  });
+}
+
+export function useDeleteCourseExportMutation(courseId: string | null) {
+  const { request } = useApp();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: async (exportId: number) => {
+      await request({
+        url: `/lms/courses/${courseId}/exports/${exportId}`,
+        method: 'DELETE',
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: courseExportsQueryKey(courseId ?? ''),
+      });
+    },
+  });
+}

package/hedhog/frontend/app/courses/[id]/structure/_data/use-course-structure-mutations.ts.ejs

@@ -20,7 +20,7 @@
  *      onError:  restore cache snapshot + Zustand rollback
  */
 
-import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
 import { useTranslations } from 'next-intl';
 import { toast } from 'sonner';
 
@@ -54,6 +54,9 @@ import {
   updateCourse as apiUpdateCourse,
   updateLesson as apiUpdateLesson,
   updateSession as apiUpdateSession,
+  listQuestions as apiListQuestions,
+  createQuestion as apiCreateQuestion,
+  type CreateQuestionPayload,
 } from './services/course-structure.service';
 import type { CourseStructureCacheData } from './use-course-structure-query';
 import { courseStructureQueryKey } from './use-course-structure-query';
@@ -1052,3 +1055,79 @@ export function useMoveLessonsMutation() {
     },
   });
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// useUpdateResourceTypeMutation (🆕 NOVO)
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface UpdateResourceTypeVars {
+  lessonId: string;
+  resourceId: string;
+  newType: string;
+  newTypeLabel?: string;
+}
+
+/**
+ * Mutation: PATCH /lms/courses/:id/lessons/:lessonId/resources/:resourceId
+ *
+ * Atualiza o tipo (type) de um recurso e refetch a estrutura.
+ * Cache: invalidateQueries para refetch em background
+ */
+export function useUpdateResourceTypeMutation() {
+  const t = useTranslations('lms.courseStructure');
+  const { request } = useApp();
+  const queryClient = useQueryClient();
+  const courseId = useStructureStore((s) => s.courseId);
+
+  return useMutation({
+    mutationFn: async ({ lessonId, resourceId, newType }: UpdateResourceTypeVars) => {
+      const response = await request<Resource>({
+        url: `/lms/courses/${courseId}/lessons/${lessonId}/resources/${resourceId}`,
+        method: 'PATCH',
+        data: { type: newType },
+      });
+      return response.data;
+    },
+    onSuccess: (_, { newType, newTypeLabel }) => {
+      // Invalidate e deixar refetch em background
+      void queryClient.invalidateQueries({
+        queryKey: courseStructureQueryKey(courseId),
+      });
+      toast.success(
+        t('mutations.resource.updateTypeSuccess', {
+          type: newTypeLabel ?? newType,
+        })
+      );
+    },
+    onError: () => {
+      void queryClient.invalidateQueries({
+        queryKey: courseStructureQueryKey(courseId),
+      });
+      toast.error(t('mutations.resource.updateTypeError'));
+    },
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// useQuestionsQuery / useCreateQuestionMutation
+// ─────────────────────────────────────────────────────────────────────────────
+
+export function useQuestionsQuery(search?: string) {
+  const { request } = useApp();
+  return useQuery({
+    queryKey: ['lms-questions', search ?? ''],
+    queryFn: () => apiListQuestions(request, search),
+    staleTime: 30_000,
+  });
+}
+
+export function useCreateQuestionMutation() {
+  const { request } = useApp();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (dto: CreateQuestionPayload) => apiCreateQuestion(request, dto),
+    onSuccess: () => {
+      void queryClient.invalidateQueries({ queryKey: ['lms-questions'] });
+    },
+  });
+}

package/hedhog/frontend/app/courses/[id]/structure/_data/use-course-xp-overview.ts.ejs

@@ -0,0 +1,76 @@
+'use client';
+
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+
+export type CourseXpOverviewLesson = {
+  courseLessonId: number;
+  lessonCode: string | null;
+  lessonTitle: string;
+  totalXp: number;
+  status: string;
+  segmentCount: number;
+  hasMap: boolean;
+};
+
+export type CourseXpOverviewArea = {
+  xpAreaId: number;
+  slug: string;
+  name: string;
+  xp: number;
+  lessonCount: number;
+  segmentCount: number;
+  sharePercent: number;
+};
+
+export type CourseXpOverviewSkill = {
+  xpSkillId: number;
+  slug: string;
+  name: string;
+  xp: number;
+  lessonCount: number;
+  segmentCount: number;
+  sharePercent: number;
+};
+
+export type CourseXpOverviewLearningType = {
+  xpLearningTypeId: number;
+  slug: string;
+  name: string;
+  multiplier: number;
+  xp: number;
+  lessonCount: number;
+  segmentCount: number;
+  sharePercent: number;
+};
+
+export type CourseXpOverview = {
+  summary: {
+    totalLessons: number;
+    mappedLessons: number;
+    unmappedLessons: number;
+    totalXp: number;
+    totalSegments: number;
+    averageXpPerMappedLesson: number;
+  };
+  lessons: CourseXpOverviewLesson[];
+  areas: CourseXpOverviewArea[];
+  skills: CourseXpOverviewSkill[];
+  learningTypes: CourseXpOverviewLearningType[];
+};
+
+export function useCourseXpOverviewQuery(courseId: string | null) {
+  const { request, currentLocaleCode } = useApp();
+
+  return useQuery<CourseXpOverview | null>({
+    queryKey: ['course-xp-overview', courseId, currentLocaleCode],
+    enabled: Boolean(courseId),
+    queryFn: async () => {
+      const response = await request<CourseXpOverview>({
+        url: `/lms/xp/lesson-maps/course/${courseId}/overview`,
+        method: 'GET',
+      });
+      return response.data ?? null;
+    },
+    initialData: null,
+  });
+}

package/hedhog/frontend/app/courses/[id]/structure/_data/use-lesson-xp-map.ts.ejs

@@ -0,0 +1,128 @@
+'use client';
+
+import { useApp, useQuery } from '@hed-hog/next-app-provider';
+import { useQueryClient } from '@tanstack/react-query';
+import { useCallback, useState } from 'react';
+
+export type LessonXpSegmentLearningType = {
+  xpLearningTypeId: number;
+  slug: string;
+  name: string;
+  multiplier: number;
+  weightPercent: number;
+};
+
+export type LessonXpSegmentArea = {
+  xpAreaId: number;
+  weightPercent: number;
+};
+
+export type LessonXpSegmentSkill = {
+  xpSkillId: number;
+  weightPercent: number;
+};
+
+export type LessonXpSegment = {
+  id: number;
+  startSeconds: number;
+  endSeconds: number;
+  xpValue: number;
+  difficulty: 'easy' | 'medium' | 'hard' | 'expert';
+  shouldGrantXp: boolean;
+  aiSummary: string | null;
+  aiConfidence: number | null;
+  sortOrder: number;
+  areas: LessonXpSegmentArea[];
+  skills: LessonXpSegmentSkill[];
+  learningTypes: LessonXpSegmentLearningType[];
+};
+
+export type LessonXpMapStatus =
+  | 'pending'
+  | 'processing'
+  | 'ready'
+  | 'needs_review'
+  | 'approved'
+  | 'rejected';
+
+export type LessonXpMap = {
+  id: number;
+  courseLessonId: number;
+  lessonTitle: string;
+  version: number;
+  totalXp: number;
+  status: LessonXpMapStatus;
+  generatedAt: string | null;
+  reviewedAt: string | null;
+  reviewNotes: string | null;
+  aiModelVersion: string | null;
+  processingError: string | null;
+  createdAt: string;
+  updatedAt: string;
+  segments: LessonXpSegment[];
+};
+
+export function useLessonXpMapQuery(
+  lessonId: string | null,
+  activeTab: string
+) {
+  const { request, currentLocaleCode } = useApp();
+  const enabled = Boolean(lessonId) && activeTab === 'xp';
+
+  return useQuery<LessonXpMap | null>({
+    queryKey: ['lesson-xp-map', lessonId, currentLocaleCode],
+    enabled,
+    queryFn: async () => {
+      const res = await request<LessonXpMap>({
+        url: `/lms/xp/lesson-maps/lesson/${lessonId}`,
+        method: 'GET',
+      });
+      return res.data ?? null;
+    },
+    initialData: null,
+    refetchInterval: (query) => {
+      const data = query.state.data as LessonXpMap | null;
+      return data?.status === 'processing' ? 3000 : false;
+    },
+  });
+}
+
+export function useRecalculateLessonXpMutation(lessonId: string | null) {
+  const { request, currentLocaleCode } = useApp();
+  const queryClient = useQueryClient();
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const mutate = useCallback(
+    async (options?: {
+      onSuccess?: (data: LessonXpMap) => void;
+      onError?: (message: string) => void;
+    }) => {
+      if (!lessonId) return;
+      setIsPending(true);
+      setError(null);
+      try {
+        const res = await request<LessonXpMap>({
+          url: `/lms/xp/lesson-maps/lesson/${lessonId}/recalculate`,
+          method: 'POST',
+        });
+        void queryClient.invalidateQueries({
+          queryKey: ['lesson-xp-map', lessonId, currentLocaleCode],
+        });
+        options?.onSuccess?.(res.data);
+      } catch (err: any) {
+        const message: string =
+          err?.response?.data?.message ??
+          err?.message ??
+          'Erro ao iniciar recálculo';
+        setError(message);
+        options?.onError?.(message);
+      } finally {
+        setIsPending(false);
+      }
+    },
+    [currentLocaleCode, lessonId, request, queryClient]
+  );
+
+  return { mutate, isPending, error };
+}

package/hedhog/frontend/app/courses/[id]/structure/_data/use-lms-settings-query.ts.ejs

@@ -3,7 +3,6 @@
 import { useApp, useQuery } from '@hed-hog/next-app-provider';
 
 export interface LmsFeatureFlags {
-  videoConversionEnabled: boolean;
   imageExtractionEnabled: boolean;
   transcriptionEnabled: boolean;
   youtubeEnabled: boolean;
@@ -11,7 +10,6 @@ export interface LmsFeatureFlags {
 }
 
 const DEFAULT_FLAGS: LmsFeatureFlags = {
-  videoConversionEnabled: true,
   imageExtractionEnabled: true,
   transcriptionEnabled: true,
   youtubeEnabled: true,

package/hedhog/frontend/app/courses/[id]/structure/_data/use-transcription-segments.ts.ejs

@@ -74,3 +74,33 @@ export function useUpdateTranscriptionSegmentsMutation(
 
   return { mutate, isPending, error };
 }
+
+export function useStartTranscriptionMutation(lessonId: string | null) {
+  const { request } = useApp();
+  const [isPending, setIsPending] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  const mutate = useCallback(
+    async (options?: { onSuccess?: () => void; onError?: (err: Error) => void }) => {
+      setIsPending(true);
+      setError(null);
+      try {
+        await request({
+          url: `/lms/lessons/${lessonId}/transcription/start`,
+          method: 'POST',
+        });
+        options?.onSuccess?.();
+      } catch (err) {
+        const e = err instanceof Error ? err : new Error(String(err));
+        setError(e);
+        options?.onError?.(e);
+        throw e;
+      } finally {
+        setIsPending(false);
+      }
+    },
+    [lessonId, request]
+  );
+
+  return { mutate, isPending, error };
+}

package/hedhog/frontend/app/courses/[id]/structure/_utils/xp-color-config.ts.ejs

@@ -0,0 +1,115 @@
+const AREA_SEMANTIC_PALETTE = [
+  '#0f766e',
+  '#0891b2',
+  '#0ea5e9',
+  '#14b8a6',
+  '#22c55e',
+  '#65a30d',
+  '#06b6d4',
+  '#2563eb',
+];
+
+const SKILL_SEMANTIC_PALETTE = [
+  '#c2410c',
+  '#ea580c',
+  '#f97316',
+  '#fb7185',
+  '#e11d48',
+  '#dc2626',
+  '#f59e0b',
+  '#d97706',
+];
+
+const LEARNING_TYPE_SEMANTIC_PALETTE = [
+  '#6d28d9',
+  '#7c3aed',
+  '#8b5cf6',
+  '#a855f7',
+  '#9333ea',
+  '#c026d3',
+  '#6366f1',
+  '#4f46e5',
+];
+
+type PaletteKind = 'area' | 'skill' | 'learningType';
+
+function hashSeed(seed: number | string) {
+  if (typeof seed === 'number') {
+    return Math.abs(seed);
+  }
+
+  let hash = 0;
+  for (let index = 0; index < seed.length; index += 1) {
+    hash = (hash << 5) - hash + seed.charCodeAt(index);
+    hash |= 0;
+  }
+
+  return Math.abs(hash);
+}
+
+function getPalette(kind: PaletteKind) {
+  switch (kind) {
+    case 'area':
+      return AREA_SEMANTIC_PALETTE;
+    case 'skill':
+      return SKILL_SEMANTIC_PALETTE;
+    case 'learningType':
+      return LEARNING_TYPE_SEMANTIC_PALETTE;
+    default:
+      return AREA_SEMANTIC_PALETTE;
+  }
+}
+
+const FALLBACK_XP_COLOR = '#0f766e';
+
+export function pickXpSemanticColor(
+  kind: PaletteKind,
+  seed: number | string,
+  index = 0
+) {
+  const palette = getPalette(kind);
+  const paletteIndex = (hashSeed(seed) + index) % palette.length;
+  return palette[paletteIndex] ?? palette[0] ?? FALLBACK_XP_COLOR;
+}
+
+export function resolveXpAreaColor(options: {
+  areaId?: number | string | null;
+  areaSlug?: string | null;
+  index?: number;
+  persistedColor?: string | null;
+}) {
+  const persistedColor = options.persistedColor?.trim();
+  if (persistedColor) {
+    return persistedColor;
+  }
+
+  return pickXpSemanticColor(
+    'area',
+    options.areaSlug ?? options.areaId ?? 'area',
+    options.index ?? 0
+  );
+}
+
+export function resolveXpSkillColor(options: {
+  skillId?: number | string | null;
+  skillSlug?: string | null;
+  index?: number;
+}) {
+  return pickXpSemanticColor(
+    'skill',
+    options.skillSlug ?? options.skillId ?? 'skill',
+    options.index ?? 0
+  );
+}
+
+export function resolveXpLearningTypeColor(options: {
+  learningTypeId?: number | string | null;
+  learningTypeSlug?: string | null;
+  index?: number;
+}) {
+  return pickXpSemanticColor(
+    'learningType',
+    options.learningTypeSlug ?? options.learningTypeId ?? 'learning-type',
+    options.index ?? 0
+  );
+}