func()

in pkg/controller/direct/mappings/validation.go [51:176]
106 lines of code
31 McCabe index (conditional complexity)

func (m *structTypeMapping) validate(checkMissing bool) []ValidationError {
	var errors []ValidationError

	for _, mapping := range m.fields {
		inField := m.inType.lookupField(mapping.InPath)
		outField := m.outType.lookupField(mapping.OutPath)

		if inField == nil {
			err := ValidationError{Message: fmt.Sprintf("field %s not found in input type %v", mapping.InPath, m.inType)}
			if outField != nil {
				err.Proposal = buildGoField(outField)
			}

			errors = append(errors, err)
			continue
		}
		if outField == nil {
			proposal := buildGoField(inField)

			klog.Infof("outType.Fields = %v", m.outType.Fields())

			errors = append(errors, ValidationError{
				Message:  fmt.Sprintf("field %s not found in output type %v", mapping.OutPath, m.outType),
				Proposal: proposal,
			})
			continue
		}

	}

	if checkMissing {

		if m.hasSpecStatus {
			specField := m.inType.lookupField(parseFieldPath("spec"))
			statusField := m.inType.lookupField(parseFieldPath("status"))
			if specField != nil && statusField != nil {
				specType := specField.Type()
				statusType := statusField.Type()

				for _, cloudField := range m.outType.Fields() {
					id := cloudField.ID()

					ignore := false
					for _, ignoreField := range m.ignore {
						if ignoreField.ID == id {
							ignore = true
						}
					}
					if ignore {
						continue
					}
					specField := specType.lookupField(newFieldPath(id))
					statusField := statusType.lookupField(newFieldPath(id))

					if specField == nil && statusField == nil {
						proposal := buildGoField(cloudField)

						errors = append(errors, ValidationError{
							Message:  fmt.Sprintf("field %s not found in KRM spec nor status %v", id, m.inType),
							Proposal: proposal,
						})
						continue
					}
				}
			}
		} else {
			for _, outField := range m.outType.Fields() {
				id := outField.ID()

				found := false
				for _, mapping := range m.fields {
					if len(mapping.OutPath.fields) == 1 && mapping.OutPath.fields[0] == id {
						found = true
					}
				}
				if found {
					continue
				}

				ignore := false
				for _, ignoreField := range m.ignore {
					if ignoreField.ID == id {
						ignore = true
					}
				}
				if ignore {
					continue
				}
				errors = append(errors, ValidationError{
					Message: fmt.Sprintf("field %s is not mapped in %v", id, m.outType),
					// Proposal: proposal,
				})
			}

			for _, inField := range m.inType.Fields() {
				id := inField.ID()

				found := false
				for _, mapping := range m.fields {
					if len(mapping.InPath.fields) == 1 && mapping.InPath.fields[0] == id {
						found = true
					}
				}
				if found {
					continue
				}

				ignore := false
				for _, ignoreField := range m.ignore {
					if ignoreField.ID == id {
						ignore = true
					}
				}
				if ignore {
					continue
				}
				errors = append(errors, ValidationError{
					Message: fmt.Sprintf("field %s is not mapped in %v", id, m.inType),
				})
			}
		}

	}

	return errors
}