我正在监听收集文档的更改事件，只是转储我收到的内容:

func ForwardUserChanged(ctx context.Context, e cloudfn.FirestoreEvent) error {
    raw, err := json.Marshal(e.Value.Fields)
    if err != nil {
        return err
    }
    fmt.Println(string(raw))

    return nil
}

其中 FirestoreEvent 是自定义结构:

// FirestoreEvent is the payload of a Firestore event.
type FirestoreEvent struct {
    OldValue   FirestoreValue `json:"oldValue"`
    Value      FirestoreValue `json:"value"`
    UpdateMask struct {
        FieldPaths []string `json:"fieldPaths"`
    } `json:"updateMask"`
}

type FirestoreValue struct {
    CreateTime time.Time `json:"createTime"`
    Fields     map[string]interface{} `json:"fields"`
    Name       string                 `json:"name"`
    UpdateTime time.Time              `json:"updateTime"`
}

我想要的是一种将 Fields 解码到我的结构中的简单方法，该结构之前保存在同一个集合中。 问题是 Fields 看起来非常复杂，它不仅仅是一个简单的映射 map[string]interface{} 到结构字段。例如，字段 如下所示:

{"answers":
  {"mapValue":
    {"fields":
      {"fish-1":
        {"mapValue":
          {"fields":{"option":{"stringValue":"yes"},

但原来的结构是

type Report struct {
  Answers map[string]Answer
}

type Answer struct {
  Option string
}

有没有一种简单的方法可以将映射反序列化为结构？还是应该“手工”完成？

应该有一种方法可以从这些数据中获取 DocumentSnapshot。来自 Firestore 的数据看起来像 protobuf 消息，甚至可以在 google.golang.org/genproto/googleapis/firestore/v1 的 Document 结构中看到。

最佳答案

在找不到其他解决方案来处理事件字段后，我决定将我的解决方案发布在这里，以防其他人(如我)正在寻找。

请记住我的解决方案存在一些问题，我只是还没有解决这些问题。

• 在某些时候，它必须重构为递归调用，以便 mapValue 和 arrayValue 类型可以根据需要深入。

• 它可能应该有更好的错误检查。

    type FirestoreValue struct {
        CreateTime time.Time `json:"createTime"`
        // Fields is the data for this value. The type depends on the format of your
        // database. Log an interface{} value and inspect the result to see a JSON
        // representation of your database fields.
        Fields     map[string]interface{} `json:"fields"` // I changed this to a map[string]interface{} instead of the example codes interface{}
        Name       string                 `json:"name"`
        UpdateTime time.Time              `json:"updateTime"`
    }
    
    func (fv *FirestoreValue) Recombobulate(destination interface{}) error {
        result := make(map[string]interface{})
        for fieldName, infVal := range fv.Fields {
            for typeKey, val := range infVal.(map[string]interface{}) {
                switch typeKey {
                case "stringValue":
                    result[fieldName] = val
                case "booleanValue":
                    result[fieldName] = val
                case "integerValue":
                    // I saw firestore give me this once: integerValue: "1"
                    sVal, ok := val.(string)
                    if ok {
                        result[fieldName], _ = strconv.Atoi(sVal)
                    } else {
                        result[fieldName] = val
                    }
                case "doubleValue":
                    result[fieldName] = val
                case "timestampValue":
                    result[fieldName], _ = time.Parse(time.RFC3339, val.(string))
                case "referenceValue": // this is just a string for all intents and purposes
                    result[fieldName] = val
                case "nullValue":
                    // not really sure what to do with this one
                    result[fieldName] = val
                case "arrayValue":
                    elements := val.(map[string]interface{})["values"]
                    var innards []interface{}
                    for _, ele := range elements.([]interface{}) {
                        for _, eleInterf := range ele.(map[string]interface{}) {
                            innards = append(innards, eleInterf)
                        }
                    }
                    result[fieldName] = innards
                case "mapValue":
                    mapFields := val.(map[string]interface{})["fields"]
                    innards := make(map[string]interface{})
                    for mapKeyName, v := range mapFields.(map[string]interface{}) {
                        for _, innard := range v.(map[string]interface{}) {
                            innards[mapKeyName] = innard
                        }
                    }
                    result[fieldName] = innards
                case "geoPointValue": // this is just a map[string]int/float
                    innards := make(map[string]interface{})
                    for mapKeyName, v := range val.(map[string]interface{}) {
                        innards[mapKeyName] = v
                    }
                    result[fieldName] = innards
                }
            }
        }
    
        
        mapstructure.Decode(result, &destination)
        return nil
    }

关于go - Firestore 云函数 : Get DocumentSnapshot from the event，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/57037488/