Feature/get cheapest basic prices

.gitignore

@@ -8,6 +8,9 @@ build/
 .idea/modules.xml
 .idea/jarRepositories.xml
 .idea/compiler.xml
+.idea/.misc.xml
+.idea/.gradle.xml
+
 .idea/libraries/
 *.iws
 *.iml

build.gradle.kts

@@ -14,6 +14,11 @@ repositories {
 
 dependencies {
     testImplementation(kotlin("test"))
+    testImplementation("org.junit.jupiter:junit-jupiter:5.8.1")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.8.1")
+    //testImplementation("com.nhaarman.mockitokotlin2:mockito-kotlin:2.1.0")
+    testImplementation("io.mockk:mockk:1.10.6")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.8.1")
 }
 
 tasks.test {

resources/src/Main.java

@@ -0,0 +1,8 @@
+/**
+ * Created by Aziza Helmy on ${DATE}.
+ */
+public class Main {
+    public static void main(String[] args) {
+        System.out.println("Hello world!");
+    }
+}

src/main/kotlin/Main.kt

@@ -1,22 +1,88 @@
 import dataSource.CsvDataSource
 import dataSource.utils.CsvParser
+import enums.TheTypeOfApartments
+import interactor.*
 import interactor.CostOfLivingDataSource
-import interactor.GetCityHasCheapestInternetConnectionInteractor
-import interactor.GetHighestSalaryAverageCititesNamesInteractor
+import interactor.GetCityHasLowestYearsToBuyApartmentInteractor
+import interactor.GetCityHasAverageMealPricesInteractor
+import interactor.GetSalaryAverageForCitiesInCountryInteractor
 
 fun main() {
     val csvParser = CsvParser()
     val dataSource: CostOfLivingDataSource = CsvDataSource(csvParser)
 
+
+    // region HighestSalaryAverageCities
     val getHighestSalaryAverageCities = GetHighestSalaryAverageCititesNamesInteractor(dataSource)
-    println(getHighestSalaryAverageCities.execute(limit = 10))
+    println(getHighestSalaryAverageCities.execute(limit = 5))
     printSeparationLine()
-
+    //endregion
+    //region 1-CityHasCheapestInternetConnection
     val getCityHasCheapestInternetConnectionInteractor = GetCityHasCheapestInternetConnectionInteractor(dataSource)
-    println(getCityHasCheapestInternetConnectionInteractor.execute())
-
+    println(getCityHasCheapestInternetConnectionInteractor.execute(100))
+    printSeparationLine()
+    //endregion
+    //region 2-TopCitiesFruitsAndVegetablesLowestCost
+    val getTopCitiesFruitsAndVegetablesLowestCost = GetTopCitiesFruitsAndVegetablesLowestCostInteractor(dataSource)
+    println(getTopCitiesFruitsAndVegetablesLowestCost.execute(10))
+    printSeparationLine()
+    //endregion
+    //region 3-SalaryAverageForCitiesInCountry
+    val getSalaryAverageForCitiesInCountry = GetSalaryAverageForCitiesInCountryInteractor(dataSource)
+    println(getSalaryAverageForCitiesInCountry.execute("Egypt"))
+    println(getSalaryAverageForCitiesInCountry.execute("Turkey"))
+    println(getSalaryAverageForCitiesInCountry.execute("syria"))
+    printSeparationLine()
+    //endregion
+    //region 4-CityHasHighestDifferentRentBetweenCityCenterAndOutside
+    val getCityHasHighestDifferentRentBetweenCityCenterAndOutside =
+        GetCityHasHighestDifferentRentBetweenCityCenterAndOutsideInteractor(dataSource)
+    println(getCityHasHighestDifferentRentBetweenCityCenterAndOutside.execute(TheTypeOfApartments.ONE_BED_ROOM))
+    printSeparationLine()
+    //endregion
+    //region 5-Top5CitiesNameHasSuitableClothesPrices
+    val  numberOfCityShouldReturn = 5
+    val getTop5NamesCitiesHasClothesFamousBrandsWithSuitablePricesInteractor =
+        GetTopCitiesNameHasSuitableClothesPricesInteractor(dataSource)
+    println(getTop5NamesCitiesHasClothesFamousBrandsWithSuitablePricesInteractor.execute(numberOfCityShouldReturn))
+    printSeparationLine()
+    //endregion
+    // region 6-CityHasLowestYearsToBuyApartment
+    val getCityHasLowestYearsToBuyApartment = GetCityHasLowestYearsToBuyApartmentInteractor(dataSource)
+    println(getCityHasLowestYearsToBuyApartment.execute(10))
+    println(getCityHasLowestYearsToBuyApartment.execute(7))
+    println(getCityHasLowestYearsToBuyApartment.execute(0))
+    printSeparationLine()
+    //endregion
+    //region 7-CheapestBananaCitiesNames
+    val getCheapestBananaCitiesNames = GetCheapestBananaCitiesNamesInteractor(dataSource)
+    println(getCheapestBananaCitiesNames.execute(dataSource.getAllCitiesData()[0]))
+    printSeparationLine()
+    //endregion
+    //region 8-CityHasCheapestMealPrices
+    val getCityHasCheapestMealPrices = GetCityHasAverageMealPricesInteractor(dataSource)
+    println(getCityHasCheapestMealPrices.execute())
+    printSeparationLine()
+    //endregion
+    //region 9-TopTenCountryEnforceHighTaxesOnCarbonatedDrinks
+    val getTopTenCountryEnforceHighTaxesOnCarbonatedDrinks =
+        GetTopCountryEnforceHighTaxesOnCarbonatedDrinksInteractor(dataSource)
+    println(getTopTenCountryEnforceHighTaxesOnCarbonatedDrinks.execute(10))
+    printSeparationLine()
+    //endregion
+    //region 10-SuitableCityMoreSavingPerMonth
+    val getSuitableCityMoreSavingPerMonth = GetSuitableCityMoreSavingPerMonthInteractor(dataSource)
+    println(getSuitableCityMoreSavingPerMonth.execute())
+    printSeparationLine()
+    //endregion
+    //region 11-SearchCheapestCarInCountryInteractor
+    val searchCheapestCarInCountryInteractor = SearchCheapestCarInCountryInteractor(dataSource)
+    println(searchCheapestCarInCountryInteractor.execute("Egypt",3))
+    printSeparationLine()
+    //endregion
 }
-private fun printSeparationLine(){
+
+private fun printSeparationLine() {
     print("\n_______________________________\n")
 }
 

src/main/kotlin/enums/TheTypeOfApartments.kt

@@ -0,0 +1,7 @@
+package enums
+
+
+enum class TheTypeOfApartments {
+    ONE_BED_ROOM,
+    THREE_BED_ROOMS
+}

src/main/kotlin/interactor/GetCheapestBananaCitiesNamesInteractor.kt

@@ -0,0 +1,16 @@
+package interactor
+
+import model.CityEntity
+
+class GetCheapestBananaCitiesNamesInteractor(private val dataSource: CostOfLivingDataSource) {
+
+    fun execute(vararg cities: CityEntity): List<String> {
+        return dataSource
+            .getAllCitiesData()
+            .filter { it.fruitAndVegetablesPrices.banana1kg != null && it in cities }
+            .sortedBy { it.fruitAndVegetablesPrices.banana1kg }
+            .distinct()
+            .map { it.cityName }
+    }
+
+}

src/main/kotlin/interactor/GetCheapestBasicPricesInAllCitiesComparingToAverageSalariesInteractor.kt

@@ -0,0 +1,30 @@
+package interactor
+
+import model.CityEntity
+
+class GetCheapestBasicPricesInAllCitiesComparingToAverageSalariesInteractor (
+    private val dataSource: CostOfLivingDataSource
+) {
+
+    fun execute(): CityEntity? {
+        return dataSource
+            .getAllCitiesData()
+            .filter { execludeNullSalaryAndQualityDataAndOtherBaicPrices(it) != null }
+            .maxByOrNull {
+                (it.averageMonthlyNetSalaryAfterTax)!! -
+                        (it.transportationsPrices.monthlyPassRegularPrice
+                        !! + it.servicesPrices.basicElectricityHeatingCoolingWaterGarbageFor85m2Apartment!!
+                                + it.realEstatesPrices.apartmentOneBedroomInCityCentre!!)
+            }
+    }
+
+    fun execludeNullSalaryAndQualityDataAndOtherBaicPrices(cityEntity: CityEntity): Boolean? {
+        return cityEntity.run {
+            dataQuality
+                    && averageMonthlyNetSalaryAfterTax != null
+                    && realEstatesPrices.apartmentOneBedroomInCityCentre != null
+                    && servicesPrices.basicElectricityHeatingCoolingWaterGarbageFor85m2Apartment != null
+                    && transportationsPrices.monthlyPassRegularPrice != null
+        }
+    }
+}

src/main/kotlin/interactor/GetCityHasAverageMealPricesInteractor.kt

@@ -0,0 +1,52 @@
+package interactor
+
+import model.CityEntity
+import kotlin.math.ceil
+import kotlin.math.floor
+
+class GetCityHasAverageMealPricesInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+
+    fun execute(): CityEntity? {
+
+        val listOfCitiesEntity = dataSource.getAllCitiesData()
+            .filter { isCitiesInUSACanadaAndMexico(it) && excludeNullMealPrices(it) }
+            .sortedByDescending { it.mealsPrices.getAverageMealInCity(it) }
+
+        return if (listOfCitiesEntity.isNotEmpty()) getAverageMealInAllCities(listOfCitiesEntity)
+        else throw Throwable("List of cities is empty")
+    }
+
+    fun isCitiesInUSACanadaAndMexico(city: CityEntity): Boolean {
+        return city.country == ThreeSpecificCountries.USA.nameOFCountry
+                || city.country == ThreeSpecificCountries.CANADA.nameOFCountry
+                || city.country == ThreeSpecificCountries.MEXICO.nameOFCountry
+    }
+
+    fun excludeNullMealPrices(city: CityEntity): Boolean {
+        return (city.mealsPrices.mealFor2PeopleMidRangeRestaurant != null)
+                || ((city.mealsPrices.mealInexpensiveRestaurant != null)
+                && (city.mealsPrices.mealAtMcDonaldSOrEquivalent != null))
+    }
+
+    fun getAverageMealInAllCities(cityEntityList: List<CityEntity>): CityEntity? {
+        if (cityEntityList.isEmpty()) return null
+        val averageMealPricesInAllCities =
+            (cityEntityList.first().mealsPrices.getAverageMealInCity(cityEntityList.first())!! +
+        cityEntityList.last().mealsPrices.getAverageMealInCity(cityEntityList.last())!!).div(2)
+
+        return cityEntityList.first {
+            (it.mealsPrices.getAverageMealInCity(it) == averageMealPricesInAllCities)
+                    || (it.mealsPrices.getAverageMealInCity(it) == floor(averageMealPricesInAllCities))
+                    || (it.mealsPrices.getAverageMealInCity(it) == ceil(averageMealPricesInAllCities))
+        }
+    }
+}
+
+enum class ThreeSpecificCountries(val nameOFCountry: String) {
+    USA("United States"),
+    CANADA("Canada"),
+    MEXICO("Mexico"),
+    EGYPT("Egypt")
+}

src/main/kotlin/interactor/GetCityHasCheapestInternetConnectionInteractor.kt

@@ -3,13 +3,27 @@ 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): CityEntity? {
+        return dataSource
+            .getAllCitiesData()
+            .filter(::excludeNullInternetOrNullSalaries)
+            .take(limit)
+            .minByOrNull(::compareInternetCostToSalary)
     }
 
+    private fun excludeNullInternetOrNullSalaries(city: CityEntity): Boolean {
+        return city.run {
+            servicesPrices.internet60MbpsOrMoreUnlimitedDataCableAdsl != null && averageMonthlyNetSalaryAfterTax != null
+        }
+    }
 
+    private fun compareInternetCostToSalary(city: CityEntity): Float {
+        return city.run {
+            (servicesPrices.internet60MbpsOrMoreUnlimitedDataCableAdsl!! / averageMonthlyNetSalaryAfterTax!!) * 100
+        }
+    }
 
 }

