func setConditionsFromMap()

in operatortrace-go/pkg/client/conditions.go [176:231]
48 lines of code
12 McCabe index (conditional complexity)

func setConditionsFromMap(obj client.Object, conditionsAsMap []map[string]interface{}, scheme *runtime.Scheme) error {
	gvk, err := apiutil.GVKForObject(obj, scheme)
	if err != nil {
		return fmt.Errorf("problem getting the GVK: %w", err)
	}

	objTyped, err := scheme.New(gvk)
	if err != nil {
		return fmt.Errorf("problem creating new object of kind %s: %w", gvk.Kind, err)
	}

	if err := scheme.Convert(obj, objTyped, nil); err != nil {
		return fmt.Errorf("problem converting object to kind %s: %w", gvk.Kind, err)
	}

	val := reflect.ValueOf(objTyped)
	statusField := val.Elem().FieldByName("Status")
	if !statusField.IsValid() {
		return fmt.Errorf("status field not found in kind %s", gvk.Kind)
	}

	conditionsField := statusField.FieldByName("Conditions")
	if !conditionsField.IsValid() {
		return fmt.Errorf("conditions field not found in kind %s", gvk.Kind)
	}

	elemType := conditionsField.Type().Elem()
	result := reflect.MakeSlice(conditionsField.Type(), len(conditionsAsMap), len(conditionsAsMap))

	for i, conditionMap := range conditionsAsMap {
		targetCond := reflect.New(elemType).Elem()
		for key, value := range conditionMap {
			field := targetCond.FieldByName(key)
			if field.IsValid() {
				val := reflect.ValueOf(value)
				if val.Type().ConvertibleTo(field.Type()) {
					field.Set(val.Convert(field.Type()))
				} else {
					return fmt.Errorf("cannot convert value of field %s from %s to %s", key, val.Type(), field.Type())
				}
			}
		}
		if conditionsField.Type().Elem().Kind() == reflect.Ptr {
			result.Index(i).Set(targetCond.Addr())
		} else {
			result.Index(i).Set(targetCond)
		}
	}

	conditionsField.Set(result)
	if err := scheme.Convert(objTyped, obj, nil); err != nil {
		return fmt.Errorf("problem converting object back to unstructured: %w", err)
	}

	return nil
}