service.tmpl

package services

import (
    "context"
    "fmt"
    "net/http"

    "github.com/labstack/echo"
    "github.com/satori/go.uuid"
    log "github.com/sirupsen/logrus"

    "github.com/Juniper/contrail/pkg/common"
    "github.com/Juniper/contrail/pkg/services/baseservices"
    "github.com/Juniper/contrail/pkg/models/basemodels"
    "{{ option.PackagePath }}/pkg/models"
)

//This is needed to prevent an import error.
var _ = fmt.Println

{% for schema in schemas %}{% if schema.Type != "abstract" and schema.ID %}

type RESTUpdate{{ schema.JSONSchema.GoName }}Request struct{
    {{ schema.JSONSchema.GoName }} map[string]interface{} `json:"{{ schema.Path }}"`
}

//RESTCreate{{ schema.JSONSchema.GoName }} handle a Create REST service.
func (service *ContrailService) RESTCreate{{ schema.JSONSchema.GoName }}(c echo.Context) error {
    requestData := &Create{{ schema.JSONSchema.GoName }}Request{
    }
    if err := c.Bind(requestData); err != nil {
        log.WithFields(log.Fields{
            "err": err,
            "resource": "{{ schema.ID }}",
        }).Debug("Bind failed on create")
        return echo.NewHTTPError(http.StatusBadRequest, "invalid JSON format")
    }
    ctx := c.Request().Context()
    response, err := service.Create{{ schema.JSONSchema.GoName }}(ctx, requestData)
    if err != nil {
        return common.ToHTTPError(err)
    }
    return c.JSON(http.StatusOK, response)
}

