Fix/highest renting for appartements

build.gradle.kts

@@ -14,6 +14,8 @@ repositories {
 
 dependencies {
     testImplementation(kotlin("test"))
+    testImplementation("com.appmattus.fixture:fixture:1.2.0")
+    testImplementation("org.junit.jupiter:junit-jupiter")
 }
 
 tasks.test {

src/main/kotlin/Main.kt

@@ -1,8 +1,6 @@
 import dataSource.CsvDataSource
 import dataSource.utils.CsvParser
-import interactor.CostOfLivingDataSource
-import interactor.GetCityHasCheapestInternetConnectionInteractor
-import interactor.GetHighestSalaryAverageCititesNamesInteractor
+import interactor.*
 
 fun main() {
     val csvParser = CsvParser()
@@ -12,11 +10,54 @@ fun main() {
     println(getHighestSalaryAverageCities.execute(limit = 10))
     printSeparationLine()
 
+    val getTenCitiesHaveTheAverageOfFruitsAndVegetablesPrices =
+        GetTenCitiesHaveTheAverageOfFruitsAndVegetablesPricesInteractor(dataSource)
+    println(getTenCitiesHaveTheAverageOfFruitsAndVegetablesPrices.execute())
+    printSeparationLine()
+
+    val getCheapestApartmentsCitiesNamesInteractor = GetCheapestApartmentsCitiesNamesInteractor(dataSource)
+    getCheapestApartmentsCitiesNamesInteractor.execute(10, 100).forEach {
+        println("Number of years needed to buy a 100m apartment in ${it.first} city is : " + "%.2f".format(it.second))
+    }
+    printSeparationLine()
+
     val getCityHasCheapestInternetConnectionInteractor = GetCityHasCheapestInternetConnectionInteractor(dataSource)
-    println(getCityHasCheapestInternetConnectionInteractor.execute())
+    println(getCityHasCheapestInternetConnectionInteractor.execute(1))
+    printSeparationLine()
+
+    val getCheapestBananaPricesCitiesNamesInteractor=GetCheapestBananaPricesCitiesNamesInteractor(dataSource)
+    getCheapestBananaPricesCitiesNamesInteractor.apply {
+        println(execute(*getCitiesVarArgs().toTypedArray()))
+    }
+    printSeparationLine()
+
+    val getBestClothesPriceCitiesNameInteractor =
+        GetTopFiveCitiesNamesForShoppingClothesFromFamousBrandsInteractor(dataSource)
+    println(getBestClothesPriceCitiesNameInteractor.execute(limit = 5))
+    printSeparationLine()
+
+    val getCityNameAndSalaryAverageInteractor = GetCityNameAndSalrayAverageInteractor(dataSource)
+    println(getCityNameAndSalaryAverageInteractor.execute("Egypt"))
+    printSeparationLine()
+
+    val getMostSuitableCityForMoreSavingsPerMonthInteractor =
+        GetMostSuitableCityForMoreSavingsPerMonthInteractor(dataSource)
+    getMostSuitableCityForMoreSavingsPerMonthInteractor.apply {
+        println(execute())
+    }
+    printSeparationLine()
+
+    val getCityManagerExpectationInteractor = GetCityManagerExpectationInteractor(dataSource)
+    println(getCityManagerExpectationInteractor.execute())
+    printSeparationLine()
+
+    val getCityHasHighestRentingBetweenApartmentsInteractor =
+        GetCityHasHighestRentingBetweenApartmentsInteractor(dataSource)
+    println("The City has highest renting between apartements inside city center and outside is: "
+            +getCityHasHighestRentingBetweenApartmentsInteractor.execute().cityName)
 
 }
-private fun printSeparationLine(){
+
+private fun printSeparationLine() {
     print("\n_______________________________\n")
 }
-

src/main/kotlin/interactor/GetCheapestApartmentsCitiesNamesInteractor.kt

@@ -0,0 +1,45 @@
+package interactor
+
+import model.CityEntity
+
+class GetCheapestApartmentsCitiesNamesInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+
+    object Const {
+        const val MONTHS_OF_THE_YEAR = 12
+    }
+
+    fun execute(limit: Int, meters: Int): List<Pair<String, Float>> {
+
+        return dataSource.getAllCitiesData()
+            .excludeNullSalariesNullPricesAndLowQualityData()
+            .sortedByDescending {
+                it.averageMonthlyNetSalaryAfterTax!! /
+                        it.realEstatesPrices.pricePerSquareMeterToBuyApartmentOutsideOfCentre!!
+            }
+            .take(limit)
+            .map { Pair(it.cityName, it.calculateNumberOfYears(meters)) }
+            .takeIf { it.isNotEmpty() && it.size == limit }
+            ?: listOf(
+                Pair("Couldn't find Cities that meet your requirements :(", 0.0f)
+            )
+    }
+
+    private fun List<CityEntity>.excludeNullSalariesNullPricesAndLowQualityData(): List<CityEntity> {
+        return this.filter {
+            it.realEstatesPrices.pricePerSquareMeterToBuyApartmentOutsideOfCentre != null &&
+                    it.averageMonthlyNetSalaryAfterTax != null &&
+                    it.dataQuality
+        }
+    }
+
+    /*
+    Calculate how many years needed to buy 100meter apartment outSide center of the city
+    depending on monthly salary and squareMeter's price.
+    */
+    private fun CityEntity.calculateNumberOfYears(meters: Int): Float {
+        return this.realEstatesPrices.pricePerSquareMeterToBuyApartmentOutsideOfCentre!! * meters /
+                (this.averageMonthlyNetSalaryAfterTax!! * Const.MONTHS_OF_THE_YEAR)
+    }
+}

src/main/kotlin/interactor/GetCheapestBananaPricesCitiesNamesInteractor.kt

@@ -0,0 +1,19 @@
+package interactor
+
+import model.CityEntity
+
+class  GetCheapestBananaPricesCitiesNamesInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+    fun getCitiesVarArgs(): List<CityEntity> {
+        return dataSource.getAllCitiesData()
+    }
+
+    fun execute(vararg cityEntities: CityEntity): List<String> {
+        return cityEntities
+            .filter { it.fruitAndVegetablesPrices.banana1kg != null }
+            .sortedBy { it.fruitAndVegetablesPrices.banana1kg }
+            .map { it.cityName }
+            .takeIf { it.isNotEmpty() } ?: listOf("No Valid Data is Entered !")
+    }
+}

src/main/kotlin/interactor/GetCityHasCheapestInternetConnectionInteractor.kt

@@ -3,13 +3,31 @@ package interactor
 import model.CityEntity
 
 class GetCityHasCheapestInternetConnectionInteractor(
-    private val dataSource: CostOfLivingDataSource,
-) {
+    private val dataSource: CostOfLivingDataSource, ) {
 
-    fun execute(): CityEntity{
-        throw Throwable("Not Implemented yet")
+    fun execute(limit: Int): String {
+        val list = dataSource
+            .getAllCitiesData()
+            .filter(::excludeNullAverageSalaryAndServicesPrices)
+            .sortingWithBestInternetPrice()
+            .take(limit)
+            .map { it.cityName }
+        return if (list.isEmpty())
+            ""
+        else
+            list[0]
     }
 
+    private fun excludeNullAverageSalaryAndServicesPrices(city: CityEntity): Boolean {
+        return city.averageMonthlyNetSalaryAfterTax != null && city.servicesPrices.internet60MbpsOrMoreUnlimitedDataCableAdsl != null
+    }
 
 
-}
+    private fun List<CityEntity>.sortingWithBestInternetPrice(): List<CityEntity> {
+        return this.sortedByDescending {
+            (it.averageMonthlyNetSalaryAfterTax?.div(
+                it.servicesPrices.internet60MbpsOrMoreUnlimitedDataCableAdsl!!
+            ))
+        }
+    }
+}

src/main/kotlin/interactor/GetCityHasHighestRentingBetweenApartmentsInteractor.kt

@@ -0,0 +1,35 @@
+package interactor
+
+import model.CityEntity
+
+class GetCityHasHighestRentingBetweenApartmentsInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+    fun execute(): CityEntity {
+        return dataSource
+            .getAllCitiesData()
+            .filter(::excludeNullValuesAndLowQualityData)
+            .sortingWithRentingPrices()
+            .take(1).first()
+    }
+
+    private fun excludeNullValuesAndLowQualityData(city: CityEntity): Boolean {
+        return city.realEstatesPrices.apartment3BedroomsInCityCentre != null
+                && city.realEstatesPrices.apartment3BedroomsOutsideOfCentre != null
+                && city.realEstatesPrices.apartmentOneBedroomInCityCentre != null
+                && city.realEstatesPrices.apartmentOneBedroomOutsideOfCentre != null
+                && city.dataQuality
+    }
+
+    private fun List<CityEntity>.sortingWithRentingPrices(): List<CityEntity> {
+        return this.sortedBy {
+            (it.realEstatesPrices.apartment3BedroomsInCityCentre
+                ?.plus(it.realEstatesPrices.apartmentOneBedroomInCityCentre!!))
+                ?.div(
+                    it.realEstatesPrices.apartment3BedroomsOutsideOfCentre
+                        ?.plus(it.realEstatesPrices.apartmentOneBedroomOutsideOfCentre!!)!!
+                )
+        }
+    }
+
+}

src/main/kotlin/interactor/GetCityManagerExpectationInteractor.kt

@@ -0,0 +1,41 @@
+package interactor
+
+import model.CityEntity
+
+class GetCityManagerExpectationInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+    fun execute(): String? {
+        val data =
+            dataSource.getAllCitiesData()
+                .filter(::filterByCountry)
+                .sortingWithAveragePrice()
+
+        return if (data.isNotEmpty()) data[data.size / 2].cityName else null
+    }
+
+
+    private fun filterByCountry(city: CityEntity): Boolean {
+        return (city.country == "United States"
+                && city.mealsPrices.mealAtMcDonaldSOrEquivalent != null
+                && city.mealsPrices.mealInexpensiveRestaurant != null
+                && city.mealsPrices.mealFor2PeopleMidRangeRestaurant != null
+                ) || (city.country == "Canada"
+                && city.mealsPrices.mealAtMcDonaldSOrEquivalent != null
+                && city.mealsPrices.mealInexpensiveRestaurant != null
+                && city.mealsPrices.mealFor2PeopleMidRangeRestaurant != null
+                ) || (city.country == "Mexico"
+                && city.mealsPrices.mealAtMcDonaldSOrEquivalent != null
+                && city.mealsPrices.mealInexpensiveRestaurant != null
+                && city.mealsPrices.mealFor2PeopleMidRangeRestaurant != null
+                )
+    }
+
+
+    private fun List<CityEntity>.sortingWithAveragePrice(): List<CityEntity> {
+        return this.sortedBy {
+            (it.mealsPrices.mealInexpensiveRestaurant?.plus(it.mealsPrices.mealAtMcDonaldSOrEquivalent!!)
+                ?.plus(it.mealsPrices.mealFor2PeopleMidRangeRestaurant!!))?.div(3)
+        }
+    }
+}

