Merge pull request #108 from flock-community/fix/small_bugs

wilmveel · web-flow · commit 8f0e35f63715 · 2020-06-22T13:54:13.000+02:00
Fix/small bugs
diff --git a/src/main/kotlin/controllers/AggregationController.kt b/src/main/kotlin/controllers/AggregationController.kt
@@ -1,40 +1,42 @@
 package community.flock.eco.workday.controllers
 
+import community.flock.eco.workday.model.AggregationClient
+import community.flock.eco.workday.model.AggregationMonth
+import community.flock.eco.workday.model.AggregationPerson
 import community.flock.eco.workday.services.AggregationService
-import java.math.BigDecimal
-import java.time.LocalDate
-import java.time.YearMonth
 import org.springframework.security.access.prepost.PreAuthorize
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
+import java.time.LocalDate
+import java.time.YearMonth
 
 @RestController
 @RequestMapping("/api/aggregations")
 class AggregationController(
     val aggregationService: AggregationService
 ) {
-    
+
     @GetMapping("/total-per-client", params = ["year"])
     @PreAuthorize("hasAuthority('AggregationAuthority.READ')")
-    fun revenuePerClientByYear(@RequestParam year: Int): List<Map<String, Any>> {
+    fun revenuePerClientByYear(@RequestParam year: Int): List<AggregationClient> {
         val from = LocalDate.of(year, 1, 1)
         val to = LocalDate.of(year, 12, 31)
         return aggregationService.totalPerClient(from, to)
     }
 
     @GetMapping("/total-per-person", params = ["year"])
     @PreAuthorize("hasAuthority('AggregationAuthority.READ')")
-    fun totalsPerPersonByYear(@RequestParam year: Int): List<Map<String, Any>> {
-        val from = LocalDate.of(year, 1,1)
-        val to = LocalDate.of(year, 12,31)
+    fun totalsPerPersonByYear(@RequestParam year: Int): List<AggregationPerson> {
+        val from = LocalDate.of(year, 1, 1)
+        val to = LocalDate.of(year, 12, 31)
         return aggregationService.totalPerPerson(from, to)
     }
 
     @GetMapping("/total-per-person", params = ["year", "month"])
     @PreAuthorize("hasAuthority('AggregationAuthority.READ')")
-    fun totalsPerPersonByYearMonth(@RequestParam year: Int, @RequestParam month: Int): List<Map<String, Any>> {
+    fun totalsPerPersonByYearMonth(@RequestParam year: Int, @RequestParam month: Int): List<AggregationPerson> {
         val yearMonth = YearMonth.of(year, month)
         val from = yearMonth.atDay(1)
         val to = yearMonth.atEndOfMonth()
@@ -43,7 +45,7 @@ class AggregationController(
 
     @GetMapping("/total-per-month", params = ["year"])
     @PreAuthorize("hasAuthority('AggregationAuthority.READ')")
-    fun totalsPerMonthByYear(@RequestParam year: Int): List<Map<String, Any>> {
+    fun totalsPerMonthByYear(@RequestParam year: Int): List<AggregationMonth> {
         val from = LocalDate.of(year, 1, 1)
         val to = LocalDate.of(year, 12, 31)
         return aggregationService.totalPerMonth(from, to)
diff --git a/src/main/kotlin/model/AggregationClient.kt b/src/main/kotlin/model/AggregationClient.kt
@@ -0,0 +1,8 @@
+package community.flock.eco.workday.model
+
+import java.math.BigDecimal
+
+data class AggregationClient(
+    val name: String,
+    val revenueGross: BigDecimal
+)
diff --git a/src/main/kotlin/model/AggregationMonth.kt b/src/main/kotlin/model/AggregationMonth.kt
@@ -0,0 +1,17 @@
+package community.flock.eco.workday.model
+
+import java.math.BigDecimal
+
+data class AggregationMonth(
+    val yearMonth: String,
+    val countContractInternal: Int,
+    val forecastRevenueGross: BigDecimal,
+    val forecastRevenueNet: BigDecimal,
+    val forecastHoursGross: BigDecimal,
+    val actualRevenue: BigDecimal,
+    val actualHours: BigDecimal,
+    val actualCostContractInternal: BigDecimal,
+    val actualCostContractExternal: BigDecimal,
+    val actualCostContractManagement: BigDecimal,
+    val actualCostContractService: BigDecimal
+)
diff --git a/src/main/kotlin/model/AggregationPerson.kt b/src/main/kotlin/model/AggregationPerson.kt
@@ -0,0 +1,16 @@
+package community.flock.eco.workday.model
+
+import java.math.BigDecimal
+
+data class AggregationPerson(
+    val name: String,
+    val contractTypes: Set<String>,
+    val sickDays:BigDecimal,
+    val workDays:BigDecimal,
+    val assignment:Int,
+    val event:Int,
+    val total:Int,
+    val holiDayUsed:BigDecimal,
+    val holiDayBalance:BigDecimal,
+    val revenue:BigDecimal
+)
diff --git a/src/main/kotlin/services/AggregationService.kt b/src/main/kotlin/services/AggregationService.kt
@@ -4,6 +4,9 @@ import community.flock.eco.workday.ApplicationConstants
 import community.flock.eco.workday.interfaces.Period
 import community.flock.eco.workday.interfaces.filterInRange
 import community.flock.eco.workday.interfaces.inRange
+import community.flock.eco.workday.model.AggregationClient
+import community.flock.eco.workday.model.AggregationMonth
+import community.flock.eco.workday.model.AggregationPerson
 import community.flock.eco.workday.model.Assignment
 import community.flock.eco.workday.model.Contract
 import community.flock.eco.workday.model.ContractExternal
@@ -39,14 +42,14 @@ class AggregationService(
     private val applicationConstants: ApplicationConstants
 ) {
 
-    fun totalPerClient(from: LocalDate, to: LocalDate): List<Map<String, Any>> {
+    fun totalPerClient(from: LocalDate, to: LocalDate): List<AggregationClient> {
         val allAssignments = assignmentService.findAllActive(from, to)
         return clientService.findAll()
-            .map {
-                client -> mapOf(
-                    "name" to client.name,
-                    "revenue" to allAssignments
-                        .filter{ it.client == client}
+            .map { client ->
+                AggregationClient(
+                    name = client.name,
+                    revenueGross = allAssignments
+                        .filter { it.client == client }
                         .toMapWorkingDay(from, to).values
                         .flatten()
                         .fold(BigDecimal.ZERO) { acc, cur -> acc + cur.revenuePerDay() }
@@ -56,101 +59,108 @@ class AggregationService(
 
     @Transactional
     fun
-        totalPerPerson(from: LocalDate, to: LocalDate): List<Map<String, Any>> {
-        val all = fetchAll(from, to)
+        totalPerPerson(from: LocalDate, to: LocalDate): List<AggregationPerson> {
+        val all = fetchAllData(from, to)
         val totalWorkDays = countWorkDaysInPeriod(from, to)
         return all.allPersons()
             .sortedBy { it.lastname }
             .map { person ->
-                mapOf(
-                    "name" to "${person.firstname} ${person.lastname}",
-                    "type" to all.contract
+                AggregationPerson(
+                    name = "${person.firstname} ${person.lastname}",
+                    contractTypes = all.contract
                         .filter { it.person == person }
-                        .map { it::class.simpleName }
-                        .toSet()
-                        .joinToString(","),
-                    "sickDays" to all.sickDay.filter { it.person == person }.totalHoursInPeriod(from, to),
-                    "workDays" to all.workDay.filter { it.assignment.person == person }.totalHoursInPeriod(from, to),
-                    "assignment" to all.assignment
+                        .mapNotNull { it::class.simpleName }
+                        .toSet(),
+                    sickDays = all.sickDay.filter { it.person == person }.totalHoursInPeriod(from, to),
+                    workDays = all.workDay.filter { it.assignment.person == person }.totalHoursInPeriod(from, to),
+                    assignment = all.assignment
                         .filter { it.person == person }
                         .toMapWorkingDay(from, to).values
                         .flatten()
                         .fold(0) { acc, cur -> acc + cur.hoursPerWeek }
                         .div(5),
-                    "event" to all.event
+                    event = all.event
                         .filter { it.persons.isEmpty() || it.persons.contains(person) }
                         .fold(0) { acc, cur -> acc + cur.hours },
-                    "total" to all.contract
+                    total = all.contract
                         .filter { it.person == person }
                         .map { it.totalHoursPerWeek() }
                         .sum()
                         .let { countWorkDaysInPeriod(from, to) * 8 * it / 40 },
-                    "holiDayUsed" to all.holiDay.filter { it.person == person }.totalHoursInPeriod(from, to),
-                    "holiDayBalance" to all.contract
+                    holiDayUsed = all.holiDay.filter { it.person == person }.totalHoursInPeriod(from, to),
+                    holiDayBalance = all.contract
                         .filter { it.person == person }
                         .filterIsInstance(ContractInternal::class.java)
                         .mapWorkingDay(from, to)
-                        .map { BigDecimal(it.hoursPerWeek * 24 * 8)  }
+                        .map { BigDecimal(it.hoursPerWeek * 24 * 8) }
                         .sum()
-                        .divide(BigDecimal(totalWorkDays * 40),10, RoundingMode.HALF_UP),
-                    "revenue" to all.workDay
+                        .divide(BigDecimal(totalWorkDays * 40), 10, RoundingMode.HALF_UP),
+                    revenue = all.workDay
                         .filter { it.assignment.person == person }
                         .sumAmount()
                 )
             }
     }
 
     @Transactional
-    fun totalPerMonth(from: LocalDate, to: LocalDate): List<Map<String, Any>> {
+    fun totalPerMonth(from: LocalDate, to: LocalDate): List<AggregationMonth> {
 
-        val all = fetchAll(from, to)
+        val all = fetchAllData(from, to)
         val months = (0..ChronoUnit.MONTHS.between(from, to))
             .map { from.plusMonths(it) }
             .map { YearMonth.from(it) }
         return months
             .map { yearMonth ->
-                mapOf(
-                    "yearMonth" to yearMonth.toString(),
-                    "countContractInternal" to all.contract
+                AggregationMonth(
+                    yearMonth = yearMonth.toString(),
+                    countContractInternal = all.contract
                         .filterIsInstance(ContractInternal::class.java)
                         .map { it.toDateRangeInPeriod(yearMonth) }
                         .filter { it.isNotEmpty() }
                         .count(),
-                    "forecastRevenueGross" to all.assignment
+                    forecastRevenueGross = all.assignment
                         .mapWorkingDay(yearMonth)
                         .sumAmount(yearMonth),
-                    "forecastRevenueNet" to all.assignment
+                    forecastRevenueNet = all.assignment
                         .mapWorkingDay(yearMonth)
                         .sumAmount(yearMonth)
                         .multiply(netRevenueFactor(from, to)),
-                    "actualRevenue" to all.workDay
+                    forecastHoursGross =  all.assignment
+                        .mapWorkingDay(yearMonth)
+                        .sumAssignmentHoursPerWeek()
+                        .divide(yearMonth.countWorkDaysInMonth().times(5).toBigDecimal(), 10, RoundingMode.HALF_UP),
+                    actualRevenue = all.workDay
                         .map { it.totalRevenueInPeriod(yearMonth) }
                         .sum(),
-                    "actualCostContractInternal" to all.contract
+                    actualHours = all.workDay
+                        .map { it.totalHoursInPeriod(yearMonth) }
+                        .sum()
+                        .divide(yearMonth.countWorkDaysInMonth().toBigDecimal(), 10, RoundingMode.HALF_UP),
+                    actualCostContractInternal = all.contract
                         .filterIsInstance(ContractInternal::class.java)
                         .map { it.totalCostInPeriod(yearMonth) }
                         .sum(),
-                    "actualCostContractExternal" to yearMonth.toDateRange()
+                    actualCostContractExternal = yearMonth.toDateRange()
                         .flatMap { date ->
                             cartesianProducts(all.contract.filterIsInstance(ContractExternal::class.java), all.workDay)
                                 .filter { (contract, workDay) -> contract.person == workDay.assignment.person }
                                 .filter { (contract, workDay) -> contract.inRange(date) && workDay.inRange(date) }
                                 .map { (contract, workDay) -> contract.hourlyRate.toBigDecimal() * workDay.hoursPerDay().getValue(date) }
                         }
                         .sum(),
-                    "actualCostContractManagement" to all.contract
+                    actualCostContractManagement = all.contract
                         .filterIsInstance(ContractManagement::class.java)
                         .map { it.totalCostInPeriod(yearMonth) }
                         .sum(),
-                    "actualCostContractService" to all.contract
+                    actualCostContractService = all.contract
                         .filterIsInstance(ContractServiceModel::class.java)
                         .map { it.totalCostInPeriod(yearMonth) }
                         .sum()
                 )
             }
     }
 
-    data class All(
+    data class AllData(
         val sickDay: List<SickDay>,
         val holiDay: List<HoliDay>,
         val workDay: List<WorkDay>,
@@ -175,7 +185,7 @@ class AggregationService(
         .fold(0.0) { acc, cur -> acc + cur.hoursPerWeek / 5 }
         .pow(countWorkDaysInPeriod(from, to))
 
-    private fun All.allPersons(): Set<Person> {
+    private fun AllData.allPersons(): Set<Person> {
         return (this.assignment.map { it.person } +
             this.contract.map { it.person } +
             this.sickDay.map { it.person } +
@@ -185,14 +195,14 @@ class AggregationService(
             .toSet()
     }
 
-    private fun fetchAll(from: LocalDate, to: LocalDate): All {
+    private fun fetchAllData(from: LocalDate, to: LocalDate): AllData {
         val activeWorkDay = workDayService.findAllActive(from, to)
         val activeHoliDay = holiDayService.findAllActive(from, to)
         val activeSickDay = sickDayService.findAllActive(from, to)
         val activeAssignment = assignmentService.findAllActive(from, to)
         val activeContract = contractService.findAllActive(from, to)
         val activeEvent = eventService.findAllActive(from, to)
-        return All(
+        return AllData(
             activeSickDay,
             activeHoliDay,
             activeWorkDay,
@@ -303,6 +313,14 @@ private fun <T : Period> List<T>.mapWorkingDay(yearMonth: YearMonth) = yearMonth
 private fun <T : Period> Iterable<T>.sumAmount(yearMonth: YearMonth) = this
     .fold(BigDecimal.ZERO) { acc, cur -> acc + cur.amountPerWorkingDay(yearMonth) }
 
+private fun Iterable<WorkDay>.sumWorkDayHoursPerWeek() = this
+    .fold(BigDecimal.ZERO) { acc, cur -> acc + cur.hours.toBigDecimal() }
+
+private fun Iterable<Assignment>.sumAssignmentHoursPerWeek() = this
+    .fold(BigDecimal.ZERO) { acc, cur -> acc + cur.hoursPerWeek.toBigDecimal() }
+
+
+
 private fun Iterable<WorkDay>.sumAmount() = this
     .fold(BigDecimal.ZERO) { acc, cur -> acc + (cur.hours * cur.assignment.hourlyRate).toBigDecimal() }
 
@@ -339,6 +357,9 @@ fun WorkDay.totalRevenueInPeriod(period: Period): BigDecimal = this
 fun WorkDay.totalRevenueInPeriod(yearMonth: YearMonth): BigDecimal = this
     .totalRevenueInPeriod(yearMonth.toPeriod())
 
+fun WorkDay.totalHoursInPeriod(yearMonth: YearMonth): BigDecimal = this
+    .totalHoursInPeriod(yearMonth.toPeriod())
+
 fun ContractInternal.totalCostInPeriod(yearMonth: YearMonth): BigDecimal = this
     .toDateRangeInPeriod(yearMonth)
     .map { this.monthlySalary.toBigDecimal() }
diff --git a/src/main/react/components/charts/AverageHoursPerDayChart.js b/src/main/react/components/charts/AverageHoursPerDayChart.js
@@ -0,0 +1,43 @@
+import React, {useEffect, useState} from "react"
+import BarChart from "recharts/es6/chart/BarChart"
+import CartesianGrid from "recharts/es6/cartesian/CartesianGrid"
+import XAxis from "recharts/es6/cartesian/XAxis"
+import YAxis from "recharts/es6/cartesian/YAxis"
+import Legend from "recharts/es6/component/Legend"
+import Tooltip from "recharts/es6/component/Tooltip"
+import Bar from "recharts/es6/cartesian/Bar"
+import ResponsiveContainer from "recharts/es6/component/ResponsiveContainer"
+import PropTypes from "prop-types"
+import {AlignedLoader} from "@flock-community/flock-eco-core/src/main/react/components/AlignedLoader"
+import {AggregationClient} from "../../clients/AggregationClient"
+
+export function AverageHoursPerDayChart({year}) {
+  const [state, setState] = useState(null)
+
+  useEffect(() => {
+    const date = new Date()
+    AggregationClient.totalPerMonthByYear(year || date.getFullYear()).then(res =>
+      setState(res)
+    )
+  }, [])
+
+  if (!state) return <AlignedLoader />
+
+  return (
+    <ResponsiveContainer>
+      <BarChart data={state}>
+        <CartesianGrid strokeDasharray="3 3" />
+        <XAxis dataKey="name" />
+        <YAxis />
+        <Tooltip formatter={value => new Intl.NumberFormat("en").format(value)} />
+        <Legend />
+        <Bar stackId="forcast" dataKey="forecastHoursGross" fill="#1de8b5" />
+        <Bar stackId="actual" dataKey="actualHours" fill="#3f51b5" />
+      </BarChart>
+    </ResponsiveContainer>
+  )
+}
+
+AverageHoursPerDayChart.propTypes = {
+  year: PropTypes.number,
+}
diff --git a/src/main/react/components/charts/RevenuePerClientChart.js b/src/main/react/components/charts/RevenuePerClientChart.js
@@ -18,8 +18,8 @@ export function RevenuePerClientChart({year}) {
 
   return (
     <ResponsiveContainer>
-      <PieChart width={400} height={400}>
-        <Pie data={state} valueKey="revenue" nameKey="name" fill="#3f51b5" label />
+      <PieChart height={500}>
+        <Pie data={state} valueKey="revenueGross" nameKey="name" fill="#3f51b5" label />
         <Tooltip formatter={value => new Intl.NumberFormat("en").format(value)} />
       </PieChart>
     </ResponsiveContainer>
diff --git a/src/main/react/features/dashboard/DashboardFeature.js b/src/main/react/features/dashboard/DashboardFeature.js
diff --git a/src/main/react/features/month/MonthFeature.js b/src/main/react/features/month/MonthFeature.js
diff --git a/src/test/kotlin/services/AggregationServiceTest.kt b/src/test/kotlin/services/AggregationServiceTest.kt
