module cleanup

apps/api/src/domain/media/MediaService.ts

@@ -8,6 +8,7 @@ import type { DeleteMediaOutputDTO } from './dtos/DeleteMediaOutputDTO';
 import type { GetAvatarOutputDTO } from './dtos/GetAvatarOutputDTO';
 import type { UpdateAvatarInputDTO } from './dtos/UpdateAvatarInputDTO';
 import type { UpdateAvatarOutputDTO } from './dtos/UpdateAvatarOutputDTO';
+import type { RacingSuitColor } from '@core/media/domain/types/AvatarGenerationRequest';
 
 type RequestAvatarGenerationInput = RequestAvatarGenerationInputDTO;
 type RequestAvatarGenerationOutput = RequestAvatarGenerationOutputDTO;
@@ -21,18 +22,41 @@ type UpdateAvatarOutput = UpdateAvatarOutputDTO;
 
 // Use cases
 import { RequestAvatarGenerationUseCase } from '@core/media/application/use-cases/RequestAvatarGenerationUseCase';
+import { UploadMediaUseCase } from '@core/media/application/use-cases/UploadMediaUseCase';
+import { GetMediaUseCase } from '@core/media/application/use-cases/GetMediaUseCase';
+import { DeleteMediaUseCase } from '@core/media/application/use-cases/DeleteMediaUseCase';
+import { GetAvatarUseCase } from '@core/media/application/use-cases/GetAvatarUseCase';
+import { UpdateAvatarUseCase } from '@core/media/application/use-cases/UpdateAvatarUseCase';
 
 // Presenters
 import { RequestAvatarGenerationPresenter } from './presenters/RequestAvatarGenerationPresenter';
+import { UploadMediaPresenter } from './presenters/UploadMediaPresenter';
+import { GetMediaPresenter } from './presenters/GetMediaPresenter';
+import { DeleteMediaPresenter } from './presenters/DeleteMediaPresenter';
+import { GetAvatarPresenter } from './presenters/GetAvatarPresenter';
+import { UpdateAvatarPresenter } from './presenters/UpdateAvatarPresenter';
 
 // Tokens
