Question

我正在监听收集文档的更改事件，只是将接收到的内容进行转储：

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 {}轻松映射到struct字段。例如，Fields如下所示：

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

但原始结构是

type Report struct {
  Answers map[string]Answer
}

type Answer struct {
  Option string
}

是否有一种简单的方法可以将地图反序列化为struct？还是应该“手工”完成？

应该有一种方法可以从此数据中获取DocumentSnapshot。来自Firestore的数据看起来像protobuf消息，甚至可以在Document的{{1}}结构中看到。

Answer 1

与Cloud Firestore一起处理的代码通常会将其从DocumentSnapshot中手动复制值到您自己定义的数据结构中。

Java代码例外，Firestore SDK可以使用反射将字段值自动映射到POJO属性或从POJO属性映射字段值。但是并不是每个人都选择它，因为他们可能需要修改输入和输出的值。但是我认为其他语言的Firestore SDK没有这种支持。

Answer 2

在没有找到处理事件字段的其他解决方案后，我决定在此处发布我的解决方案，以防其他人（如我）正在寻找。

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

在某些时候，它必须被重构为递归调用，以便 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
    }

Firestore云功能：从事件中获取DocumentSnapshot

2 个答案: