Finished events report, implemented GeofenceController, fixed geofencesGet() and many fixes

1 files changed, 87 insertions, 42 deletions

diff --git a/androidApp/src/main/java/mx/trackermap/TrackerMap/android/details/reports/UnitReportsViewModel.kt b/androidApp/src/main/java/mx/trackermap/TrackerMap/android/details/reports/UnitReportsViewModel.kt
index 98b8a34..48486e1 100644
--- a/androidApp/src/main/java/mx/trackermap/TrackerMap/android/details/reports/UnitReportsViewModel.kt
+++ b/androidApp/src/main/java/mx/trackermap/TrackerMap/android/details/reports/UnitReportsViewModel.kt
@@ -1,22 +1,20 @@
 package mx.trackermap.TrackerMap.android.details.reports
 
 import android.util.Log
-import androidx.lifecycle.MutableLiveData
-import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.asFlow
-import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.*
+import kotlinx.coroutines.DelicateCoroutinesApi
 import java.text.SimpleDateFormat
-import java.util.Calendar
-import java.util.Date
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
 import mx.trackermap.TrackerMap.client.apis.ReportsApi
-import mx.trackermap.TrackerMap.client.models.Event
-import mx.trackermap.TrackerMap.client.models.Position
-import mx.trackermap.TrackerMap.client.models.Stop
+import mx.trackermap.TrackerMap.client.models.*
+import mx.trackermap.TrackerMap.controllers.GeofencesController
 import org.koin.core.component.KoinComponent
+import org.koin.core.component.inject
+import java.util.*
+import java.util.Calendar
 