-import { REQUEST_AVATAR_GENERATION_USE_CASE_TOKEN, LOGGER_TOKEN } from './MediaProviders';
+import {
+  REQUEST_AVATAR_GENERATION_USE_CASE_TOKEN,
+  UPLOAD_MEDIA_USE_CASE_TOKEN,
+  GET_MEDIA_USE_CASE_TOKEN,
+  DELETE_MEDIA_USE_CASE_TOKEN,
+  GET_AVATAR_USE_CASE_TOKEN,
+  UPDATE_AVATAR_USE_CASE_TOKEN,
+  LOGGER_TOKEN
+} from './MediaProviders';
 import type { Logger } from '@core/shared/application';
 
 @Injectable()
 export class MediaService {
   constructor(
     @Inject(REQUEST_AVATAR_GENERATION_USE_CASE_TOKEN) private readonly requestAvatarGenerationUseCase: RequestAvatarGenerationUseCase,
+    @Inject(UPLOAD_MEDIA_USE_CASE_TOKEN) private readonly uploadMediaUseCase: UploadMediaUseCase,
+    @Inject(GET_MEDIA_USE_CASE_TOKEN) private readonly getMediaUseCase: GetMediaUseCase,
+    @Inject(DELETE_MEDIA_USE_CASE_TOKEN) private readonly deleteMediaUseCase: DeleteMediaUseCase,
+    @Inject(GET_AVATAR_USE_CASE_TOKEN) private readonly getAvatarUseCase: GetAvatarUseCase,
+    @Inject(UPDATE_AVATAR_USE_CASE_TOKEN) private readonly updateAvatarUseCase: UpdateAvatarUseCase,
     @Inject(LOGGER_TOKEN) private readonly logger: Logger,
   ) {}
 
@@ -43,46 +67,118 @@ export class MediaService {
     await this.requestAvatarGenerationUseCase.execute({
       userId: input.userId,
       facePhotoData: input.facePhotoData,
-      suitColor: input.suitColor as any,
+      suitColor: input.suitColor as RacingSuitColor,
     }, presenter);
     return presenter.viewModel;
   }
 
   async uploadMedia(input: UploadMediaInput & { file: Express.Multer.File }): Promise<UploadMediaOutput> {
     this.logger.debug('[MediaService] Uploading media.');
-    // TODO: Implement media upload logic
-    return {
-      success: true,
-      mediaId: 'placeholder-media-id',
-      url: 'placeholder-url',
-    };
+
+    const presenter = new UploadMediaPresenter();
+
+    await this.uploadMediaUseCase.execute({
+      file: input.file,
+      uploadedBy: input.userId, // Assuming userId is the uploader
+      metadata: input.metadata,
+    }, presenter);
+
+    const result = presenter.viewModel;
+
+    if (result.success) {
+      return {
+        success: true,
+        mediaId: result.mediaId!,
+        url: result.url!,
+      };
+    } else {
+      return {
+        success: false,
+        errorMessage: result.errorMessage || 'Upload failed',
+      };
+    }
   }
 
   async getMedia(mediaId: string): Promise<GetMediaOutput | null> {
     this.logger.debug(`[MediaService] Getting media: ${mediaId}`);
-    // TODO: Implement get media logic
+
+    const presenter = new GetMediaPresenter();
+
+    await this.getMediaUseCase.execute({ mediaId }, presenter);
+
+    const result = presenter.viewModel;
+
+    if (result.success && result.media) {
+      return {
+        success: true,
+        mediaId: result.media.id,
+        filename: result.media.filename,
+        originalName: result.media.originalName,
+        mimeType: result.media.mimeType,
+        size: result.media.size,
+        url: result.media.url,
+        type: result.media.type,
+        uploadedBy: result.media.uploadedBy,
+        uploadedAt: result.media.uploadedAt,
+        metadata: result.media.metadata,
+      };
+    }
+
     return null;
   }
 
   async deleteMedia(mediaId: string): Promise<DeleteMediaOutput> {
     this.logger.debug(`[MediaService] Deleting media: ${mediaId}`);
-    // TODO: Implement delete media logic
+
+    const presenter = new DeleteMediaPresenter();
+
+    await this.deleteMediaUseCase.execute({ mediaId }, presenter);
+
+    const result = presenter.viewModel;
+
     return {
-      success: true,
+      success: result.success,
+      errorMessage: result.errorMessage,
     };
   }
 
   async getAvatar(driverId: string): Promise<GetAvatarOutput | null> {
     this.logger.debug(`[MediaService] Getting avatar for driver: ${driverId}`);
-    // TODO: Implement get avatar logic
+
+    const presenter = new GetAvatarPresenter();
+
+    await this.getAvatarUseCase.execute({ driverId }, presenter);
+
+    const result = presenter.viewModel;
+
+    if (result.success && result.avatar) {
+      return {
+        success: true,
+        avatarId: result.avatar.id,
+        driverId: result.avatar.driverId,
+        mediaUrl: result.avatar.mediaUrl,
+        selectedAt: result.avatar.selectedAt,
+      };
+    }
+
     return null;
   }
 
   async updateAvatar(driverId: string, input: UpdateAvatarInput): Promise<UpdateAvatarOutput> {
     this.logger.debug(`[MediaService] Updating avatar for driver: ${driverId}`);
-    // TODO: Implement update avatar logic
+
+    const presenter = new UpdateAvatarPresenter();
+
+    await this.updateAvatarUseCase.execute({
+      driverId,
+      mediaUrl: input.mediaUrl,
+    }, presenter);
+
+    const result = presenter.viewModel;
+
     return {
-      success: true,
+      success: result.success,
+      errorMessage: result.errorMessage,
     };
   }
 }