setupLocator function

Implementation

Future<void> setupLocator(String token) async {
  final dio = createDio(token);
  getIt.registerLazySingleton<Dio>(() => dio);

  getIt.registerLazySingleton<Storage>(() => Storage());

  getIt.registerLazySingleton<AppRouter>(
      () => AppRouter(storage: getIt<Storage>()));

  final projectService = ProjectService(dio);
  getIt.registerLazySingleton<ProjectService>(() => projectService);

  // Register Hive Boxes
  final taskBox = await Hive.openBox<TaskModelResponse>('tasks');
  final projectBox = await Hive.openBox<ProjectModelResponse>('projects');
  final syncBox = await Hive.openBox<SyncOperation>('sync');
  final durationBox = await Hive.openBox<DurationModel>('duration');
  final dueBox = await Hive.openBox<DueModel>('due');
  final commentBox = await Hive.openBox<CommentModel>('comment');
  final attachmentBox = await Hive.openBox<AttachmentModel>('attachment');

  getIt.registerSingleton<Box<TaskModelResponse>>(taskBox);
  getIt.registerSingleton<Box<ProjectModelResponse>>(projectBox);
  getIt.registerSingleton<Box<SyncOperation>>(syncBox);
  getIt.registerSingleton<Box<DurationModel>>(durationBox);
  getIt.registerSingleton<Box<DueModel>>(dueBox);
  getIt.registerSingleton<Box<CommentModel>>(commentBox);
  getIt.registerSingleton<Box<AttachmentModel>>(attachmentBox);

  getIt.registerSingleton<ProjectProvider>(ProjectProviderImpl());

  // Register data sources
  //register data sources
  getIt.registerLazySingleton<ProjectsRemoteDataSource>(
      () => ProjectsRemoteDataSourceImpl(getIt()));

  getIt.registerLazySingleton<TasksRemoteDataSource>(
    () => TasksRemoteDataSourceImpl(
      service: getIt<ProjectService>(),
    ),
  );

  // Register Local Data Sources
  getIt.registerLazySingleton<TasksLocalDataSource>(
      () => TasksLocalDataSourceImpl(getIt()));
  getIt.registerLazySingleton<ProjectsLocalDataSource>(
      () => ProjectsLocalDataSourceImpl(getIt()));
  getIt.registerLazySingleton<SyncLocalDataSource>(
      () => SyncLocalDataSource(getIt()));

  //register repositories
  getIt.registerSingleton<Connectivity>(Connectivity());

  getIt.registerLazySingleton<ProjectsRepository>(() => ProjectsRepositoryImpl(
        remoteDataSource: getIt<ProjectsRemoteDataSource>(),
        localDataSource: getIt<ProjectsLocalDataSource>(),
        syncQueue: getIt<SyncLocalDataSource>(),
      ));

  getIt.registerLazySingleton<TasksRepository>(
    () => TasksRepositoryImpl(
        remoteDataSource: getIt<TasksRemoteDataSource>(),
        localDataSource: getIt(),
        syncQueue: getIt()),
  );
  getIt.registerLazySingleton<CommentsRepository>(
    () => CommentsRepositoryImpl(
        remoteDataSource: getIt<CommentsRemoteDataSource>()),
  );
  getIt.registerLazySingleton<CommentsRemoteDataSource>(
    () => CommentsRemoteDataSourceImpl(
      getIt<ProjectService>(),
    ),
  );
  getIt.registerLazySingleton(() => SyncManager(
        syncQueue: getIt<SyncLocalDataSource>(),
        projectsRemoteDataSource: getIt<ProjectsRemoteDataSource>(),
        tasksRemoteDataSource: getIt<TasksRemoteDataSource>(),
        projectsLocalDataSource: getIt(),
        tasksLocalDataSource: getIt(),
      ));

  // Register use cases
  //register use cases
  getIt.registerLazySingleton<GetProjectsUseCase>(
      () => GetProjectsUseCase(getIt<ProjectsRepository>()));

  getIt.registerLazySingleton<CreateProjectUseCase>(
    () => CreateProjectUseCase(getIt<ProjectsRepository>()),
  );

  getIt.registerLazySingleton<GetTasksUseCase>(
    () => GetTasksUseCase(getIt<TasksRepository>()),
  );

  getIt.registerLazySingleton<DeleteProjectUseCase>(
    () => DeleteProjectUseCase(getIt<ProjectsRepository>()),
  );

  getIt.registerLazySingleton<CreateTaskUseCase>(
    () => CreateTaskUseCase(getIt<TasksRepository>()),
  );

  getIt.registerLazySingleton<DeleteTaskUseCase>(
    () => DeleteTaskUseCase(getIt<TasksRepository>()),
  );

  getIt.registerLazySingleton<CloseTaskUseCase>(
    () => CloseTaskUseCase(getIt<TasksRepository>()),
  );

  getIt.registerLazySingleton<UpdateTaskUseCase>(
    () => UpdateTaskUseCase(getIt<TasksRepository>()),
  );

  getIt.registerLazySingleton<GetAllCommentsUseCase>(
    () => GetAllCommentsUseCase(getIt<CommentsRepository>()),
  );

  getIt.registerLazySingleton<GetTaskUseCase>(
    () => GetTaskUseCase(getIt<TasksRepository>()),
  );

  getIt.registerLazySingleton<CreateCommentUseCase>(
    () => CreateCommentUseCase(getIt<CommentsRepository>()),
  );

  //register blocs
  getIt.registerFactory<ProjectsBloc>(
    () => ProjectsBloc(
        createProjectUseCase: getIt<CreateProjectUseCase>(),
        getProjectsUseCase: getIt<GetProjectsUseCase>(),
        deleteUseCase: getIt<DeleteProjectUseCase>()),
  );

  getIt.registerFactory<TasksBloc>(
    () => TasksBloc(
        getTasksUseCase: getIt<GetTasksUseCase>(),
        updateTaskUseCase: getIt<UpdateTaskUseCase>(),
        deleteTaskUseCase: getIt<DeleteTaskUseCase>()),
  );

  getIt.registerFactory<UpdateTaskBloc>(() => UpdateTaskBloc(
      updateTaskUseCase: getIt<UpdateTaskUseCase>(),
      getTaskUseCase: getIt<GetTaskUseCase>()));

  getIt.registerFactory<CreateTaskBloc>(() => CreateTaskBloc(
        createTaskUseCase: getIt<CreateTaskUseCase>(),
        getProjectsUseCase: getIt<GetProjectsUseCase>(),
      ));

  getIt.registerFactory<CommentBloc>(() => CommentBloc(
        getAllCommentsUseCase: getIt<GetAllCommentsUseCase>(),
        createCommentUseCase: getIt<CreateCommentUseCase>(),
      ));
}