func FromUserProp()

in go/protocol/internal/errutil/protocol.go [121:224]
92 lines of code
17 McCabe index (conditional complexity)

func FromUserProp(user map[string]string) error {
	status := user[constants.Status]
	statusMessage := user[constants.StatusMessage]
	propertyName := user[constants.InvalidPropertyName]
	propertyValue := user[constants.InvalidPropertyValue]
	protocolVersion := user[constants.RequestProtocolVersion]
	supportedVersions := user[constants.SupportedProtocolMajorVersion]

	if status == "" {
		return &errors.Client{
			Message: "status missing",
			Kind: errors.HeaderMissing{
				HeaderName: constants.Status,
			},
		}
	}

	code, err := strconv.ParseInt(status, 10, 32)
	if err != nil {
		return &errors.Client{
			Message: "status is not a valid integer",
			Kind: errors.HeaderInvalid{
				HeaderName:  constants.Status,
				HeaderValue: status,
			},
			Nested: err,
		}
	}

	// No error, we're done.
	if code < 400 {
		return nil
	}

	e := &errors.Remote{Message: statusMessage}

	switch code {
	case 400, 415:
		switch {
		case propertyName == "" && propertyValue == "":
			e.Kind = errors.PayloadInvalid{}
		case propertyValue == "":
			e.Kind = errors.HeaderMissing{
				HeaderName: propertyName,
			}
		default:
			e.Kind = errors.HeaderInvalid{
				HeaderName:  propertyName,
				HeaderValue: propertyValue,
			}
		}
	case 408:
		to, err := duration.Parse(propertyValue)
		if err != nil {
			return &errors.Client{
				Message: "invalid timeout value",
				Kind: errors.HeaderInvalid{
					HeaderName:  constants.InvalidPropertyValue,
					HeaderValue: propertyValue,
				},
				Nested: err,
			}
		}
		e.Kind = errors.Timeout{
			TimeoutName:  propertyName,
			TimeoutValue: to.ToTimeDuration(),
		}
	case 500:
		appErr := user[constants.IsApplicationError]
		switch {
		case appErr != "" && appErr != "false":
			e.Kind = errors.ExecutionError{}
		case propertyName != "":
			e.Kind = errors.InternalLogicError{PropertyName: propertyName}
		default:
			e.Kind = errors.UnknownError{}
		}
	case 503:
		e.Kind = errors.StateInvalid{
			PropertyName: propertyName,
		}
	case 505:
		e.Kind = errors.UnsupportedVersion{
			ProtocolVersion: protocolVersion,
			SupportedMajorProtocolVersions: version.ParseSupported(
				supportedVersions,
			),
		}
	default:
		// Treat unknown status as an unknown error, but otherwise allow them.
		k := errors.UnknownError{}

		//nolint:staticcheck // Capture 422 data for schemaregistry.
		k.PropertyName = propertyName
		if propertyValue != "" {
			//nolint:staticcheck // Capture 422 data for schemaregistry.
			k.PropertyValue = propertyValue
		}

		e.Kind = k
	}

	return e
}