fix in error output

add decoder for lsn50 3-way, fix 1
add decoder for lsn50 3-way
2024-02-09 14:05:14 +01:00 · 2024-02-09 13:40:21 +01:00 · 2024-02-09 13:38:55 +01:00 · 2024-02-07 22:46:35 +01:00 · 2024-02-07 22:41:01 +01:00 · 2024-02-07 22:35:15 +01:00
59 changed files with 1804 additions and 330 deletions
--- a/.gitignore
+++ b/.gitignore
@ -3,3 +3,5 @@ src/udi/migrate_schema
 tmp/
 ENVDB
 ENVDB.cluster
+deployment/secrets.txt
+deployment/secrets
--- a/.woodpecker.yml
+++ b/.woodpecker.yml
@ -2,8 +2,7 @@ steps:
  build:
    image: plugins/kaniko
    settings:
-      repo:
-        from_secret: image_name
+      repo: ${FORGE_NAME}/${CI_REPO}
      registry: 
        from_secret: container_registry
      tags: latest,${CI_COMMIT_SHA},${CI_COMMIT_TAG}
@ -15,16 +14,26 @@ steps:
    when:
      - event: [push, tag]

+  scan_image:
+    image: aquasec/trivy
+    commands:
+      - trivy image $FORGE_NAME/$CI_REPO:$CI_COMMIT_SHA --quiet --exit-code 1
+    when:
+      - event: [push, tag]
+        
  deploy:
    image: portainer/kubectl-shell:latest
    secrets:
      - source: kube_config
        target: KUBE_CONFIG_CONTENT
-      - source: image_name
-        target: IMAGE_NAME
+      - source: encryption_key
+        target: ENCRYPTION_KEY
+      - source: secrets_checksum
+        target: MD5_CHECKSUM
    commands:
+      - export IMAGE_TAG=$CI_COMMIT_TAG
      - printf "$KUBE_CONFIG_CONTENT" > /tmp/kubeconfig
      - export KUBECONFIG=/tmp/kubeconfig
-      - cat $CI_WORKSPACE/deployment/deploy-yml.tmpl | sed -e 's,%IMAGE%,'$IMAGE_NAME':'$CI_COMMIT_TAG',' | kubectl apply -f - 
+      - ./deployment/deploy.sh
    when:
      - event: tag
--- a/1
+++ b/1
@ -13,4 +13,3 @@ ENV UDI_CONF ""
 COPY --from=builder /go/src/udi ./
 ENTRYPOINT ["./udi"]

-
--- a/deployment/decrypt-secrets.sh
+++ b/deployment/decrypt-secrets.sh
@ -0,0 +1,43 @@
+#!/bin/bash
+
+if [ "$ENCRYPTION_KEY" = "" ]; then
+  echo "ENCRYPTION_KEY not set"
+  exit 1
+fi
+
+if [ "$MD5_CHECKSUM" = "" ]; then
+  echo "No checksum given"
+  exit 1
+fi
+
+SECRETS_CIPHERTEXT_FILE=secrets.enc
+SECRETS_PLAINTEXT_FILE=/tmp/secrets
+TMP_FILE=`mktemp`
+POD_NAME_SUFFIX=`date +%s`
+
+cat $SECRETS_CIPHERTEXT_FILE | \
+  kubectl run openssl-$POD_NAME_SUFFIX \
+    --rm \
+    --image bitnami/debian-base-buildpack:latest \
+    --env KEY=$ENCRYPTION_KEY \
+    -i \
+    -q \
+    -- \
+    /bin/sh -c "openssl enc -aes-256-cbc -salt -pass env:KEY -a -d" > \
+    $TMP_FILE
+
+if [ `uname` = "Darwin" ]; then
+  CALCULATED_CHECKSUM=`cat $TMP_FILE | md5`
+elif [ `uname` = "Linux" ]; then
+  CALCULATED_CHECKSUM=`cat $TMP_FILE | md5sum - | awk '{print $1}'`
+fi
+
+if [ "$MD5_CHECKSUM" != "$CALCULATED_CHECKSUM" ]; then
+  echo "Invalid checksum"
+  exit 1
+fi
+
+# cat $TMP_FILE
+mv $TMP_FILE $SECRETS_PLAINTEXT_FILE
+
+
--- a/deployment/deploy-yml.tmpl
+++ b/deployment/deploy-yml.tmpl
@ -1,8 +1,7 @@
 apiVersion: v1
 kind: PersistentVolumeClaim
 metadata:
-  name: udi-archive
-  namespace: udi
+  name: %PRE%-udi-archive
 spec:
  accessModes:
    - ReadWriteOnce
@ -14,12 +13,11 @@ spec:
 apiVersion: apps/v1
 kind: Deployment
 metadata:
-  name: udi
-  namespace: udi
+  name: %PRE%-udi
  labels:
    app: udi
  annotations:
-    secret.reloader.stakater.com/reload: "udi-conf,udi-db-cred"
+    secret.reloader.stakater.com/reload: "%PRE%-udi-conf,%PRE%-udi-db-cred,%PRE%-mqtt-password"
 spec:
  replicas: 1
  selector:
@ -33,20 +31,18 @@ spec:
      containers:
        - name: udi
          image: %IMAGE%
-          env:
-            - name: UDI_CONF
-              valueFrom:
-                secretKeyRef:
-                  name: udi-conf
-                  key: UDI_CONF
          envFrom:
            - secretRef: 
-                name: udi-db-cred
+                name: %PRE%-udi-db-cred
+            - secretRef:
+                name: %PRE%-mqtt-password
+            - configMapRef:
+                name: %PRE%-udi-conf
          volumeMounts:
            - mountPath: /archive
              name: udi-archive
      volumes:
        - name: udi-archive
          persistentVolumeClaim:
-            claimName: udi-archive
+            claimName: %PRE%-udi-archive

--- a/deployment/deploy.sh
+++ b/deployment/deploy.sh
@ -0,0 +1,92 @@
+#!/bin/bash
+
+if [ "$IMAGE_TAG" == "" ]; then
+  echo "Make sure IMAGE_TAG is set"
+  exit 1
+fi
+
+
+IMAGE_NAME=$FORGE_NAME/$CI_REPO
+
+CONFIG_FILE=config.json
+
+
+DEPLOYMENT_DIR=$PWD/deployment
+INSTANCES_DIR=$DEPLOYMENT_DIR/instances
+
+pushd $DEPLOYMENT_DIR > /dev/null
+./decrypt-secrets.sh || exit 1 
+. /tmp/secrets
+rm /tmp/secrets
+popd > /dev/null
+
+for NAMESPACE_DIR in `find $INSTANCES_DIR -type d -mindepth 1 -maxdepth 1`; do
+  NAMESPACE=`basename $NAMESPACE_DIR`
+  echo "Namespace: $NAMESPACE"
+
+  kubectl create namespace $NAMESPACE \
+    --dry-run=client \
+    -o yaml | \
+    kubectl -f - apply
+
+  pushd $NAMESPACE_DIR > /dev/null
+  for INSTANCE_DIR in `find . -type d -mindepth 1 -maxdepth 1`; do
+    pushd $INSTANCE_DIR > /dev/null
+    INSTANCE=`basename $INSTANCE_DIR`
+    echo "Instance: $INSTANCE"
+
+    # set secret configuration from encrypted and decrypted file
+    VARIABLE_PREFIX=`echo "$NAMESPACE""_""$INSTANCE" | tr - _`
+
+    
+    # set MQTT_PASSWORD as secret
+    MQTT_PASSWORD_VARIABLE=$VARIABLE_PREFIX"_MQTT_PASSWORD"
+    MQTT_PASSWORD="${!MQTT_PASSWORD_VARIABLE}"
+    # echo "MQTT_PASSWORD_VARIABLE: $MQTT_PASSWORD_VARIABLE"
+    # echo "MQTT_PASSWORD: $MQTT_PASSWORD"
+    kubectl create secret generic $INSTANCE-mqtt-password \
+      --from-literal=MQTT_PASSWORD="$MQTT_PASSWORD" \
+      --dry-run=client \
+      -o yaml \
+      --save-config | \
+      kubectl apply -f - -n $NAMESPACE
+
+
+    LOGIN_VARIABLE=$VARIABLE_PREFIX"_PGUSER"
+    NEW_UDI_DB_LOGIN="${!LOGIN_VARIABLE}"
+    PASSWORD_VARIABLE=$VARIABLE_PREFIX"_PGPASSWORD"
+    NEW_UDI_DB_PASSWORD="${!PASSWORD_VARIABLE}"
+    DATABASE_VARIABLE=$VARIABLE_PREFIX"_PGDATABASE"
+    NEW_UDI_DB_DATABASE="${!DATABASE_VARIABLE}"
+    NEW_UDI_DB_HOST=timescaledb.database.svc.cluster.local
+
+    kubectl create secret generic $INSTANCE-udi-db-cred \
+      --dry-run=client \
+      -o yaml \
+      --save-config \
+      --from-literal=PGUSER="$NEW_UDI_DB_LOGIN" \
+      --from-literal=PGPASSWORD="$NEW_UDI_DB_PASSWORD" \
+      --from-literal=PGDATABASE="$NEW_UDI_DB_DATABASE" \
+      --from-literal=PGHOST="$NEW_UDI_DB_HOST" \
+      --from-literal=PGSSLMODE="require" | \
+      kubectl apply -f - -n $NAMESPACE
+
+    # set configuration as configMap
+    kubectl create configmap $INSTANCE-udi-conf \
+      --from-literal=UDI_CONF="`cat $CONFIG_FILE`" \
+      --dry-run=client \
+      -o yaml \
+      --save-config | \
+      kubectl apply -f - -n $NAMESPACE
+
+    # prepare k8s deployment statement
+    cat $DEPLOYMENT_DIR/deploy-yml.tmpl | \
+      sed -e 's,%IMAGE%,'$IMAGE_NAME':'$IMAGE_TAG','g | \
+      sed -e 's,%PRE%,'$INSTANCE','g | \
+      kubectl apply -f - -n $NAMESPACE
+
+    popd > /dev/null
+  done
+  popd > /dev/null
+done
+
--- a/deployment/encrypt-secrets.sh
+++ b/deployment/encrypt-secrets.sh
@ -0,0 +1,27 @@
+#!/bin/bash
+
+ENCRYPTION_KEY=`openssl rand -hex 32`
+echo $ENCRYPTION_KEY
+
+SECRETS_PLAINTEXT_FILE=secrets.txt
+SECRETS_CIPHERTEXT_FILE=secrets.enc
+
+if [ `uname` = "Darwin" ]; then
+  cat $SECRETS_PLAINTEXT_FILE | md5
+elif [ `uname` = "Linux" ]; then
+  cat $SECRETS_PLAINTEXT_FILE | md5sum - | awk '{print $1}'
+fi
+
+POD_NAME_SUFFIX=`date +%s`
+
+cat $SECRETS_PLAINTEXT_FILE | \
+  kubectl run openssl-$POD_NAME_SUFFIX \
+    --rm \
+    --image bitnami/debian-base-buildpack:latest \
+    --env KEY=$ENCRYPTION_KEY \
+    -i \
+    -q \
+    -- \
+    /bin/sh -c "openssl enc -aes-256-cbc -salt -pass env:KEY -a" > \
+    $SECRETS_CIPHERTEXT_FILE
+
--- a/deployment/instances/udi-berresheim/default/config.json
+++ b/deployment/instances/udi-berresheim/default/config.json
@ -0,0 +1,23 @@
+{
+  "mqtt": {
+    "broker": "ssl://eu1.cloud.thethings.network:8883",
+    "username": "de-hottis-level-monitoring@ttn",
+    "password": "ENV",
+    "tlsEnable": "true"
+  },
+  "topicMappings": [
+    {
+      "topics": [ "v3/#" ],
+      "handler": "TTN",
+      "id": "TTN0",
+      "config": {
+        "databaseConnStr": "",
+        "attributes": {
+        }
+      }
+    }
+  ],
+  "archiver": {
+    "dir": "/archive"
+  }
+}
--- a/deployment/instances/udi-pg/default/config.json
+++ b/deployment/instances/udi-pg/default/config.json
@ -2,7 +2,6 @@
  "mqtt": {
    "broker": "ssl://eu1.cloud.thethings.network:8883",
    "username": "com-passavant-geiger-poc@ttn",
-    "password": "ENV",
    "tlsEnable": "true"
  },
  "topicMappings": [
@ -11,13 +10,12 @@
      "handler": "TTN",
      "id": "TTN0",
      "config": {
-        "databaseConnStr": "",
        "attributes": {
        }
      }
    }
  ],
  "archiver": {
-    "dir": "./tmp/udi"
+    "dir": "/archive"
  }
 }
