Feature/get cities has lowest fruit veg prices comparing salaries paid

.gitignore

@@ -39,4 +39,6 @@ bin/
 .vscode/
 
 ### Mac OS ###
-.DS_Store
+.DS_Store
+/.idea/uiDesigner.xml
+/.idea/kotlinc.xml

build.gradle.kts

@@ -3,8 +3,10 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 plugins {
     kotlin("jvm") version "1.6.20"
     application
+
 }
 
+
 group = "org.the-chance"
 version = "1.0-SNAPSHOT"
 
@@ -13,7 +15,11 @@ repositories {
 }
 
 dependencies {
+    implementation("junit:junit:4.13.1")
+    implementation("org.testng:testng:7.1.0")
     testImplementation(kotlin("test"))
+    testImplementation("org.junit.jupiter:junit-jupiter:5.8.1")
+    testImplementation("org.mockito:mockito-core:3.3.3")
 }
 
 tasks.test {
@@ -22,8 +28,10 @@ tasks.test {
 
 tasks.withType<KotlinCompile> {
     kotlinOptions.jvmTarget = "1.8"
+
 }
 
 application {
     mainClass.set("MainKt")
+
 }

src/main/kotlin/Main.kt

@@ -3,20 +3,54 @@ import dataSource.utils.CsvParser
 import interactor.CostOfLivingDataSource
 import interactor.GetCityHasCheapestInternetConnectionInteractor
 import interactor.GetHighestSalaryAverageCititesNamesInteractor
+import interactor.GetTopCountriesHaveHighCarbonatedDrinksPricesInterctor
+import interactor.GetCitiesAndYearsToBuyApartmentInteractor
+import interactor.GetTopFashionCitiesInteractor
+import interactor.GetCitiesNamesSortedByCheapestBananaPricesInteractor
+import interactor.*
 
 fun main() {
     val csvParser = CsvParser()
     val dataSource: CostOfLivingDataSource = CsvDataSource(csvParser)
 
+    val getTopCountriesWithHighTaxOnCarbonatedDrinks= GetTopCountriesHaveHighCarbonatedDrinksPricesInterctor(dataSource)
+    println(getTopCountriesWithHighTaxOnCarbonatedDrinks.execute(limit = 10))
+    printSeparationLine()
+
     val getHighestSalaryAverageCities = GetHighestSalaryAverageCititesNamesInteractor(dataSource)
     println(getHighestSalaryAverageCities.execute(limit = 10))
     printSeparationLine()
 
-    val getCityHasCheapestInternetConnectionInteractor = GetCityHasCheapestInternetConnectionInteractor(dataSource)
-    println(getCityHasCheapestInternetConnectionInteractor.execute())
+    val getTopFashionCities = GetTopFashionCitiesInteractor(dataSource)
+    println(getTopFashionCities.execute(limit = 5))
+    printSeparationLine()
+
+    val getCitiesNamesSortedByCheapestBananaPricesInteractor = GetCitiesNamesSortedByCheapestBananaPricesInteractor(dataSource)
+    println(getCitiesNamesSortedByCheapestBananaPricesInteractor.execute("Caracas","Accra","Giza"))
+    printSeparationLine()
+
+    val getCitiesAndYearsToBuyApartment = GetCitiesAndYearsToBuyApartmentInteractor(dataSource)
+    println(getCitiesAndYearsToBuyApartment.execute(limit = 10))
+    printSeparationLine()
+
+    val getCountryCitiesAverageSalary = GetCountryCitiesAverageSalaryInteractor(dataSource)
+    println(getCountryCitiesAverageSalary.execute("Syria"))
+    printSeparationLine()
+
+    val getLowCostFruitVegetableCitiesWithHighSalaries = GetLowCostFruitVegetableCitiesWithHighSalariesInteractor(dataSource)
+    println(getLowCostFruitVegetableCitiesWithHighSalaries.execute(10))
+    printSeparationLine()
+
+
+    val getCityHasCheapestInternetConnection = GetCityHasCheapestInternetConnectionInteractor(dataSource)
+    println(getCityHasCheapestInternetConnection.execute())
+    printSeparationLine()
+
+
 
 }
-private fun printSeparationLine(){
+
+private fun printSeparationLine() {
     print("\n_______________________________\n")
 }
 

src/main/kotlin/interactor/GetCitiesAndYearsToBuyApartmentInteractor.kt

@@ -0,0 +1,40 @@
+package interactor
+
+import interactor.util.Constants.ONE_HUNDRED_SQUARE_METER
+import interactor.util.Constants.TWELVE_MONTH
+import model.CityEntity
+import interactor.util.toFormat
+import interactor.util.toYear
+
+class GetCitiesAndYearsToBuyApartmentInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+
+    fun execute(limit: Int): List<Pair<String, String>> {
+        return dataSource
+            .getAllCitiesData()
+            .filter(::excludeNullValueAndLowQualityData)
+            .sortedBy(::calculateYearsNeededToBuyApartment)
+            .take(limit)
+            .map { Pair(it.cityName, calculateYearsNeededToBuyApartment(it).toYear()) }
+    }
+
+
+    private fun excludeNullValueAndLowQualityData(city: CityEntity): Boolean {
+        return city.let {
+            it.dataQuality &&
+                    it.averageMonthlyNetSalaryAfterTax != null &&
+                    it.realEstatesPrices.pricePerSquareMeterToBuyApartmentOutsideOfCentre != null
+        }
+    }
+
+    private fun calculateYearsNeededToBuyApartment(city: CityEntity): Float {
+        return with(city) {
+            ((realEstatesPrices.pricePerSquareMeterToBuyApartmentOutsideOfCentre?.times(ONE_HUNDRED_SQUARE_METER))?.div(
+                (averageMonthlyNetSalaryAfterTax?.times(TWELVE_MONTH)!!)
+            ))?.toFormat() ?: 0f
+        }
+    }
+}
+
+

src/main/kotlin/interactor/GetCitiesNamesSortedByCheapestBananaPricesInteractor.kt

@@ -0,0 +1,26 @@
+package interactor
+
+import model.CityEntity
+
+
+class GetCitiesNamesSortedByCheapestBananaPricesInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+    fun execute(vararg cities: String): List<String> {
+        return dataSource
+            .getAllCitiesData()
+            .filter { excludeNullBananaPricesAndLowQualityData(it) }
+            .filter { compereCitiesNamesWithInputCities(cities, it.cityName) }
+            .sortedBy { it.fruitAndVegetablesPrices.banana1kg }
+            .map { it.cityName }
+    }
+
+    private fun compereCitiesNamesWithInputCities(inputCity: Array<out String>, city: String): Boolean {
+        return inputCity.map { it.toLowerCase().trim() }.contains(city.toLowerCase())
+    }
+
+    private fun excludeNullBananaPricesAndLowQualityData(city: CityEntity): Boolean {
+        return city.fruitAndVegetablesPrices.banana1kg != null
+    }
+
+}

src/main/kotlin/interactor/GetCountryCitiesAverageSalaryInteractor.kt

@@ -0,0 +1,29 @@
+package interactor
+
+import interactor.util.Constants.COUNTRY_WAS_NOT_FOUND
+import interactor.util.formatSentence
+import model.CityEntity
+
+class GetCountryCitiesAverageSalaryInteractor(
+    private val dataSource: CostOfLivingDataSource,
+) {
+
+    fun execute(country: String): List<Pair<String, Float>> {
+        val citiesSalaries = dataSource.getAllCitiesData()
+            .filter { searchCountry(it, country) && excludeNullSalariesAndLowQualityData(it) }
+            .map { Pair(it.cityName, it.averageMonthlyNetSalaryAfterTax!!) }
+        if (citiesSalaries.isEmpty()) throw Exception(COUNTRY_WAS_NOT_FOUND)
+
+        return citiesSalaries
+    }
+
+    private fun excludeNullSalariesAndLowQualityData(city: CityEntity): Boolean {
+        return city.averageMonthlyNetSalaryAfterTax != null && city.dataQuality
+    }
+
+    private fun searchCountry(city: CityEntity, country: String): Boolean {
+        return city.country.formatSentence() == country.formatSentence()
+    }
+
+
+}

src/main/kotlin/interactor/GetHighestSalaryAverageCititesNamesInteractor.kt

@@ -6,7 +6,7 @@ class GetHighestSalaryAverageCititesNamesInteractor(
     private val dataSource: CostOfLivingDataSource,
 ) {
 
-    fun execute(limit: Int): List<String> {
+    fun execute(limit: Int): List<String?> {
         return dataSource
             .getAllCitiesData()
             .filter(::excludeNullSalariesAndLowQualityData)

src/main/kotlin/interactor/GetLowCostFruitVegetableCitiesWithHighSalariesInteractor.kt

@@ -0,0 +1,35 @@
+package interactor
+
+import model.CityEntity
+import model.FruitAndVegetablesPrices
+
+
+
+class GetLowCostFruitVegetableCitiesWithHighSalariesInteractor(
+    private val dataSource: CostOfLivingDataSource
+) {
+
+    fun execute(limit: Int): List<String> {
+        return dataSource.getAllCitiesData()
+            .filter(::excludeNullSalariesAndNullFruitVegPrices)
+            .sortedBy { calculateFruitVegTotalPrice(it.fruitAndVegetablesPrices).div(it.averageMonthlyNetSalaryAfterTax!!) }
+            .takeUnless { limit<=0 || limit > it.count() }!!
+            .take(limit)
+            .map { it.cityName }
+    }
+    private fun excludeNullSalariesAndNullFruitVegPrices(city: CityEntity): Boolean {
+        return city.averageMonthlyNetSalaryAfterTax != null &&
+                with(city.fruitAndVegetablesPrices){
+                    this.apples1kg!= null && this.banana1kg!= null && this.lettuceOneHead!= null &&
+                    this.onion1kg!= null && this.oranges1kg!= null && this.potato1kg!= null &&
+                    this.tomato1kg!= null
+                }
+
+    }
+
+    private fun calculateFruitVegTotalPrice(fruitAndVegetablesPrices: FruitAndVegetablesPrices): Float =
+        with(fruitAndVegetablesPrices){
+                return this.apples1kg!! + this.banana1kg!!+ this.lettuceOneHead!!+ this.onion1kg!!+ this.oranges1kg!!+
+                   this.potato1kg!!+ this.tomato1kg!!
+        }
+}

src/main/kotlin/interactor/GetTopCountriesHaveHighCarbonatedDrinksPricesInterctor.kt

@@ -0,0 +1,20 @@
+package interactor
+
+import model.CityEntity
+
+class GetTopCountriesHaveHighCarbonatedDrinksPricesInterctor(
+    private val dataSource: CostOfLivingDataSource
+) {
+    fun execute(limit: Int): List<Pair<String, Float?>> {
+        return dataSource.getAllCitiesData()
+            .filter(::exceptionNullDrinkPriceAndQualityData)
+            .sortedByDescending { it.drinksPrices.cokePepsiAThirdOfLiterBottleInRestaurants }
+            .take(if (limit > 0) limit else 0)
+            .map { Pair(it.country, it.drinksPrices.cokePepsiAThirdOfLiterBottleInRestaurants) }
+    }
+
+    private fun exceptionNullDrinkPriceAndQualityData(city: CityEntity): Boolean {
+        return city.drinksPrices.cokePepsiAThirdOfLiterBottleInRestaurants != null
+                && city.dataQuality
+    }
+}

src/main/kotlin/interactor/GetTopFashionCitiesInteractor.kt

@@ -0,0 +1,33 @@
+package interactor
+
+import model.CityEntity
+
+class GetTopFashionCitiesInteractor(
+    private val dataSource: CostOfLivingDataSource,
+) {
+    fun execute(limit: Int): List<String> {
+        return dataSource.getAllCitiesData()
+            .filter(::excludeNullPrices)
+            .sortedBy(::calculateClothesPrices)
+            .take(limit)
+            .map { it.cityName }
+    }
+
+    private fun excludeNullPrices(city: CityEntity): Boolean {
+        return with(city.clothesPrices) {
+            this.onePairOfJeansLevis50oneOrSimilar != null &&
+                    this.onePairOfNikeRunningShoesMidRange != null &&
+                    this.oneSummerDressInAChainStoreZaraHAndM != null
+        }
+    }
+
+    private fun calculateClothesPrices(city: CityEntity): Float {
+        return with(city.clothesPrices) {
+            onePairOfJeansLevis50oneOrSimilar!! +
+                    oneSummerDressInAChainStoreZaraHAndM!! +
+                    onePairOfNikeRunningShoesMidRange!!
+        }
+    }
+}
+
+

src/main/kotlin/interactor/util/Constants.kt

@@ -0,0 +1,8 @@
+package interactor.util
+
+object Constants {
+    const val TWELVE_MONTH = 12
+    const val ONE_HUNDRED_SQUARE_METER = 100
+    const val COUNTRY_WAS_NOT_FOUND = "country was not found !"
+
+}

src/main/kotlin/interactor/util/Extension.kt

@@ -0,0 +1,14 @@
+package interactor.util
+
+
+fun Float.toFormat(limit: Int = 1): Float {
+    return String.format("%.${limit}f", this).toFloat()
+}
+
+fun String.formatSentence(): String {
+    return this.lowercase().trim().replace(Regex(" +"), " ")
+}
+
+fun Float.toYear(): String {
+    return if (this >= 2.0) "$this years" else "$this year"
+}