//Create{{ schema.JSONSchema.GoName }} handle a Create API
func (service *ContrailService) Create{{ schema.JSONSchema.GoName }}(
    ctx context.Context,
    request *Create{{ schema.JSONSchema.GoName }}Request) (*Create{{ schema.JSONSchema.GoName }}Response, error) {
    model := request.{{ schema.JSONSchema.GoName }}
    if model == nil {
        return nil, common.ErrorBadRequest("create body is empty")
    }
    auth := common.GetAuthCTX(ctx)
    if auth == nil {
        return nil, common.ErrorUnauthenticated
    }
    if model.UUID == "" {
        model.UUID = uuid.NewV4().String()
    }

    if model.Name == "" {
        if fqName := model.FQName; len(fqName) > 0 {
            model.Name = fqName[len(fqName)-1]
        } else {
            model.Name = "default-{{ schema.TypeName }}"
        }
    }

{% if schema.IsConfigRootInParents %}
    if model.ParentType == models.KindConfigRoot {
        model.ParentType = ""
    }
{% endif %}

{% if schema.Parents | length == 1 and !schema.IsConfigRootInParents %}{# There is only one parent, so "for" will extract him #}
    if model.ParentType == "" { {% for key, reference in schema.Parents %}
        model.ParentType = "{{ reference.LinkTo.TypeName }}"{% endfor %}
    }{% endif %}


    if err := service.sanitizeFQNameFor{{ schema.JSONSchema.GoName }}(ctx, request); err != nil {
        return nil, err
    }

{% if schema.Parents | length != 0 %}
    if model.ParentUUID == "" {
        // fqName must be have at least 2 elements to contain parent fqName
        if l := len(model.FQName); l > 1 {
            // get parentUUID by parent fqName
            parentFQName := model.FQName[:l-1]
            metadata, err := service.MetadataGetter.GetMetaData(ctx, "", parentFQName)
            if err != nil {
                return nil, common.ErrorBadRequest("please provide correct FQName or ParentUUID")
            }
            model.ParentUUID = metadata.UUID
        }
    }
{% endif %}

    model.Perms2 = &models.PermType2{
        OwnerAccess: basemodels.PermsRWX,
    }
    model.Perms2.Owner = auth.ProjectID()

    if model.IDPerms == nil {
        model.IDPerms = models.NewIDPerms(model.UUID)
    }

    if model.IDPerms.UUID == nil {
        model.IDPerms.UUID = models.NewUUIDType(model.UUID)
    }

    err := service.TypeValidator.Validate{{ schema.JSONSchema.GoName }}(request.{{ schema.JSONSchema.GoName }})
    if err != nil {
        return nil, common.ErrorBadRequest(fmt.Sprintf(
        	"validation failed for resource with UUID %v: %v",
        	request.{{ schema.JSONSchema.GoName }}.UUID,
        	err,
        ))
    }

    return service.Next().Create{{ schema.JSONSchema.GoName }}(ctx, request)
}

func (service *ContrailService) sanitizeFQNameFor{{ schema.JSONSchema.GoName }} (
    ctx context.Context,
    request *Create{{ schema.JSONSchema.GoName }}Request,
) error {
    model := request.{{ schema.JSONSchema.GoName }}
    if len(model.FQName) != 0 {
        return nil
    }
{% if schema.Parents | length == 0 %}
    model.FQName = []string{model.Name}
{% else %}
    {% if schema.IsConfigRootInParents %}
    if model.ParentUUID == "" && model.ParentType == "" {
        model.FQName = []string{model.Name}
        return nil
    }
    {% endif %}
    if model.ParentUUID != "" {
        // fqName is empty but parentUUID is not - get parent fqName
        metadata, err := service.MetadataGetter.GetMetaData(ctx, model.ParentUUID, nil)
        if err != nil {
            return common.ErrorBadRequestf("Failed to generate FQName: %v", err)
        }
        model.FQName = append(metadata.FQName, model.Name)
        return nil
    }
    if model.ParentType != "" {
        // assign default fqName
        auth := common.GetAuthCTX(ctx)
        model.FQName = []string{auth.DomainID(), fmt.Sprintf("default-%s", model.ParentType), model.Name}
    }
{% endif %}
    return nil
}

//RESTUpdate{{ schema.JSONSchema.GoName }} handles a REST Update request.
func (service *ContrailService) RESTUpdate{{ schema.JSONSchema.GoName }}(c echo.Context) error {
    id := c.Param("id")
    request := &RESTUpdate{{ schema.JSONSchema.GoName }}Request{}
    if err := c.Bind(request); err != nil {
            log.WithFields(log.Fields{
                "err": err,
                "resource": "{{ schema.ID }}",
            }).Debug("Bind failed on update")
            return echo.NewHTTPError(http.StatusBadRequest, "invalid JSON format")
    }
    ctx := c.Request().Context()
    model := models.InterfaceTo{{ schema.JSONSchema.GoName }}(request.{{ schema.JSONSchema.GoName }})
    model.UUID = id
    response, err := service.Update{{ schema.JSONSchema.GoName }}(ctx, &Update{{ schema.JSONSchema.GoName }}Request{
        {{ schema.JSONSchema.GoName }}: model,
        FieldMask: baseservices.MapToFieldMask(request.{{ schema.JSONSchema.GoName }}),
    })
    if err != nil {
        return common.ToHTTPError(err)
    }
    return c.JSON(http.StatusOK, response)
}

//Update{{ schema.JSONSchema.GoName }} handles a Update request.
func (service *ContrailService) Update{{ schema.JSONSchema.GoName }}(
    ctx context.Context,
    request *Update{{ schema.JSONSchema.GoName }}Request) (*Update{{ schema.JSONSchema.GoName }}Response, error) {
    model := request.{{ schema.JSONSchema.GoName }}
    if model == nil {
        return nil, common.ErrorBadRequest("update body is empty")
    }
    return service.Next().Update{{ schema.JSONSchema.GoName }}(ctx, request)
}

//RESTDelete{{ schema.JSONSchema.GoName }} delete a resource using REST service.
func (service *ContrailService) RESTDelete{{ schema.JSONSchema.GoName }}(c echo.Context) error {
    id := c.Param("id")
    request := &Delete{{ schema.JSONSchema.GoName }}Request{
        ID: id,
    }
    ctx := c.Request().Context()
    _, err := service.Delete{{ schema.JSONSchema.GoName }}(ctx, request)
    if err != nil {
        return common.ToHTTPError(err)
    }
    return c.NoContent(http.StatusOK)
}


//RESTGet{{ schema.JSONSchema.GoName }} a REST Get request.
func (service *ContrailService) RESTGet{{ schema.JSONSchema.GoName }}(c echo.Context) (error) {
    id := c.Param("id")
    request := &Get{{ schema.JSONSchema.GoName }}Request{
        ID: id,
    }
    ctx := c.Request().Context()
    response, err := service.Get{{ schema.JSONSchema.GoName }}(ctx, request)
    if err != nil {
        return common.ToHTTPError(err)
    }
    return c.JSON(http.StatusOK, response)
}

//RESTList{{ schema.JSONSchema.GoName }} handles a List REST service Request.
func (service *ContrailService) RESTList{{ schema.JSONSchema.GoName }}(c echo.Context) (error) {
    var err error
    spec := baseservices.GetListSpec(c)
    request := &List{{ schema.JSONSchema.GoName }}Request{
        Spec: spec,
    }
    ctx := c.Request().Context()
    response, err := service.List{{ schema.JSONSchema.GoName }}(ctx, request)
    if err != nil {
        return common.ToHTTPError(err)
    }
    return c.JSON(http.StatusOK, response)
}

{% endif %}
{% endfor %}