func()

in internal/elasticsearch/index/index/models.go [309:432]
108 lines of code
23 McCabe index (conditional complexity)

func (model tfModel) toIndexSettings(ctx context.Context) (map[string]interface{}, diag.Diagnostics) {
	settings := map[string]interface{}{}
	modelType := reflect.TypeOf(model)

	for _, key := range allSettingsKeys {
		tfFieldKey := convertSettingsKeyToTFFieldKey(key)
		value, ok := model.getFieldValueByTagValue(tfFieldKey, modelType)
		if !ok {
			return map[string]interface{}{}, diag.Diagnostics{
				diag.NewErrorDiagnostic(
					"failed to find setting value",
					fmt.Sprintf("expected setting with key %s", tfFieldKey),
				),
			}
		}

		if !value.IsNull() && !value.IsUnknown() {
			var settingsValue interface{}
			switch a := value.(type) {
			case types.String:
				settingsValue = a.ValueString()
			case types.Bool:
				settingsValue = a.ValueBool()
			case types.Int64:
				settingsValue = a.ValueInt64()
			case types.List:
				elemType := a.ElementType(ctx)
				if elemType != types.StringType {
					return map[string]interface{}{}, diag.Diagnostics{
						diag.NewErrorDiagnostic(
							"expected list of string",
							fmt.Sprintf("expected list element type to be string but got %s", elemType),
						),
					}
				}

				elems := []string{}
				if diags := a.ElementsAs(ctx, &elems, true); diags.HasError() {
					return map[string]interface{}{}, diags
				}

				settingsValue = elems
			case types.Set:
				elemType := a.ElementType(ctx)
				if elemType != types.StringType {
					return map[string]interface{}{}, diag.Diagnostics{
						diag.NewErrorDiagnostic(
							"expected set of string",
							fmt.Sprintf("expected set element type to be string but got %s", elemType),
						),
					}
				}

				elems := []string{}
				if diags := a.ElementsAs(ctx, &elems, true); diags.HasError() {
					return map[string]interface{}{}, diags
				}

				settingsValue = elems
			default:
				return map[string]interface{}{}, diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"unknown value type",
						fmt.Sprintf("unknown index setting value type %s", a.Type(ctx)),
					),
				}
			}

			settings[key] = settingsValue
		}
	}

	analysisProperties := map[string]jsontypes.Normalized{
		"analyzer":    model.AnalysisAnalyzer,
		"tokenizer":   model.AnalysisTokenizer,
		"char_filter": model.AnalysisCharFilter,
		"filter":      model.AnalysisFilter,
		"normalizer":  model.AnalysisNormalizer,
	}

	analysis := map[string]interface{}{}
	for name, property := range analysisProperties {
		if utils.IsKnown(property) {
			var parsedValue map[string]interface{}
			if diags := property.Unmarshal(&parsedValue); diags.HasError() {
				return map[string]interface{}{}, diags
			}

			analysis[name] = parsedValue
		}
	}

	if len(analysis) > 0 {
		settings["analysis"] = analysis
	}

	var settingSet []settingsTfSet
	if diags := model.Settings.ElementsAs(ctx, &settingSet, true); diags.HasError() {
		return map[string]interface{}{}, diags
	}

	if len(settingSet) == 1 {
		var rawSettings []settingTfModel
		if diags := settingSet[0].Setting.ElementsAs(ctx, &rawSettings, true); diags.HasError() {
			return map[string]interface{}{}, diags
		}

		for _, setting := range rawSettings {
			name := setting.Name.ValueString()
			if _, ok := settings[name]; ok {
				return map[string]interface{}{}, diag.Diagnostics{
					diag.NewErrorDiagnostic(
						"duplicate setting definition",
						fmt.Sprintf("setting [%s] is both explicitly defined and included in the deprecated raw settings blocks. Please remove it from `settings` to avoid unexpected settings", name),
					),
				}
			}

			settings[name] = setting.Value.ValueString()
		}
	}

	return settings, nil
}