@dataclouder/ngx-lessons 0.0.30 → 0.0.31

package/src/lib/services/lesson-ai.service.ts

@@ -0,0 +1,103 @@
+import { Injectable, inject } from '@angular/core';
+import { IAgentCard, IMiniAgentCard, TextEngines, ConversationType } from '@dataclouder/ngx-agent-cards';
+import { ILesson, LangCodeDescription, LESSONS_TOKEN, LessonsAbstractService } from '../components/lesson-mini-components/components/lessons.clases';
+
+// Re-define or import constants if they are not exported from the component file
+const DEFAULT_LESSON_AGENT_CARD: IAgentCard = {
+  conversationSettings: {
+    conversationType: ConversationType.General,
+    textEngine: TextEngines.SimpleText,
+    autoStart: true,
+  },
+  characterCard: {
+    data: {
+      name: 'Lesson Master',
+      description: 'You are an AI developed by Polilan Company, you are a lesson master, you are going to help the user to learn english',
+      tags: ['lesson', 'master', 'ai'],
+      post_history_instructions:
+        'Your reply should be always short, 1 or 2 paragraphs at most, and to the point, and you should ask friendly questions all the time',
+    },
+  },
+  model: { provider: 'google' },
+};
+
+function getDefaultLessonEvaluatorAgentCard(lessonText: string): IMiniAgentCard {
+  return {
+    expectedResponseType: `interface EvalResult {
+      score: number;                       // Score of the user's response 0 to 3
+      feedback: string;                    // Feedback of the user's understanding of the conversation
+    }`,
+    messages: [],
+    model: { id: 'gpt-4o-mini', provider: 'openai' },
+    sources: [lessonText],
+    task: `User is reading a taking a lesson, now their are having a conversation,
+    you have to evaluate the current conversation, and give a feedback of the user understanding of the lesson,
+    this is the lesson:  ${lessonText}`,
+  };
+}
+
+@Injectable({
+  providedIn: 'root', // Or provide appropriately if it's library-specific
+})
+export class LessonAIService {
+  private readonly lessonService = inject<LessonsAbstractService>(LESSONS_TOKEN);
+  // TODO: Inject the application-level UserService
+  // private readonly userService = inject(UserService);
+
+  constructor() {}
+
+  /**
+   * Generates the necessary agent cards for a lesson chat session.
+   * @param lesson The lesson data.
+   * @returns An object containing the master agent card and the evaluator agent card.
+   */
+  async generateAgentCards(lesson: ILesson): Promise<{ masterAgent: IAgentCard; evaluatorAgent: IMiniAgentCard } | null> {
+    // TODO: Implement the logic moved from DCLessonRendererComponent.startAI here
+    // 1. Get user data using the injected UserService
+    // 2. Extract lesson text using lessonService
+    // 3. Build prompts (scenario, userInformationPrompt)
+    // 4. Configure and return the agent cards
+
+    alert('AI User data fetching needs refactoring into this service.');
+    // Placeholder for user data - replace with actual service call
+    const user = {
+      personalData: { firstname: 'Test', lastname: 'User' },
+      settings: { targetLanguage: 'en', baseLanguage: 'es' },
+      languageProgress: { en: { level: '1' } },
+    } as any; // Replace 'any' with your actual User type/interface
+
+    if (!user) {
+      console.error('User data not available to generate agent cards.');
+      // Handle error appropriately - maybe return null or throw?
+      return null;
+    }
+
+    const lessonText = this.lessonService.extractTextFromHtml(lesson.textCoded);
+
+    const scenario = `The user is reading lessons through this app interface. They will now talk with you, and you need to evaluate their understanding of the lesson.
+Ask friendly questions throughout the conversation and help them learn English. Here is the lesson text the user just read:
+${lessonText}
+In your next reply, start by greeting the user, asking something about the lesson, and then continue the conversation.`;
+
+    const targetLevel = parseInt(user.languageProgress[user.settings.targetLanguage]?.level ?? '1');
+    const langTargetDesc = LangCodeDescription[user.settings.targetLanguage] ?? user.settings.targetLanguage;
+    const langBaseDesc = LangCodeDescription[user.settings.baseLanguage] ?? user.settings.baseLanguage;
+
+    let userInformationPrompt = `
+User information: user name is ${user.personalData.firstname} ${user.personalData.lastname}, their native language is ${langBaseDesc},
+and right now is learning ${langTargetDesc}, their current level is ${targetLevel} out of 5.`;
+
+    if (targetLevel <= 2) {
+      userInformationPrompt += `\nUser is a beginner in ${langTargetDesc}, always reply mainly in ${langBaseDesc}, but during the conversation use simple words and phrases in ${langTargetDesc} to help them learn.`;
+    }
+
+    // Create a deep copy of the default card to avoid modifying the constant
+    const masterAgent: IAgentCard = JSON.parse(JSON.stringify(DEFAULT_LESSON_AGENT_CARD));
+    masterAgent.characterCard.data.scenario = scenario;
+    masterAgent.characterCard.data.post_history_instructions += `\n${userInformationPrompt}`;
+
+    const evaluatorAgent = getDefaultLessonEvaluatorAgentCard(lessonText);
+
+    return { masterAgent, evaluatorAgent };
+  }
+}

