UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?

[legro]

@mickym sagte in JSON Objekte in Liste:

@legro Ja wie gesagt das nützt nichts, ich gehe ja davon aus, dass Dein Array weiter wächst.

Wenn ich in dem Beispiel-ARRAY mit den Zahlen Elemente ergänze, wird doch alles dynamisch bereits berücksichtigt. Das Ganze funktioniert doch schon wie gewünscht. Oder wo liegt mein Denkfehler?

[mickym]

@legro Ja da funktioniert es auch aber ich komme mit den Objekten noch nicht klar - ich versuch das nun mal mit bissi Code. Hab einfach bissi Geduld.

[legro]

@mickym sagte in JSON Objekte in Liste:

@legro Ja da funktioniert es auch aber ich komme mit den Objekten noch nicht klar - ich versuch das nun mal mit bissi Code. Hab einfach bissi Geduld.

Du kannst gerne alle Zeit der Welt haben. Wenn du bei der Anpassung an meinen Beispielcode noch überlegen muss, habe ich gar keinen Mut das Beispiel daraufhin zu erweitern.

Kannst du bitte die neue Struktur verwenden?

[mickym]

@legro Ja mach ich

[mickym]

So ich habs fertig. Deine Formel stimmt meines Erachtens auch nicht - aber so dürfte das nun gehen.

https://try.jsonata.org/p-SrPKlgy

Die Summe ist nun: 1213.29

(gerundet)

Wenn Du die Aufsummierung weglässt, siehst Du das Ergebnis jedes Blocks:

[
  190.3172341,
  0,
  1022.9705301
]

Grundsätzlich würde ich aber mit Sonderzeichen aufpassen - also Umlauten auch wenn es hier im Moment kein Problem gibt

Man kann das Ganze auch ohne Programm schreiben:

https://try.jsonata.org/AUkOIVcjP

ABER - deine 1. Struktur war viel besser. ....

damit geht es in einer Zeile: https://try.jsonata.org/1lDqzoiKc

Das liegt daran weil Du das Objekt Stände benannt hast. Sowas ist wesentlich besser, als unbenannte Objekte in einem Array aneinanderzureihen. Ich hätte auch deine jetzige Struktur in die alte Struktur überführen können, hängt halt davon ab, wie Du die erzeugst.

Nachtrag:

Im Prinzip ist es egal - ob Du mit einem 0 Wert anfängst oder nicht - es wird halt immer brav die Differenz zwischen einem Objekt und seinem Vorgänger ermittelt und wenn das Stände Array nur ein Objekt enthält, wird 0 zurückgegeben.

Und das Array kann nun beliebig wachsen.

[legro]

@mickym

Vielen herzlichen Dank für die vielen Mühen, die du sicherlich trotz deinem großen Können hast auf dich genommen. Wie ich befürchtet habe: Das Ganze war gleich mehrere Nummern zu groß für einen Anfänger wie mich. Da du jedoch gleich mehrere Lösungen anbietest, habe ich Hoffnung, wenigstens die ein oder andere zu verstehen.

[mickym]

@legro Du musst halt fragen, wenn Du was nicht verstehst. Kern ist dieses Mal das nutzen der $reduce Funktion: https://docs.jsonata.org/higher-order-functions#reduce

Diese verwendet man generell, wenn man mehrere Werte in einem Zusammenfassen will.

Sowas kannst Du wenn Du das lieber machst auch in Blockly machen. Ich behaupte nur mal, da brauchst Du 10 mal soviel Code bzw. Puzzleteilchen.

[legro]

@mickym sagte in JSON Objekte in Liste:

@legro Du musst halt fragen, wenn Du was nicht verstehst. Kern ist dieses Mal das nutzen der $reduce Funktion: https://docs.jsonata.org/higher-order-functions#reduce

Die hatte ich mir angeschaut, während ich auf deine Lösungen wartete. Mich überfordert das Ganze noch gewaltig. Allein um weitere Fragen zu stellen, muss ich erst einmal die eine oder andere Grundlage sicher verstanden haben.

Sowas kannst Du wenn Du das lieber machst auch in Blockly machen. Ich behaupte nur mal, da brauchst Du 10 mal soviel Code bzw. Puzzleteilchen.

Da kann ich dir nur zustimmen. Während du hier für mich die Lösung in JSONata erstellt hast, hatte ich parallel dazu versucht, meine Ziele via Blockly zu realisieren. Selbstverständlich stampfe ich dieses Vorhaben ein, verfüge ich doch nun über deine großartige Lösung in JSONata.

Meine nächste Vorhaben ..

• Ich möchte in das jeweils letzte ARRAY-Element den jeweils aktuellen Zählerstand schreiben.
• Ich möchte ein weiteres ARRAY-Element (Zählerstand) an-/einfügen.

