rename to core

core/media/application/use-cases/RequestAvatarGenerationUseCase.ts

@@ -0,0 +1,156 @@
+import type { AsyncUseCase, ILogger } from '@gridpilot/shared/application';
+import type { IAvatarGenerationRepository } from '../../domain/repositories/IAvatarGenerationRepository';
+import type { FaceValidationPort } from '../ports/FaceValidationPort';
+import type { AvatarGenerationPort } from '../ports/AvatarGenerationPort';
+import { AvatarGenerationRequest } from '../../domain/entities/AvatarGenerationRequest';
+import type { RacingSuitColor, AvatarStyle } from '../../domain/types/AvatarGenerationRequest';
+
+export interface RequestAvatarGenerationCommand {
+  userId: string;
+  facePhotoData: string; // Base64 encoded image data
+  suitColor: RacingSuitColor;
+  style?: AvatarStyle;
+}
+
+export interface RequestAvatarGenerationResult {
+  requestId: string;
+  status: 'validating' | 'generating' | 'completed' | 'failed';
+  avatarUrls?: string[];
+  errorMessage?: string;
+}
+
+export class RequestAvatarGenerationUseCase
+  implements AsyncUseCase<RequestAvatarGenerationCommand, RequestAvatarGenerationResult> {
+  constructor(
+    private readonly avatarRepository: IAvatarGenerationRepository,
+    private readonly faceValidation: FaceValidationPort,
+    private readonly avatarGeneration: AvatarGenerationPort,
+    private readonly logger: ILogger,
+  ) {}
+
+  async execute(command: RequestAvatarGenerationCommand): Promise<RequestAvatarGenerationResult> {
+    this.logger.debug(
+      `Executing RequestAvatarGenerationUseCase for userId: ${command.userId}`,
+      command,
+    );
+
+    try {
+      // Create the generation request
+      const requestId = this.generateId();
+      const request = AvatarGenerationRequest.create({
+        id: requestId,
+        userId: command.userId,
+        facePhotoUrl: `data:image/jpeg;base64,${command.facePhotoData}`,
+        suitColor: command.suitColor,
+        ...(command.style ? { style: command.style } : {}),
+      });
+
+      this.logger.info(`Avatar generation request created with ID: ${requestId}`);
+
+      // Mark as validating
+      request.markAsValidating();
+      await this.avatarRepository.save(request);
+      this.logger.debug(`Request ${requestId} marked as validating.`);
+
+      // Validate the face photo
+      const validationResult = await this.faceValidation.validateFacePhoto(command.facePhotoData);
+      this.logger.debug(
+        `Face validation result for request ${requestId}:`,
+        validationResult,
+      );
+      
+      if (!validationResult.isValid) {
+        const errorMessage = validationResult.errorMessage || 'Face validation failed';
+        request.fail(errorMessage);
+        await this.avatarRepository.save(request);
+        this.logger.error(`Face validation failed for request ${requestId}: ${errorMessage}`);
+        return {
+          requestId,
+          status: 'failed',
+          errorMessage: validationResult.errorMessage || 'Please upload a clear photo of your face',
+        };
+      }
+
+      if (!validationResult.hasFace) {
+        const errorMessage = 'No face detected in the image';
+        request.fail(errorMessage);
+        await this.avatarRepository.save(request);
+        this.logger.error(`No face detected for request ${requestId}: ${errorMessage}`);
+        return {
+          requestId,
+          status: 'failed',
+          errorMessage: 'No face detected. Please upload a photo that clearly shows your face.',
+        };
+      }
+
+      if (validationResult.faceCount > 1) {
+        const errorMessage = 'Multiple faces detected';
+        request.fail(errorMessage);
+        await this.avatarRepository.save(request);
+        this.logger.error(`Multiple faces detected for request ${requestId}: ${errorMessage}`);
+        return {
+          requestId,
+          status: 'failed',
+          errorMessage: 'Multiple faces detected. Please upload a photo with only your face.',
+        };
+      }
+      this.logger.info(`Face validation successful for request ${requestId}.`);
+
+      // Mark as generating
+      request.markAsGenerating();
+      await this.avatarRepository.save(request);
+      this.logger.debug(`Request ${requestId} marked as generating.`);
+
+      // Generate avatars
+      const generationResult = await this.avatarGeneration.generateAvatars({
+        facePhotoUrl: request.facePhotoUrl.value,
+        prompt: request.buildPrompt(),
+        suitColor: request.suitColor,
+        style: request.style,
+        count: 3, // Generate 3 options
+      });
+      this.logger.debug(
+        `Avatar generation service result for request ${requestId}:`,
+        generationResult,
+      );
+
+      if (!generationResult.success) {
+        const errorMessage = generationResult.errorMessage || 'Avatar generation failed';
+        request.fail(errorMessage);
+        await this.avatarRepository.save(request);
+        this.logger.error(`Avatar generation failed for request ${requestId}: ${errorMessage}`);
+        return {
+          requestId,
+          status: 'failed',
+          errorMessage: generationResult.errorMessage || 'Failed to generate avatars. Please try again.',
+        };
+      }
+
+      // Complete with generated avatars
+      const avatarUrls = generationResult.avatars.map(a => a.url);
+      request.completeWithAvatars(avatarUrls);
+      await this.avatarRepository.save(request);
+      this.logger.info(`Avatar generation completed successfully for request ${requestId}.`);
+
+      return {
+        requestId,
+        status: 'completed',
+        avatarUrls,
+      };
+    } catch (error) {
+      this.logger.error(
+        `An unexpected error occurred during avatar generation for userId: ${command.userId}`,
+        error,
+      );
+      // Re-throw or return a generic error, depending on desired error handling strategy
+      throw error; 
+    }
+  }
+
+  private generateId(): string {
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    return 'avatar-' + Date.now().toString(36) + Math.random().toString(36).substr(2, 9);
+  }
+}