src/main/kotlin/interactor/GetCityNameAndSalrayAverageInteractor.kt

@@ -0,0 +1,37 @@
+package interactor
+
+import model.CityEntity
+import java.lang.reflect.Executable
+
+class GetCityNameAndSalrayAverageInteractor(private val dataSource: CostOfLivingDataSource) {
+
+
+    fun execute(country: String): List<Pair<String,Float>>
+    {
+        val list = dataSource
+            .getAllCitiesData()
+            .filter { (it.country == country.convert()) && (it.dataQuality) }.getSalary()
+        if(list.isEmpty())
+        {
+            throw Exception("Enter Valid Country")
+        }
+        return list
+    }
+    private fun List<CityEntity>.getSalary(): List<Pair<String, Float>> {
+        val newList = mutableListOf<Pair<String, Float>>()
+        var salary: Float
+        this.forEach{
+            salary =
+                it.averageMonthlyNetSalaryAfterTax!!
+            newList.add(Pair(it.cityName, salary))
+        }
+        return newList
+    }
+    private fun String.convert(): String {
+        return capitalize(lowercase())!!
+    }
+    private fun capitalize(str: String?): String? {
+        return str?.capitalize() ?: str
+    }
+
+}

src/main/kotlin/interactor/GetHighestCarbonatedDrinksPricesInteractor.kt