--- a/deployment/instances/udi-saerbeck/default/config.json
+++ b/deployment/instances/udi-saerbeck/default/config.json
@ -0,0 +1,22 @@
+{
+  "mqtt": {
+    "broker": "ssl://eu1.cloud.thethings.network:8883",
+    "username": "de-hottis-saerbeck-monitoring@ttn",
+    "password": "ENV",
+    "tlsEnable": "true"
+  },
+  "topicMappings": [
+    {
+      "topics": [ "v3/#" ],
+      "handler": "TTN",
+      "id": "TTN0",
+      "config": {
+        "attributes": {
+        }
+      }
+    }
+  ],
+  "archiver": {
+    "dir": "/archive"
+  }
+}
--- a/deployment/instances/udi-saerbeck/level/config.json
+++ b/deployment/instances/udi-saerbeck/level/config.json
@ -0,0 +1,22 @@
+{
+  "mqtt": {
+    "broker": "ssl://eu1.cloud.thethings.network:8883",
+    "username": "de-hottis-level-monitoring@ttn",
+    "password": "ENV",
+    "tlsEnable": "true"
+  },
+  "topicMappings": [
+    {
+      "topics": [ "v3/#" ],
+      "handler": "TTN",
+      "id": "TTN0",
+      "config": {
+        "attributes": {
+        }
+      }
+    }
+  ],
+  "archiver": {
+    "dir": "/archive"
+  }
+}
--- a/deployment/instances/udi-saerbeck/soil/config.json
+++ b/deployment/instances/udi-saerbeck/soil/config.json
@ -0,0 +1,22 @@
+{
+  "mqtt": {
+    "broker": "ssl://eu1.cloud.thethings.network:8883",
+    "username": "de-hottis-lora-test1@ttn",
+    "password": "ENV",
+    "tlsEnable": "true"
+  },
+  "topicMappings": [
+    {
+      "topics": [ "v3/#" ],
+      "handler": "TTN",
+      "id": "TTN0",
+      "config": {
+        "attributes": {
+        }
+      }
+    }
+  ],
+  "archiver": {
+    "dir": "/archive"
+  }
+}
--- a/deployment/instances/udi/default/config.json
+++ b/deployment/instances/udi/default/config.json
@ -4,6 +4,45 @@
    "tlsEnable": "false"
  },
  "topicMappings": [
+    {
+      "topics": [ "snmp" ],
+      "handler": "SNMP",
+      "id": "SNMP",
+      "config": {
+        "attributes": {
+        }
+      }
+    },
+    {
+      "topics": [ "dt1/ai/periodic/1" ],
+      "handler": "DT1T",
+      "id": "DT1T.0",
+      "config": {
+        "attributes": {
+          "Application": "Temperature Wago",
+          "Device": "Freezer",
+          "HardLow": "-273",
+          "SoftLow": "-50",
+          "SoftHigh": "20",
+          "HardHigh": "100"
+        }
+      }
+    },
+    {
+      "topics": [ "dt1/ai/periodic/3" ],
+      "handler": "DT1T",
+      "id": "DT1T.1",
+      "config": {
+        "attributes": {
+          "Application": "Temperature Wago",
+          "Device": "Outdoor",
+          "HardLow": "-273",
+          "SoftLow": "-60",
+          "SoftHigh": "60",
+          "HardHigh": "100"
+        }
+      }
+    },
    {
      "topics": [ "IoT/PV/Values" ],
      "handler": "PV",
@ -14,6 +53,16 @@
        }
      }
    },
