Add rest of aggregation parameters

src/main/scala/parse/AggregateData.scala

@@ -13,20 +13,36 @@ object AggregateValue {
   val dateFormatter = DateTimeFormatter.ofPattern("yyyyMMdd-HHmm")
 
   case class tempMax(value: Double) extends AggregateValue
-
   case class tempMaxList(value: Map[LocalDateTime, Double]) extends AggregateValue
-
   case class tempMin(value: Double) extends AggregateValue
-
   case class tempMinList(value: Map[LocalDateTime, Double]) extends AggregateValue
-
   case class tempAvg(value: Double) extends AggregateValue
-
   case class tempAvgList(value: Map[LocalDateTime, Double]) extends AggregateValue
-
   case class precipitationSum(value: Double) extends AggregateValue
-
   case class precipitationList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class windAvg(value: Double) extends AggregateValue
+  case class windAvgList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class windMax(value: Double) extends AggregateValue
+  case class windMaxList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class visibilityMin(value: Double) extends AggregateValue
+  case class visibilityMinList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class visibilityAvg(value: Double) extends AggregateValue
+  case class visibilityAvgList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class snowAvgList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class snowAvg(value: Double) extends AggregateValue
+  case class snowMax(value: Double) extends AggregateValue
+  case class atmPressureList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class atmPressureMin(value: Double) extends AggregateValue
+  case class atmPressureMax(value: Double) extends AggregateValue
+  case class atmPressureAvg(value: Double) extends AggregateValue
+  case class dewList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class dewMin(value: Double) extends AggregateValue
+  case class dewMax(value: Double) extends AggregateValue
+  case class dewAvg(value: Double) extends AggregateValue
+  case class humidityAvg(value: Double) extends AggregateValue
+  case class humidityAvgList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class sunDurationList(value: Map[LocalDateTime, Double]) extends AggregateValue
+  case class sunDurationSum(value: Double) extends AggregateValue
 
   private def encodeDateTimeMap(map: Map[LocalDateTime, Double]): Json = {
     map.map { case (dateTime, value) =>
@@ -43,6 +59,29 @@ object AggregateValue {
     case key: tempAvgList => encodeDateTimeMap(key.value)
     case key: precipitationSum => Json.fromDoubleOrNull(key.value)
     case key: precipitationList => encodeDateTimeMap(key.value)
+    case key: windAvg => Json.fromDoubleOrNull(key.value)
+    case key: windAvgList => encodeDateTimeMap(key.value)
+    case key: windMax => Json.fromDoubleOrNull(key.value)
+    case key: windMaxList => encodeDateTimeMap(key.value)
+    case key: visibilityMin => Json.fromDoubleOrNull(key.value)
+    case key: visibilityMinList => encodeDateTimeMap(key.value)
+    case key: visibilityAvg => Json.fromDoubleOrNull(key.value)
+    case key: visibilityAvgList => encodeDateTimeMap(key.value)
+    case key: snowAvgList => encodeDateTimeMap(key.value)
+    case key: snowAvg => Json.fromDoubleOrNull(key.value)
+    case key: snowMax => Json.fromDoubleOrNull(key.value)
+    case key: atmPressureList => encodeDateTimeMap(key.value)
+    case key: atmPressureMin => Json.fromDoubleOrNull(key.value)
+    case key: atmPressureMax => Json.fromDoubleOrNull(key.value)
+    case key: atmPressureAvg => Json.fromDoubleOrNull(key.value)
+    case key: dewList => encodeDateTimeMap(key.value)
+    case key: dewMin => Json.fromDoubleOrNull(key.value)
+    case key: dewMax => Json.fromDoubleOrNull(key.value)
+    case key: dewAvg => Json.fromDoubleOrNull(key.value)
+    case key: humidityAvg => Json.fromDoubleOrNull(key.value)
+    case key: humidityAvgList => encodeDateTimeMap(key.value)
+    case key: sunDurationList => encodeDateTimeMap(key.value)
+    case key: sunDurationSum => Json.fromDoubleOrNull(key.value)
   }
 
   def getKeys: List[String] = {
@@ -68,11 +107,29 @@ object AggregateKey {
     case "tempAvgList" => Some(AggregateKey.tempAvgList)
     case "precipitationSum" => Some(AggregateKey.precipitationSum)
     case "precipitationList" => Some(AggregateKey.precipitationList)
-    //    case "windSpeedAvg" => Some(AggregateKey.windSpeedAvg)
+    case "windAvg" => Some(AggregateKey.windAvg)
-    //    case "windGustMax" => Some(AggregateKey.windGustMax)
+    case "windAvgList" => Some(AggregateKey.windAvgList)
-    //    case "snowThicknessAvg" => Some(AggregateKey.snowThicknessAvg)
+    case "windMax" => Some(AggregateKey.windMax)
-    //    case "dewPointAvg" => Some(AggregateKey.dewPointAvg)
+    case "windMaxList" => Some(AggregateKey.windMaxList)
-    //    case "airHumidityAvg" => Some(AggregateKey.airHumidityAvg)
+    case "visibilityMin" => Some(AggregateKey.visibilityMin)
+    case "visibilityMinList" => Some(AggregateKey.visibilityMinList)
+    case "visibilityAvg" => Some(AggregateKey.visibilityAvg)
+    case "visibilityAvgList" => Some(AggregateKey.visibilityAvgList)
+    case "snowAvgList" => Some(AggregateKey.snowAvgList)
+    case "snowAvg" => Some(AggregateKey.snowAvg)
+    case "snowMax" => Some(AggregateKey.snowMax)
+    case "atmPressureList" => Some(AggregateKey.atmPressureList)
+    case "atmPressureMin" => Some(AggregateKey.atmPressureMin)
+    case "atmPressureMax" => Some(AggregateKey.atmPressureMax)
+    case "atmPressureAvg" => Some(AggregateKey.atmPressureAvg)
+    case "dewList" => Some(AggregateKey.dewList)
+    case "dewMin" => Some(AggregateKey.dewMin)
+    case "dewMax" => Some(AggregateKey.dewMax)
+    case "dewAvg" => Some(AggregateKey.dewAvg)
+    case "humidityAvg" => Some(AggregateKey.humidityAvg)
+    case "humidityAvgList" => Some(AggregateKey.humidityAvgList)
+    case "sunDurationList" => Some(AggregateKey.sunDurationList)
+    case "sunDurationSum" => Some(AggregateKey.sunDurationSum)
     case _ => None
   }
 
@@ -98,13 +155,35 @@ object AggregateKey {
   case object precipitationSum extends AggregateKey
   case object precipitationList extends AggregateKey
 
-  //  case object windSpeedAvg extends AggregateKey
+  case object windAvg extends AggregateKey
-  //
+  case object windAvgList extends AggregateKey
-  //  case object windGustMax extends AggregateKey
+
-  //
+  case object windMax extends AggregateKey
-  //  case object snowThicknessAvg extends AggregateKey
+  case object windMaxList extends AggregateKey
-  //
+
-  //  case object dewPointAvg extends AggregateKey
+  case object visibilityMin extends AggregateKey
-  //
+  case object visibilityMinList extends AggregateKey
-  //  case object airHumidityAvg extends AggregateKey
+
+  case object visibilityAvg extends AggregateKey
+  case object visibilityAvgList extends AggregateKey
+
+  case object snowAvg extends AggregateKey
+  case object snowAvgList extends AggregateKey
+  case object snowMax extends AggregateKey
+
+  case object atmPressureList extends AggregateKey
+  case object atmPressureMin extends AggregateKey
+  case object atmPressureMax extends AggregateKey
+  case object atmPressureAvg extends AggregateKey
+
+  case object dewList extends AggregateKey
+  case object dewMin extends AggregateKey
+  case object dewMax extends AggregateKey
+  case object dewAvg extends AggregateKey
+
+  case object humidityAvg extends AggregateKey
+  case object humidityAvgList extends AggregateKey
+
+  case object sunDurationList extends AggregateKey
+  case object sunDurationSum extends AggregateKey
 }

src/main/scala/parse/Parser.scala

@@ -79,6 +79,38 @@ object Parser {
 
       case AggKey.precipitationSum => aggregateValue(_.precipitation, _.sum, AggVal.precipitationSum)
       case AggKey.precipitationList => aggregateList(wd => wd.meteo.precipitation.map(wd.timestamp -> _), AggVal.precipitationList)
+
+      case AggKey.windAvg => aggregateValue(_.windSpeedAvg, values => values.sum / values.length, AggVal.windAvg)
+      case AggKey.windAvgList => aggregateList(wd => wd.meteo.windSpeedAvg.map(wd.timestamp -> _), AggVal.windAvgList)
+
+      case AggKey.windMax => aggregateValue(_.windGustMax, _.max, AggVal.windMax)
+      case AggKey.windMaxList => aggregateList(wd => wd.meteo.windGustMax.map(wd.timestamp -> _), AggVal.windMaxList)
+
+      case AggKey.visibilityMin => aggregateValue(_.visibilityMin, _.min, AggVal.visibilityMin)
+      case AggKey.visibilityMinList => aggregateList(wd => wd.meteo.visibilityMin.map(wd.timestamp -> _), AggVal.visibilityMinList)
+
+      case AggKey.visibilityAvg => aggregateValue(_.visibilityAvg, values => values.sum / values.length, AggVal.visibilityAvg)
+      case AggKey.visibilityAvgList => aggregateList(wd => wd.meteo.visibilityAvg.map(wd.timestamp -> _), AggVal.visibilityAvgList)
+
+      case AggKey.snowAvgList => aggregateList(wd => wd.meteo.snowThicknessAvg.map(wd.timestamp -> _), AggVal.snowAvgList)
+      case AggKey.snowAvg => aggregateValue(_.snowThicknessAvg, values => values.sum / values.length, AggVal.snowAvg)
+      case AggKey.snowMax => aggregateValue(_.snowThicknessAvg, _.max, AggVal.snowMax)
+
+      case AggKey.atmPressureList => aggregateList(wd => wd.meteo.atmPressure.map(wd.timestamp -> _), AggVal.atmPressureList)
+      case AggKey.atmPressureMin => aggregateValue(_.atmPressure, _.min, AggVal.atmPressureMin)
+      case AggKey.atmPressureMax => aggregateValue(_.atmPressure, _.max, AggVal.atmPressureMax)
+      case AggKey.atmPressureAvg => aggregateValue(_.atmPressure, values => values.sum / values.length, AggVal.atmPressureAvg)
+
+      case AggKey.dewList => aggregateList(wd => wd.meteo.dewPoint.map(wd.timestamp -> _), AggVal.dewList)
+      case AggKey.dewMin => aggregateValue(_.dewPoint, _.min, AggVal.dewMin)
+      case AggKey.dewMax => aggregateValue(_.dewPoint, _.max, AggVal.dewMax)
+      case AggKey.dewAvg => aggregateValue(_.dewPoint, values => values.sum / values.length, AggVal.dewAvg)
+
+      case AggKey.humidityAvg => aggregateValue(_.airHumidity, values => values.sum / values.length, AggVal.humidityAvg)
+      case AggKey.humidityAvgList => aggregateList(wd => wd.meteo.airHumidity.map(wd.timestamp -> _), AggVal.humidityAvgList)
+
+      case AggKey.sunDurationList => aggregateList(wd => wd.meteo.sunshineDuration.map(wd.timestamp -> _), AggVal.sunDurationList)
+      case AggKey.sunDurationSum => aggregateValue(_.sunshineDuration, _.sum, AggVal.sunDurationSum)
     }
   }
 }