Hierzu bietet Blockly erst gar nichts an. Ich denke, dass ich mit den Blöcken ..

.. das realisiert bekomme.

[mickym]

@legro na dann musst Du wieder JS programmieren. Wie gesagt ich bin kein Blockly Spezialist, das kann @paul53 viel besser, aber

mit diesem Baustein solltest Du das Array erweitern können.

und wenn Du auf setze änderst, wird das letzte Element geändert

Aber wie gesagt musst ausprobieren. Ich nutze das Tool sonst nicht.

[legro]

@mickym sagte in JSON Objekte in Liste:

Aber wie gesagt musst ausprobieren.

In der Tat.

Ich entnehme das Objekt ja aus einem Datenpunkt, der nach meinem Verständnis ja bloß einen JSON-Text enthält. Schreiben sollte ich jedoch nur auf die Felder des aus diesem Text erzeugten Objektes können. Somit sollte nach den Änderungen das Ganze wieder zurück als Text in den Datenpunkt geschrieben werden.

Mal sehen, ob ich mit dieser Strategie ans Ziel komme.

[legro]

[@mickym sagte in JSON Objekte in Liste:

@legro Du musst halt fragen, wenn Du was nicht verstehst. ..

Dann will ich dich mal beim Wort nehmen. Während du für mich deine Lösungen zusammengebastelt hast, war ich nämlich nicht untätig.

Nachdem wir ja die Aufgabenstellung zerlegt hatten in ..

1. Summe der Produkte (Wert * Energiepreis) und ..
2. Summe der Differenzen auf einanderfolgender ARRAY-Elemente, ..

.. versuchte ich aus diesen beiden Gedanken die Lösung zusammenzubasteln. Leider mit viel wenig Erfolg.

1. Produktsumme

In diesem ARRAY galt es nun mittels der ersten Idee die Differenzsummen zu bilden, was mir nicht gelang, weil ich diese deine oben angegebene Lösung hierzu letztendlich wohl nicht tiefgreifend genug verstanden habe.

2. Differenzsumme

Die Kodierung $#$i.[$$[$i+1]-$$[$i]] verstehe ich nur teilweise. Hier, was ich glaube, verstanden zu haben ..

• $ steht für einen relativen Pfad. (Am Anfang hätte also auch $$ stehen können.)
• $$ steht für den absoluten (gesamten) Pfad von Beginn an.
• $i steht für eine - nennen wie sie mal - Hilfsvariable (und könnte auch ganz anders heißen).
• Aber was macht der Operator '#' genau? Pappt er (wie auch '@') den Pfad aus $ an die Variable $i und bezeichnet damit in der Ausgabe das ermittelte ARRAY-Element (Differenz).
• [$$[$i+1]-$$[$i]] bildet die Differenz zweier aufeinander folgender Element, die durch die Indizes $i und $i+1 referenziert werden.

Was ich mich frage ..

• Könnte man nicht die beiden Ansätze 1. und 2. zu einer Lösung zusammenfügen? Wenn ja, wie?
• Was mich nach wie vor völlig verwirrt, ist die Tatsache, dass keinerlei Syntax auf eine Kontrollstruktur (hier wird ja wohl eine Schleife erzeugt) zu sehen ist.
• Auch verstehe ich nicht, warum ich nicht in Anlehnung aus deiner Lösung zu 2. in 1. hätte kodieren können [ZählerStände.Bezug[$i].Wert * ZählerStände.Bezug[$i].Wert.Energiepreis]

[mickym]

@legro sagte in JSON Objekte in Liste:

[@mickym sagte in JSON Objekte in Liste:

@legro Du musst halt fragen, wenn Du was nicht verstehst. ..

Dann will ich dich mal beim Wort nehmen. Während du für mich deine Lösungen zusammengebastelt hast, war ich nämlich nicht untätig.

Nun manches kann ich erklären, manches nicht. Manchmal muss ich auch ausprobieren und ich habe auch erst lange gebraucht bis ich es einigermaßen verstanden habe. Manches habe ich aber auch nicht verstanden. Was ich nicht verstehe, warum DU nicht meine endgültige Lösung nimmst, die funktioniert (nämlich die mit der $reduce Funktion). Die lässt Du bei den Fragen hier komplett außen vor.

Grundsätzlich ist es so, dass JSONATA eine mächtige Bibliothek ist, aber kein Compiler und auch kein Interpreter, wie Du ihn bei klassischen Programmiertools findest. Deswegen kannst Du JSONATA in andere Tools einbinden, aber es hat kein Gedächtnis. Deshalb schon mal ein Grundsatz, den Du Dir unbedingt merken musst.
JSONATA arbeitet einfach die Anweisungen von links nach rechts (oder oben nach unten ab) und kann NICHT auf Ergebnisse zurückgreifen oder auf Strukturen zurückgreifen, die sich während der Abarbeitung ergeben. Du hast lediglich den Anker $$, der immer auf das unverfälschte Eingangsobjekt zugreifen kann. $ hingegen enthält immer den aktuellen Kontext, der NICHT fest ist sondern wo Du Dich gerade in einer Objekthierarchie befindest. Das musst Du im Hinterkopf haben und deshalb funktioniert das Kombinieren der beiden Methoden mit komplexen Objekten eben nicht und ich habe auf die $reduce Funktion zurück gegriffen.

Nachdem wir ja die Aufgabenstellung zerlegt hatten in ..

1. Summe der Produkte (Wert * Energiepreis) und ..
2. Summe der Differenzen auf einanderfolgender ARRAY-Elemente, ..

.. versuchte ich aus diesen beiden Gedanken die Lösung zusammenzubasteln. Leider mit viel wenig Erfolg.

Die Differenzsumme mit diesen Mitteln zu erreichen, ist von der Syntax sehr kompliziert, weil Du IMMER den vollständigen Pfad von der Wurzel aus referenzieren musst. Bei dem einfachen Array ging das - deswegen ist die $reduce Funktion wesentlich besser, da Du hier sowohl relativ als auch auf den Dich beziehenden Teil des Arrays Dich beziehen kannst.

1. Produktsumme

In diesem ARRAY galt es nun mittels der ersten Idee die Differenzsummen zu bilden, was mir nicht gelang, weil ich diese deine oben angegebene Lösung hierzu letztendlich wohl nicht tiefgreifend genug verstanden habe.

Das ist eine geniale Möglichkeit von JSONATA, das funktioniert aber nur innerhalb von Objekten, die ein Index gerade durchläuft. DU kannst NICHT auf Elemente vorher und hinterher zurückgreifen, da JSONATA die nicht kennt. Zumindest nicht ohne Dich wieder auf das root-Objekt zu beziehen und nicht im aktuellen Kontext.

2. Differenzsumme

Die Kodierung $#$i.[$$[$i+1]-$$[$i]] verstehe ich nur teilweise. Hier, was ich glaube, verstanden zu haben ..

• $ steht für einen relativen Pfad. (Am Anfang hätte also auch $$ stehen können.)

Ja für den aktuellen Kontext. Stimmt am Anfang entspricht $ = $$. Sobald Du aber ein Objekt darunter ansprichst z.Bsp. $.Zählerstände - enthält nun die Variable $ das Array aber nicht mehr das gesamte Objekt wie $$.

• $$ steht für den absoluten (gesamten) Pfad von Beginn an.

Einfach das GESAMTE Objekt oder Array (so wie es im linken Fenster steht)

• $i steht für eine - nennen wie sie mal - Hilfsvariable (und könnte auch ganz anders heißen).
  Ja - ich hätte es auch $index nennen können. Alle Variablen in JSONATA beginnen mit einem $

• Aber was macht der Operator '#' genau? Pappt er (wie auch '@') den Pfad aus $ an die Variable $i und bezeichnet damit in der Ausgabe das ermittelte ARRAY-Element (Differenz).

Er weist der darauffolgenden Variable den aktuellen Index, der beim Durchlaufen eines Arrays gebildet wird. Wenn Du Dein Array Zählerstände anschaust, dann hat es genau 3 Elemente, die kannst Du so referenzieren.

https://try.jsonata.org/Car4x9aq9

• [$$[$i+1]-$$[$i]] bildet die Differenz zweier aufeinander folgender Element, die durch die Indizes $i und $i+1 referenziert werden.

Was ich mich frage ..

• Könnte man nicht die beiden Ansätze 1. und 2. zu einer Lösung zusammenfügen? Wenn ja, wie?

Ich habe es mal gemacht und habe den Ansatz 2 aus der Differensumme mit Deinem Objekt berechnet:
https://try.jsonata.org/iqLO5ZyO9

[$sum($.ZählerStände.Bezug#$Index.[($$.ZählerStände.Bezug[$Index+1].Wert-$$.ZählerStände.Bezug[$Index].Wert)/1000 * $$.ZählerStände.Bezug[$Index+1].Energiepreis]),
$sum($.ZählerStände.Verkauf#$Index.[($$.ZählerStände.Verkauf[$Index+1].Wert-$$.ZählerStände.Verkauf[$Index].Wert)/1000 * $$.ZählerStände.Verkauf[$Index+1].Energiepreis]),
$sum($.ZählerStände.Erzeugt#$Index.[($$.ZählerStände.Erzeugt[$Index+1].Wert-$$.ZählerStände.Erzeugt[$Index].Wert)/1000 * $$.ZählerStände.Erzeugt[$Index+1].Energiepreis])]

• Was mich nach wie vor völlig verwirrt, ist die Tatsache, dass keinerlei Syntax auf eine Kontrollstruktur (hier wird ja wohl eine Schleife erzeugt) zu sehen ist.

Das ist das geniale an JSONATA mit dem MAP Operator durchläufst Du automatisch ein Array. Und der Map Operator ist ein "Punkt" .

https://docs.jsonata.org/path-operators#-map

Also wo Du in anderen Programmiersprachen ein ewiges Konstrukt mit for() und irgendwelchen Schleifen machen musst, langt es in JSONATA hinter einem Array einen Punkt zu machen und es wird durchlaufen. Ist ja an diesem Beispiel schön zu sehen:

• Auch verstehe ich nicht, warum ich nicht in Anlehnung aus deiner Lösung zu 2. in 1. hätte kodieren können [ZählerStände.Bezug[$i].Wert * ZählerStände.Bezug[$i].Wert.Energiepreis]

Wie gesagt ich hab es Dir ja nach der 2. Methode nun codiert, obwohl die $reduce Funktion einfacher ist, zumindest wenn Du die Objekte benennst, wie hier: https://try.jsonata.org/1lDqzoiKc

So streng genommen um Lösung 1 und 2 kombinieren - muss man halt statt der eckigen runde Klammern verwenden:

[$sum($.ZählerStände.Bezug#$Index.(($$.ZählerStände.Bezug[$Index+1].Wert-$$.ZählerStände.Bezug[$Index].Wert)/1000 * $$.ZählerStände.Bezug[$Index+1].Energiepreis)),
$sum($.ZählerStände.Verkauf#$Index.(($$.ZählerStände.Verkauf[$Index+1].Wert-$$.ZählerStände.Verkauf[$Index].Wert)/1000 * $$.ZählerStände.Verkauf[$Index+1].Energiepreis)),
$sum($.ZählerStände.Erzeugt#$Index.(($$.ZählerStände.Erzeugt[$Index+1].Wert-$$.ZählerStände.Erzeugt[$Index].Wert)/1000 * $$.ZählerStände.Erzeugt[$Index+1].Energiepreis))]

https://try.jsonata.org/O15UAuwUB

Im Prinzip kann man bei der 2. Methode auch runde Klammern verwenden. So sind 1 und 2 kombiniert. Manchmal liegts bei mir auch am Probieren, bis ich es verstehe.

$#$i.($$[$i+1]-$$[$i])

funktioniert also genauso und ist im Prinzip - Methode 1 nur mit jeweiligem Bezug zum Root-Objekt

Schau Dir bitte alle Beispiele und Links an, sonst wirst Du es nicht verstehen - hoffe nun aber Klarheit in die Sache gebraucht zu haben und habe nun nach der 2. Methode (Differenzsumme) auch Deine Werte kalkuliert.

[legro]

@mickym

Vielen Dank für deine sehr ausführliche Antwort.

Vorab ..

Eines hast du leider vermutlich völlig falsch eingeschätzt; daher hier zur Klarstellung: Deine Lösung ist hervorragend, ich habe sie verstanden und selbstverständlich ist sie bereits in Verwendung.

Selbstverständlich erwarte ich nicht, dass du mir sozusagen eine Einführung in die Verwendung von JSONata gibst. Meine Hoffnung war, dass du das eine oder andere zu erklären weißt, was mir weiterhilft, mich tiefer in diese Thematik einfinden zu können. In der Tat verstehe ich mit deiner Hilfe jetzt einiges mehr und besser. Danke hierfür!

Ich geb's zu. Ich gehöre zur vorletzten Generation und verstehe Informatik anders als sie heute offenbar kolportiert wird. Es gab eine klare Syntax, anhand derer man seine Konstrukte konstruieren/prüfen konnte. So fehlt mir etwa in JSONata etwa eine Antwort auf die Frage, warum von meinen beiden Versuchen nur einer funktioniert. Sei's d'rum! Ich habe deine Lösung, die's tut. Das soll's gewesen sein.

Ich bin derzeit dabei, in den Ausdrücken ..

    {
      "Name": "Bezug",
      "Stände": [
        {
          "Datum": "0000-00-00",
          "Energiepreis": 0,
          "Wert": 0
        },
        {
          "Datum": "2023-01-01",
          "Energiepreis": 0.3963,
          "Wert": 468303
        },
        {
          "Datum": "2023-06-30",
          "Energiepreis": 0.3328,
          "Wert": 482512
        }
      ]
    },

.. schreibend auf die Felder "Wert" zuzugreifen. Mit Blockly scheint das gar nicht so einfach zu sein.

[mickym]

@legro sagte in JSON Objekte in Liste:

Selbstverständlich erwarte ich nicht, dass du mir sozusagen eine Einführung in die Verwendung von JSONata gibst. Meine Hoffnung war, dass du das eine oder andere zu erklären weißt, was mir weiterhilft, mich tiefer in diese Thematik einfinden zu können.

Na ich hoffe, ich habe Deine Erwartungen nicht enttäuscht. Ich habe doch alle Fragen beantwortet. Deswegen verstehe ich Deine Formulierung

meine Hoffnung war, ....

nicht. Was fehlt Dir denn an meinen Erklärungen?

So fehlt mir etwa in JSONata etwa eine Antwort auf die Frage, warum von meinen beiden Versuchen nur einer funktioniert.

Habe ich doch lang und breit erklärt. Was gefällt Dir an meinen Erklärungen nicht?

[mickym]

@legro Blockly kann nicht so einfach mit Objekten um gehen.

Das ist ein Riesennachteil von Blockly weswegen ich es nicht mag, deswegen halt JSONATA verwenden und ich zeig Dir wie man das in Blockly integrieren kann.

https://try.jsonata.org/r0XmLrKQc

Hier siehst Du wie ich das letzte Arrayelement mit JSONATA auf das heutige Datum und auf 500000 verändere

Die JSONATA Anweisung zum Updaten ist die hier:

$ ~> |ZählerStände[Name = "Bezug"].Stände[-1]|{"Datum": "2023-07-06","Wert": 500000}|

Verwendet wird der Transform Operator: https://docs.jsonata.org/other-operators#-------transform

das Referenzieren von Array-Elementen mit negativen Zahlen - kann übrigens auch nur JSONATA und nicht Javascript:
siehe hier:
https://docs.jsonata.org/simple#navigating-json-arrays

Nun in Blockly musst Du halt den JSONATA Ausdruck konstruieren.

[legro]

@mickym

Bitte nicht gleich jede Formulierung sozusagen als Kritik an deinen Antworten auslegen. Mein Klagen bezog sich auf die Dokumentation von JSONata und keinesfalls auf deine Antworten. Hier ging es mir um meine (noch) beschränkte Verständnisfähigkeiten.

Es tut mir leid, wenn ich mich hier so unglücklich ausgedrückt habe.

Übrigens, was du in deiner letzten Antwort schreibst, genau das versuche ich derzeit mit Blockly zu erreichen - leider (noch) mit viel wenig Erfolg.

Die hier dargestellten Blöcke zeigen das Dilemma. Ich verstehe - als einer aus der vorletzten Generation - das Ganze folgendermaßen ..

• Der Block "setzt Obj auf JSON nach Objekt .." allokiert im Speicher einen Datensatz als Abbild der JSON-Datenstruktur.
• Mittels des zweiten Blocks "setze Wert auf Attribut ".." .." wird lesend auf die Speicherzelle des im Speicher allokierten Objektes zugegriffen. Dieser zweite Block bewirkt jedoch offenbar bloß eine neue Allokation des referierten Wertes aus dem Obj, indem eine Kopie in die Variable "Wert" geschrieben wird.

Was ich jedoch benötige, wäre eine Referenz (pointer) auf die Speicherzelle von "ZählerStände.0.Bezug.1.Wert" innerhalb der im Speicher allokierten Variable Obj. In den mir über die Jahrzehnte bekannten Sprachen konnte ich die Variablen dezidiert einmal als reference (pointer) oder value (Kopie des Inhalts) kodieren.

Ja, so denkt unsereiner, der noch aus der vorletzten Generation stammt.

Jetzt hilft wohl nur noch JavaScript weiter!?

[mickym]

@legro sagte in JSON Objekte in Liste:

Übrigens, was du in deiner letzten Antwort schreibst, genau das versuche ich derzeit mit Blockly zu erreichen - leider (noch) mit viel wenig Erfolg.

Ich arbeite daran. - Leider ist Blockly auch bei Textersetzungen so was von schlecht, dass man da besser JSONATA zur Hilfe nimmt, wenn Du nicht JS Funktionen schreiben willst. Ich nehm aber für Textersetzungen wohl auch besser eine Javascript Funktion. Du solltest wirklich auf NodeRed umsteigen - das Blockly ist für solche Dinge einfach nur grottenschlecht. Aber ich machs.

[mickym]

@legro sagte in JSON Objekte in Liste:

Jetzt hilft wohl nur noch JavaScript weiter!?

Jein - warte mal - ich nehm jetzt mal Javascript für Textersetzungen - da selbst dass Blockly nicht kann. Ich kann Dir nur sagen, steig auf NodeRed um - ich bin auch nicht mehr der Jüngste aber Du wirst begeistert sein. So ich mach aber ein Blockly für Dich.

[legro]

@mickym sagte in JSON Objekte in Liste:

@legro sagte in JSON Objekte in Liste:

Jetzt hilft wohl nur noch JavaScript weiter!?

Jein - warte mal - ich nehm jetzt mal Javascript für Textersetzungen - da selbst dass Blockly nicht kann. Ich kann Dir nur sagen, steig auf NodeRed um - ich bin auch nicht mehr der Jüngste aber Du wirst begeistert sein. So ich mach aber ein Blockly für Dich.

Auf NodeRed möchte ich nicht umsteigen müssen, obwohl ich nach meinen Erfahrungen mit deinen Hilfestellungen deinem Urteil absolut vertraue. Ich habe, seit ich im Ruhestand bin, eine Hausautomatisierung auf Basis von ioBroker aufgebaut. Wollte ich die auf NodeRed umstellen, ist zu befürchten, dass ich gar nicht mehr lange genug lebe, die Früchte dieser Arbeit genießen zu können.

[mickym]

@legro sagte in JSON Objekte in Liste:

@mickym sagte in JSON Objekte in Liste:

@legro sagte in JSON Objekte in Liste:

Jetzt hilft wohl nur noch JavaScript weiter!?

Jein - warte mal - ich nehm jetzt mal Javascript für Textersetzungen - da selbst dass Blockly nicht kann. Ich kann Dir nur sagen, steig auf NodeRed um - ich bin auch nicht mehr der Jüngste aber Du wirst begeistert sein. So ich mach aber ein Blockly für Dich.

Auf NodeRed möchte ich nicht umsteigen müssen, obwohl ich nach meinen Erfahrungen mit deinen Hilfestellungen deinem Urteil absolut vertraue. Ich habe, seit ich im Ruhestand bin, eine Hausautomatisierung auf Basis von ioBroker aufgebaut. Wollte ich die auf NodeRed umstellen, ist zu befürchten, dass ich gar nicht mehr lange genug lebe, die Früchte dieser Arbeit genießen zu können.

Nein das stimmt nicht - weil Du ja beides parallel betreiben kannst. Ich meine ja nicht das iobroker System wegschmeissen, sondern nur NodeRed (als Adapter hier im iobroker) anstelle Blockly als Logikmaschine zu verwenden. Du kannst das zum Beispiel auch jetzt machen - ohne deine bisherigen Blocklies anzufassen.
Ausserdem kannst Du selbst entscheiden, ob Du dann später einzelne Blocklies in NodeRed konverierst.

Nun habe ich aber Dein Blockly fertig zusammen mit JSONATA.

Weitere Erklärungen folgen gleich.

Im neuen Datum und im neuen Wert als Variable einfach das halt reingeben was Du aus Deinen Datenpunkten/Adaptern holst.

Den JSONATA Ausdruck zum Aktualisieren des letzten Objektes unter Bezug hatte ich Dir ja gepostet. Ich habe nur die beiden Werte zum aktualisieren - ein Dummytext verwendet.

$ ~> |ZählerStände[Name = "Bezug"].Stände[-1]|{"Datum": "-neuesDatum-","Wert": -neuerWert-}|

Diese beiden Texte -neues Datum- und -neuerWert- ersetze ich nun durch die Variablen "neues Datum" und "neuer Wert".
Da dieses Blockly in seinen Textbausteinen (zumindest hab ich nichts gefunden) kein Suchen und Ersetzen hat habe ich eine JS Funktion implementiert.

Diese nimmt 3 Parameter auf.

1. Den Text der geändert werden soll
2. Welche Stelle geändert werden soll
3. Mit was ersetzt wird.

Der dahinterstehende JS Code - ist banal. - auch wenn ich nicht weiß warum man hier auf Text2 referenzieren muss.

return Text2.replace(Suche,ErsetzeMit);

Somit wird also das neue Datum

im Ausdruck durch den Inhalt der Variable ersetzt.

bei dem neuen Wert analog.

Im Debug siehst Du das dann:

Mit dem JSONATA Ausdruck aktualisierst Du dann Dein Objekt.

Somit wird aus:

Korrespondierende Stellen sind farblich ähnlich markiert.

Hier zum Import das gesamte Blockly:

Spoiler

<xml xmlns="https://developers.google.com/blockly/xml">
 <variables>
   <variable id="Ecm2OgfZ8GI=K~naW9FW">Text</variable>
   <variable id="uQ6ik6Rp*f%TY48I.?KS">Suche</variable>
   <variable id="1A,HmaVf6-tm#bCww00G">ErsetzeMit</variable>
   <variable id="NWR;`_N@3a:sTiBKQkne">Objekt</variable>
   <variable id="9u8X/Eqh]Ug6kT2?)@]y">neues Datum</variable>
   <variable id="b5?do~@03)oSd?w4b/=O">neuer Wert</variable>
   <variable id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</variable>
 </variables>
 <block type="procedures_defcustomreturn" id="%8$N60_9!!Uf5a$$-#AX" x="-1138" y="-412">
   <mutation statements="false">
     <arg name="Text" varid="Ecm2OgfZ8GI=K~naW9FW"></arg>
     <arg name="Suche" varid="uQ6ik6Rp*f%TY48I.?KS"></arg>
     <arg name="ErsetzeMit" varid="1A,HmaVf6-tm#bCww00G"></arg>
   </mutation>
   <field name="NAME">Textersetzen</field>
   <field name="SCRIPT">cmV0dXJuIFRleHQyLnJlcGxhY2UoU3VjaGUsRXJzZXR6ZU1pdCk7</field>
   <comment pinned="false" h="80" w="160">Beschreibe diese Funktion …</comment>
 </block>
 <block type="variables_set" id="M@F*zUMa;{#yJo2.2goG" x="-1137" y="-337">
   <field name="VAR" id="NWR;`_N@3a:sTiBKQkne">Objekt</field>
   <value name="VALUE">
     <block type="convert_json2object" id="wV#~g_#qRM}fhgD[;waT">
       <value name="VALUE">
         <block type="text" id="7@h4[@Y-M.M.tsLuCU56">
           <field name="TEXT">{   "ZählerStände": [     {       "Name": "Bezug",       "Stände": [         {           "Datum": "0000-00-00",           "Energiepreis": 0,           "Wert": 0         },         {           "Datum": "2023-01-01",           "Energiepreis": 0.3963,           "Wert": 468303         },         {           "Datum": "2023-06-30",           "Energiepreis": 0.3328,           "Wert": 482512         }       ]     },     {       "Name": "Verkauf",       "Stände": [         {           "Datum": "0000-00-00",           "Energiepreis": 0,           "Wert": 0         },         {           "Datum": "2023-01-01",           "Energiepreis": 0.082,           "Wert": 0         },         {           "Datum": "2023-06-30",           "Energiepreis": 0.082,           "Wert": 0         }       ]     },     {       "Name": "Erzeugt",       "Stände": [         {           "Datum": "0000-00-00",           "Energiepreis": 0,           "Wert": 0         },         {           "Datum": "2023-01-01",           "Energiepreis": 0.3963,           "Wert": 2510191         },         {           "Datum": "2023-06-30",           "Energiepreis": 0.3328,           "Wert": 2597930         }       ]     }   ] }</field>
         </block>
       </value>
     </block>
   </value>
   <next>
     <block type="debug" id="9S+u#Vzo/zuptK|}o,?9">
       <field name="Severity">log</field>
       <value name="TEXT">
         <shadow type="text" id="COg%Nwdd92sEj=QP[Lt)">
           <field name="TEXT">test</field>
         </shadow>
         <block type="variables_get" id="N=A4,QQsE8/8~[BL])Xc">
           <field name="VAR" id="NWR;`_N@3a:sTiBKQkne">Objekt</field>
         </block>
       </value>
       <next>
         <block type="variables_set" id="k.1XtKn$8B-y3gL%:f.-">
           <field name="VAR" id="9u8X/Eqh]Ug6kT2?)@]y">neues Datum</field>
           <value name="VALUE">
             <block type="text" id="5@NN=W}#{Jh6M-|kUH^[">
               <field name="TEXT">2023-07-06</field>
             </block>
           </value>
           <next>
             <block type="variables_set" id="l4S9d+HMDqUB1T/,OxPm">
               <field name="VAR" id="b5?do~@03)oSd?w4b/=O">neuer Wert</field>
               <value name="VALUE">
                 <block type="text" id="l.okZ;;D[ZLfm/gi@6hS">
                   <field name="TEXT">520000</field>
                 </block>
               </value>
               <next>
                 <block type="variables_set" id="QyDxg]4E#TKf|eK6:VER">
                   <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                   <value name="VALUE">
                     <block type="text" id="sKl-kQyq({+ymSEB,jE+">
                       <field name="TEXT">$ ~&gt; |ZählerStände[Name = "Bezug"].Stände[-1]|{"Datum": "-neuesDatum-","Wert": -neuerWert-}|</field>
                     </block>
                   </value>
                   <next>
                     <block type="debug" id="!_829~nwqQFuY32{MH~:">
                       <field name="Severity">log</field>
                       <value name="TEXT">
                         <shadow type="text" id="{eQ7UY*O`Z-67f0;Y[yV">
                           <field name="TEXT">test</field>
                         </shadow>
                         <block type="variables_get" id="VnIOH%}+/fC-S6S[:2`C">
                           <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                         </block>
                       </value>
                       <next>
                         <block type="variables_set" id="QHrof-UDHIQ_;fIhHaW%">
                           <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                           <value name="VALUE">
                             <block type="procedures_callcustomreturn" id="vK7EZ646K9j}n;v%MKno">
                               <mutation name="Textersetzen">
                                 <arg name="Text"></arg>
                                 <arg name="Suche"></arg>
                                 <arg name="ErsetzeMit"></arg>
                               </mutation>
                               <value name="ARG0">
                                 <block type="variables_get" id="9ud0X|_*(eIlG,Cw;XR?">
                                   <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                                 </block>
                               </value>
                               <value name="ARG1">
                                 <block type="text" id="h)@hKKIXRZPv%7i-%FP+">
                                   <field name="TEXT">-neuesDatum-</field>
                                 </block>
                               </value>
                               <value name="ARG2">
                                 <block type="variables_get" id="24j_WUdw2qM]{,!T:A#I">
                                   <field name="VAR" id="9u8X/Eqh]Ug6kT2?)@]y">neues Datum</field>
                                 </block>
                               </value>
                             </block>
                           </value>
                           <next>
                             <block type="variables_set" id="h^_Nx6jY^iKU2cxl{z*D">
                               <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                               <value name="VALUE">
                                 <block type="procedures_callcustomreturn" id="^.zPIF+|ECBT!VyZh|:W">
                                   <mutation name="Textersetzen">
                                     <arg name="Text"></arg>
                                     <arg name="Suche"></arg>
                                     <arg name="ErsetzeMit"></arg>
                                   </mutation>
                                   <value name="ARG0">
                                     <block type="variables_get" id="0H[@K-TQ+j:2?YXLuFsY">
                                       <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                                     </block>
                                   </value>
                                   <value name="ARG1">
                                     <block type="text" id="J]uql_B_Ah99|[?Kqg`]">
                                       <field name="TEXT">-neuerWert-</field>
                                     </block>
                                   </value>
                                   <value name="ARG2">
                                     <block type="variables_get" id="EzQAy(X?|J.wwiIO~0Ty">
                                       <field name="VAR" id="b5?do~@03)oSd?w4b/=O">neuer Wert</field>
                                     </block>
                                   </value>
                                 </block>
                               </value>
                               <next>
                                 <block type="debug" id="8q-q]*bOU4}Y,_iXC?g8">
                                   <field name="Severity">log</field>
                                   <value name="TEXT">
                                     <shadow type="text" id="z{,C85)D6K=@u2QbXPwa">
                                       <field name="TEXT">test</field>
                                     </shadow>
                                     <block type="variables_get" id="-O~0B:dy$tuF_D~jyC%%">
                                       <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                                     </block>
                                   </value>
                                   <next>
                                     <block type="debug" id="^5#in-UU}%!K~KPOKHz_">
                                       <field name="Severity">log</field>
                                       <value name="TEXT">
                                         <shadow type="text" id="-,TGC$b5|aHgxT-/9J]`">
                                           <field name="TEXT">test</field>
                                         </shadow>
                                         <block type="convert_jsonata" id="lJ3pgV,d!Gi]8s,TMKUf">
                                           <value name="EXPRESSION">
                                             <shadow type="text" id="$?E[/Hc*GGc|PsLH./zl">
                                               <field name="TEXT">$ ~&gt; |ZählerStände[Name = "Bezug"].Stände[-1]|{"Datum": "2023-07-06","Wert": 500000}|</field>
                                             </shadow>
                                             <block type="variables_get" id="@bh(Gu.?bybsmVE,%;NA">
                                               <field name="VAR" id="GwCfcA.)Sm4A[NF{ep7K">JSONATA</field>
                                             </block>
                                           </value>
                                           <value name="TARGET">
                                             <block type="variables_get" id="$EtNHY[c50V=?^FK.SM-">
                                               <field name="VAR" id="NWR;`_N@3a:sTiBKQkne">Objekt</field>
                                             </block>
                                           </value>
                                         </block>
                                       </value>
                                     </block>
                                   </next>
                                 </block>
                               </next>
                             </block>
                           </next>
                         </block>
                       </next>
                     </block>
                   </next>
                 </block>
               </next>
             </block>
           </next>
         </block>
       </next>
     </block>
   </next>
 </block>
</xml>

Aber wie gesagt mit dem Blockly gebe ich hier nur ein Gastspiel. - Und nochmal man muss nicht auf NodeRed umsteigen, kann es aber zusätzlich benutzen.