sanitizer_service.tmpl

package services

import (
	"bytes"
	"context"
	"fmt"

	"github.com/pkg/errors"

	"github.com/Juniper/contrail/pkg/models/basemodels"
	"github.com/Juniper/contrail/pkg/services/baseservices"
	"github.com/Juniper/contrail/pkg/common"

	"{{ option.PackagePath }}/pkg/models"
)

//This is needed to prevent an import error.
var _ = common.ErrorNotFound
var _ = models.Version
var _ = basemodels.MetaData{}

// SanitizerService fills up missing properties based on resources logic and metadata
// TODO: Move logic from ContrailService when validation will be a separate service
type SanitizerService struct {
	BaseService
	MetadataGetter baseservices.MetadataGetter
}

func (sv *SanitizerService) sanitizeRefs(ctx context.Context, refs []basemodels.Reference) error {
	fqNameToRef:= make(map[string] basemodels.Reference)
	var fqNameUUIDPairs []*basemodels.FQNameUUIDPair
	for _, ref := range refs {
		if ref.GetUUID() != "" {
			continue
		}
		fqNameToRef[basemodels.FQNameToString(ref.GetTo())] = ref
		fqNameUUIDPairs = append(fqNameUUIDPairs, &basemodels.FQNameUUIDPair{FQName: ref.GetTo()})
	}

	if len(fqNameUUIDPairs) == 0 {
		return nil
	}

	metadatas, err := sv.MetadataGetter.ListMetadata(ctx, fqNameUUIDPairs)
	if err != nil {
		return err
	}

	if len(metadatas) != len(fqNameUUIDPairs) {
		for _, metadata := range metadatas {
			delete(fqNameToRef, basemodels.FQNameToString(metadata.FQName))
		}
		var missingRefs bytes.Buffer
		for _, ref := range fqNameToRef {
			missingRefs.WriteString(fmt.Sprintf(" {type: %v, to: %v}", ref.GetReferredKind(), ref.GetTo()))
		}
		return errors.Errorf("couldn't get metadatas for references:%v", missingRefs.String())
	}

	for _, metadata := range metadatas {
		fqNameToRef[basemodels.FQNameToString(metadata.FQName)].SetUUID(metadata.UUID)
	}
	return nil
}

{% for schema in schemas %}{% if schema.Type != "abstract" and schema.ID %}
func (sv *SanitizerService) sanitize{{ schema.JSONSchema.GoName }}DisplayName(ctx context.Context, m *models.{{ schema.JSONSchema.GoName }}) {
	if m.DisplayName == "" {
		m.DisplayName = m.Name
	}
}

func (sv *SanitizerService) Create{{ schema.JSONSchema.GoName }}(
	ctx context.Context, request *Create{{ schema.JSONSchema.GoName }}Request,
) (*Create{{ schema.JSONSchema.GoName }}Response, error) {
	m := request.Get{{ schema.JSONSchema.GoName }}()
	sv.sanitize{{ schema.JSONSchema.GoName }}DisplayName(ctx, m)
	{% if schema.References | length != 0 %}
	if err := sv.sanitizeRefs(ctx, m.GetReferences()); err != nil {
		return nil, common.ErrorBadRequestf("couldn't sanitize refs of {{ schema.JSONSchema.GoName }} %v: %v", m.GetUUID(), err)
	}
	{% endif %}

	return sv.BaseService.Create{{ schema.JSONSchema.GoName }}(ctx, request)
}

func (sv *SanitizerService) Update{{ schema.JSONSchema.GoName }}(
	ctx context.Context, request *Update{{ schema.JSONSchema.GoName }}Request,
) (*Update{{ schema.JSONSchema.GoName }}Response, error) {
	{% if schema.References | length != 0 %}
	m := request.Get{{ schema.JSONSchema.GoName }}()
	if err := sv.sanitizeRefs(ctx, m.GetReferences()); err != nil {
		return nil, common.ErrorBadRequestf("couldn't sanitize refs of {{ schema.JSONSchema.GoName }} %v: %v", m.GetUUID(), err)
	}
	{% endif %}
	return sv.BaseService.Update{{ schema.JSONSchema.GoName }}(ctx, request)
}
{% endif %}{% endfor %}