+@DelicateCoroutinesApi
 class UnitReportsViewModel(
     private val reportsApi: ReportsApi,
     savedStateHandle: SavedStateHandle
@@ -24,7 +22,7 @@ class UnitReportsViewModel(
 
     sealed class Report {
         class PositionsReport(val positions: Array<Position>) : Report()
-        class EventsReport(val events: Array<Event>) : Report()
+        class EventsReport(val events: Array<EventInformation>) : Report()
         class StopsReport(val stops: Array<Stop>) : Report()
         object LoadingReport: Report()
     }
@@ -37,13 +35,22 @@ class UnitReportsViewModel(
         DAY, WEEK, MONTH
     }
 
-    var deviceId = savedStateHandle.getLiveData("deviceId", 0)
-    val reportType: MutableLiveData<ReportType> = savedStateHandle.getLiveData("reportType", null)
-    val reportPeriod: MutableLiveData<ReportPeriod> =
+    private val geofenceController: GeofencesController by inject()
+
+    private var _deviceId = savedStateHandle.getLiveData("deviceId", 0)
+    private val _reportType: MutableLiveData<ReportType> = savedStateHandle.getLiveData("reportType", null)
+    private val _reportPeriod: MutableLiveData<ReportPeriod> =
         savedStateHandle.getLiveData("reportPeriod", null)
-    val report: MutableLiveData<Report> = MutableLiveData()
+    private val _report: MutableLiveData<Report> = MutableLiveData()
+    private val _geofences: MutableLiveData<Map<Int, Geofence>> = MutableLiveData()
 
-    val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'")
+    val deviceId: LiveData<Int> get() = _deviceId
+    val reportType: LiveData<ReportType> get() = _reportType
+    val reportPeriod: LiveData<ReportPeriod> get() = _reportPeriod
+    val report: LiveData<Report> get() = _report
+    val geofences: LiveData<Map<Int, Geofence>> get() = _geofences
+
+    private val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.getDefault())
 
     init {
         viewModelScope.launch {
@@ -52,47 +59,49 @@ class UnitReportsViewModel(
         viewModelScope.launch {
             setupPeriodObserver()
         }
+        viewModelScope.launch {
+            setupGeofenceObserver()
+        }
     }
 
     private suspend fun setupTypeObserver() {
-        reportType.asFlow().collect {
+        _reportType.asFlow().collect {
             fetchReport()
         }
     }
 
     private suspend fun setupPeriodObserver() {
-        reportPeriod.asFlow().collect {
+        _reportPeriod.asFlow().collect {
             fetchReport()
         }
     }
 
-    private fun fetchReport() {
-        if (reportType.value == null || reportPeriod.value == null) {
-            return
+    private suspend fun setupGeofenceObserver() {
+        geofenceController.geofencesFlow.collect {
+            _geofences.postValue(it)
         }
+    }
 
-        val (currentDate, previousDate) = getDates()
-        Log.d("UnitReportsVM", "Current report type: ${reportType.value.toString()}")
-        Log.d("UnitReportsVM", "Current report period: ${reportPeriod.value.toString()}")
-        Log.d("UnitReportsVM", "Current date:${dateFormat.format(currentDate)}")
-        Log.d("UnitReportsVM", "Previous date:${dateFormat.format(previousDate)}")
+    fun setDeviceId (id: Int) {
+        _deviceId.value = id
+    }
 
-        report.postValue(Report.LoadingReport)
-        viewModelScope.launch {
-            when (reportType.value!!) {
-                ReportType.POSITIONS -> fetchPositions(previousDate, currentDate)
-                ReportType.EVENTS -> fetchEvents(previousDate, currentDate)
-                ReportType.STOPS -> fetchStops(previousDate, currentDate)
-            }
-        }
+    fun setReportType(reportType: ReportType) {
+        _reportType.value = reportType
+    }
+
+    fun setReportPeriod(reportPeriod: ReportPeriod) {
+        _reportPeriod.value = reportPeriod
     }
 
+    fun getGeofence(id: Int): Geofence? = _geofences.value?.get(id)
+
     private fun getDates(): Pair<Date, Date> {
         val calendar = Calendar.getInstance()
         val currentDate = calendar.time
 
         calendar.add(
-            Calendar.DATE, when (reportPeriod.value!!) {
+            Calendar.DATE, when (_reportPeriod.value!!) {
                 ReportPeriod.DAY -> -1
                 ReportPeriod.WEEK -> -7
                 ReportPeriod.MONTH -> -30
@@ -103,30 +112,66 @@ class UnitReportsViewModel(
         return Pair(currentDate, previousDate)
     }
 
+    private fun fetchReport() {
+        if (_reportType.value == null || _reportPeriod.value == null) {
+            return
+        }
+
+        val (currentDate, previousDate) = getDates()
+        Log.d("UnitReportsVM", "Current report type: ${_reportType.value.toString()}")
+        Log.d("UnitReportsVM", "Current report period: ${_reportPeriod.value.toString()}")
+        Log.d("UnitReportsVM", "Current date:${dateFormat.format(currentDate)}")
+        Log.d("UnitReportsVM", "Previous date:${dateFormat.format(previousDate)}")
+
+        _report.postValue(Report.LoadingReport)
+        viewModelScope.launch {
+            when (_reportType.value!!) {
+                ReportType.POSITIONS -> fetchPositions(previousDate, currentDate)
+                ReportType.EVENTS -> fetchEvents(previousDate, currentDate)
+                ReportType.STOPS -> fetchStops(previousDate, currentDate)
+            }
+        }
+    }
+
     private suspend fun fetchPositions(from: Date, to: Date) {
         Log.d("UnitReportsVM", "Fetching positions")
 
         val result = reportsApi.reportsRouteGet(
             dateFormat.format(from),
             dateFormat.format(to),
-            deviceId.value!!
+            _deviceId.value!!
         )
 
         Log.d("UnitReportsVM", "Positions report: $result")
-        report.postValue(Report.PositionsReport(result))
+        _report.postValue(Report.PositionsReport(result))
     }
 
     private suspend fun fetchEvents(from: Date, to: Date) {
         Log.d("UnitReportsVM", "Fetching events")
 
-        val result = reportsApi.reportsEventsGet(
+        val positionsResult = reportsApi.reportsRouteGet(
             dateFormat.format(from),
             dateFormat.format(to),
-            deviceId.value!!
+            _deviceId.value!!
         )
 
+        val eventsResult = reportsApi.reportsEventsGet(
+            dateFormat.format(from),
+            dateFormat.format(to),
+            _deviceId.value!!
+        )
+
+        val result = mutableListOf<EventInformation>()
+
+        eventsResult.forEach { event ->
+            result.add(EventInformation(
+                event = event,
+                position = positionsResult.find { it.id == event.positionId }
+            ))
+        }
+
         Log.d("UnitReportsVM", "Events report: $result")
-        report.postValue(Report.EventsReport(result))
+        _report.postValue(Report.EventsReport(result.toTypedArray()))
     }
 
     private suspend fun fetchStops(from: Date, to: Date) {
@@ -135,10 +180,10 @@ class UnitReportsViewModel(
         val result = reportsApi.reportsStopsGet(
             dateFormat.format(from),
             dateFormat.format(to),
-            deviceId.value!!
+            _deviceId.value!!
         )
 
         Log.d("UnitReportsVM", "Stops report: $result")
-        report.postValue(Report.StopsReport(result))
+        _report.postValue(Report.StopsReport(result))
     }
 }
\ No newline at end of file