From ac4d42620a79665b27b3a1fa31c0d848f7589981 Mon Sep 17 00:00:00 2001
From: Wolfgang Hottgenroth <wolfgang.hottgenroth@icloud.com>
Date: Mon, 4 Dec 2023 13:46:31 +0100
Subject: [PATCH] mbgw3 completed

---
 src/udi/dispatcher/dispatcher.go | 24 ++----------
 src/udi/handlers/mbgw3/mbgw3.go  | 64 ++++++++++++++++++--------------
 src/udi/handlers/pv/pv.go        |  1 -
 3 files changed, 41 insertions(+), 48 deletions(-)

diff --git a/src/udi/dispatcher/dispatcher.go b/src/udi/dispatcher/dispatcher.go
index 1bc8e7c..40a23ae 100644
--- a/src/udi/dispatcher/dispatcher.go
+++ b/src/udi/dispatcher/dispatcher.go
@@ -20,25 +20,10 @@ var archiverChannel chan handler.MessageT = make(chan handler.MessageT, 100)
 func InitDispatcher() {
   log.Printf("Initializing dispatcher")
   go archiver()
-  for _, handlerEntry := range config.Config.Handlers {
-    log.Printf("Trying %s", handlerEntry.Name)
-    switch handlerEntry.Name {
-    case "TTN":
-      handlerMap[handlerEntry.Name] = ttn.NewTTNHandler()
-      log.Printf("TTN initialized")
-    case "IoT":
-      handlerMap[handlerEntry.Name] = iot.NewIoTHandler()
-      log.Printf("IoT initialized")
-    case "PV":
-      handlerMap[handlerEntry.Name] = pv.NewPvHandler()
-      log.Printf("PV initialized")
-    case "MBGW3":
-      handlerMap[handlerEntry.Name] = mbgw3.NewMbgw3Handler()
-      log.Printf("MBGW3 initialized")
-    default:
-      log.Fatalf("Handler %s not found", handlerEntry.Name)
-    }
-  }
+  handlerMap["TTN"] = ttn.NewTTNHandler()
+  handlerMap["IoT"] = iot.NewIoTHandler()
+  handlerMap["PV"] = pv.NewPvHandler()
+  handlerMap["MBGW3"] = mbgw3.NewMbgw3Handler()
 }
 
 func storeMessage(filename string, item handler.MessageT) {
@@ -97,7 +82,6 @@ func InputDispatcher() {
             handler, exists := handlerMap[mapping.Handler]
             if exists {
               handler.Handle(message)
-              break
             } else {
               log.Printf("Handler not found, message is lost")
             }
diff --git a/src/udi/handlers/mbgw3/mbgw3.go b/src/udi/handlers/mbgw3/mbgw3.go
index 402f559..6e0f5ea 100644
--- a/src/udi/handlers/mbgw3/mbgw3.go
+++ b/src/udi/handlers/mbgw3/mbgw3.go
@@ -3,7 +3,7 @@ package mbgw3
 import (
   "log"
   //"reflect"
-  //"time"
+  "time"
   "strconv"
   "encoding/json"
   "udi/handlers/handler"
@@ -34,7 +34,6 @@ func NewMbgw3Handler() *Mbgw3Handler {
     id: idSeq,
   }
   idSeq += 1
-
   t.dbh = database.NewDatabaseHandle("")
   return t
 }
@@ -48,40 +47,51 @@ func (self *Mbgw3Handler) Handle(message handler.MessageT) {
     log.Printf("Unable to parse payload into Observation struct, values are lost: ", err)
     return
   }
-  log.Printf("Parsed observation: %s", observation)
 
-  attributes := make(map[string]interface{})
+  var measurement database.Measurement
+  measurement.Time = time.Now()
+
+  if observation.Device == "Gas" {
+    measurement.Application = "Gas"
+    measurement.Device = "Gasmeter"
+  } else {
+    measurement.Application = "Power"
+    measurement.Device = observation.Device
+  }
+
+  measurement.Attributes = make(map[string]interface{})
   if v, err := strconv.Atoi(observation.RequestId); err == nil {
-    attributes["RequestId"] = v
+    measurement.Attributes["RequestId"] = v
   }
+  if v, err := strconv.ParseFloat(observation.ErrorRatio, 32); err == nil {
+    measurement.Attributes["ErrorRatio"] = v
+  }
+  if v, err := strconv.Atoi(observation.Errors); err == nil {
+    measurement.Attributes["Errors"] = v
+  }
+  if v, err := strconv.Atoi(observation.Requests); err == nil {
+    measurement.Attributes["Requests"] = v
+  }
+  measurement.Attributes["Status"] = observation.Status
 
-  attributes["Errors"] = observation.Errors
-  attributes["Requests"] = observation.Requests
-
-  /*
-  variables := make(map[string]database.VariableType)
-  pvValueStructValue := reflect.ValueOf(pvValue)
-  for i := 0; i < pvValueStructValue.NumField(); i++ {
-    field := pvValueStructValue.Type().Field(i)
-    fieldValue := pvValueStructValue.Field(i)
-    v := database.VariableType {
-      Label: "",
-      Variable: field.Name,
-      Unit: field.Tag.Get("unit"),
-      Value: fieldValue.Interface(),
+  measurement.Values = make(map[string]database.VariableType)
+  unitMap := map[string]string { "Energy": "Wh", "Power": "W", "Voltage": "V", "Current": "A", "Volume": "m3" }
+  for k, v := range observation.Values {
+    unit, exists := unitMap[k]
+    if ! exists {
+      unit = "Unmapped Unit"
+    }
+    measurement.Values[k] = database.VariableType {
+      Label: "",
+      Variable: k,
+      Unit: unit,
+      Value: v,
     }
-    variables[field.Name] = v
   }
 
-  measurement := database.Measurement {
-    Time: time.Now(),
-    Application: "PV",
-    Device: "Powermeter",
-    Values: variables,
-  }
+  log.Printf("Prepared measurement item: %s", measurement)
 
   self.dbh.StoreMeasurement(&measurement)
-  */
 }
 
 
diff --git a/src/udi/handlers/pv/pv.go b/src/udi/handlers/pv/pv.go
index 712dac1..44df3cd 100644
--- a/src/udi/handlers/pv/pv.go
+++ b/src/udi/handlers/pv/pv.go
@@ -43,7 +43,6 @@ func NewPvHandler() *PvHandler {
     id: idSeq,
   }
   idSeq += 1
-
   t.dbh = database.NewDatabaseHandle("")
   return t
 }