Réunissez les événements cloud Firestore au format protojson dans une mapinterface {} ou une structure

Dans cet article, l'éditeur PHP Zimo présentera comment désorganiser les événements cloud Firestore au format protojson dans une carte[interface{}] ou une structure. Firestore est une solution de base de données de documents flexible fournie par Google Cloud, et protojson est un outil permettant de convertir les données des tampons de protocole au format JSON. Comprendre comment désorganiser les événements cloud Firestore est une compétence importante pour les développeurs lorsqu'ils utilisent la base de données Firestore. Cet article expliquera en détail les étapes et les précautions à prendre pour aider les développeurs à mieux utiliser les fonctions de la base de données Firestore.

Contenu de la question

Existe-t-il un moyen simple de regrouper les données Firestore au format protojson dans une map[string]interface{} ou une structure sans utiliser toutes les balises de type de données protobuf ? c'est-à-dire aplatir les données de protojson.

J'ai une fonction Google Cloud qui se déclenche chaque fois qu'un nouveau document Firebase est créé ("événement cloud"). Cet événement cloud contient des informations contextuelles, notamment des documents modifiés au format protojson :

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": {}
}

Je souhaite rassembler des morceaux de ce document protojson dans une structure go personnalisée pour valider facilement chaque type d'entrée, comme ceci :

// 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?"
            }
        }
    }
}

Le SDK Firestore comprend une méthode datato qui facilite la désagrégation des données formatées Protojson dans des structures personnalisées. J'essaie de faire quelque chose de très similaire, mais j'obtiens déjà les données du document en dehors du SDK Firestore.

// 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)
}

Solution

J'ai écrit un package Go open source appelé "firestruct" pour résoudre ce défi. Vous pouvez le trouver ici : github.com/bennovw/firestruct Vos commentaires et contributions sont les bienvenus !

J'ai fini par écrire une fonction qui décompresse de manière récursive les champs Firestore en cartes correspondantes. J'ai ensuite refactorisé la méthode DataTo() dans cloud.google.com/go/firestore pour transformer ma carte en une structure.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!