Line data    Source code

       1             : import 'package:tech_proof/core/error/failure.dart';
       2             : import 'package:tech_proof/core/error/logger_service.dart';
       3             : import 'package:tech_proof/core/network/safe_call.dart';
       4             : import 'package:tech_proof/data/mappers/movie_mapper.dart';
       5             : import 'package:tech_proof/data/mappers/popular_movies_mapper.dart';
       6             : import 'package:tech_proof/data/mappers/search_response_mapper.dart';
       7             : import 'package:tech_proof/data/models/movie_detail_model.dart';
       8             : import 'package:tech_proof/data/models/popular_movies_model.dart';
       9             : import 'package:tech_proof/data/models/search_response_model.dart';
      10             : import 'package:tech_proof/domain/entities/movie_entity.dart';
      11             : import 'package:tech_proof/domain/entities/popular_movies_entity.dart';
      12             : import 'package:tech_proof/domain/entities/search_response_entity.dart';
      13             : import 'package:tech_proof/domain/repositories/movies_repository.dart';
      14             : import 'package:dartz/dartz.dart';
      15             : import 'package:dio/dio.dart';
      16             : 
      17             : class MovieRepositoryImpl implements MovieRepository {
      18             :   final Dio dio;
      19             : 
      20           1 :   MovieRepositoryImpl(this.dio);
      21             : 
      22           1 :   @override
      23             :   Future<Either<Failure, PopularMoviesResponseEntity>> getPopularMovies({
      24             :     int page = 1,
      25             :   }) async {
      26           2 :     final response = await safeCall(() async {
      27           2 :       final response = await dio.get(
      28             :         "/movie/popular",
      29           1 :         queryParameters: {"page": page},
      30             :       );
      31           1 :       return response.data;
      32             :     });
      33             :     PopularMoviesResponseModel? model;
      34           2 :     response.fold((l) {
      35           1 :       LoggerService.error("Repository", 'Failed to parse popular movies');
      36           1 :       return UnexpectedFailure('message');
      37           2 :     }, (r) => model = PopularMoviesResponseModel.fromJson(r));
      38             :     if (model == null) {
      39           1 :       LoggerService.error("Repository", 'Failed to parse popular movies');
      40             : 
      41           2 :       return Left(UnexpectedFailure("Failed to parse popular movies"));
      42             :     } else {
      43           1 :       final modelEntity = model!.toEntity();
      44           1 :       return Right(modelEntity);
      45             :     }
      46             :   }
      47             : 
      48           1 :   @override
      49             :   Future<Either<Failure, SearchResponseEntity>> searchMovies({
      50             :     required String query,
      51             :     int page = 1,
      52             :   }) async {
      53           2 :     final response = await safeCall(() async {
      54           2 :       final response = await dio.get(
      55             :         "/search/movie",
      56           1 :         queryParameters: {"query": query, "page": page},
      57             :       );
      58           1 :       return response.data;
      59             :     });
      60             :     SearchResponseModel? model;
      61             : 
      62           2 :     response.fold((l) {
      63           1 :       LoggerService.error("Repository", 'Failed to parse search results');
      64           1 :       return UnexpectedFailure('message');
      65           2 :     }, (r) => model = SearchResponseModel.fromJson(r));
      66             : 
      67             :     if (model == null) {
      68           1 :       LoggerService.error("Repository", 'Failed to parse search results');
      69           2 :       return Left(UnexpectedFailure("Failed to parse search results"));
      70             :     } else {
      71           1 :       final modelEntity = model!.toEntity();
      72           1 :       return Right(modelEntity);
      73             :     }
      74             :   }
      75             : 
      76           1 :   @override
      77             :   Future<Either<Failure, MovieEntity>> getMovie({required int id}) async {
      78           2 :     final response = await safeCall(() async {
      79           3 :       final response = await dio.get("/movie/$id");
      80           1 :       return response.data;
      81             :     });
      82             :     MovieDetail? model;
      83           2 :     response.fold((l) {
      84           1 :       LoggerService.error("Repository", 'Failed to parse movie details');
      85           1 :       return UnexpectedFailure('message');
      86           2 :     }, (r) => model = MovieDetail.fromJson(r));
      87             :     if (model != null) {
      88           2 :       return Right(model!.toEntity());
      89             :     } else {
      90           1 :       LoggerService.error("Repository", 'Failed to parse movie details');
      91           2 :       return Left(UnexpectedFailure("Failed to parse movie details"));
      92             :     }
      93             :   }
      94             : }