func expandFilters()

in ec/ecdatasource/deploymentsdatasource/expanders.go [33:141]
94 lines of code
13 McCabe index (conditional complexity)

func expandFilters(ctx context.Context, state modelV0) (*models.SearchRequest, diag.Diagnostics) {
	var diags diag.Diagnostics
	var queries []*models.QueryContainer

	namePrefix := state.NamePrefix.ValueString()
	if namePrefix != "" {
		queries = append(queries, &models.QueryContainer{
			Prefix: map[string]models.PrefixQuery{
				// The "keyword" addition denotes that the query will be using a keyword
				// field rather than a text field in order to ensure the query is not analyzed
				"name.keyword": {Value: &namePrefix},
			},
		})
	}

	name := state.Name.ValueString()
	if name != "" {
		queries = append(queries, &models.QueryContainer{
			Term: map[string]models.TermQuery{
				"name.keyword": {Value: &name},
			},
		})
	}

	depTemplateID := state.DeploymentTemplateID.ValueString()
	if depTemplateID != "" {
		esPath := "resources.elasticsearch"
		tplTermPath := esPath + ".info.plan_info.current.plan.deployment_template.id"

		queries = append(queries, newNestedTermQuery(esPath, tplTermPath, depTemplateID))
	}

	healthy := state.Healthy.ValueString()
	if healthy != "" {
		if healthy != "true" && healthy != "false" {
			diags.AddError("invalid value for healthy",
				fmt.Sprintf("expected either [true] or [false] but got [%s]", healthy))
			return nil, diags
		}

		queries = append(queries, &models.QueryContainer{
			Term: map[string]models.TermQuery{
				"healthy": {Value: &healthy},
			},
		})
	}

	var tags = make(map[string]string)
	diags.Append(state.Tags.ElementsAs(ctx, &tags, false)...)
	if diags.HasError() {
		return nil, diags
	}

	var tagQueries []*models.QueryContainer
	for key, value := range tags {
		tagQueries = append(tagQueries,
			newNestedTagQuery(key, value),
		)
	}
	if len(tagQueries) > 0 {
		queries = append(queries, &models.QueryContainer{
			Bool: &models.BoolQuery{
				MinimumShouldMatch: int32(len(tags)),
				Should:             tagQueries,
			},
		})
	}
	type resourceFilter struct {
		resourceKind string
		settings     *types.List
	}

	resourceFilters := []resourceFilter{
		{resourceKind: util.Elasticsearch, settings: &state.Elasticsearch},
		{resourceKind: util.Kibana, settings: &state.Kibana},
		{resourceKind: util.Apm, settings: &state.Apm},
		{resourceKind: util.EnterpriseSearch, settings: &state.EnterpriseSearch},
		{resourceKind: util.IntegrationsServer, settings: &state.IntegrationsServer},
	}

	for _, filter := range resourceFilters {
		req, diags := expandResourceFilters(ctx, filter.settings, filter.resourceKind)
		if diags.HasError() {
			return nil, diags
		}
		queries = append(queries, req...)
	}

	searchReq := models.SearchRequest{
		Size: int32(state.Size.ValueInt64()),
		Sort: []interface{}{"id"},
	}

	if len(queries) > 0 {
		searchReq.Query = &models.QueryContainer{
			Bool: &models.BoolQuery{
				Filter: []*models.QueryContainer{
					{
						Bool: &models.BoolQuery{
							Must: queries,
						},
					},
				},
			},
		}
	}

	return &searchReq, nil
}