src/main/kotlin/interactor/GetCityHasHighestDifferentRentBetweenCityCenterAndOutsideInteractor.kt

@@ -0,0 +1,54 @@
+package interactor
+
+import enums.TheTypeOfApartments
+import model.CityEntity
+import kotlin.math.abs
+
+class GetCityHasHighestDifferentRentBetweenCityCenterAndOutsideInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+
+    fun execute(type: TheTypeOfApartments): CityEntity {
+        if (type == TheTypeOfApartments.ONE_BED_ROOM) {
+            return dataSource.getAllCitiesData()
+                .filter(::excludeNullRentOneTypeOneAndLowQualityData)
+                .maxByOrNull {
+                    abs(
+                        it.realEstatesPrices.apartmentOneBedroomInCityCentre!!
+                                - it.realEstatesPrices.apartmentOneBedroomOutsideOfCentre!!
+                    )
+                }!!
+
+        } else {
+            return dataSource.getAllCitiesData()
+                .filter(::excludeNullRentOneTypeTwoAndLowQualityData)
+                .maxByOrNull {
+                    abs(
+                        it.realEstatesPrices.apartment3BedroomsInCityCentre!! -
+                                it.realEstatesPrices.apartment3BedroomsOutsideOfCentre!!
+                    )
+                }!!
+
+        }
+    }
+
+    private fun excludeNullRentOneTypeOneAndLowQualityData(city: CityEntity): Boolean {
+        return city.dataQuality
+                && city.realEstatesPrices.apartmentOneBedroomInCityCentre != null
+                && city.realEstatesPrices.apartmentOneBedroomOutsideOfCentre != null
+    }
+
+
+    private fun excludeNullRentOneTypeTwoAndLowQualityData(city: CityEntity): Boolean {
+
+        return city.dataQuality
+                && city.realEstatesPrices.apartment3BedroomsInCityCentre != null
+                && city.realEstatesPrices.apartment3BedroomsOutsideOfCentre != null
+
+
+    }
+}
+
+
+
+