@@ -0,0 +1,60 @@
+package interactor
+
+import model.CityEntity
+import model.DrinksPrices
+
+
+class GetHighestCarbonatedDrinksPricesInteractor(private val dataSource: CostOfLivingDataSource) {
+    fun execute(): Set<Pair<String, Float>> {
+
+        val city: List<CityEntity> = dataSource.getAllCitiesData()
+            .filter { nullAndLowQualityDrinks(it) }
+            .sortedByDescending { avgPriceForASingleCity(it) }
+
+        return if (city.isEmpty()) {
+            emptySet()
+        } else {
+            finalList(city)
+        }
+    }
+
+    private fun nullAndLowQualityDrinks(cityEntity: CityEntity): Boolean =
+
+        cityEntity.drinksPrices.cappuccinoRegularInRestaurants != null &&
+                cityEntity.drinksPrices.milkRegularOneLiter != null &&
+                cityEntity.drinksPrices.waterAThirdOfLiterBottleInRestaurants != null &&
+                cityEntity.drinksPrices.cokePepsiAThirdOfLiterBottleInRestaurants != null &&
+                cityEntity.drinksPrices.waterOneAndHalfLiterBottleAtTheMarket != null &&
+                cityEntity.dataQuality
+
+
+    // function to return the average prices for only one city
+    private fun avgPriceForASingleCity(cityEntity: CityEntity) = (cityEntity.drinksPrices.milkRegularOneLiter!! +
+            cityEntity.drinksPrices.cappuccinoRegularInRestaurants!! +
+            cityEntity.drinksPrices.waterOneAndHalfLiterBottleAtTheMarket!! +
+            cityEntity.drinksPrices.waterAThirdOfLiterBottleInRestaurants!! +
+            cityEntity.drinksPrices.cokePepsiAThirdOfLiterBottleInRestaurants!!) / 5
+
+    //a function to return the average prices for a whole country
+    private fun avgpriceforacountry(list: List<CityEntity>): Float {
+        val listofprices = mutableListOf<Float>()
+        var finalvalue = 0f
+        list.forEach {
+            listofprices.add(avgPriceForASingleCity(it))
+        }
+        listofprices.forEach {
+            finalvalue += it
+        }
+        return  finalvalue / listofprices.size
+    }
+
+    // function to sort the list into a sorted set and return a list of 10 countries
+    fun finalList(list: List<CityEntity>) :Set<Pair<String,Float>> {
+        val finallist = mutableListOf<Pair<String, Float>>()
+        list.forEach { cityEntity ->
+            finallist .add(Pair(cityEntity.country,avgpriceforacountry(list.filter{cityEntity.country ==it.country })))
+
+        }
+        return finallist.toSet().take(10).toSet()
+    }
+}