package/src/lib/services/lesson-notion.service.ts

@@ -0,0 +1,161 @@
+import { Injectable, inject, signal } from '@angular/core';
+import { ILesson, LESSONS_TOKEN } from '../components/lesson-mini-components/components/lessons.clases';
+import { NOTION_SERVICE_TOKEN, NotionExportType } from '../models/notion.models';
+import { TOAST_ALERTS_TOKEN } from '@dataclouder/ngx-core';
+
+@Injectable() // Consider providing in root or specific module/component
+export class LessonNotionService {
+  #notionService = inject(NOTION_SERVICE_TOKEN);
+  #lessonService = inject(LESSONS_TOKEN);
+  #toastService = inject(TOAST_ALERTS_TOKEN);
+
+  // Keep track of loading state specific to Notion operations
+  isLoading = signal(false);
+
+  /**
+   * Extracts the Notion Page ID from a URL.
+   * @param url The Notion page URL.
+   * @returns The extracted page ID or null if invalid.
+   */
+  private extractNotionPageId(url: string): string | null {
+    const notionIdRegex = /[a-f0-9]{32}(?=\?|$)/;
+    const match = url.match(notionIdRegex);
+    const notionId = match ? match[0] : null;
+    if (!notionId) {
+      this.#toastService.error({
+        title: 'URL inválido',
+        subtitle: 'Por favor ingresa una URL válida de Notion.',
+      });
+      return null;
+    }
+    return notionId;
+  }
+
+  /**
+   * Links an existing lesson with a Notion page ID by updating the lesson's extras.
+   * @param lesson The current lesson data.
+   * @param notionPageId The Notion page ID to link.
+   * @returns The updated lesson data from the backend or undefined on failure.
+   */
+  public async linkLessonWithNotion(lesson: ILesson, notionPageId: string): Promise<ILesson | undefined> {
+    if (!lesson || !lesson.id) {
+      // Ensure lesson exists and has an ID
+      this.#toastService.warn({ title: 'No se puede enlazar', subtitle: 'La lección debe existir y tener un ID.' });
+      return undefined;
+    }
+
+    const updatedLesson = {
+      ...lesson,
+      extras: {
+        ...(lesson.extras || {}),
+        notionPageId: notionPageId,
+      },
+    };
+
+    this.isLoading.set(true);
+    try {
+      const savedLesson = await this.#lessonService.postLesson(updatedLesson);
+      this.#toastService.success({ title: 'Listo', subtitle: 'Se enlazó la lección con Notion.' });
+      return savedLesson;
+    } catch (error) {
+      // Remove explicit type, rely on tsconfig setting
+      console.error('Error linking with Notion:', error);
+      this.#toastService.error({ title: 'Error al enlazar', subtitle: 'Ocurrió un error inesperado.' });
+      return undefined;
+    } finally {
+      this.isLoading.set(false);
+    }
+  }
+
+  /**
+   * Handles the process of importing lesson content from Notion.
+   * It prompts the user for a URL if necessary, extracts the ID, fetches content,
+   * and potentially links the lesson if it's an existing one.
+   * @param currentLesson The current lesson data (can be a new or existing lesson).
+   * @param lessonId The current lesson ID (null if it's a new lesson).
+   * @returns The fetched HTML content from Notion, or null if the process fails.
+   */
+  public async importAndLinkLessonFromNotion(currentLesson: ILesson | undefined, lessonId: string | null): Promise<string | null> {
+    if (!currentLesson) return null;
+
+    let notionPageId: string | null = null;
+
+    if (currentLesson.extras?.notionPageId) {
+      const useExisting = confirm(`Ya tenemos el id ${currentLesson.extras.notionPageId} ¿Quieres usar este id para importar?`);
+      if (useExisting) {
+        notionPageId = currentLesson.extras.notionPageId;
+      } else {
+        const inputUrl = prompt('Ingresa la NUEVA URL de Notion para importar (este ID NO se guardará automáticamente si la lección ya existe)');
+        if (!inputUrl) return null; // User cancelled
+        notionPageId = this.extractNotionPageId(inputUrl);
+      }
+    } else {
+      const inputUrl = prompt('Ingresa el URL de Notion para importar la lección (se enlazará si la lección ya existe)');
+      if (!inputUrl) return null; // User cancelled
+      notionPageId = this.extractNotionPageId(inputUrl);
+      // Link automatically only if we got a valid Notion ID AND the lesson already exists (has an ID)
+      if (notionPageId && lessonId) {
+        const linkedLesson = await this.linkLessonWithNotion(currentLesson, notionPageId);
+        if (!linkedLesson) {
+          // Linking failed, maybe stop the import? Or proceed without linking?
+          // For now, let's stop.
+          this.#toastService.error({ title: 'Error de Enlace', subtitle: 'No se pudo enlazar con Notion antes de importar.' });
+          return null;
+        }
+        // If linking succeeded, the lesson object might have changed, but we proceed with the import using the notionPageId.
+      }
+    }
+
+    if (!notionPageId) {
+      this.#toastService.warn({ title: 'Sin ID de Notion', subtitle: 'No se proporcionó un ID de Notion válido para importar.' });
+      return null;
+    }
+
+    this.isLoading.set(true);
+    try {
+      this.#toastService.info({ title: 'Importando lección...', subtitle: 'Espera unos segundos' });
+      const md = await this.#notionService.getPageInSpecificFormat(notionPageId, NotionExportType.HTML);
+      console.log('Imported MD/HTML:', md);
+      this.#toastService.success({ title: 'Contenido Importado', subtitle: 'Contenido de Notion obtenido.' });
+      return md.content; // Return the fetched content
+    } catch (error) {
+      // Remove explicit type, rely on tsconfig setting
+      console.error('Error importing from Notion:', error);
+      this.#toastService.error({ title: 'Error de importación', subtitle: 'Ocurrió un error inesperado.' });
+      return null; // Return null on failure
+    } finally {
+      this.isLoading.set(false);
+    }
+  }
+
+  /**
+   * Fetches content from the linked Notion page for AI improvement (placeholder).
+   * @param lesson The current lesson data.
+   */
+  public async improveLessonWithNotionAI(lesson: ILesson | undefined): Promise<void> {
+    if (!lesson) return;
+    const notionId = lesson.extras?.notionPageId;
+
+    if (!notionId) {
+      this.#toastService.warn({ title: 'Sin ID de Notion', subtitle: 'Enlaza la lección con Notion primero.' });
+      return;
+    }
+
+    this.isLoading.set(true);
+    try {
+      this.#toastService.info({ title: 'Mejorando con IA...', subtitle: 'Obteniendo contenido de Notion.' });
+      const md = await this.#notionService.getPageInSpecificFormat(notionId, NotionExportType.HTML);
+      console.log('Content to improve:', md);
+      // TODO: Add actual AI improvement logic here
+      // e.g., call another service: await this.aiImprovementService.improve(md.content);
+      // Then potentially update the lesson via lessonService or return data
+      this.#toastService.success({ title: 'Contenido Obtenido', subtitle: 'Listo para mejorar con IA (lógica no implementada).' });
+    } catch (error) {
+      // Remove explicit type, rely on tsconfig setting
+      console.error('Error improving with AI:', error);
+      this.#toastService.error({ title: 'Error de IA', subtitle: 'Ocurrió un error inesperado.' });
+    } finally {
+      this.isLoading.set(false);
+    }
+  }
+}

