Refactored reports code into ReportController.kt and added extra report periods

1 files changed, 22 insertions, 157 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 fe13ba0..865f096 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,58 +1,31 @@
 package mx.trackermap.TrackerMap.android.details.reports
 
-import android.util.Log
 import androidx.lifecycle.*
 import kotlinx.coroutines.DelicateCoroutinesApi
-import java.text.SimpleDateFormat
 import kotlinx.coroutines.flow.collect
 import kotlinx.coroutines.launch
-import mx.trackermap.TrackerMap.client.apis.ReportsApi
-import mx.trackermap.TrackerMap.client.models.*
-import mx.trackermap.TrackerMap.controllers.GeofencesController
+import mx.trackermap.TrackerMap.controllers.ReportController
+import mx.trackermap.TrackerMap.utils.ReportDates
 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
 ) : ViewModel(), KoinComponent {
 
-    sealed class Report {
-        class PositionsReport(val positions: Array<Position>) : Report()
-        class EventsReport(val events: Array<EventInformation>) : Report()
-        class StopsReport(val stops: Array<Stop>) : Report()
-        object LoadingReport: Report()
-    }
-
-    enum class ReportType {
-        POSITIONS, EVENTS, STOPS
-    }
-
-    enum class ReportPeriod {
-        DAY, WEEK, MONTH
-    }
-
-    private val geofenceController: GeofencesController by inject()
+    private val reportController: ReportController by inject()
 
     private var _deviceId = savedStateHandle.getLiveData("deviceId", 0)
-    private val _reportType: MutableLiveData<ReportType> = savedStateHandle.getLiveData("reportType", null)
-    private val _reportPeriod: MutableLiveData<ReportPeriod> =
+    private val _reportType: MutableLiveData<ReportController.ReportType> = savedStateHandle.getLiveData("reportType", null)
+    private val _reportPeriod: MutableLiveData<ReportDates.ReportPeriod> =
         savedStateHandle.getLiveData("reportPeriod", null)
-    private val _report: MutableLiveData<Report> = MutableLiveData()
-    private val _reportFile: MutableLiveData<ByteArray> = MutableLiveData()
-    private val _geofences: MutableLiveData<Map<Int, Geofence>> = MutableLiveData()
+    private val _report: MutableLiveData<ReportController.Report> = MutableLiveData()
 
     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 reportFile: LiveData<ByteArray> get() = _reportFile
-    val geofences: LiveData<Map<Int, Geofence>> get() = _geofences
-
-    private val dateFormat = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.getDefault())
+    val reportType: LiveData<ReportController.ReportType> get() = _reportType
+    val reportPeriod: LiveData<ReportDates.ReportPeriod> get() = _reportPeriod
+    val report: LiveData<ReportController.Report> get() = _report
 
     init {
         viewModelScope.launch {
@@ -62,7 +35,7 @@ class UnitReportsViewModel(
             setupPeriodObserver()
         }
         viewModelScope.launch {
-            setupGeofenceObserver()
+            setupReportObserver()
         }
     }
 
@@ -78,9 +51,9 @@ class UnitReportsViewModel(
         }
     }
 
-    private suspend fun setupGeofenceObserver() {
-        geofenceController.geofencesFlow.collect {
-            _geofences.postValue(it)
+    private suspend fun setupReportObserver() {
+        reportController.reportFlow.collect {
+            _report.value = it
         }
     }
 
@@ -88,32 +61,14 @@ class UnitReportsViewModel(
         _deviceId.value = id
     }
 
-    fun setReportType(reportType: ReportType) {
+    fun setReportType(reportType: ReportController.ReportType) {
         _reportType.value = reportType
     }
 
-    fun setReportPeriod(reportPeriod: ReportPeriod) {
+    fun setReportPeriod(reportPeriod: ReportDates.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!!) {
-                ReportPeriod.DAY -> -1
-                ReportPeriod.WEEK -> -7
-                ReportPeriod.MONTH -> -30
-            }
-        )
-        val previousDate = calendar.time
-
-        return Pair(currentDate, previousDate)
-    }
-
     fun fetchReportXlsx() {
         fetchReport(true)
     }
@@ -123,105 +78,15 @@ class UnitReportsViewModel(
             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)}")
-
-        if (!xlsx) {
-            _report.postValue(Report.LoadingReport)
-        }
         viewModelScope.launch {
-            when (_reportType.value!!) {
-                ReportType.POSITIONS -> fetchPositions(previousDate, currentDate, xlsx)
-                ReportType.EVENTS -> fetchEvents(previousDate, currentDate, xlsx)
-                ReportType.STOPS -> fetchStops(previousDate, currentDate, xlsx)
-            }
-        }
-    }
-
-    private suspend fun fetchPositions(from: Date, to: Date, xlsx: Boolean) {
-        Log.d("UnitReportsVM", "Fetching positions")
-
-        if (!xlsx) {
-            val result = reportsApi.reportsRouteGet(
-                dateFormat.format(from),
-                dateFormat.format(to),
-                _deviceId.value!!
-            )
-            Log.d("UnitReportsVM", "Positions report: $result")
-            _report.postValue(Report.PositionsReport(result))
-        } else {
-            val result = reportsApi.reportsRouteGetXlsx(
-                dateFormat.format(from),
-                dateFormat.format(to),
-                _deviceId.value!!
-            )
-            Log.d("UnitReportsVM", "Positions report: $result")
-            _reportFile.postValue(result)
-        }
-
-    }
-
-    private suspend fun fetchEvents(from: Date, to: Date, xlsx: Boolean) {
-        Log.d("UnitReportsVM", "Fetching events")
-
-        if (!xlsx) {
-            val positionsResult = reportsApi.reportsRouteGet(
-                dateFormat.format(from),
-                dateFormat.format(to),
-                _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 }
-                ))
+            _deviceId.value?.let { id ->
+                reportController.fetchReport(
+                    deviceId = id,
+                    reportType = _reportType.value,
+                    reportPeriod = _reportPeriod.value,
+                    xlsx = xlsx
+                )
             }
-
-            Log.d("UnitReportsVM", "Events report: $result")
-            _report.postValue(Report.EventsReport(result.toTypedArray()))
-        } else {
-            val result = reportsApi.reportsEventsGetXlsx(
-                dateFormat.format(from),
-                dateFormat.format(to),
-                _deviceId.value!!
-            )
-            Log.d("UnitReportsVM", "Events report: $result")
-            _reportFile.postValue(result)
-        }
-    }
-
-    private suspend fun fetchStops(from: Date, to: Date, xlsx: Boolean) {
-        Log.d("UnitReportsVM", "Fetching stops")
-
-        if (!xlsx) {
-            val result = reportsApi.reportsStopsGet(
-                dateFormat.format(from),
-                dateFormat.format(to),
-                _deviceId.value!!
-            )
-            Log.d("UnitReportsVM", "Stops report: $result")
-            _report.postValue(Report.StopsReport(result))
-        } else {
-            val result = reportsApi.reportsStopsGetXlsx(
-                dateFormat.format(from),
-                dateFormat.format(to),
-                _deviceId.value!!
-            )
-            Log.d("UnitReportsVM", "Stops report: $result")
-            _reportFile.postValue(result)
         }
-
     }
 }
\ No newline at end of file