service_interface.tmpl

package services

import (
    "context"

    "github.com/gogo/protobuf/types"

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

//This is needed to prevent an import error.
var _ = types.AnyMessageName

type Service interface {
    Next() Service
    SetNext(Service)

    WriteService
    ReadService
}

type WriteService interface {
{% for schema in schemas %}{% if schema.Type != "abstract" and schema.ID %}
    Create{{ schema.JSONSchema.GoName }}(context.Context, *Create{{ schema.JSONSchema.GoName }}Request) (*Create{{ schema.JSONSchema.GoName }}Response, error)
    Update{{ schema.JSONSchema.GoName }}(context.Context, *Update{{ schema.JSONSchema.GoName }}Request) (*Update{{ schema.JSONSchema.GoName }}Response, error)
    Delete{{ schema.JSONSchema.GoName }}(context.Context, *Delete{{ schema.JSONSchema.GoName }}Request) (*Delete{{ schema.JSONSchema.GoName }}Response, error)

{% for _, reference in schema.References %}
{% set refType = schema.JSONSchema.GoName| add:reference.GoName | add:"Ref" %}
    Create{{ refType }}(context.Context, *Create{{ refType }}Request) (*Create{{ refType }}Response, error)
    Delete{{ refType }}(context.Context, *Delete{{ refType }}Request) (*Delete{{ refType }}Response, error)
{% endfor %}
{% endif%}{% endfor %}
}

type ReadService interface{
{% for schema in schemas %}{% if schema.Type != "abstract" and schema.ID %}
    Get{{ schema.JSONSchema.GoName }}(context.Context, *Get{{ schema.JSONSchema.GoName }}Request) (*Get{{ schema.JSONSchema.GoName }}Response, error)
    List{{ schema.JSONSchema.GoName }}(context.Context, *List{{ schema.JSONSchema.GoName }}Request) (*List{{ schema.JSONSchema.GoName }}Response, error)
{% endif %}{% endfor %}
}

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

type {{ schema.JSONSchema.GoName }} = models.{{ schema.JSONSchema.GoName }}

func (service *BaseService) Create{{ schema.JSONSchema.GoName }}(ctx context.Context, request *Create{{ schema.JSONSchema.GoName }}Request) (*Create{{ schema.JSONSchema.GoName }}Response, error) {
    if service.next == nil {
        return &Create{{ schema.JSONSchema.GoName }}Response{
            {{ schema.JSONSchema.GoName }}: request.Get{{ schema.JSONSchema.GoName }}(),
        }, nil
    }
    return service.Next().Create{{ schema.JSONSchema.GoName }}(ctx, request)
}
func (service *BaseService) Update{{ schema.JSONSchema.GoName }}(ctx context.Context, request *Update{{ schema.JSONSchema.GoName }}Request) (*Update{{ schema.JSONSchema.GoName }}Response, error) {
    if service.next == nil {
        return &Update{{ schema.JSONSchema.GoName }}Response{
            {{ schema.JSONSchema.GoName }}: request.Get{{ schema.JSONSchema.GoName }}(),
        }, nil
    }
    return service.Next().Update{{ schema.JSONSchema.GoName }}(ctx, request)
}
func (service *BaseService) Delete{{ schema.JSONSchema.GoName }}(ctx context.Context, request *Delete{{ schema.JSONSchema.GoName }}Request) (*Delete{{ schema.JSONSchema.GoName }}Response, error) {
    if service.next == nil {
        return &Delete{{ schema.JSONSchema.GoName }}Response{
            ID: request.ID,
        }, nil
    }
    return service.Next().Delete{{ schema.JSONSchema.GoName }}(ctx, request)
}
func (service *BaseService) Get{{ schema.JSONSchema.GoName }}(ctx context.Context, request *Get{{ schema.JSONSchema.GoName }}Request) (*Get{{ schema.JSONSchema.GoName }}Response, error) {
    if service.next == nil {
        return nil, nil
    }
    return service.Next().Get{{ schema.JSONSchema.GoName }}(ctx, request)
}
func (service *BaseService) List{{ schema.JSONSchema.GoName }}(ctx context.Context, request *List{{ schema.JSONSchema.GoName }}Request) (*List{{ schema.JSONSchema.GoName }}Response, error) {
    if service.next == nil {
        return nil, nil
    }
    return service.Next().List{{ schema.JSONSchema.GoName }}(ctx, request)
}

{% for _, reference in schema.References %}
{% set refType = schema.JSONSchema.GoName| add:reference.GoName | add:"Ref" %}
func (service *BaseService) Create{{ refType }}(ctx context.Context, request *Create{{ refType }}Request) (*Create{{ refType }}Response, error) {
    if service.next == nil {
        return &Create{{ refType }}Response{
            ID: request.ID,
            {{ refType }}: request.Get{{ refType }}(),
        }, nil
    }
    return service.Next().Create{{ refType }}(ctx, request)
}

func (service *BaseService) Delete{{ refType }}(ctx context.Context, request *Delete{{ refType }}Request) (*Delete{{ refType }}Response, error) {
    if service.next == nil {
        return &Delete{{ refType }}Response{
            ID: request.ID,
            {{ refType }}: request.Get{{ refType }}(),
        }, nil
    }
    return service.Next().Delete{{ refType }}(ctx, request)
}

func (s *RefUpdateToUpdateService) Create{{ refType }}(ctx context.Context, request *Create{{ refType }}Request) (*Create{{ refType }}Response, error) {
    refField := models.{{ schema.JSONSchema.GoName }}Field{{ reference.GoName }}Refs
    if err := s.InTransactionDoer.DoInTransaction(ctx, func(ctx context.Context) error {
        objResp, err := s.ReadService.Get{{ schema.JSONSchema.GoName }}(ctx, &Get{{ schema.JSONSchema.GoName }}Request{
            ID: request.ID,
            Fields: []string{refField},
        })
        if err != nil {
            return err
        }
        obj := objResp.{{ schema.JSONSchema.GoName }}
        obj.Add{{ reference.GoName }}Ref(request.{{ refType }})

        _, err = s.BaseService.Update{{ schema.JSONSchema.GoName }}(ctx, &Update{{ schema.JSONSchema.GoName }}Request{
            {{ schema.JSONSchema.GoName }}: obj,
            FieldMask: types.FieldMask{Paths: []string{refField}},
        })
        return err
    }); err != nil {
        return nil, err
    }
    return &Create{{ refType }}Response{
        ID: request.ID,
        {{ refType }}: request.Get{{ refType }}(),
    }, nil
}

func (s *RefUpdateToUpdateService) Delete{{ refType }}(ctx context.Context, request *Delete{{ refType }}Request) (*Delete{{ refType }}Response, error) {
    refField := models.{{ schema.JSONSchema.GoName }}Field{{ reference.GoName }}Refs
    if err := s.InTransactionDoer.DoInTransaction(ctx, func(ctx context.Context) error {
        objResp, err := s.ReadService.Get{{ schema.JSONSchema.GoName }}(ctx, &Get{{ schema.JSONSchema.GoName }}Request{
            ID: request.ID,
            Fields: []string{refField},
        })
        if err != nil {
            return err
        }
        obj := objResp.{{ schema.JSONSchema.GoName }}
        obj.Remove{{ reference.GoName }}Ref(request.{{ refType }})

        _, err = s.BaseService.Update{{ schema.JSONSchema.GoName }}(ctx, &Update{{ schema.JSONSchema.GoName }}Request{
            {{ schema.JSONSchema.GoName }}: obj,
            FieldMask: types.FieldMask{Paths: []string{refField}},
        })
        return err
    }); err != nil {
        return nil, err
    }
    return &Delete{{ refType }}Response{
        ID: request.ID,
        {{ refType }}: request.Get{{ refType }}(),
    }, nil
}
{% endfor %}

func (service *EventProducerService) Create{{ schema.JSONSchema.GoName }}(ctx context.Context, request *Create{{ schema.JSONSchema.GoName }}Request) (*Create{{ schema.JSONSchema.GoName }}Response, error) {
    _, err := service.Processor.Process(
        ctx,
        &Event{
            Request: &Event_Create{{ schema.JSONSchema.GoName }}Request{
                Create{{ schema.JSONSchema.GoName }}Request: request,
            },
        })
    if err != nil {
        return nil, err
    }
    return service.Next().Create{{ schema.JSONSchema.GoName }}(ctx, request)
}
func (service *EventProducerService) Update{{ schema.JSONSchema.GoName }}(ctx context.Context, request *Update{{ schema.JSONSchema.GoName }}Request) (*Update{{ schema.JSONSchema.GoName }}Response, error) {
    _, err := service.Processor.Process(
        ctx,
        &Event{
            Request: &Event_Update{{ schema.JSONSchema.GoName }}Request{
                Update{{ schema.JSONSchema.GoName }}Request: request,
            },
        })
    if err != nil {
        return nil, err
    }
    return service.Next().Update{{ schema.JSONSchema.GoName }}(ctx, request)
}
func (service *EventProducerService) Delete{{ schema.JSONSchema.GoName }}(ctx context.Context, request *Delete{{ schema.JSONSchema.GoName }}Request) (*Delete{{ schema.JSONSchema.GoName }}Response, error) {
    _, err := service.Processor.Process(
        ctx,
        &Event{
            Request: &Event_Delete{{ schema.JSONSchema.GoName }}Request{
                Delete{{ schema.JSONSchema.GoName }}Request: request,
            },
        })
    if err != nil {
        return nil, err
    }
    return service.Next().Delete{{ schema.JSONSchema.GoName }}(ctx, request)
}

{% for _, reference in schema.References %}
{% set refType = schema.JSONSchema.GoName| add:reference.GoName | add:"Ref" %}
func (service *EventProducerService) Create{{ refType }}(ctx context.Context, request *Create{{ refType }}Request) (*Create{{ refType }}Response, error) {
    _, err := service.Processor.Process(
        ctx,
        &Event{Request: &Event_Create{{ refType }}Request{
            Create{{ refType }}Request: request,
        }},
    )
    if err != nil {
        return nil, err
    }
    return service.Next().Create{{ refType }}(ctx, request)
}

func (service *EventProducerService) Delete{{ refType }}(ctx context.Context, request *Delete{{ refType }}Request) (*Delete{{ refType }}Response, error) {
    _, err := service.Processor.Process(
        ctx,
        &Event{Request: &Event_Delete{{ refType }}Request{
            Delete{{ refType }}Request: request,
        }},
    )
    if err != nil {
        return nil, err
    }
    return service.Next().Delete{{ refType }}(ctx, request)
}
{% endfor %}

func (e *Event_Create{{ schema.JSONSchema.GoName }}Request) Process(ctx context.Context, service Service) (*Event, error) {
    request := e.Create{{ schema.JSONSchema.GoName }}Request
    model := request.{{ schema.JSONSchema.GoName }}
    uuid := model.GetUUID()
    if uuid != "" {
        _, err := service.Get{{ schema.JSONSchema.GoName }}(ctx,
            &Get{{ schema.JSONSchema.GoName }}Request{
                ID: uuid,
                Fields: []string{"uuid"},
        })
        if err == nil {
            model := request.{{ schema.JSONSchema.GoName }}
            response, err := service.Update{{ schema.JSONSchema.GoName }}(ctx, &Update{{ schema.JSONSchema.GoName }}Request{
                {{ schema.JSONSchema.GoName }}: model,
                FieldMask: baseservices.MapToFieldMask(model.ToMap()),
            })
            if err != nil {
                return nil, err
            }
            return &Event{
                Request: &Event_Update{{ schema.JSONSchema.GoName }}Request{
                    Update{{ schema.JSONSchema.GoName }}Request: &Update{{ schema.JSONSchema.GoName }}Request{
                        {{ schema.JSONSchema.GoName }}: response.Get{{ schema.JSONSchema.GoName }}(),
                    },
                },
            }, nil
        }
    }
    response, err := service.Create{{ schema.JSONSchema.GoName }}(ctx, request)
    if err != nil {
        return nil, err
    }
    return &Event{
        Request: &Event_Create{{ schema.JSONSchema.GoName }}Request{
            Create{{ schema.JSONSchema.GoName }}Request: &Create{{ schema.JSONSchema.GoName }}Request{
                {{ schema.JSONSchema.GoName }}: response.Get{{ schema.JSONSchema.GoName }}(),
            },
        },
    }, nil
}

func (e *Event_Update{{ schema.JSONSchema.GoName }}Request) Process(ctx context.Context, service Service) (*Event, error) {
    request := e.Update{{ schema.JSONSchema.GoName }}Request
    response, err := service.Update{{ schema.JSONSchema.GoName }}(ctx, request)
    if err != nil {
        return nil, err
    }
    return &Event{
        Request: &Event_Update{{ schema.JSONSchema.GoName }}Request{
            Update{{ schema.JSONSchema.GoName }}Request: &Update{{ schema.JSONSchema.GoName }}Request{
                {{ schema.JSONSchema.GoName }}: response.Get{{ schema.JSONSchema.GoName }}(),
            },
        },
    }, nil
}

func (e *Event_Delete{{ schema.JSONSchema.GoName }}Request) Process(ctx context.Context, service Service) (*Event, error) {
    request := e.Delete{{ schema.JSONSchema.GoName }}Request
    _, err := service.Delete{{ schema.JSONSchema.GoName }}(ctx, request)
    if err != nil {
        return nil, err
    }
    return &Event{
        Request: &Event_Delete{{ schema.JSONSchema.GoName }}Request{
            Delete{{ schema.JSONSchema.GoName }}Request: &Delete{{ schema.JSONSchema.GoName }}Request{
                ID: request.ID,
            },
        },
    }, nil
}

{% for _, reference in schema.References %}
{% set refType = schema.JSONSchema.GoName| add:reference.GoName | add:"Ref" %}
func (e *Event_Create{{ refType }}Request) Process(ctx context.Context, service Service) (*Event, error) {
    request := e.Create{{ refType }}Request
    if _, err := service.Create{{ refType }}(ctx, request); err != nil {
        return nil, err
    }
    return &Event{Request: &Event_Create{{ refType }}Request{
        Create{{ refType }}Request: request,
    }}, nil
}

func (e *Event_Delete{{ refType }}Request) Process(ctx context.Context, service Service) (*Event, error) {
    request := e.Delete{{ refType }}Request
    if _, err := service.Delete{{ refType }}(ctx, request); err != nil {
        return nil, err
    }
    return &Event{Request: &Event_Delete{{ refType }}Request{
        Delete{{ refType }}Request: request,
    }}, nil
}
{% endfor %}

{% endif%}{% endfor %}

//Dump dumps all service data.
func Dump(ctx context.Context, service Service) (*EventList, error) {
    response := []*Event{}
    {% for schema in schemas %}{% if schema.Type != "abstract" and schema.ID %}
    list{{ schema.JSONSchema.GoName }}, err := service.List{{ schema.JSONSchema.GoName }}(ctx,
        &List{{ schema.JSONSchema.GoName }}Request{
           &baseservices.ListSpec{
               Detail: true,
           },
        },
    )
    if err != nil {
        return nil, common.ToHTTPError(err)
    }
    for _, resource := range list{{ schema.JSONSchema.GoName }}.{{ schema.JSONSchema.GoName }}s {
        response = append(response, &Event{
                    Request: &Event_Create{{ schema.JSONSchema.GoName }}Request{
                        Create{{ schema.JSONSchema.GoName }}Request: &Create{{ schema.JSONSchema.GoName }}Request{
                            {{ schema.JSONSchema.GoName }}: resource,
                        }}})
    }
    {% endif %}{% endfor %}
    return &EventList{
        Events: response,
    }, nil
}