Method syncEvent

server/sync_writer.go:150–250

(resource *schema.Resource)

}

func (writer *SyncWriter) syncEvent(resource *schema.Resource) error {
	schemaManager := schema.GetManager()
	eventSchema, _ := schemaManager.Schema("event")
	return db.Within(writer.db, func(tx transaction.Transaction) error {
		var err error
		eventType := resource.Get("type").(string)
		resourcePath := resource.Get("path").(string)
		body := resource.Get("body").(string)
		syncPlain := resource.Get("sync_plain").(bool)
		syncProperty := resource.Get("sync_property").(string)

		path := generatePath(resourcePath, body)

		version, ok := resource.Get("version").(int)
		if !ok {
			log.Debug("cannot cast version value in int for %s", path)
		}
		log.Debug("event %s", eventType)

		if eventType == "create" || eventType == "update" {
			log.Debug("set %s on sync", path)

			content := body

			var data map[string]interface{}
			if syncProperty != "" {
				err = json.Unmarshal(([]byte)(body), &data)
				if err != nil {
					return fmt.Errorf("failed to unmarshal body on sync: %s", err)
				}
				target, ok := data[syncProperty]
				if !ok {
					return fmt.Errorf("could not find property `%s`", syncProperty)
				}
				jsonData, err := json.Marshal(target)
				if err != nil {
					return err
				}
				content = string(jsonData)
			}

			if syncPlain {
				var target interface{}
				json.Unmarshal([]byte(content), &target)
				switch target.(type) {
				case string:
					content = fmt.Sprintf("%v", target)
				}
			} else {
				data, err := json.Marshal(map[string]interface{}{
					"body":    content,
					"version": version,
				})
				if err != nil {
					return fmt.Errorf("failed to marshal marshalling sync object: %s", err)
				}
				content = string(data)
			}