+    {
+      "topics": [ "locative/event/#" ],
+      "handler": "Locative",
+      "id": "Locative",
+      "config": {
+        "databaseConnStr": "",
+        "attributes": {
+        }
+      }
+    },
    {
      "topics": [ "IoT/MBGW3/Measurement" ],
      "handler": "MBGW3",
--- a/deployment/instances/udi/soil/config.json
+++ b/deployment/instances/udi/soil/config.json
@ -0,0 +1,22 @@
+{
+  "mqtt": {
+    "broker": "ssl://eu1.cloud.thethings.network:8883",
+    "username": "de-hottis-app01@ttn",
+    "password": "ENV",
+    "tlsEnable": "true"
+  },
+  "topicMappings": [
+    {
+      "topics": [ "v3/#" ],
+      "handler": "TTN",
+      "id": "TTN0",
+      "config": {
+        "attributes": {
+        }
+      }
+    }
+  ],
+  "archiver": {
+    "dir": "/archive"
+  }
+}
--- a/deployment/load-config.sh
+++ b/deployment/load-config.sh
@ -1,47 +0,0 @@
-#!/bin/bash
-
-FILE=$1
-if [ "$FILE" = "" ]; then
-  echo "give config file to load as first argument"
-  exit 1
-fi
-SECRET_NAME=$2
-if [ "$SECRET_NAME" = "" ]; then
-  echo "give secret name to create/modify as second argument"
-  exit 1
-fi
-NAMESPACE=$3
-if [ "$NAMESPACE" = "" ]; then
-  echo "give namespace as third argument"
-  exit 1
-fi
-
-kubectl create secret generic $SECRET_NAME \
-  --from-literal=UDI_CONF="`cat $FILE`" \
-  -n $NAMESPACE \
-  --dry-run=client \
-  -o yaml \
-  --save-config | \
-kubectl apply -f -
-
-. ~/Workspace/MyKubernetesEnv/ENVDB
-DATABASE=udi
-LOGIN=udi
-PASSWORD=`openssl rand -base64 24` 
-psql <<EOF
-ALTER USER $LOGIN WITH PASSWORD '$PASSWORD';
-GRANT ALL PRIVILEGES ON DATABASE $DATABASE TO $LOGIN;
-COMMIT;
-EOF
-
-kubectl create secret generic udi-db-cred \
-  --dry-run=client \
-  -o yaml \
-  --save-config \
-  --from-literal=PGUSER="$LOGIN" \
-  --from-literal=PGHOST="timescaledb.database.svc.cluster.local" \
-  --from-literal=PGPASSWORD="$PASSWORD" \
-  --from-literal=PGSSLMODE="require" \
-  --from-literal=PGDATABASE="$DATABASE" | \
-kubectl apply -f - -n $NAMESPACE
-
--- a/deployment/secrets.enc
+++ b/deployment/secrets.enc
@ -0,0 +1,38 @@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--- a/migration/.gitignore
+++ b/migration/.gitignore
@ -0,0 +1 @@
+.venv
--- a/migration/migrate-level.py
+++ b/migration/migrate-level.py
@ -0,0 +1,38 @@
+import psycopg2
+from loguru import logger
+
+try:
+    srcConn = psycopg2.connect(database="level_monitoring_berresheim")
+    srcConn.autocommit = False
+    destConn = psycopg2.connect(database="udi-berresheim")
+    destConn.autocommit = False
+
+    with srcConn.cursor() as srcCur, destConn.cursor() as destCur:
+        srcCur.execute("select time, application_name, raw_level, level, status, battery from measurement_t")
+        for srcObj in srcCur:
+            timestamp = srcObj[0]
+            deviceName = srcObj[1]
+            rawLevel = srcObj[2]
+            level = srcObj[3]
+            status = srcObj[4]
+            battery = srcObj[5]
+
+            logger.info(f"{timestamp=}, {deviceName=}, {rawLevel=}, {level=}, {status=}, {battery=}")
+
+            destTime = timestamp
+            destApplication = "de-hottis-level-monitoring"
+            destDevice = "eui-a84041a2c18341d6"
+            destAttributes = '{"ApplicationId":"de-hottis-level-monitoring", "DeviceType":"dragino-ldds75", "Status":"' + status + '","Hint": "Migrated"}'
+            destValues = '{"Battery":{"unit":"V","label":"Battery","value":' + str(battery) + ',"variable":"Voltage"}, "Distance":{"unit":"mm","label":"Distance","variable":"Level","value":' + str(rawLevel) + '}, "CorrectedDistance":{"unit":"mm", "label":"CorrectedDistance", "variable":"Level","value":' + str(level) + '}}'
+            logger.info(f"{destTime=}, {destApplication=}, {destDevice=}, {destAttributes=}, {destValues=}")
+
+            destCur.execute("insert into measurements (time, application, device, attributes, values) values(%s, %s, %s, %s, %s)",
+                            (destTime, destApplication, destDevice, destAttributes, destValues))
+            destConn.commit()
+finally:
+    if srcConn:
+        srcConn.close()
+    if destConn:
+        destConn.close()
+
+
--- a/migration/migrate-pv.py
+++ b/migration/migrate-pv.py
@ -0,0 +1,79 @@
+import psycopg2
+from loguru import logger
+import os
+
+srcPgHost = os.environ["SRC_PGHOST"]
+srcPgUser = os.environ["SRC_PGUSER"]
+srcPgPassword = os.environ["SRC_PGPASSWORD"]
+srcPgDatabase = os.environ["SRC_PGDATABASE"]
+destPgHost = os.environ["DEST_PGHOST"]
+destPgUser = os.environ["DEST_PGUSER"]
+destPgPassword = os.environ["DEST_PGPASSWORD"]
+destPgDatabase = os.environ["DEST_PGDATABASE"]
+
+try:
+    srcConn = psycopg2.connect(
+                host=srcPgHost,
+                dbname=srcPgDatabase,
+                user=srcPgUser,
+                password=srcPgPassword,
+                sslmode='require'
+            )
+    srcConn.autocommit = False
+
+    destConn = psycopg2.connect(
+                host=destPgHost,
+                dbname=destPgDatabase,
+                user=destPgUser,
+                password=destPgPassword,
+                sslmode='require'
+            )
+    destConn.autocommit = False
+
+    with srcConn.cursor() as srcCur, destConn.cursor() as destCur:
+        srcCur.execute("select time, deviceid, status, state, importenergyactive, importenergyreactive, exportenergyactive, exportenergyreactive, powerapparent, poweractive, powerreactive, powerdemandpositive, powerdemandreverse, factor, angle, voltage, current, powerdemand from pv_power_measurement_t order by time")
+        for srcObj in srcCur:
+            timestamp = srcObj[0]
+            deviceName = srcObj[1]
+            status = srcObj[2]
+            state = srcObj[3]
+            importenergyactive = srcObj[4]
+            importenergyreactive = srcObj[5]
+            exportenergyactive = srcObj[6]
+            exportenergyreactive = srcObj[7]
+            powerapparent = srcObj[8]
+            poweractive = srcObj[9]
+            powerreactive = srcObj[10]
+            powerdemandpositive = srcObj[11]
+            powerdemandreverse = srcObj[12]
+            factor = srcObj[13]
+            angle = srcObj[14]
+            voltage = srcObj[15]
+            current = srcObj[16]
+            powerdemand = srcObj[17]
+
+
+            logger.info(f"{timestamp=}, {deviceName=}")
+
+            destTime = timestamp
+            destApplication = "PV"
+            destDevice = "Powermeter"
+            destAttributes = f"{{\"ApplicationId\":\"PV\", \"Status\":\"{status}\",\"Hint\": \"Migrated\"}}"
+            destValues = f"{{\"Cnt\": {{\"unit\": \"\", \"label\": \"\", \"value\": \"-1\", \"variable\": \"Cnt\"}}, \"Angle\": {{\"unit\": \"degree\", \"label\": \"\", \"value\": \"{angle}\", \"variable\": \"Angle\"}}, \"State\": {{\"unit\": \"\", \"label\": \"\", \"value\": \"{state}\", \"variable\": \"State\"}}, \"Factor\": {{\"unit\": \"\", \"label\": \"\", \"value\": \"{factor}\", \"variable\": \"Factor\"}}, \"Current\": {{\"unit\": \"A\", \"label\": \"\", \"value\": \"{current}\", \"variable\": \"Current\"}}, \"Voltage\": {{\"unit\": \"V\", \"label\": \"\", \"value\": \"{voltage}\", \"variable\": \"Voltage\"}}, \"PowerActive\": {{\"unit\": \"W\", \"label\": \"\", \"value\": \"{poweractive}\", \"variable\": \"PowerActive\"}}, \"PowerApparent\": {{\"unit\": \"VA\", \"label\": \"\", \"value\": \"{powerapparent}\", \"variable\": \"PowerApparent\"}}, \"PowerReactive\": {{\"unit\": \"VA\", \"label\": \"\", \"value\": \"{powerreactive}\", \"variable\": \"PowerReactive\"}}, \"ExportEnergyActive\": {{\"unit\": \"Wh\", \"label\": \"\", \"value\": \"{exportenergyactive}\", \"variable\": \"ExportEnergyActive\"}}, \"ImportEnergyActive\": {{\"unit\": \"Wh\", \"label\": \"\", \"value\": \"{importenergyactive}\", \"variable\": \"ImportEnergyActive\"}}, \"PowerDemandReverse\": {{\"unit\": \"W\", \"label\": \"\", \"value\": \"{powerdemandreverse}\", \"variable\": \"PowerDemandReverse\"}}, \"PowerDemandPositive\": {{\"unit\": \"W\", \"label\": \"\", \"value\": \"{powerdemandpositive}\", \"variable\": \"PowerDemandPositive\"}}, \"ExportEnergyReactive\": {{\"unit\": \"VAh\", \"label\": \"\", \"value\": \"{exportenergyreactive}\", \"variable\": \"ExportEnergyReactive\"}}, \"ImportEnergyReactive\": {{\"unit\": \"VAh\", \"label\": \"\", \"value\": \"{importenergyreactive}\", \"variable\": \"ImportEnergyReactive\"}}}}"
+            logger.info(f"{destTime=}, {destApplication=}, {destDevice=}, {destAttributes=}, {destValues=}")
+
+
+            try:
+                destCur.execute("insert into measurements (time, application, device, attributes, values) values(%s, %s, %s, %s, %s)",
+                                (destTime, destApplication, destDevice, destAttributes, destValues))
+                destConn.commit()
+            except Exception as e:
+                destConn.rollback()
+                logger.error(f"Error {e} when inserted time {destTime}")
+finally:
+    if srcConn:
+        srcConn.close()
+    if destConn:
+        destConn.close()
+
+
--- a/migration/migrate-temperature.py
+++ b/migration/migrate-temperature.py
@ -0,0 +1,78 @@
+import psycopg2
+from loguru import logger
+import os
+
+srcPgHost = os.environ["SRC_PGHOST"]
+srcPgUser = os.environ["SRC_PGUSER"]
+srcPgPassword = os.environ["SRC_PGPASSWORD"]
+srcPgDatabase = os.environ["SRC_PGDATABASE"]
+destPgHost = os.environ["DEST_PGHOST"]
+destPgUser = os.environ["DEST_PGUSER"]
+destPgPassword = os.environ["DEST_PGPASSWORD"]
+destPgDatabase = os.environ["DEST_PGDATABASE"]
+
+try:
+    srcConn = psycopg2.connect(
+                host=srcPgHost,
+                dbname=srcPgDatabase,
+                user=srcPgUser,
+                password=srcPgPassword,
+                sslmode='require'
+            )
+    srcConn.autocommit = False
+
+    destConn = psycopg2.connect(
+                host=destPgHost,
+                dbname=destPgDatabase,
+                user=destPgUser,
+                password=destPgPassword,
+                sslmode='require'
+            )
+    destConn.autocommit = False
+
+    with srcConn.cursor() as srcCur, destConn.cursor() as destCur:
+        srcCur.execute("select time, location, status, temperature, category from room_climate_measurement_t where category = 'heating' and time > '2023-12-19 05:20:00' order by time")
+        for srcObj in srcCur:
+            timestamp = srcObj[0]
+            location = srcObj[1]
+            status = srcObj[2]
+            temperature = srcObj[3]
+            category = srcObj[4]
+
+            logger.info(f"{timestamp=}, {location=}, {status=}, {temperature=}, {category=}")
+
+            destTime = timestamp
+
+            match category:
+                case 'heating':
+                    destApplication = 'Temperature Heating'
+                case 'Outdoor':
+                    destApplication = 'Temperature Wago'
+                case 'Device':
+                    destApplication = 'Temperature Wago'
+                case 'Indoor':
+                    destApplication = 'Temperature Multisensor' if location != 'Anna-Koeln-2' else 'Temperature Shelly Plus HT'
+                case 'Special':
+                    destApplication = 'Temperature Multisensor'
+
+            destDevice = location
+            destAttributes = '{"ApplicationId":"temperature-imported", "Status":"' + status + '","Location":"' + location + '","Category":"' + category + '","Hint": "Migrated"}'
+            destValues = '{"Value": {"unit": "°C", "label": "", "value": "' + str(temperature) + '", "variable": ""}}'
+
+            logger.info(f"{destTime=}, {destApplication=}, {destDevice=}, {destAttributes=}, {destValues=}")
+
+            try:
+                destCur.execute("insert into measurements (time, application, device, attributes, values) values(%s, %s, %s, %s, %s)",
+                                (destTime, destApplication, destDevice, destAttributes, destValues))
+                destConn.commit()
+            except Exception as e:
+                destConn.rollback()
+                logger.error(f"Error {e} when inserted time {destTime}")
+
+finally:
+    if srcConn:
+        srcConn.close()
+
+    if destConn:
+        destConn.close()
+
--- a/migration/requirements.txt
+++ b/migration/requirements.txt
@ -0,0 +1,2 @@
+loguru==0.7.2
+psycopg2==2.9.9
--- a/queries/berresheim.sql
+++ b/queries/berresheim.sql
@ -0,0 +1,8 @@
+create or replace view level_v as
+  select time, 
+         cast(values->'CorrectedDistance'->>'value' as float) as level,
+         cast(values->'Battery'->>'value' as float) as battery,
+         attributes->>'Status' as status,
+         device
+    from measurements
+    where application = 'de-hottis-level-monitoring';
--- a/queries/hottis.sql
+++ b/queries/hottis.sql
@ -45,3 +45,53 @@ create or replace view temperature_v as
    from measurements
    where application in ('Temperature Multisensor', 'Temperature Shelly Plus HT');

+create or replace view temperature2_v as
+  select time,
+         cast(values->'Value'->>'value' as float) as temperature,
+         device
+    from measurements
+    where application = 'Temperature Wago';
+
+create or replace view humidity_v as
+  select time,
+         cast(values->'Value'->>'value' as float) as humidity,
+         device
+    from measurements
+    where application in ('Humidity Multisensor');
+
+create or replace view soil_v as
+  select time,
+         cast(values->'Water'->>'value' as float) as water,
+         cast(values->'Conductance'->>'value' as float) as conductance,
+         cast(values->'Temperature'->>'value' as float) as temperature,
+         device
+    from measurements
+    where application = 'de-hottis-app01' and attributes->>'DeviceType' = 'dragino-lse01';
+
+create or replace view co2_v as
+  select time,
+         cast(m.values->'CO2concentration'->>'value' as float) as co2concentration,
+         cast(m.values->'Humidity'->>'value' as float) as humidity,
+         cast(m.values->'Temperature'->>'value' as float) as temperature,
+         m.device as device,
+         d.attributes->>'Label' as label 
+    from measurements m, devices d
+    where m.application = 'de-hottis-app01' and 
+          m.attributes->>'DeviceType' = 'hottis-scd30' and
+          m.device = d.label;
+
+create or replace view locative_v as
+  select time,
+         device as person,
+         values->'Location'->>'value' as location,
+         values->'Trigger'->>'value' as direction
+    from measurements
+    where application = 'Locative';
+
+create or replace view router_v as
+  select time,
+         device,
+         cast(values->'wan-in'->>'value'  as int) as wanInOctetsPerSeconds,
+         cast(values->'wan-out'->>'value'  as int) as wanOutOctetsPerSeconds
+    from measurements
+    where application = 'SNMP' and device = '172.16.3.1';
--- a/queries/old-daily-temperature-query.sql
+++ b/queries/old-daily-temperature-query.sql
@ -0,0 +1,11 @@
+select
+        extract('day' from time)::varchar || '.' || extract('month' from time)::varchar || '.' || extract('year' from time)::varchar as day,
+        avg(temperature)::numeric(10,0) as temperature
+    from room_climate_measurement_t
+    where
+        category = 'Outdoor' and
+        location = 'Outdoor' and
+        extract('hour' from time) = 12 and
+        time::date = now()::date
+    group by day
+
--- a/queries/old-pv-yield-query.sql
+++ b/queries/old-pv-yield-query.sql
@ -0,0 +1,73 @@
+-- query
+
+with 
+    first_day_in_year as (
+        select 
+                date_trunc('day', min(time)) as day
+            from pv_power_measurement_t
+            where 
+                time between date_trunc('year', time) and now()
+    ),
+    first_value_in_year as (
+        select 
+                time_bucket('1 day', time) as interval,
+                first(exportenergyactive, time) as energy
+            from pv_power_measurement_t
+            where 
+                time between (select day from first_day_in_year) and (select day from first_day_in_year) + interval '1 day' and
+                status = 'Ok'
+            group by interval
+    ),
+    first_day_in_month as (
+        select 
+                date_trunc('day', min(time)) as day
+            from pv_power_measurement_t
+            where 
+                time between date_trunc('month', now()) and now()
+    ),
+    first_value_in_month as (
+        select 
+                time_bucket('1 day', time) as interval,
+                first(exportenergyactive, time) as energy
+            from pv_power_measurement_t
+            where 
+                time between (select day from first_day_in_month) and (select day from first_day_in_month) + interval '1 day' and
+                status = 'Ok'
+            group by interval
+    ),
+    first_value_in_day as (
+        select
+                time_bucket('1 day', time) as interval,
+                first(exportenergyactive, time) as energy
+            from pv_power_measurement_t
+            where time >= date_trunc('day', now())
+            group by interval
+    ),
+    last_value as (
+        select  
+                time_bucket('1 day', time) as interval,
+                last(exportenergyactive, time) as energy
+            from pv_power_measurement_t
+            where 
+                time between date_trunc('day', now()) and date_trunc('day', now()) + interval '1 day' and
+                status = 'Ok'
+            group by interval
+    )
+    select
+        extract(year from (select day from first_day_in_year))::text as period_value,
+        'Year' as period_name,
+        round(((select energy from last_value) - (select energy from first_value_in_year))::numeric, 2) as yield
+    union
+    select
+        to_char((select day from first_day_in_month), 'Month') as period_value,
+        'Month' as period_name,
+        round(((select energy from last_value) - (select energy from first_value_in_month))::numeric, 2) as yield
+    union
+    select
+        now()::date::text as period_value,
+        'Day' as period_name,
+        round(((select energy from last_value) - (select energy from first_value_in_day))::numeric, 2) as yield;
+
+-- output format
+-- wn@atuin:~/Workspace/go-workspace/src/universal-data-ingest  [main ≡ +0 ~1 -0 !]$ mosquitto_sub -h 172.23.1.102 -v -t IoT/PV/Yields
+-- IoT/PV/Yields {"Month":"1.43","Year":"285.39","Day":"0.00"}
--- a/queries/pg.sql
+++ b/queries/pg.sql
@ -0,0 +1,14 @@
+create or replace view power_v as
+  select time,
+         cast(values->'ActivePowerL1'->>'value' as float) as power_l1,
+         cast(values->'ActivePowerL2'->>'value' as float) as power_l2,
+         cast(values->'ActivePowerL3'->>'value' as float) as power_l3,
+         cast(values->'ActivePowerL123'->>'value' as float) as power_total,
+         cast(values->'PowerfactorL1'->>'value' as float) as factor_l1,
+         cast(values->'PowerfactorL2'->>'value' as float) as factor_l2,
+         cast(values->'PowerfactorL3'->>'value' as float) as factor_l3,
+         device
+    from measurements
+    where application = 'com-passavant-geiger-poc' and
+          attributes->>'FPort' = '1';
+
--- a/src/udi/ENVDB.udiload
+++ b/src/udi/ENVDB.udiload
@ -0,0 +1,14 @@
+if [ "$1" = "" ]; then
+  echo "set namespace as argument"
+fi
+N=$1
+if [ "$2" = "" ]; then
+  echo "set instance as argument"
+fi
+I=$2
+PGHOST=`kubectl get services traefik -n system -o jsonpath="{.status.loadBalancer.ingress[0].ip}"`
+PGPASSWORD=`kubectl get secrets $I-udi-db-cred -n $N -o jsonpath="{.data.PGPASSWORD}" | base64 --decode`
+PGUSER=`kubectl get secrets $I-udi-db-cred -n $N -o jsonpath="{.data.PGUSER}" | base64 --decode`
+PGSSLMODE=`kubectl get secrets $I-udi-db-cred -n $N -o jsonpath="{.data.PGSSLMODE}" | base64 --decode`
+PGDATABASE=`kubectl get secrets $I-udi-db-cred -n $N -o jsonpath="{.data.PGDATABASE}" | base64 --decode`
+export PGUSER PGHOST PGPASSWORD PGSSLMODE PGDATABASE
--- a/src/udi/ENVDB.uditest
+++ b/src/udi/ENVDB.uditest
@ -1,6 +1,6 @@
-PGUSER="udi"
+PGUSER="uditest"
 PGHOST=`kubectl get services traefik -n system -o jsonpath="{.status.loadBalancer.ingress[0].ip}"`
-PGPASSWORD=`kubectl get secrets udi-db-cred -n udi -o jsonpath="{.data.PGPASSWORD}" | base64 --decode`
+PGPASSWORD=`kubectl get secrets uditest-db-cred -n udi-test -o jsonpath="{.data.PGPASSWORD}" | base64 --decode`
 PGSSLMODE=require
 PGDATABASE="uditest"
 export PGUSER PGHOST PGPASSWORD PGSSLMODE PGDATABASE
--- a/src/udi/config-test-ttn.json
+++ b/src/udi/config-test-ttn.json
@ -1,15 +1,15 @@
 {
  "mqtt": {
-    "broker": "mqtt://172.23.1.102:1883",
-    "tlsEnable": "false"
+    "broker": "ssl://eu1.cloud.thethings.network:8883",
+    "username": "de-hottis-lora-test1@ttn",
+    "tlsEnable": "true"
  },
  "topicMappings": [
    {
-      "topics": [ "ttn/#" ],
+      "topics": [ "v3/#" ],
      "handler": "TTN",
      "id": "TTN0",
      "config": {
-        "databaseConnStr": "",
        "attributes": {
        }
      }
--- a/src/udi/config-test.json
+++ b/src/udi/config-test.json
@ -9,7 +9,6 @@
      "handler": "PV",
      "id": "PV",
      "config": {
-        "databaseConnStr": "",
        "attributes": {
        }
      }
@ -19,11 +18,40 @@
      "handler": "MBGW3",
      "id": "MBGW3",
      "config": {
-        "databaseConnStr": "",
        "attributes": {
        }
      }
    },
+    {
+      "topics": [ "dt1/ai/periodic/1" ],
+      "handler": "DT1T",
+      "id": "DT1T.0",
+      "config": {
+        "attributes": {
+          "Application": "Temperature Wago",
+          "Device": "Freezer",
+          "HardLow": "-273",
+          "SoftLow": "-50",
+          "SoftHigh": "20",
+          "HardHigh": "100"
+        }
+      }
+    },
+    {
+      "topics": [ "dt1/ai/periodic/3" ],
+      "handler": "DT1T",
+      "id": "DT1T.1",
+      "config": {
+        "attributes": {
+          "Application": "Temperature Wago",
+          "Device": "Outdoor",
+          "HardLow": "-273",
+          "SoftLow": "-60",
+          "SoftHigh": "60",
+          "HardHigh": "100"
+        }
+      }
+    },
    {
      "topics": [ "IoT/OneWireGW/Bus 1/#" ],
      "handler": "SVER",
--- a/src/udi/config-ttn.json
+++ b/src/udi/config-ttn.json
@ -1,29 +0,0 @@
-{
-  "mqtt": {
-    "broker": "mqtt://172.23.1.102:1883",
-    "tlsEnable": "false"
-  },
-  "topicMappings": [
-    {
-      "topics": [ "v3/de-hottis-level-monitoring@ttn/devices/+/up" ],
-      "handler": "TTN"
-    }
-  ],
-  "handlers": [
-    {
-      "name": "TTN",
-      "databaseConnStr": "",
-      "attributes": {
-      }
-    },
-		{
-			"name": "IoT",
-			"databaseConnStr": "",
-			"attributes": {
-			}
-		}
-  ],
-  "archiver": {
-    "dir": "./tmp/udi"
-  }
-}
--- a/src/udi/config/config.go
+++ b/src/udi/config/config.go
@ -5,7 +5,6 @@ import "log"
 import "os"

 type HandlerConfigT struct {
-  DatabaseConnStr string `json:"databaseConnStr"`
  Attributes map[string]string `json:"attributes"`
 }

@ -13,7 +12,7 @@ type ConfigT struct {
  Mqtt struct {
    Broker string `json:"broker"`
    Username string `json:"username"`
-    Password string `json:"password"`
+    Password string
    TlsEnable string `json:"tlsEnable"`
  } `json:"mqtt"`
  TopicMappings []struct {
@ -36,8 +35,6 @@ func LoadConfiguration() {
    log.Fatalf("Unable to parse configuration: %s", err)
  }

-  if Config.Mqtt.Password == "ENV" {
-    Config.Mqtt.Password = os.Getenv("MQTT_PASSWORD")
-  }
+  Config.Mqtt.Password = os.Getenv("MQTT_PASSWORD")
 }

--- a/src/udi/config/example.json
+++ b/src/udi/config/example.json
@ -1,26 +0,0 @@
-{
-	"mqtt": {
-		"broker": "172.23.1.102:1883",
-		"username": "",
-		"password": "",
-		"tlsEnable": "false"
-	},
-	"topicMappings": [
-		{
-			"topics": ["IoT/MBGW3/Measurement"],
-			"handler": "IoT"
-		}
-	],
-	"handlers": [
-		{
-			"name": "IoT",
-			"databaseConnStr": "",
-			"attributes": {
-			}
-		}
-	],
-	"archiver": {
-		"dir": "/mnt/udi/archive"
-	}
-}
-
--- a/src/udi/counter/counter.go
+++ b/src/udi/counter/counter.go
@ -0,0 +1,94 @@
+package counter
+
+import (
+  "log"
+  "time"
+  "encoding/json"
+)
+
+type statsTuple_t struct {
+  Successful int `json:"good"`
+  Failed int `json:"bad"`
+}
+
+type stats_t struct {
+  Received statsTuple_t `json:"received"`
+  Archived statsTuple_t `json:"archived"`
+  Dispatched statsTuple_t `json:"dispatched"`
+  Handled map[string]statsTuple_t `json:"handled"`
+  Stored statsTuple_t `json:"stored"`
+}
+
+var stats stats_t
+
+func S(id string) {
+  switch id {
+  case "Received": 
+    stats.Received.Successful = stats.Received.Successful + 1
+  case "Archived": 
+    stats.Archived.Successful += 1
+  case "Dispatched":
+    stats.Dispatched.Successful += 1
+  case "Stored":
+    stats.Stored.Successful += 1
+  default:
+    log.Printf("Unknown stats id %s", id)
+  }
+}
+
+func F(id string) {
+  switch id {
+  case "Received": 
+    stats.Received.Failed += 1
+  case "Archived": 
+    stats.Archived.Failed += 1
+  case "Dispatched":
+    stats.Dispatched.Failed += 1
+  case "Stored":
+    stats.Stored.Failed += 1
+  default:
+    log.Printf("Unknown stats id %s", id)
+  }
+}
+
+func SH(id string) {
+  if _, ok := stats.Handled[id]; ok {
+    tuple := stats.Handled[id]
+    tuple.Successful += 1
+    stats.Handled[id] = tuple
+  } else {
+    stats.Handled[id] = statsTuple_t { Successful:1, Failed:0, }
+  }
+}
+
+func FH(id string) {
+  if _, ok := stats.Handled[id]; ok {
+    tuple := stats.Handled[id]
+    tuple.Failed += 1
+    stats.Handled[id] = tuple
+  } else {
+    stats.Handled[id] = statsTuple_t { Successful:0, Failed:1, }
+  }
+}
+
+func InitCounter() {
+  stats = stats_t {
+    Received: statsTuple_t {Successful:0,Failed:0,},
+    Archived: statsTuple_t {Successful:0,Failed:0,},
+    Dispatched: statsTuple_t {Successful:0,Failed:0,},
+    Stored: statsTuple_t {Successful:0,Failed:0,},
+    Handled: make(map[string]statsTuple_t),
+  }
+
+  go func() { 
+    for {
+      sj, err := json.Marshal(stats)
+      if err != nil {
+        log.Printf("Unable to marshal stats object: %s", err)
+      }
+      log.Println(string(sj))
+      time.Sleep(time.Second * 60)
+    }
+  }()
+}
+
--- a/src/udi/database/database.go
+++ b/src/udi/database/database.go
@ -5,6 +5,7 @@ import (
  "log"
  //"time"
  "fmt"
+  "udi/counter"
  "gorm.io/driver/postgres"
  "gorm.io/gorm"
 )
@ -14,16 +15,17 @@ type DatabaseHandle struct {
  dbh *gorm.DB 
 }

-func NewDatabaseHandle(dsn string) *DatabaseHandle {
+func NewDatabaseHandle() *DatabaseHandle {
  var db DatabaseHandle
-  conn, err := gorm.Open(postgres.Open(dsn))
+  // inject the whole database configuration via the well-known PG* env variables
+  conn, err := gorm.Open(postgres.Open(""))
  if err != nil {
    log.Printf("Unable to open database connection: %s", err)
    db.initialized = false
  } else {
    db.dbh = conn
    db.initialized = true
-    log.Println("Database connection opened")
+    //log.Println("Database connection opened")
  }
  return &db
 }
@ -31,16 +33,19 @@ func NewDatabaseHandle(dsn string) *DatabaseHandle {
 func (self *DatabaseHandle) StoreMeasurement(measurement *Measurement) {
  if ! self.initialized {
    log.Printf("Database connection not initialized, can not store, measurement %s lost", measurement)
+    counter.F("Stored")
    return
  }

  result := self.dbh.Create(measurement)
  if result.Error != nil {
    log.Printf("Unable to insert, measurement %s lost, error: %s", measurement, result.Error)
+    counter.F("Stored")
    return
  }

-  log.Println("Successfully stored measurement")
+  //log.Println("Successfully stored measurement")
+  counter.S("Stored")
 }

 func (self *DatabaseHandle) GetDeviceByLabelAndApplication(applicationLabel string, deviceLabel string) (*Device, error) {
--- a/src/udi/dispatcher/dispatcher.go
+++ b/src/udi/dispatcher/dispatcher.go
@ -7,6 +7,7 @@ import "fmt"
 import "net/url"
 import "udi/mqtt"
 import "udi/config"
+import "udi/counter"
 import "udi/handlers/handler"
 import "udi/handlers/ttn"
 import "udi/handlers/iot"
@ -14,13 +15,16 @@ import "udi/handlers/pv"
 import "udi/handlers/mbgw3"
 import "udi/handlers/sver"
 import "udi/handlers/svej"
+import "udi/handlers/dt1t"
+import "udi/handlers/locative"
+import "udi/handlers/snmp"


 var handlerMap map[string]handler.Handler = make(map[string]handler.Handler)
 var archiverChannel chan handler.MessageT = make(chan handler.MessageT, 100)

 func InitDispatcher() {
-  log.Printf("Initializing dispatcher")
+  log.Printf("Dispatcher initializing")
  go archiver()

  for _, mapping := range config.Config.TopicMappings {
@ -29,38 +33,45 @@ func InitDispatcher() {
    var factory interface{}
    switch mapping.Handler {
    case "TTN":
-      factory = ttn.NewTTNHandler
+      factory = ttn.New
    case "IoT":
-      factory = iot.NewIoTHandler
+      factory = iot.New
    case "PV":
-      factory = pv.NewPvHandler
+      factory = pv.New
    case "MBGW3":
-      factory = mbgw3.NewMbgw3Handler
+      factory = mbgw3.New
    case "SVER":
-      factory = sver.NewSverHandler
+      factory = sver.New
    case "SVEJ":
-      factory = svej.NewSvejHandler
+      factory = svej.New
+    case "DT1T":
+      factory = dt1t.New
+    case "Locative":
+      factory = locative.New
+    case "SNMP":
+      factory = snmp.New
    default:
      factory = nil
      log.Printf("No handler %s found, ignore mapping", mapping.Handler)
    }

-    fn, ok := factory.(func(config.HandlerConfigT) handler.Handler)
+    fn, ok := factory.(func(string, config.HandlerConfigT) handler.Handler)
    if ! ok {
      log.Println("Typ Assertion failed")
      break
    }
-    handler := fn(mapping.Config)
+    handler := fn(mapping.Id, mapping.Config)
    handlerMap[mapping.Id] = handler
  }

-  log.Printf("handlerMap: %s", handlerMap)
+  //log.Printf("handlerMap: %s", handlerMap)
 }

 func storeMessage(filename string, item handler.MessageT) {
  file, err := os.OpenFile(filename, os.O_APPEND | os.O_CREATE | os.O_WRONLY, 0644)
  if err != nil {
    log.Printf("Unable to open archiving file %s, message is not archived: %s", filename, err)
+    counter.F("Archived")
    return
  }
  defer file.Close()
@ -68,9 +79,11 @@ func storeMessage(filename string, item handler.MessageT) {
  _, err = file.WriteString(string(archivingString) + "\n")
  if err != nil {
    log.Printf("Unable to write message, message is not archived: %s", err)
+    counter.F("Archived")
    return
  }
-  log.Println("Successfully archived message")
+  //log.Println("Successfully archived message")
+  counter.S("Archived")
 }

 func archiver() {
@ -86,9 +99,10 @@ func archiver() {
        err := os.MkdirAll(currentArchivingDir, 0755)
        if err != nil {
          log.Printf("Unable to create archiving dir %s: %s", currentArchivingDir, err)
+          counter.F("Archived")
        }
        lastArchivingDir = currentArchivingDir
-        log.Printf("Archiving dir %s created", currentArchivingDir)
+        //log.Printf("Archiving dir %s created", currentArchivingDir)
      }
      archivingFilename := fmt.Sprintf("%s/%s", currentArchivingDir, url.PathEscape(message.Topic))
      storeMessage(archivingFilename, message)
@ -100,7 +114,7 @@ func InputDispatcher() {
  for {
    select {
    case mqttMessage := <- mqtt.InputChannel:
-      log.Printf("Message arrived in inputDispatcher, topic: %s\n", mqttMessage.Topic)
+      //log.Printf("Message arrived in inputDispatcher, topic: %s\n", mqttMessage.Topic)
      message := handler.MessageT { time.Now(), mqttMessage.Topic, string(mqttMessage.Payload) }
      archiverChannel <- message
      handleMessage(message)
@ -114,16 +128,19 @@ func handleMessage(message handler.MessageT) {
    for _, subscribedTopic := range mapping.Topics {
      // log.Printf("Testing %s in %s", message.Topic, subscribedTopic)
      if mqtt.TopicMatchesSubscription(message.Topic, subscribedTopic) {
-        log.Printf("Handle message in handler %s", mapping.Id)
+        //log.Printf("Handle message in handler %s", mapping.Id)
        handler, exists := handlerMap[mapping.Id]
        if exists {
          handler.Handle(message)
+          counter.S("Dispatched")
          return
        } else {
          log.Printf("Handler %s not found, message %s is lost", mapping.Id, message)
+          counter.F("Dispatched")
        }
      }
    }
  }
  log.Printf("No match for topic %s, message %s is lost", message.Topic, message)
+  counter.F("Dispatched")
 }
--- a/src/udi/go.mod
+++ b/src/udi/go.mod
@ -17,8 +17,8 @@ require (
 	github.com/jackc/pgx/v5 v5.4.3 // indirect
 	github.com/jinzhu/inflection v1.0.0 // indirect
 	github.com/jinzhu/now v1.1.5 // indirect
-	golang.org/x/crypto v0.14.0 // indirect
-	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/crypto v0.19.0 // indirect
+	golang.org/x/net v0.20.0 // indirect
 	golang.org/x/sync v0.1.0 // indirect
-	golang.org/x/text v0.13.0 // indirect
+	golang.org/x/text v0.14.0 // indirect
 )
--- a/src/udi/go.sum
+++ b/src/udi/go.sum
@ -28,12 +28,18 @@ github.com/stretchr/testify v1.8.1 h1:w7B6lhMri9wdJUVmEZPGGhZzrYTPvgJArz7wNPgYKs
 github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
 golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc=
 golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4=
+golang.org/x/crypto v0.19.0 h1:ENy+Az/9Y1vSrlrvBSyna3PITt4tiZLf7sgCjZBX7Wo=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
 golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
 golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.20.0 h1:aCL9BSgETF1k+blQaYUBx9hJ9LOGP3gAVemcZlf1Kpo=
+golang.org/x/net v0.20.0/go.mod h1:z8BVo6PvndSri0LbOE3hAn0apkU+1YvI6E70E9jsnvY=
 golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
 golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
--- a/src/udi/handlers/dt1t/dt1t.go
+++ b/src/udi/handlers/dt1t/dt1t.go
@ -0,0 +1,80 @@
+package dt1t
+
+import (
+  "log"
+  "fmt"
+  "time"
+  "strconv"
+  "udi/handlers/handler"
+  "udi/database"
+  "udi/config"
+)
+
+
+type Dt1tHandler struct {
+  handler.CommonHandler
+  ready bool
+  label string
+  dbh *database.DatabaseHandle
+  application string
+  device string
+
+}
+
+func New(id string, config config.HandlerConfigT) handler.Handler {
+  t := &Dt1tHandler {
+  }
+
+  if config.Attributes["Application"] == "" {
+    log.Println("Error: application not configured")
+    return t
+  }
+  t.application = config.Attributes["Application"]
+  if config.Attributes["Device"] == "" {
+    log.Println("Error: device not configured")
+    return t
+  }
+  t.device = config.Attributes["Device"]
+  t.Id = id
+  
+  t.dbh = database.NewDatabaseHandle()
+  t.ready = true
+  return t
+}
+
+func (self *Dt1tHandler) Handle(message handler.MessageT) {
+  if ! self.ready {
+    self.Lost("Handler is not marked as ready", nil, message)
+    return
+  }
+  // log.Printf("Handler DT1T %d processing %s -> %s", self.id, message.Topic, message.Payload)
+
+  temperature, err := strconv.Atoi(message.Payload)
+  if err != nil {
+    self.Lost("Invalid raw value", err, message)
+    return
+  }
+  if temperature & 0x8000 != 0{
+    temperature = ((temperature - 1) ^ 0xffff) * -1
+  }
+  temperatureF := float32(temperature) / 10.0
+
+  var measurement database.Measurement
+  measurement.Time = time.Now()
+  measurement.Application = self.application
+  measurement.Device = self.device
+  
+  var variable database.VariableType
+  variable.Label = "Temperature"
+  variable.Variable = ""
+  variable.Unit = "°C"
+  variable.Value = fmt.Sprintf("%f", temperatureF)
+  measurement.Values = make(map[string]database.VariableType)
+  measurement.Values["Value"] = variable
+
+  // log.Printf("Prepared measurement item: %s", measurement)
+  self.dbh.StoreMeasurement(&measurement)
+  self.S()
+}
+
+
--- a/src/udi/handlers/handler/handler.go
+++ b/src/udi/handlers/handler/handler.go
@ -1,6 +1,10 @@
 package handler

-import "time"
+import (
+  "time"
+  "log"
+  "udi/counter"
+)

 type MessageT struct {
  Timestamp time.Time
@ -11,5 +15,32 @@ type MessageT struct {
 type Handler interface {
  GetId() string
  Handle(MessageT)
+  Lost(msg string, err error, message MessageT)
+  S()
+  F()
+}
+
+type CommonHandler struct {
+  Id string
+}
+
+func (self *CommonHandler) S() {
+  counter.SH(self.Id)
+}
+func (self *CommonHandler) F() {
+  counter.FH(self.Id)
+}
+
+func (self *CommonHandler) GetId() string {
+  return self.Id
+}
+
+func (self *CommonHandler) Lost(msg string, err error, message MessageT) {
+  if err == nil {
+    log.Printf("Error: %s, message %s is lost", msg, message)
+  } else {
+    log.Printf("Error: %s (%s), message %s is lost", msg, err, message)
+  }
+  self.F()
 }

--- a/src/udi/handlers/iot/iot.go
+++ b/src/udi/handlers/iot/iot.go
@ -1,29 +1,23 @@
 package iot

 import "log"
-import "fmt"
+import "udi/config"
 import "udi/handlers/handler"

-var idSeq int = 0

 type IoTHandler struct {
-  id int
+  handler.CommonHandler
 }

-func NewIoTHandler() handler.Handler {
+func New(id string, config config.HandlerConfigT) handler.Handler {
  t := &IoTHandler {
-    id: idSeq,
  }
-  idSeq += 1
+  t.Id = id
  return t
 }

-func (self *IoTHandler) GetId() string {
-  return fmt.Sprintf("IoT%d", self.id)
-}
-
 func (self *IoTHandler) Handle(message handler.MessageT) {
-  log.Printf("Handler IoT %d processing %s -> %s", self.id, message.Topic, message.Payload)
+  log.Printf("Handler IoT %d processing %s -> %s", self.Id, message.Topic, message.Payload)
 }


--- a/src/udi/handlers/locative/locative.go
+++ b/src/udi/handlers/locative/locative.go
@ -0,0 +1,73 @@
+package locative
+
+import (
+  "reflect"
+  "time"
+  "log"
+  "encoding/json"
+  "udi/config"
+  "udi/handlers/handler"
+  "udi/database"
+)
+
+
+type LocativeHandler struct {
+  handler.CommonHandler
+  dbh *database.DatabaseHandle
+}
+
+type locativeEvent struct {
+  Trigger string `json:"trigger"`
+  Device string `json:"device"`
+  Location string `json:"location"`
+  Latitude string `json:"latitude"`
+  Longitude string `json:"longitude"`
+  Person string `json:"person"`
+  Timestamp string `json:"timestamp"`
+}
+
+func New(id string, config config.HandlerConfigT) handler.Handler {
+  t := &LocativeHandler {
+  }
+  t.Id = id
+  t.dbh = database.NewDatabaseHandle()
+  return t
+}
+
+
+func (self *LocativeHandler) Handle(message handler.MessageT) {
+  log.Printf("Handler Locative %d processing %s -> %s", self.Id, message.Topic, message.Payload)
+
+  var locativeEvent locativeEvent
+  err := json.Unmarshal([]byte(message.Payload), &locativeEvent)
+  if err != nil {
+    self.Lost("Unable to parse payload into locativeEvent struct", err, message)
+    return
+  }
+
+  variables := make(map[string]database.VariableType)
+  locativeEventStructValue := reflect.ValueOf(locativeEvent)
+  for i := 0; i < locativeEventStructValue.NumField(); i++ {
+    field := locativeEventStructValue.Type().Field(i)
+    fieldValue := locativeEventStructValue.Field(i)
+    v := database.VariableType {
+      Label: "",
+      Variable: field.Name,
+      Unit: "",
+      Value: fieldValue.Interface(),
+    }
+    variables[field.Name] = v
+  }
+
+  measurement := database.Measurement {
+    Time: time.Now(),
+    Application: "Locative",
+    Device: locativeEvent.Person,
+    Values: variables,
+  }
+
+  self.dbh.StoreMeasurement(&measurement)
+  self.S()
+}
+
+
--- a/src/udi/handlers/mbgw3/mbgw3.go
+++ b/src/udi/handlers/mbgw3/mbgw3.go
@ -1,11 +1,8 @@
 package mbgw3

 import (
-  "log"
-  //"reflect"
  "time"
  "strconv"
-  "fmt"
  "encoding/json"
  "udi/config"
  "udi/handlers/handler"
@ -13,10 +10,8 @@ import (
 )


-var idSeq int = 0
-
 type Mbgw3Handler struct {
-  id int
+  handler.CommonHandler
  dbh *database.DatabaseHandle
 }

@ -31,26 +26,21 @@ type Observation struct {
 }


-func NewMbgw3Handler(config config.HandlerConfigT) handler.Handler {
+func New(id string, config config.HandlerConfigT) handler.Handler {
  t := &Mbgw3Handler {
-    id: idSeq,
  }
-  idSeq += 1
-  t.dbh = database.NewDatabaseHandle(config.DatabaseConnStr)
+  t.Id = id
+  t.dbh = database.NewDatabaseHandle()
  return t
 }

-func (self *Mbgw3Handler) GetId() string {
-  return fmt.Sprintf("MBGW3%d", self.id)
-}
-
 func (self *Mbgw3Handler) Handle(message handler.MessageT) {
-//  log.Printf("Handler MBGW3 %d processing %s -> %s", self.id, message.Topic, message.Payload)
+  //log.Printf("Handler MBGW3 %d processing %s -> %s", self.Id, message.Topic, message.Payload)

  var observation Observation
  err := json.Unmarshal([]byte(message.Payload), &observation)
  if err != nil {
-    log.Printf("Unable to parse payload into Observation struct, message %s -> %s is lost, error ", message.Topic, message.Payload, err)
+    self.Lost("Unable to parse payload into Observation struct", err, message)
    return
  }

@ -95,9 +85,10 @@ func (self *Mbgw3Handler) Handle(message handler.MessageT) {
    }
  }

-  // log.Printf("Prepared measurement item: %s", measurement)
+  //log.Printf("Prepared measurement item: %s", measurement)

  self.dbh.StoreMeasurement(&measurement)
+  self.S()
 }


--- a/src/udi/handlers/pv/pv.go
+++ b/src/udi/handlers/pv/pv.go
@ -1,10 +1,8 @@
 package pv

 import (
-  "log"
  "reflect"
  "time"
-  "fmt"
  "encoding/json"
  "udi/config"
  "udi/handlers/handler"
@ -12,10 +10,8 @@ import (
 )


-var idSeq int = 0
-
 type PvHandler struct {
-  id int
+  handler.CommonHandler
  dbh *database.DatabaseHandle
 }

@ -40,18 +36,14 @@ type PvValue struct {
 }


-func NewPvHandler(config config.HandlerConfigT) handler.Handler {
+func New(id string, config config.HandlerConfigT) handler.Handler {
  t := &PvHandler {
-    id: idSeq,
  }
-  idSeq += 1
-  t.dbh = database.NewDatabaseHandle(config.DatabaseConnStr)
+  t.Id = id
+  t.dbh = database.NewDatabaseHandle()
  return t
 }

-func (self *PvHandler) GetId() string {
-  return fmt.Sprintf("PV%d", self.id)
-}

 func (self *PvHandler) Handle(message handler.MessageT) {
  //log.Printf("Handler PV %d processing %s -> %s", self.id, message.Topic, message.Payload)
@ -59,7 +51,7 @@ func (self *PvHandler) Handle(message handler.MessageT) {
  var pvValue PvValue
  err := json.Unmarshal([]byte(message.Payload), &pvValue)
  if err != nil {
-    log.Printf("Unable to parse payload into pvValue struct, message %s -> %s is lost, error: %s", message.Topic, message.Payload, err)
+    self.Lost("Unable to parse payload into pvValue struct", err, message)
    return
  }

@ -85,6 +77,7 @@ func (self *PvHandler) Handle(message handler.MessageT) {
  }

  self.dbh.StoreMeasurement(&measurement)
+  self.S()
 }


--- a/src/udi/handlers/snmp/snmp.go
+++ b/src/udi/handlers/snmp/snmp.go
@ -0,0 +1,75 @@
+package snmp
+
+import (
+  "time"
+  "log"
+  "encoding/json"
+  "udi/config"
+  "udi/handlers/handler"
+  "udi/database"
+)
+
+
+type SnmpHandler struct {
+  handler.CommonHandler
+  dbh *database.DatabaseHandle
+}
+
+type endpoint_t struct {
+  Label string `json:"label"`
+  Variable string `json:"variable"`
+  Value string `json:"value"`
+}
+
+type observation_t struct {
+  Device string `json:"device"`
+  Label string `json:"label"`
+  Variables map[string]endpoint_t `json:"variables"`
+}
+
+
+func New(id string, config config.HandlerConfigT) handler.Handler {
+  t := &SnmpHandler {
+  }
+  t.Id = id
+  t.dbh = database.NewDatabaseHandle()
+  return t
+}
+
+func (self *SnmpHandler) Handle(message handler.MessageT) {
+  log.Printf("Handler SNMP %d processing %s -> %s", self.Id, message.Topic, message.Payload)
+
+  var observation observation_t
+  err := json.Unmarshal([]byte(message.Payload), &observation)
+  if err != nil {
+    self.Lost("Unable to parse payload into Observation struct", err, message)
+    return
+  }
+
+  var measurement database.Measurement
+  measurement.Time = time.Now()
+
+  measurement.Application = "SNMP"
+  measurement.Device = observation.Device
+
+  measurement.Attributes = map[string]interface{} {
+    "Label": observation.Label,
+  }
+
+  measurement.Values = make(map[string]database.VariableType)
+  for k, v := range observation.Variables {
+    measurement.Values[k] = database.VariableType {
+      Label: v.Label,
+      Variable: v.Variable,
+      Unit: "",
+      Value: v.Value,
+    }
+  }
+
+  log.Printf("Prepared measurement item: %s", measurement)
+
+  self.dbh.StoreMeasurement(&measurement)
+  self.S()
+}
+
+
--- a/src/udi/handlers/svej/svej.go
+++ b/src/udi/handlers/svej/svej.go
@ -13,10 +13,8 @@ import (
  "udi/database"
 )

-var idSeq int = 0
-
 type SingleValueExtractorJsonpathHandler struct {
-  id int
+  handler.CommonHandler
  ready bool
  application string
  deviceSelector string
@ -36,12 +34,10 @@ C:ConstantValue
 */


-func NewSvejHandler(config config.HandlerConfigT) handler.Handler {
+func New(id string, config config.HandlerConfigT) handler.Handler {
  t := &SingleValueExtractorJsonpathHandler {
-    id: idSeq,
    ready: false,
  }
-  idSeq += 1

  if config.Attributes["application"] == "" {
    log.Println("Error: application not configured")
@ -77,19 +73,12 @@ func NewSvejHandler(config config.HandlerConfigT) handler.Handler {
    t.unitJsonpath = jp
  }

+  t.Id = id
  t.ready = true
-  t.dbh = database.NewDatabaseHandle(config.DatabaseConnStr)
+  t.dbh = database.NewDatabaseHandle()
  return t
 }

-func (self *SingleValueExtractorJsonpathHandler) GetId() string {
-  return fmt.Sprintf("SVE%d", self.id)
-}
-
-func lost(msg string, message handler.MessageT) {
-  log.Printf("Error: %s, message %s is lost", msg, message)
-}
-
 func extractionHelper(subTopics []string, jPayload interface{}, selector string, jp *jsonpath.Compiled) (string, error) {
  var res string
  switch selector[:2] {
@ -119,10 +108,10 @@ func extractionHelper(subTopics []string, jPayload interface{}, selector string,

 func (self *SingleValueExtractorJsonpathHandler) Handle(message handler.MessageT) {
  if ! self.ready {
-    log.Println("Handler is not marked as ready, message %s is lost", message)
+    self.Lost("Handler is not marked as ready", nil, message)
    return
  }
-  log.Printf("Handler SingleValueExtractorJsonpath %d processing %s -> %s", self.id, message.Topic, message.Payload)
+  //log.Printf("Handler SingleValueExtractorJsonpath %d processing %s -> %s", self.Id, message.Topic, message.Payload)

  var measurement database.Measurement
  measurement.Time = time.Now()
@ -133,23 +122,23 @@ func (self *SingleValueExtractorJsonpathHandler) Handle(message handler.MessageT
  var jPayload interface{}
  err := json.Unmarshal([]byte(message.Payload), &jPayload)
  if err != nil {
-    lost(fmt.Sprintf("Unable to unmarshal payload: %s", err), message)
+    self.Lost("Unable to unmarshal payload", err, message)
    return
  }

  device, err1 := extractionHelper(subTopics, jPayload, self.deviceSelector, self.deviceJsonpath)
  if err1 != nil {
-    lost(fmt.Sprintf("Device extraction failed with %s", err1), message)
+    self.Lost("Device extraction failed", err1, message)
    return
  }
  value, err2 := extractionHelper(subTopics, jPayload, self.valueSelector, self.valueJsonpath)
  if err2 != nil {
-    lost(fmt.Sprintf("Value extraction failed with %s", err2), message)
+    self.Lost("Value extraction failed", err2, message)
    return
  }
  unit, err3 := extractionHelper(subTopics, jPayload, self.unitSelector, self.unitJsonpath)
  if err3 != nil {
-    lost(fmt.Sprintf("Unit extraction failed with %s", err3), message)
+    self.Lost("Unit extraction failed", err3, message)
    return
  }

@ -163,7 +152,8 @@ func (self *SingleValueExtractorJsonpathHandler) Handle(message handler.MessageT
  measurement.Values = make(map[string]database.VariableType)
  measurement.Values["Value"] = variable

-  log.Printf("Prepared measurement item: %s", measurement)
+  //log.Printf("Prepared measurement item: %s", measurement)
  self.dbh.StoreMeasurement(&measurement)
+  self.S()
 }

--- a/src/udi/handlers/sver/sver.go
+++ b/src/udi/handlers/sver/sver.go
@ -1,28 +1,22 @@
 package sver

 import (
-  "log"
  "time"
  "strconv"
  "strings"
  "regexp"
-  "fmt"
-  "reflect"
-  "encoding/json"
-  "github.com/oliveagle/jsonpath"
+  "log"
  "udi/config"
  "udi/handlers/handler"
  "udi/database"
 )

-var idSeq int = 0

 type SingleValueExtractorRegexHandler struct {
-  id int
+  handler.CommonHandler
  ready bool
  config localConfig
  payloadRegex *regexp.Regexp
-  payloadJsonpath *jsonpath.Compiled
  dbh *database.DatabaseHandle
 }

@ -44,12 +38,10 @@ type localConfig struct {
 }


-func NewSverHandler(config config.HandlerConfigT) handler.Handler {
+func New(id string, config config.HandlerConfigT) handler.Handler {
  t := &SingleValueExtractorRegexHandler {
-    id: idSeq,
    ready: false,
  }
-  idSeq += 1

  var localConfig localConfig
  if config.Attributes["application"] == "" {
@ -64,18 +56,6 @@ func NewSverHandler(config config.HandlerConfigT) handler.Handler {
  } else {
    t.payloadRegex = nil
  }
-  payloadJsonpath := config.Attributes["payloadJsonpath"]
-  if payloadJsonpath != "" {
-    j, err := jsonpath.Compile(payloadJsonpath)
-    if err != nil {
-      log.Printf("Unable to compile jsonpath %s", payloadJsonpath)
-      t.payloadJsonpath = nil
-    } else {
-      t.payloadJsonpath = j
-    }
-  } else {
-    t.payloadJsonpath = nil
-  }

  if config.Attributes["deviceFrom"] != TOPIC_SEL && config.Attributes["deviceFrom"] != PAYLOAD_SEL && config.Attributes["deviceFrom"] != CONSTANT_SEL {
    log.Printf("Error: invalid value %s for deviceFrom", config.Attributes["deviceFrom"])
@ -128,22 +108,15 @@ func NewSverHandler(config config.HandlerConfigT) handler.Handler {

  t.config = localConfig

+  t.Id = id
  t.ready = true
-  t.dbh = database.NewDatabaseHandle(config.DatabaseConnStr)
+  t.dbh = database.NewDatabaseHandle()
  return t
 }

-func (self *SingleValueExtractorRegexHandler) GetId() string {
-  return fmt.Sprintf("SVE%d", self.id)
-}
-
-func lost(msg string, message handler.MessageT) {
-  log.Printf("Error: %s, message %s is lost", msg, message)
-}
-
 func (self *SingleValueExtractorRegexHandler) Handle(message handler.MessageT) {
  if ! self.ready {
-    log.Println("Handler is not marked as ready, message %s is lost", message)
+    self.Lost("Handler is not marked as ready", nil, message)
    return
  }
  //log.Printf("Handler SingleValueExtractor %d processing %s -> %s", self.id, message.Topic, message.Payload)
@ -160,31 +133,21 @@ func (self *SingleValueExtractorRegexHandler) Handle(message handler.MessageT) {
    payloadMatches = self.payloadRegex.FindStringSubmatch(message.Payload)
    //log.Printf("Matches: %s", strings.Join(payloadMatches, ", "))
  }
-  if self.payloadJsonpath != nil {
-    var jsonData interface{}
-    json.Unmarshal([]byte(message.Payload), &jsonData)
-    p, err := self.payloadJsonpath.Lookup(jsonData)
-    if err != nil {
-      lost(fmt.Sprintf("jsonpath error: %s", err), message)
-      return
-    }
-    log.Printf("XXXX: %s", reflect.TypeOf(p))
-  }

  switch self.config.deviceFrom {
  case TOPIC_SEL:
    if self.config.devicePart >= len(subTopics) {
-      lost("devicePart out of range", message)
+      self.Lost("devicePart out of range", nil, message)
      return
    }
    measurement.Device = subTopics[self.config.devicePart]
  case PAYLOAD_SEL:
-    if self.payloadRegex == nil && self.payloadJsonpath == nil {
-      lost("no payloadRegex or payloadJsonpath defined, devicePart can't be used", message)
+    if self.payloadRegex == nil {
+      self.Lost("no payloadRegex defined, devicePart can't be used", nil, message)
      return
    }
    if self.config.devicePart >= len(payloadMatches) {
-      lost("devicePart out of range", message)
+      self.Lost("devicePart out of range", nil, message)
      return
    }
    measurement.Device = payloadMatches[self.config.devicePart]
@ -199,12 +162,12 @@ func (self *SingleValueExtractorRegexHandler) Handle(message handler.MessageT) {

  switch self.config.valueFrom {
  case PAYLOAD_SEL:
-    if self.payloadRegex == nil && self.payloadJsonpath == nil {
-      lost("no payloadRegex or payloadJsonpath defined, valuePart can't be used", message)
+    if self.payloadRegex == nil {
+      self.Lost("no payloadRegex defined, valuePart can't be used", nil, message)
      return
    }
    if self.config.valuePart >= len(payloadMatches) {
-      lost("valuePart out of range", message)
+      self.Lost("valuePart out of range", nil, message)
      return
    }
    variable.Value = payloadMatches[self.config.valuePart]
@ -214,12 +177,12 @@ func (self *SingleValueExtractorRegexHandler) Handle(message handler.MessageT) {

  switch self.config.unitFrom {
  case PAYLOAD_SEL:
-    if self.payloadRegex == nil && self.payloadJsonpath == nil {
-      lost("no payloadRegex or payloadJsonpath defined, unitPart can't be used", message)
+    if self.payloadRegex == nil {
+      self.Lost("no payloadRegex defined, unitPart can't be used", nil, message)
      return
    }
    if self.config.unitPart >= len(payloadMatches) {
-      lost("unitPart out of range", message)
+      self.Lost("unitPart out of range", nil, message)
      return
    }
    variable.Unit = payloadMatches[self.config.unitPart]
@ -231,5 +194,6 @@ func (self *SingleValueExtractorRegexHandler) Handle(message handler.MessageT) {

  //log.Printf("Prepared measurement item: %s", measurement)
  self.dbh.StoreMeasurement(&measurement)
+  self.S()
 }

--- a/src/udi/handlers/ttn/models/draginoLdds75/draginoLdds75.go
+++ b/src/udi/handlers/ttn/models/draginoLdds75/draginoLdds75.go
@ -0,0 +1,89 @@
+package draginoLdds75
+
+import (
+  "fmt"
+  // "log"
+  "strings"
+  "strconv"
+  "encoding/json"
+  "udi/database"
+)
+
+/*
+    "decoded_payload": {
+      "Bat": 3.299,
+      "Distance": "352 mm",
+      "Interrupt_flag": 0,
+      "Sensor_flag": 1,
+      "TempC_DS18B20": "0.00"
+    },
+*/
+type message struct {
+  Bat float32 `json:"Bat"`
+  Distance string `json:"Distance"`
+  Interrupt_flag int `json:"Interrupt_flag"`
+  Sensor_flag int `json:"Sensor_flag"`
+  TempC_DS18B20 string `json:"TempC_DS18B20"`
+}
+
+func Parse(fPort int, decodedPayload []byte, _ string, variables *map[string]database.VariableType, attributes *map[string]interface{}, device *database.Device) error {
+  if fPort != 2 {
+    return fmt.Errorf("Unexpected fPort %d", fPort)
+  }
+  var message message
+  err := json.Unmarshal(decodedPayload, &message)
+  if err != nil {
+    return fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
+  }
+  distanceParts := strings.Split(message.Distance, " ")
+  if len(distanceParts) != 2 && distanceParts[1] != "mm" {
+    return fmt.Errorf("Invalid format for distance value: %s", message.Distance)
+  }
+  distance, err2 := strconv.Atoi(distanceParts[0])
+  if err2 != nil {
+    return fmt.Errorf("Distance value is no number: %s -> %s", message.Distance, err2)
+  }
+  (*variables)["Battery"] = database.VariableType {
+    Label: "Battery",
+    Variable: "Voltage",
+    Unit: "V",
+    Value: message.Bat,
+  }
+  (*variables)["Distance"] = database.VariableType {
+    Label: "Distance",
+    Variable: "Level",
+    Unit: "mm",
+    Value: distance,
+  }
+
+  if distance == 20 {
+    (*attributes)["Status"] = "invalid value"
+  } else if distance == 0 {
+    (*attributes)["Status"] = "no sensor detected"
+  } else {
+    (*attributes)["Status"] = "Ok"
+  }
+
+  groundLevelI, exists := device.Attributes["GroundLevel"]
+  groundLevelS, ok := groundLevelI.(string)
+  groundLevel, err3 := strconv.Atoi(groundLevelS)
+  if exists && err3 == nil && ok {
+    //log.Println("add corrected distance")
+    correctedDistance := groundLevel - distance
+    (*variables)["CorrectedDistance"] = database.VariableType {
+      Label: "CorrectedDistance",
+      Variable: "Level",
+      Unit: "mm",
+      Value: correctedDistance,
+    }
+  } /* else {
+    log.Printf("no ground level: %s %s %s", exists, err3, ok)
+    log.Printf("Device: %s", device)
+    log.Printf("Attributes: %s", device.Attributes)
+  } */
+
+  return nil
+}
+
+
+
--- a/src/udi/handlers/ttn/models/draginoLdds75/example-ldds75.json
+++ b/src/udi/handlers/ttn/models/draginoLdds75/example-ldds75.json
@ -0,0 +1,83 @@
+{
+  "end_device_ids": {
+    "device_id": "eui-a84041a14185f67f",
+    "application_ids": {
+      "application_id": "de-hottis-level-monitoring"
+    },
+    "dev_eui": "A84041A14185F67F",
+    "join_eui": "A840410000000101",
+    "dev_addr": "260B3987"
+  },
+  "correlation_ids": [
+    "gs:uplink:01HHP8EVC1N78FGTNBTNZYGCVY"
+  ],
+  "received_at": "2023-12-15T08:11:04.142793605Z",
+  "uplink_message": {
+    "session_key_id": "AYZ/cI2YeDLCZr4urRDzCw==",
+    "f_port": 2,
+    "f_cnt": 27758,
+    "frm_payload": "DOMBYAAAAAE=",
+    "decoded_payload": {
+      "Bat": 3.299,
+      "Distance": "352 mm",
+      "Interrupt_flag": 0,
+      "Sensor_flag": 1,
+      "TempC_DS18B20": "0.00"
+    },
+    "rx_metadata": [
+      {
+        "gateway_ids": {
+          "gateway_id": "eui-00005813d35e3021",
+          "eui": "00005813D35E3021"
+        },
+        "timestamp": 3654294763,
+        "rssi": -85,
+        "channel_rssi": -85,
+        "snr": 8.8,
+        "location": {
+          "latitude": 52.17065267448476,
+          "longitude": 7.629437184774199,
+          "source": "SOURCE_REGISTRY"
+        },
+        "uplink_token": "CiIKIAoUZXVpLTAwMDA1ODEzZDM1ZTMwMjESCAAAWBPTXjAhEOu5wM4NGgwIl5TwqwYQ5Z/7vgMg+OvDp63eBA==",
+        "channel_index": 2,
+        "received_at": "2023-12-15T08:11:03.937349093Z"
+      }
+    ],
+    "settings": {
+      "data_rate": {
+        "lora": {
+          "bandwidth": 125000,
+          "spreading_factor": 7,
+          "coding_rate": "4/5"
+        }
+      },
+      "frequency": "867500000",
+      "timestamp": 3654294763
+    },
+    "received_at": "2023-12-15T08:11:03.938112475Z",
+    "consumed_airtime": "0.056576s",
+    "locations": {
+      "user": {
+        "latitude": 52.1710648323742,
+        "longitude": 7.62751003482794,
+        "altitude": 37,
+        "source": "SOURCE_REGISTRY"
+      }
+    },
+    "version_ids": {
+      "brand_id": "dragino",
+      "model_id": "ldds75",
+      "hardware_version": "_unknown_hw_version_",
+      "firmware_version": "1.1.4",
+      "band_id": "EU_863_870"
+    },
+    "network_ids": {
+      "net_id": "000013",
+      "ns_id": "EC656E0000000181",
+      "tenant_id": "ttn",
+      "cluster_id": "eu1",
+      "cluster_address": "eu1.cloud.thethings.network"
+    }
+  }
+}
--- a/src/udi/handlers/ttn/models/draginoLmds200/draginoLmds200.go
+++ b/src/udi/handlers/ttn/models/draginoLmds200/draginoLmds200.go
@ -0,0 +1,90 @@
+package draginoLmds200
+
+import (
+  "fmt"
+  "strconv"
+  "encoding/json"
+  "udi/database"
+)
+
+/*
+    "decoded_payload": {
+      "Bat": 3.082,
+      "DALARM_count": 0,
+      "Distance_alarm": 0,
+      "Interrupt_alarm": 0,
+      "dis1": 105,
+      "dis2": 201
+    },
+*/
+type message struct {
+  Bat float32 `json:"Bat"`
+  DALARM_count int `json:"DALARM_count"`
+  Distance_alarm int `json:"Distance_alarm"`
+  Interrupt_alarm int `json:"Interrupt_alarm"`
+  Dis1 int `json:"dis1"`
+  Dis2 int `json:"dis2"`
+}
+
+func Parse(fPort int, decodedPayload []byte, _ string, variables *map[string]database.VariableType, attributes *map[string]interface{}, device *database.Device) error {
+  if fPort != 2 {
+    return fmt.Errorf("Unexpected fPort %d", fPort)
+  }
+  var message message
+  err := json.Unmarshal(decodedPayload, &message)
+  if err != nil {
+    return fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
+  }
+  (*variables)["Battery"] = database.VariableType {
+    Label: "Battery",
+    Variable: "Voltage",
+    Unit: "V",
+    Value: message.Bat,
+  }
+  distance1 := message.Dis1 * 10
+  (*variables)["Distance1"] = database.VariableType {
+    Label: "Distance1",
+    Variable: "Level",
+    Unit: "mm",
+    Value: distance1,
+  }
+  distance2 := message.Dis2 * 10
+  (*variables)["Distance2"] = database.VariableType {
+    Label: "Distance2",
+    Variable: "Level",
+    Unit: "mm",
+    Value: distance2,
+  }
+
+  if distance1 == 2 {
+    (*attributes)["Status"] = "invalid value"
+  } else if distance1 == 1 {
+    (*attributes)["Status"] = "no sensor detected"
+  } else {
+    (*attributes)["Status"] = "Ok"
+  }
+
+  groundLevelI, exists := device.Attributes["GroundLevel"]
+  groundLevelS, ok := groundLevelI.(string)
+  groundLevel, err3 := strconv.Atoi(groundLevelS)
+  if exists && err3 == nil && ok {
+    correctedDistance1 := groundLevel - distance1
+    (*variables)["CorrectedDistance1"] = database.VariableType {
+      Label: "CorrectedDistance1",
+      Variable: "Level",
+      Unit: "mm",
+      Value: correctedDistance1,
+    }
+    correctedDistance2 := groundLevel - distance2
+    (*variables)["CorrectedDistance2"] = database.VariableType {
+      Label: "CorrectedDistance2",
+      Variable: "Level",
+      Unit: "mm",
+      Value: correctedDistance2,
+    }
+  }
+  return nil
+}
+
+
+
--- a/src/udi/handlers/ttn/models/draginoLmds200/lmds200-example.json
+++ b/src/udi/handlers/ttn/models/draginoLmds200/lmds200-example.json
--- a/src/udi/handlers/ttn/models/draginoLse01/draginoLse01.go
+++ b/src/udi/handlers/ttn/models/draginoLse01/draginoLse01.go
@ -0,0 +1,63 @@
+package draginoLse01
+
+import (
+  "fmt"
+  "encoding/json"
+  "udi/database"
+)
+
+/*
+{
+  "Bat":3.211,
+  "TempC_DS18B20":"0.0",
+  "conduct_SOIL":32,
+  "temp_SOIL":"7.56",
+  "water_SOIL":"25.92"
+}
+*/
+
+type message struct {
+  Bat float32 `json:"Bat"`
+  TempC_DS18B20 string `json:"TempC_DS18B20"`
+  Conduct_SOIL int `json:"conduct_SOIL"`
+  Temp_SOIL string `json:"temp_SOIL"`
+  Water_SOIL string `json:"water_SOIL"`
+}
+
+func Parse(fPort int, decodedPayload []byte, _ string, variables *map[string]database.VariableType, _ *map[string]interface{}, _ *database.Device) error {
+  if fPort != 2 {
+    return fmt.Errorf("Unexpected fPort %d", fPort)
+  }
+  var message message
+  err := json.Unmarshal(decodedPayload, &message)
+  if err != nil {
+    return fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
+  }
+  (*variables)["Battery"] = database.VariableType {
+    Label: "Battery",
+    Variable: "Voltage",
+    Unit: "V",
+    Value: message.Bat,
+  }
+  (*variables)["Conductance"] = database.VariableType {
+    Label: "Conductance",
+    Variable: "Conductance",
+    Unit: "uS/cm",
+    Value: message.Conduct_SOIL,
+  }
+  (*variables)["Temperature"] = database.VariableType {
+    Label: "Temperature",
+    Variable: "Temperature",
+    Unit: "°C",
+    Value: message.Temp_SOIL,
+  }
+  (*variables)["Water"] = database.VariableType {
+    Label: "Water",
+    Variable: "Water",
+    Unit: "%",
+    Value: message.Water_SOIL,
+  }
+
+  return nil
+}
+
--- a/src/udi/handlers/ttn/models/draginoLsn50/draginoLsn50.go
+++ b/src/udi/handlers/ttn/models/draginoLsn50/draginoLsn50.go
@ -0,0 +1,74 @@
+package draginoLsn50
+
+import (
+  "fmt"
+  "encoding/json"
+  "udi/database"
+)
+
+/*
+      "decoded_payload": {
+        "ALARM_status": "FALSE",
+        "BatV": 3.659,
+        "Temp_Black": 3276.7,
+        "Temp_Red": 22.6,
+        "Temp_White": 3276.7,
+        "Work_mode": "DS18B20"
+      },
+*/
+type message struct {
+  ALARM_status string `json:"ALARM_status"`
+  Bat float32 `json:"BatV"`
+  Work_mode string `json:"Work_mode"`
+  Temp_Black string `json:"Temp_Black"`
+  Temp_Red string `json:"Temp_Red"`
+  Temp_White string `json:"Temp_White"`
+}
+
+func Parse(fPort int, decodedPayload []byte, _ string, variables *map[string]database.VariableType, attributes *map[string]interface{}, device *database.Device) error {
+  if fPort != 2 {
+    return fmt.Errorf("Unexpected fPort %d", fPort)
+  }
+  var message message
+  err := json.Unmarshal(decodedPayload, &message)
+  if err != nil {
+    return fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
+  }
+  (*variables)["Battery"] = database.VariableType {
+    Label: "Battery",
+    Variable: "Voltage",
+    Unit: "V",
+    Value: message.Bat,
+  }
+  (*variables)["Alarm"] = database.VariableType {
+    Label: "Alarm",
+    Variable: "Alarm",
+    Unit: "",
+    Value: message.ALARM_status,
+  }
+  (*variables)["Temp_Red"] = database.VariableType {
+    Label: "Temp_Red",
+    Variable: "Temperature",
+    Unit: "°C",
+    Value: message.Temp_Red,
+  }
+  (*variables)["Temp_Black"] = database.VariableType {
+    Label: "Temp_Black",
+    Variable: "Temperature",
+    Unit: "°C",
+    Value: message.Temp_Black,
+  }
+  (*variables)["Temp_White"] = database.VariableType {
+    Label: "Temp_White",
+    Variable: "Temperature",
+    Unit: "°C",
+    Value: message.Temp_White,
+  }
+
+  (*attributes)["Status"] = "Ok"
+
+  return nil
+}
+
+
+
--- a/src/udi/handlers/ttn/models/emuProfIILoRaCfg1/emuProfIILoRaCfg1.go
+++ b/src/udi/handlers/ttn/models/emuProfIILoRaCfg1/emuProfIILoRaCfg1.go
@ -177,83 +177,81 @@ type emuMessage1 struct {



-func Parse(fPort int, decodedPayload []byte) (map[string]database.VariableType, error) {
+func Parse(fPort int, decodedPayload []byte, _ string, variables *map[string]database.VariableType, _ *map[string]interface{}, _ *database.Device) error {
  //log.Printf("Parse input: %d, %s", fPort, decodedPayload)
  switch fPort {
  case 1:
    var emuMessage1 emuMessage1
    err := json.Unmarshal(decodedPayload, &emuMessage1)
    if err != nil {
-      return nil, fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
+      return fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
    }
-    variables := make(map[string]database.VariableType)
-    variables["ActivePowerL1"] = database.VariableType { 
+    (*variables)["ActivePowerL1"] = database.VariableType { 
      Variable: "ActivePowerL1", 
      Unit: emuMessage1.ActivePowerL1.Unit,
      Value: emuMessage1.ActivePowerL1.Value,
    }
-    variables["ActivePowerL2"] = database.VariableType { 
+    (*variables)["ActivePowerL2"] = database.VariableType { 
      Variable: "ActivePowerL2", 
      Unit: emuMessage1.ActivePowerL2.Unit,
      Value: emuMessage1.ActivePowerL2.Value,
    }
-    variables["ActivePowerL3"] = database.VariableType { 
+    (*variables)["ActivePowerL3"] = database.VariableType { 
      Variable: "ActivePowerL3", 
      Unit: emuMessage1.ActivePowerL3.Unit,
      Value: emuMessage1.ActivePowerL3.Value,
    }
-    variables["ActivePowerL123"] = database.VariableType { 
+    (*variables)["ActivePowerL123"] = database.VariableType { 
      Variable: "ActivePowerL123", 
      Unit: emuMessage1.ActivePowerL123.Unit,
      Value: emuMessage1.ActivePowerL123.Value,
    }
-    variables["PowerfactorL1"] = database.VariableType { 
+    (*variables)["PowerfactorL1"] = database.VariableType { 
      Variable: "PowerfactorL1", 
      Unit: emuMessage1.PowerfactorL1.Unit,
      Value: emuMessage1.PowerfactorL1.Value,
    }
-    variables["PowerfactorL2"] = database.VariableType { 
+    (*variables)["PowerfactorL2"] = database.VariableType { 
      Variable: "PowerfactorL2", 
      Unit: emuMessage1.PowerfactorL2.Unit,
      Value: emuMessage1.PowerfactorL2.Value,
    }
-    variables["PowerfactorL3"] = database.VariableType { 
+    (*variables)["PowerfactorL3"] = database.VariableType { 
      Variable: "PowerfactorL3", 
      Unit: emuMessage1.PowerfactorL3.Unit,
      Value: emuMessage1.PowerfactorL3.Value,
    }

-    return variables, nil
+    return nil
  case 2:
    var emuMessage2 emuMessage2
    err := json.Unmarshal(decodedPayload, &emuMessage2)
    if err != nil {
-      return nil, fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
+      return fmt.Errorf("Unable to parse payload, fPort %d, error %s", fPort, err)
    }
-    variables := make(map[string]database.VariableType)
-    variables["ActiveEnergyExport"] = database.VariableType { 
+    (*variables)["ActiveEnergyExport"] = database.VariableType { 
      Variable: "ActiveEnergyExport", 
      Unit: emuMessage2.ActiveEnergyExport.Unit,
      Value: emuMessage2.ActiveEnergyExport.Value,
    }
-    variables["ActiveEnergyImport"] = database.VariableType { 
+    (*variables)["ActiveEnergyImport"] = database.VariableType { 
      Variable: "ActiveEnergyImport", 
      Unit: emuMessage2.ActiveEnergyImport.Unit,
      Value: emuMessage2.ActiveEnergyImport.Value,
    }
-    variables["ReactiveEnergyExport"] = database.VariableType { 
+    (*variables)["ReactiveEnergyExport"] = database.VariableType { 
      Variable: "ReactiveEnergyExport", 
      Unit: emuMessage2.ReactiveEnergyExport.Unit,
      Value: emuMessage2.ReactiveEnergyExport.Value,
    }
-    variables["ReactiveEnergyImport"] = database.VariableType { 
+    (*variables)["ReactiveEnergyImport"] = database.VariableType { 
      Variable: "ReactiveEnergyImport", 
      Unit: emuMessage2.ReactiveEnergyImport.Unit,
      Value: emuMessage2.ReactiveEnergyImport.Value,
    }
-    return variables, nil
+    return nil
  default:
-    return nil, fmt.Errorf("Unexpected fPort %d", fPort)
+    return fmt.Errorf("Unexpected fPort %d", fPort)
  }
 }

--- a/src/udi/handlers/ttn/models/hottisScd30/hottisScd30.go
+++ b/src/udi/handlers/ttn/models/hottisScd30/hottisScd30.go
@ -0,0 +1,61 @@
+package hottisScd30
+
+import (
+  //"log"
+  "fmt"
+  "bytes"
+  "encoding/base64"
+  "encoding/binary"
+  "udi/database"
+)
+
+type hottisScd30Values struct {
+  Status uint8
+  CO2Conc int32
+  Temp int32
+  Hum int32
+}
+
+
+func Parse(fPort int, _ []byte, frmPayload string, variables *map[string]database.VariableType, attributes *map[string]interface{}, _ *database.Device) error {
+  if fPort != 2 {
+    return fmt.Errorf("Unexpected fPort %d", fPort)
+  }
+
+  b, err := base64.StdEncoding.DecodeString(frmPayload)
+  if err != nil {
+    return fmt.Errorf("Unable to base64-decode payload: %v", err)
+  }
+
+  var values hottisScd30Values
+  err = binary.Read(bytes.NewReader(b), binary.LittleEndian, &values)
+  if err != nil {
+    return fmt.Errorf("Unable to cast into struct: %v", err)
+  }
+  var co2concentration float32 = float32(values.CO2Conc) / 100;
+  var temperature float32 = float32(values.Temp) / 100;
+  var humidity float32 = float32(values.Hum) / 100;
+  // log.Printf("CO2: %f, Temp: %f, Hum: %f, Status: %d", co2concentration, temperature, humidity, values.Status)
+
+  (*variables)["CO2concentration"] = database.VariableType {
+    Label: "CO2concentration",
+    Variable: "Concentration",
+    Unit: "ppm",
+    Value: co2concentration,
+  }
+  (*variables)["Temperature"] = database.VariableType {
+    Label: "Temperature",
+    Variable: "Temperature",
+    Unit: "°C",
+    Value: temperature,
+  }
+  (*variables)["Humidity"] = database.VariableType {
+    Label: "Humidity",
+    Variable: "Humidity",
+    Unit: "%",
+    Value: humidity,
+  }
+
+  (*attributes)["Status"] = values.Status
+  return nil
+}
--- a/src/udi/handlers/ttn/models/rawPayloadPrinter/rawPayloadPrinter.go
+++ b/src/udi/handlers/ttn/models/rawPayloadPrinter/rawPayloadPrinter.go
@ -0,0 +1,25 @@
+package rawPayloadPrinter
+
+import (
+  "log"
+  "fmt"
+  "encoding/base64"
+  "encoding/hex"
+  "udi/database"
+)
+
+
+func Parse(fPort int, _ []byte, frmPayload string, variables *map[string]database.VariableType, _ *map[string]interface{}, _ *database.Device) error {
+  if fPort != 2 {
+    return fmt.Errorf("Unexpected fPort %d", fPort)
+  }
+
+  bytes, err := base64.StdEncoding.DecodeString(frmPayload)
+  if err != nil {
+    return fmt.Errorf("Unable to base64-decode payload: %v", err)
+  }
+  hexString := hex.EncodeToString(bytes)
+
+  log.Printf("Payload: %s", hexString)
+  return nil
+}
--- a/src/udi/handlers/ttn/ttn.go
+++ b/src/udi/handlers/ttn/ttn.go
@ -1,18 +1,25 @@
 package ttn

-import "log"
-import "fmt"
-import "time"
-import "encoding/json"
-import "udi/config"
-import "udi/handlers/handler"
-import "udi/handlers/ttn/models/emuProfIILoRaCfg1"
-import "udi/database"
+import (
+  "fmt"
+  //"log"
+  "time"
+  "encoding/json"
+  "udi/config"
+  "udi/handlers/handler"
+  "udi/handlers/ttn/models/emuProfIILoRaCfg1"
+  "udi/handlers/ttn/models/draginoLdds75"
+  "udi/handlers/ttn/models/draginoLmds200"
+  "udi/handlers/ttn/models/draginoLse01"
+  "udi/handlers/ttn/models/draginoLsn50"
+  "udi/handlers/ttn/models/rawPayloadPrinter"
+  "udi/handlers/ttn/models/hottisScd30"
+  "udi/database"
+)

-var idSeq int = 0

 type TTNHandler struct {
-  id int
+  handler.CommonHandler
  dbh *database.DatabaseHandle
 }

@ -72,25 +79,16 @@ func (self *DecodedPayloaderHolder) UnmarshalJSON(data []byte) error {
  return nil
 }

-func NewTTNHandler(config config.HandlerConfigT) handler.Handler {
+func New(id string, config config.HandlerConfigT) handler.Handler {
  t := &TTNHandler {
-    id: idSeq,
  }
-  idSeq += 1
-  t.dbh = database.NewDatabaseHandle(config.DatabaseConnStr)
+  t.Id = id
+  t.dbh = database.NewDatabaseHandle()
  return t
 }

-func (self *TTNHandler) GetId() string {
-  return fmt.Sprintf("TTN%d", self.id)
-}
-
-func lost(msg string, message handler.MessageT) {
-  log.Printf("Error: %s, message %s is lost", msg, message)
-}
-
 func (self *TTNHandler) Handle(message handler.MessageT) {
-  // log.Printf("Handler TTN %d processing %s -> %s", self.id, message.Topic, message.Payload)
+  //log.Printf("Handler TTN %d processing %s -> %s", self.Id, message.Topic, message.Payload)

  var measurement database.Measurement
  measurement.Time = time.Now()
@ -98,7 +96,7 @@ func (self *TTNHandler) Handle(message handler.MessageT) {
  var uplinkMessage uplinkMessage
  err := json.Unmarshal([]byte(message.Payload), &uplinkMessage)
  if err != nil {
-    lost(fmt.Sprintf("Error when unmarshaling message: %s, ", err), message)
+    self.Lost("Error when unmarshaling message", err, message)
    return
  }
  //log.Printf("Parsed message: %s", uplinkMessage)
@ -111,7 +109,7 @@ func (self *TTNHandler) Handle(message handler.MessageT) {
  attributes.FrmPayload = uplinkMessage.UplinkMessage.FrmPayload
  attributes.ConsumedAirtime = uplinkMessage.UplinkMessage.ConsumedAirtime
  for _, rxm := range uplinkMessage.UplinkMessage.RxMetadata {
-    log.Printf("RXM: %s", rxm)
+    //log.Printf("RXM: %s", rxm)
    g := gatewayAttributes { GatewayId: rxm.GatewayIds.GatewayId, Rssi: rxm.Rssi, Snr: rxm.Snr }
    attributes.Gateways = append(attributes.Gateways, g)
  }
@ -129,31 +127,50 @@ func (self *TTNHandler) Handle(message handler.MessageT) {
  //log.Printf("ApplicationId: %s, DeviceId: %s", attributes.ApplicationId, attributes.DeviceId)
  device, err2 := self.dbh.GetDeviceByLabelAndApplication(attributes.ApplicationId, attributes.DeviceId)
  if err2 != nil {
-    lost(fmt.Sprintf("Error when loading device: %s, ", err2), message)
+    self.Lost("Error when loading device", err2, message)
    return
  }
  measurement.Application = attributes.ApplicationId
  measurement.Device = attributes.DeviceId
+  measurement.Attributes["DeviceType"] = device.DeviceType.ModelIdentifier

  //log.Printf("DeviceLabel: %s, DeviceType: %s", device.Label, device.DeviceType.ModelIdentifier)

-  var parser func(int, []byte) (map[string]database.VariableType, error)
+  var parser func(int, []byte, string, *map[string]database.VariableType, *map[string]interface{}, *database.Device) error
  switch device.DeviceType.ModelIdentifier {
  case "emu-prof-ii-lora-cfg1":
    parser = emuProfIILoRaCfg1.Parse
+  case "dragino-ldds75":
+    parser = draginoLdds75.Parse
+  case "dragino-lmds200":
+    parser = draginoLmds200.Parse
+  case "dragino-lse01":
+    parser = draginoLse01.Parse
+  case "dragino-lsn50":
+    parser = draginoLsn50.Parse
+  case "raw-payload-printer":
+    parser = rawPayloadPrinter.Parse
+  case "hottis-scd30":
+    parser = hottisScd30.Parse
  default:
-    lost(fmt.Sprintf("No parser found for %s", device.DeviceType.ModelIdentifier), message)
+    self.Lost(fmt.Sprintf("No parser found for %s", device.DeviceType.ModelIdentifier), nil, message)
    return
  }

-  variables, err3 := parser(uplinkMessage.UplinkMessage.FPort, uplinkMessage.UplinkMessage.DecodedPayload.Payload)
+  measurement.Values = make(map[string]database.VariableType)
+  err3 := parser(uplinkMessage.UplinkMessage.FPort, 
+                 uplinkMessage.UplinkMessage.DecodedPayload.Payload, 
+                 uplinkMessage.UplinkMessage.FrmPayload,
+                 &(measurement.Values), 
+                 &(measurement.Attributes),
+                 device)
  if err3 != nil {
-    lost(fmt.Sprintf("Model parser failed: %s", err3), message)
+    self.Lost("Model parser failed", err3, message)
    return
  }
-  measurement.Values = variables
-  log.Printf("Prepared measurement item: %s", measurement)
+  //log.Printf("Prepared measurement item: %s", measurement)
  self.dbh.StoreMeasurement(&measurement)
+  self.S()
 }


--- a/src/udi/main.go
+++ b/src/udi/main.go
@ -5,6 +5,7 @@ import "os"
 import "os/signal"
 import "udi/mqtt"
 import "udi/config"
+import "udi/counter"
 import "udi/dispatcher"


@ -23,6 +24,8 @@ func main() {
  mqtt.StartMqttClient()
  defer mqtt.StopMqttClient()

+  counter.InitCounter()
+
  log.Println("UDI running")

  c := make(chan os.Signal, 1)
--- a/src/udi/mqtt/mqtt.go
+++ b/src/udi/mqtt/mqtt.go
@ -7,6 +7,7 @@ import MQTT "github.com/eclipse/paho.mqtt.golang"
 import "github.com/google/uuid"
 import "crypto/tls"
 import "udi/config"
+import "udi/counter"

 type Message struct {
  Topic string
@ -26,10 +27,12 @@ func onMessageReceived(client MQTT.Client, message MQTT.Message) {
  }
  select {
  case InputChannel <- m:
+    counter.S("Received")
    {}
    //log.Println("Message sent to channel")
  default:
    log.Println("Channel full, message lost")
+    counter.F("Received")
  }
 }

@ -54,7 +57,7 @@ func onConnect(client MQTT.Client) {
    if token := client.Subscribe(topic, 0, onMessageReceived); token.Wait() && token.Error() != nil {
      log.Fatalf("Unable to subscribe to topic %s, error %s", topic, token.Error())
    }
-    log.Printf("Successfully subscribed to topic %s", topic)
+    log.Printf("Topic %s subscribed", topic)
  }
 }

@ -101,19 +104,19 @@ func StartMqttClient() {

  enableTls := config.Config.Mqtt.TlsEnable
  if enableTls == "true" {
-    log.Println("Enabling TLS connection")
+    //log.Println("Enabling TLS connection")
    tlsConfig := &tls.Config { 
      InsecureSkipVerify: true, 
    }
    opts.SetTLSConfig(tlsConfig)
 	}

-  log.Println("Trying to connect to broker")
+  log.Println("Broker connecting")
  mqttClient = MQTT.NewClient(opts)
  if token := mqttClient.Connect(); token.Wait() && token.Error() != nil {
    log.Fatalf("Unable to connect to broker %s, error %s", broker, token.Error())
  }
-  log.Printf("Successfully connected to broker %s", broker)
+  //log.Printf("Successfully connected to broker %s", broker)

  go outputDispatcher(mqttClient)
Author	SHA1	Message	Date
Wolfgang Hottgenroth	17b2b362a0	fix in error output All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-02-09 14:05:14 +01:00
Wolfgang Hottgenroth	c1a8a0b8f2	add decoder for lsn50 3-way, fix 1 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-02-09 13:40:21 +01:00
Wolfgang Hottgenroth	8dbef7c647	add decoder for lsn50 3-way Some checks failed ci/woodpecker/push/woodpecker Pipeline failed Details	2024-02-09 13:38:55 +01:00
Wolfgang Hottgenroth	42b307ff7b	fix image name in deploy script All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-02-07 22:46:35 +01:00
Wolfgang Hottgenroth	943516f1ac	upgrade some modules due to vulnerabilities All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-02-07 22:41:01 +01:00
Wolfgang Hottgenroth	1a8e76dc32	add trivy in pipeline Some checks failed ci/woodpecker/push/woodpecker Pipeline failed Details	2024-02-07 22:35:15 +01:00
Wolfgang Hottgenroth	3e4c621645	test All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-01-30 16:54:50 +01:00
Wolfgang Hottgenroth	c8e60df30b	test	2024-01-30 16:33:09 +01:00
Wolfgang Hottgenroth	664a2831ab	test All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-01-30 16:28:49 +01:00
Wolfgang Hottgenroth	00524c0a3f	label in snmp measurements All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-26 14:44:23 +01:00
Wolfgang Hottgenroth	3af9482880	fix All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-25 15:27:33 +01:00
Wolfgang Hottgenroth	df353d4f6c	skip diff value Some checks failed ci/woodpecker/push/woodpecker Pipeline failed Details ci/woodpecker/tag/woodpecker Pipeline failed Details	2024-01-25 15:24:11 +01:00
Wolfgang Hottgenroth	d1bbbeaccf	snmp All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-25 15:13:36 +01:00
Wolfgang Hottgenroth	8cfc92c226	some more views All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-01-15 11:12:23 +01:00
Wolfgang Hottgenroth	08e81e309c	locative handler, config adjusted All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-15 10:16:58 +01:00
Wolfgang Hottgenroth	f44664eaad	locative handler All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-15 10:10:51 +01:00
Wolfgang Hottgenroth	15458b9955	hottisScd30 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-07 18:48:47 +01:00
Wolfgang Hottgenroth	f55990cc57	hottisScd30 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-07 18:23:22 +01:00
Wolfgang Hottgenroth	766355f85d	hottisScd30 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-07 18:14:59 +01:00
Wolfgang Hottgenroth	73aaa2225d	hottisScd30 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2024-01-07 17:28:32 +01:00
Wolfgang Hottgenroth	44b7461d19	fix migrate pv All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-01-04 22:22:19 +01:00
Wolfgang Hottgenroth	c54b335e5f	queries and migrations All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2024-01-03 20:57:26 +01:00
Wolfgang Hottgenroth	956d1bdcdb	fix status in migration All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-28 15:56:30 +01:00
Wolfgang Hottgenroth	b938d48c7f	add status in ttn handlers All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-28 15:48:51 +01:00
Wolfgang Hottgenroth	b374b7f49d	some queries All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-28 13:04:25 +01:00
Wolfgang Hottgenroth	879825a260	format paylaod All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-27 14:21:21 +01:00
Wolfgang Hottgenroth	b6132afb11	disable logging in ttn All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-27 12:14:05 +01:00
Wolfgang Hottgenroth	5e94782575	add RawPayloadPrinter All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-27 12:06:50 +01:00
Wolfgang Hottgenroth	57c63adeb2	handover FrmPayload to model parsers too	2023-12-27 12:00:02 +01:00
Wolfgang Hottgenroth	e209598f9e	secrets All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-24 15:57:53 +01:00
Wolfgang Hottgenroth	03f8f9fade	fix in deploy script All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-24 14:41:49 +01:00
Wolfgang Hottgenroth	fc91a0da2e	change db password approach All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-24 14:28:46 +01:00
Wolfgang Hottgenroth	7d8d8b1c6a	soil hottis All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-24 11:05:37 +01:00
Wolfgang Hottgenroth	ffbda52c36	migration stuff All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-23 22:57:27 +01:00
Wolfgang Hottgenroth	647a2d36e5	saerbeck All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-23 21:57:43 +01:00
Wolfgang Hottgenroth	a8db62ea52	LSE01 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-22 17:28:32 +01:00
Wolfgang Hottgenroth	8e6bea3f19	dt1t and counter and refactoring using embedded interfaces All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-21 13:05:00 +01:00
Wolfgang Hottgenroth	99d678b4b1	dt1t All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-20 17:15:44 +01:00
Wolfgang Hottgenroth	3779547a95	dt1t Some checks failed ci/woodpecker/push/woodpecker Pipeline failed Details	2023-12-20 14:14:55 +01:00
Wolfgang Hottgenroth	caffafdfbc	fix secret name All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-19 14:05:54 +01:00
Wolfgang Hottgenroth	f5d271bba9	add udi-berresheim All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-19 14:01:59 +01:00
Wolfgang Hottgenroth	a69b33ac32	fix ci, 6, remove debug All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-19 13:03:32 +01:00
Wolfgang Hottgenroth	9041034723	fix ci, 5 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-19 12:11:41 +01:00
Wolfgang Hottgenroth	dae37100f5	fix ci, 4 All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-19 12:05:07 +01:00
Wolfgang Hottgenroth	f6728eb898	fix ci, 3 Some checks failed ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline failed Details	2023-12-19 11:56:45 +01:00
Wolfgang Hottgenroth	e18aeed273	fix ci, 2 Some checks failed ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline failed Details	2023-12-19 11:53:08 +01:00
Wolfgang Hottgenroth	4eab542960	fix ci Some checks failed ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline failed Details	2023-12-19 11:50:22 +01:00
Wolfgang Hottgenroth	c77394bf4d	secrets handling, part 2	2023-12-19 11:47:37 +01:00
Wolfgang Hottgenroth	7eb7ec4798	secrets handling	2023-12-19 11:43:29 +01:00
Wolfgang Hottgenroth	bcc74dda29	ci fixed All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-18 22:05:31 +01:00
Wolfgang Hottgenroth	291fec96d1	ci fixed All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-18 21:41:21 +01:00
Wolfgang Hottgenroth	52f1b4680d	ci fixed All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-18 21:35:36 +01:00
Wolfgang Hottgenroth	6398c1978f	deploy script All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-18 18:16:01 +01:00
Wolfgang Hottgenroth	9d435159ce	configMap All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-17 22:47:26 +01:00
Wolfgang Hottgenroth	96377e9572	start deployment stuff All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-17 22:36:13 +01:00
Wolfgang Hottgenroth	ee2c5f31e8	database configuration only via PG* env variables and MQTT password only via configured env var All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-17 13:53:16 +01:00
Wolfgang Hottgenroth	6d932f56c8	groundlevel stuff All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-15 17:29:12 +01:00
Wolfgang Hottgenroth	7ee7d4df89	Dragino parser All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-15 11:44:35 +01:00
Wolfgang Hottgenroth	084f9fbf31	queries All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details	2023-12-14 15:56:04 +01:00
Wolfgang Hottgenroth	b9203c4cb3	fix deploy All checks were successful ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline was successful Details	2023-12-14 11:21:34 +01:00
Wolfgang Hottgenroth	7205f9794a	fix deploy Some checks failed ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline failed Details	2023-12-14 11:17:38 +01:00
Wolfgang Hottgenroth	985d05b0a0	fix deploy Some checks failed ci/woodpecker/push/woodpecker Pipeline was successful Details ci/woodpecker/tag/woodpecker Pipeline failed Details	2023-12-14 11:14:50 +01:00