package/src/lib/services/lesson-utils.service.ts

@@ -0,0 +1,181 @@
+import { Injectable, inject, WritableSignal } from '@angular/core';
+import { ILesson, LessonImage, LESSONS_TOKEN, DynamicContentComponent } from '../components/lesson-mini-components/components/lessons.clases'; // Added DynamicContentComponent
+import { TOAST_ALERTS_TOKEN } from '@dataclouder/ngx-core';
+
+@Injectable({
+  providedIn: 'root', // Provide globally or in a specific module if preferred
+})
+export class LessonUtilsService {
+  #lessonService = inject(LESSONS_TOKEN);
+  #toastService = inject(TOAST_ALERTS_TOKEN);
+
+  constructor() {}
+
+  /**
+   * Validates if audios need generation for the given lesson.
+   * Currently logs a placeholder message.
+   * @param lesson The lesson object (or signal) to validate.
+   */
+  public validateAudios(lesson: ILesson | undefined): void {
+    // Access lesson data directly
+    if (!lesson?.components) {
+      return;
+    }
+    // Placeholder logic - adapt as needed from original component
+    console.log('Validating audios for lesson:', lesson.id);
+    // Original logic commented out - requires SpeakerCompConfiguration type
+    // const needsGeneration = lesson.components.some((component: any) => // Use 'any' or define SpeakerCompConfiguration
+    //   component.component === 'speaker' && component.settings?.voice && !component.audio
+    // );
+    // if (needsGeneration) {
+    //   this.#toastService.warn({ title: 'Audios por generar', subtitle: 'Se encontraron audios pendientes' });
+    //   // Consider calling generation service here or returning a flag
+    //   // this.#lessonService.generateAudiosForLesson(lesson.id).then(res => { ... });
+    // }
+  }
+
+  /**
+   * Updates the lesson signal with a new cover image.
+   * @param lessonSignal The signal holding the lesson data.
+   * @param imageUploaded The image data object from the upload event.
+   */
+  public uploadCover(lessonSignal: WritableSignal<ILesson | undefined>, imageUploaded: any): void {
+    // Use 'any' for now, refine if event structure is known
+    const newImage: LessonImage = {
+      type: 'cover',
+      url: imageUploaded?.url,
+      path: imageUploaded?.path,
+      fullPath: imageUploaded?.fullPath,
+      resolutions: imageUploaded?.resolutions ?? [],
+      resolution: imageUploaded?.resolution,
+      bucket: imageUploaded?.bucket,
+      // Add any other required fields from LessonImage or ImgStorageData
+    };
+
+    lessonSignal.update((currentLesson) => {
+      if (!currentLesson) return undefined;
+
+      let updatedImages: LessonImage[];
+      const existingMedia = currentLesson.media;
+
+      if (!existingMedia || !existingMedia.images) {
+        updatedImages = [newImage];
+      } else {
+        const filteredImages = existingMedia.images.filter((img: any) => img.type !== 'cover');
+        const mappedExistingImages: LessonImage[] = filteredImages.map(
+          (img: any): LessonImage => ({
+            type: img.type,
+            url: img.url,
+            path: img.path,
+            fullPath: img.fullPath,
+            resolutions: img.resolutions ?? [],
+            resolution: img.resolution,
+            bucket: img.bucket,
+          }),
+        );
+        updatedImages = [...mappedExistingImages, newImage];
+      }
+
+      return {
+        ...currentLesson,
+        media: {
+          ...(existingMedia || {}),
+          images: updatedImages,
+        },
+      };
+    });
+    // Note: Saving the lesson should be triggered from the component after calling this.
+  }
+
+  /**
+   * Generates lesson content using AI. Assumes the lesson is already saved.
+   * @param lessonId The ID of the lesson to generate content for.
+   * @returns The updated lesson object after AI generation, or null on failure.
+   */
+  public async generateByAI(lessonId: string): Promise<ILesson | null> {
+    if (!lessonId) {
+      this.#toastService.warn({ title: 'ID Requerido', subtitle: 'Se necesita un ID de lección para usar IA.' });
+      return null;
+    }
+
+    // No need to save here, component should ensure it's saved before calling.
+    try {
+      await this.#lessonService.postGenerateByAI(lessonId);
+      // Re-fetch the lesson data to get AI updates
+      const updatedLesson = await this.#lessonService.getLesson(lessonId);
+      if (updatedLesson) {
+        this.#toastService.success({ title: 'IA completada', subtitle: 'Lección actualizada con IA.' });
+        return updatedLesson;
+      } else {
+        throw new Error('Failed to fetch lesson after AI generation');
+      }
+    } catch (error: any) {
+      // Type the error object
+      console.error('Error during AI generation in service:', error);
+      this.#toastService.error({ title: 'Error de IA', subtitle: 'No se pudo generar la lección con IA.' });
+      return null; // Return null in catch block
+    }
+    // Loading state should be managed by the component calling this service.
+  }
+
+  /**
+   * Cleans orphaned components from the lesson's dynamicComponents.
+   * An orphaned component is one present in dynamicComponents but its ID is not found in the textCoded HTML.
+   * @param lesson The lesson object to clean.
+   * @returns A new lesson object with orphaned components removed from dynamicComponents.
+   */
+  public cleanOrphanedComponents(lesson: ILesson): ILesson {
+    if (!lesson || !lesson.textCoded || !lesson.dynamicComponents) {
+      // Return the original lesson if essential parts are missing
+      return lesson;
+    }
+
+    const textCoded = lesson.textCoded;
+    const existingComponents = lesson.dynamicComponents;
+    const existingComponentIds = new Set(Object.keys(existingComponents));
+
+    // Regex to find "id":"<component_id>" within the textCoded string
+    const idRegex = /"id":"([^"]+)"/g;
+    const foundIdsInText = new Set<string>();
+    let match;
+
+    while ((match = idRegex.exec(textCoded)) !== null) {
+      const potentialId = match[1];
+      // Check if the found ID actually exists in our dynamic components map
+      // This ensures we only count IDs that correspond to known components.
+      if (existingComponentIds.has(potentialId)) {
+        foundIdsInText.add(potentialId);
+      }
+    }
+
+    const orphanedIds: string[] = [];
+    const cleanedDynamicComponents: Record<string, DynamicContentComponent> = {};
+
+    // Iterate through existing component IDs
+    for (const componentId of existingComponentIds) {
+      if (foundIdsInText.has(componentId)) {
+        // Keep the component if its ID was found in the text
+        cleanedDynamicComponents[componentId] = existingComponents[componentId];
+      } else {
+        // Mark as orphaned if not found
+        orphanedIds.push(componentId);
+      }
+    }
+
+    // Log a warning if any orphaned components were found
+    if (orphanedIds.length > 0) {
+      console.warn(`[LessonUtilsService] Orphaned components detected and will be removed from lesson data (IDs not found in textCoded):`, orphanedIds);
+      this.#toastService.warn({
+        title: 'Componentes Huérfanos Detectados',
+        subtitle: `Se removerán ${orphanedIds.length} componentes no usados del editor.`,
+        // life: 5000, // Removed 'life' property as it might not be supported by ToastData
+      });
+    }
+
+    // Return a new lesson object with the cleaned components
+    return {
+      ...lesson,
+      dynamicComponents: cleanedDynamicComponents,
+    };
+  }
+}

