module cleanup

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

@@ -1,16 +1,16 @@
 /**
  * Use Case: SelectAvatarUseCase
- * 
- * Allows a user to select one of the generated avatars as their profile avatar.
+ *
+ * Handles the business logic for selecting a generated avatar from the options.
  */
 
-import type { AsyncUseCase, Logger } from '@core/shared/application';
 import type { IAvatarGenerationRepository } from '../../domain/repositories/IAvatarGenerationRepository';
+import type { Logger } from '@core/shared/application';
+import type { ISelectAvatarPresenter } from '../presenters/ISelectAvatarPresenter';
 
-export interface SelectAvatarCommand {
+export interface SelectAvatarInput {
   requestId: string;
-  userId: string;
-  avatarIndex: number;
+  selectedIndex: number;
 }
 
 export interface SelectAvatarResult {
@@ -19,60 +19,69 @@ export interface SelectAvatarResult {
   errorMessage?: string;
 }
 
-export class SelectAvatarUseCase
-  implements AsyncUseCase<SelectAvatarCommand, SelectAvatarResult> {
+export interface ISelectAvatarPresenter {
+  present(result: SelectAvatarResult): void;
+}
+
+export class SelectAvatarUseCase {
   constructor(
-    private readonly avatarRepository: IAvatarGenerationRepository,
+    private readonly avatarRepo: IAvatarGenerationRepository,
     private readonly logger: Logger,
   ) {}
 
-  async execute(command: SelectAvatarCommand): Promise<SelectAvatarResult> {
-    this.logger.debug(`Executing SelectAvatarUseCase for userId: ${command.userId}, requestId: ${command.requestId}, avatarIndex: ${command.avatarIndex}`);
-
-    const request = await this.avatarRepository.findById(command.requestId);
-
-    if (!request) {
-      this.logger.info(`Avatar generation request not found for requestId: ${command.requestId}`);
-      return {
-        success: false,
-        errorMessage: 'Avatar generation request not found',
-      };
-    }
-
-    if (request.userId !== command.userId) {
-      this.logger.info(`Permission denied for userId: ${command.userId} to select avatar for requestId: ${command.requestId}`);
-      return {
-        success: false,
-        errorMessage: 'You do not have permission to select this avatar',
-      };
-    }
-
-    if (request.status !== 'completed') {
-      this.logger.info(`Avatar generation not completed for requestId: ${command.requestId}, current status: ${request.status}`);
-      return {
-        success: false,
-        errorMessage: 'Avatar generation is not yet complete',
-      };
-    }
-
+  async execute(
+    input: SelectAvatarInput,
+    presenter: ISelectAvatarPresenter,
+  ): Promise<void> {
     try {
-      request.selectAvatar(command.avatarIndex);
-      await this.avatarRepository.save(request);
+      this.logger.info('[SelectAvatarUseCase] Selecting avatar', {
+        requestId: input.requestId,
+        selectedIndex: input.selectedIndex,
+      });
+
+      const request = await this.avatarRepo.findById(input.requestId);
+
+      if (!request) {
+        presenter.present({
+          success: false,
+          errorMessage: 'Avatar generation request not found',
+        });
+        return;
+      }
+
+      if (request.status !== 'completed') {
+        presenter.present({
+          success: false,
+          errorMessage: 'Avatar generation is not completed yet',
+        });
+        return;
+      }
+
+      request.selectAvatar(input.selectedIndex);
+      await this.avatarRepo.save(request);
 
       const selectedAvatarUrl = request.selectedAvatarUrl;
-      const result: SelectAvatarResult =
-        selectedAvatarUrl !== undefined
-          ? { success: true, selectedAvatarUrl }
-          : { success: true };
 
-      this.logger.info(`Avatar selected successfully for userId: ${command.userId}, requestId: ${command.requestId}, selectedAvatarUrl: ${selectedAvatarUrl}`);
-      return result;
+      presenter.present({
+        success: true,
+        selectedAvatarUrl,
+      });
+
+      this.logger.info('[SelectAvatarUseCase] Avatar selected successfully', {
+        requestId: input.requestId,
+        selectedAvatarUrl,
+      });
+
     } catch (error) {
-      this.logger.error(`Failed to select avatar for userId: ${command.userId}, requestId: ${command.requestId}: ${error instanceof Error ? error.message : 'Unknown error'}`, error);
-      return {
+      this.logger.error('[SelectAvatarUseCase] Error selecting avatar', {
+        error: error instanceof Error ? error.message : 'Unknown error',
+        requestId: input.requestId,
+      });
+
+      presenter.present({
         success: false,
-        errorMessage: error instanceof Error ? error.message : 'Failed to select avatar',
-      };
+        errorMessage: 'Internal error occurred while selecting avatar',
+      });
     }
   }
 }