DenisBronx

class AlbumDataMapper(
    private val songListDataMapper: NullableInputListMapper<NetworkSong, Song>
) : Mapper<NetworkAlbum, Album> {

    override fun map(input: NetworkAlbum): Album {
        return Album(
            input.id.orEmpty(),
            input.title.orEmpty(),
            songListDataMapper.map(input.songs)
        )

DenisBronx

inline fun mapAlbumDto(input: NetworkAlbum, mapSongList: (List<NetworkSong>?) -> List<Song>): Album {
    return Album(
        input.id.orEmpty(),
        input.title.orEmpty(),
        mapSongList(input.songs)
    )
}

fun mapSongDto(input: NetworkSong): Song {
    return Song(

DenisBronx

class AlbumRepositoryImpl(
    private val albumApiService: AlbumApiService,
    private val albumDataMapper: Mapper<NetworkAlbum, Album>
) : AlbumRepository {

    override fun getAlbumById(id: String): Single<SimpleResult<Album>> {
        return albumApiService.getAlbumById(id).map {
            it.fold(
                success = { dto -> Result.Success(albumDataMapper.map(dto)) },
                failure = { throwable -> Result.Failure(throwable) }

DenisBronx

class AlbumRepositoryImpl(
    private val albumApiService: AlbumApiService,
    private val mapAlbumDto: (NetworkAlbum) -> Album
) : AlbumRepository {

    override fun getAlbumById(id: String): Single<SimpleResult<Album>> {
        return albumApiService.getAlbumById(id).map {
            it.fold(
                success = { dto -> Result.Success(mapAlbumDto(dto)) },
                failure = { throwable -> Result.Failure(throwable) }

DenisBronx

object OOPRepositoryFactory {

    fun makeAlbumRepository(): AlbumRepository {
        return AlbumRepositoryImpl(
            AlbumApiServiceImpl(),
            AlbumDataMapper(NullableInputListMapperImpl(SongDataMapper()))
        )
    }
}

DenisBronx

object FPRepositoryFactory {

    fun makeAlbumRepository(): AlbumRepository {
        return AlbumRepositoryImpl(
            AlbumApiServiceImpl(),
            makeAlbumDataMapper()
        )
    }

    private fun makeAlbumDataMapper(): (NetworkAlbum) -> Album = { albumDto ->

DenisBronx

class GetTransactionsUseCaseImpl(
    private val getUserUseCase: GetUserUseCase,
    private val transactionRepository: TransactionRepository
) : GetTransactionsUseCase {

    override fun invoke(): Single<SimpleResult<List<Transaction>>> {
        return transactionRepository.getTransactions(getUserUseCase().id)
    }

}

DenisBronx

inline fun getTransactions(
    getUserUseCase: GetUserUseCase,
    transactionRepository: TransactionRepository
): Single<SimpleResult<List<Transaction>>> {
    return transactionRepository.getTransactions(getUserUseCase().id)
}

typealias GetTransactionsUseCase = () -> Single<SimpleResult<List<Transaction>>>

DenisBronx

interface TransactionRepository {

    fun getTransactions(userId: String): Single<SimpleResult<List<Transaction>>>

}

interface UserRepository {

    fun getUser(): User

DenisBronx

class GetUserUseCaseImpl(
    private val userRepository: UserRepository
) : GetUserUseCase {

    override fun invoke(): User = userRepository.getUser()
}