package/src/lib/components/lesson-mini-components/components/selector/selector-builder/selector-builder.component.spec.ts

@@ -1,25 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-
-import { SelectorBuilderComponent } from './selector-builder.component';
-
-describe('SelectorBuilderComponent', () => {
-  let component: SelectorBuilderComponent;
-  let fixture: ComponentFixture<SelectorBuilderComponent>;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-    imports: [SelectorBuilderComponent]
-})
-    .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(SelectorBuilderComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

package/src/lib/components/lesson-mini-components/components/speaker/speaker-builder/speaker-builder.component.spec.ts

@@ -1,25 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-
-import { SpeakerBuilderComponent } from './speaker-builder.component';
-
-describe('SpeakerBuilderComponent', () => {
-  let component: SpeakerBuilderComponent;
-  let fixture: ComponentFixture<SpeakerBuilderComponent>;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-    imports: [SpeakerBuilderComponent]
-})
-    .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(SpeakerBuilderComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});

package/src/lib/components/lesson-mini-components/components/speaker/speaker.component.spec.ts

@@ -1,25 +0,0 @@
-import { ComponentFixture, TestBed } from '@angular/core/testing';
-
-import { SpeakerComponent } from './speaker.component';
-
-describe('SpeakerComponent', () => {
-  let component: SpeakerComponent;
-  let fixture: ComponentFixture<SpeakerComponent>;
-
-  beforeEach(async () => {
-    await TestBed.configureTestingModule({
-    imports: [SpeakerComponent]
-})
-    .compileComponents();
-  });
-
-  beforeEach(() => {
-    fixture = TestBed.createComponent(SpeakerComponent);
-    component = fixture.componentInstance;
-    fixture.detectChanges();
-  });
-
-  it('should create', () => {
-    expect(component).toBeTruthy();
-  });
-});