Entpacken Sie Firestore-Cloud-Ereignisse im Protojson-Format in ein Mapinterface{} oder eine Struktur

In diesem Artikel stellt PHP-Editor Zimo vor, wie man Firestore-Cloud-Ereignisse im Protojson-Format in eine Map[Schnittstelle{}] oder eine Struktur entmarshallt. Firestore ist eine flexible Dokumentendatenbanklösung von Google Cloud und protojson ist ein Tool zum Konvertieren von Protocol Buffers-Daten in das JSON-Format. Für Entwickler bei der Verwendung der Firestore-Datenbank ist es wichtig zu verstehen, wie man Firestore-Cloud-Ereignisse entmarshallt. In diesem Artikel werden die Schritte und Vorsichtsmaßnahmen für das Unmarshalling ausführlich erläutert, damit Entwickler die Funktionen der Firestore-Datenbank besser nutzen können.

Frageninhalt

Gibt es eine einfache Möglichkeit, Firestore-Daten im Protojson-Format in eine Map[string]interface{} oder Struktur zu entmarshalieren, ohne alle Protobuf-Datentyp-Tags zu verwenden? d.h. Protojson-Daten reduzieren.

Ich habe eine Google Cloud-Funktion, die immer dann ausgelöst wird, wenn ein neues Firebase-Dokument erstellt wird („Cloud-Ereignis“). Dieses Cloud-Ereignis enthält Kontextinformationen, einschließlich geänderter Dokumente im Protojson-Format:

import (
    "google.golang.org/protobuf/encoding/protojson"
    "github.com/davecgh/go-spew/spew"
)

func cloudfunction(ctx context.context, e event.event) error {
    data := firestoredata.documenteventdata{}
    _ = protojson.unmarshal(e.dataencoded, &data);

    spew.dump(data)
}

--------console output--------

{
"oldvalue": {},
"value": {
    "createtime": "2023-03-30t00:00:00.000000z",
    "updatetime": "2023-03-30t00:00:00.000000z",
    "name": "projects/myproject/databases/(default)/documents/collectionname/00000000-0000-0000-0000-000000000000",
    "fields": {
        "id": {
        "stringvalue": "00000000-0000-0000-0000-000000000000"
        },
        "action": {
            "stringvalue": "serverdosomething"
        },
        "payload": {
            "mapvalue": {
                "fields": {
                    "questionslist": {
                        "arrayvalue": {
                            "values": [
                                {
                                    "mapvalue": {
                                        "fields": {
                                            "title": {
                                                "stringvalue": "how do i fly a kite?"
                                            },
                                        }
                                    }
                                },
                                {
                                    "mapvalue": {
                                        "fields": {
                                            "title": {
                                            "stringvalue": "how do i fly a plane?"
                                            },
                                        }
                                    }
                                }
                            ]
                        }
                    }
                }
            }
        }
    }
},
"updatemask": {}
}

Ich möchte Teile dieses Protojson-Dokuments in einer benutzerdefinierten Go-Struktur zusammenstellen, um jeden Eintragstyp einfach zu validieren, etwa so:

// cloudeventrequest is a struct that wraps around one or more data validation structs contained in the payload
cloudeventrequest {
    id: "00000000-0000-0000-0000-000000000000"
    action: "serverdostuff"
    payload: map{
        "questionslist": []question{
            question{
                title: "how do i fly a kite?"
            },
            question{
                title: "how do i fly a plane?"
            }
        }
    }
}

Das Firestore-SDK enthält eine Datato-Methode, die das Unmarshalieren von protojson-formatierten Daten in benutzerdefinierte Strukturen erleichtert. Ich versuche etwas sehr Ähnliches zu tun, erhalte die Dokumentdaten jedoch bereits außerhalb des Firestore-SDK.

// datato uses the document's fields to populate p, which can be a pointer to a map[string]interface{} or a pointer to a struct.

func (*firestore.documentsnapshot).datato(p interface{}) error

import (
    "context"
    "cloud.google.com/go/firestore"
)

func FirestoreRead(docEvent firestoredata.DocumentEventData) error {
    ctx := context.Background()

    ref := h.client.Collection("mycollection").Doc(docEvent.value.ID)
    docSnapshot, err := tx.Get(ref)

    dataValidationStruct := CloudEventRequest{}
    err = docSnapshot.DataTo(&dataValidationStruct)
}

Lösung

Ich habe ein Open-Source-Go-Paket namens „firestruct“ geschrieben, um diese Herausforderung zu lösen. Sie finden es hier: github.com/bennovw/firestruct Ihr Feedback und Ihre Beiträge sind herzlich willkommen!

Am Ende habe ich eine Funktion geschrieben, die Firestore-Felder rekursiv in passende Karten entpackt. Anschließend habe ich die DataTo()-Methode in cloud.google.com/go/firestore umgestaltet, um meine Karte in eine Struktur zu entmarshalieren.

Das obige ist der detaillierte Inhalt vonEntpacken Sie Firestore-Cloud-Ereignisse im Protojson-Format in ein Mapinterface{} oder eine Struktur. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!