add init api methode for create redirects

domain/redirectdefinition/api.go

@@ -1,40 +1,63 @@
 package redirectdefinition
 
 import (
+	"context"
 	"errors"
 
+	redirectcommand "github.com/foomo/redirects/domain/redirectdefinition/command"
+	redirectrepository "github.com/foomo/redirects/domain/redirectdefinition/repository"
 	"go.uber.org/zap"
 )
 
 // API for the domain
 type (
 	API struct {
-		Queries  Queries
-		Commands Commands
-		//repo     *cmrccheckoutrepo.CheckoutRepository
-		l *zap.Logger
+		//qry  Queries
+		cmd  Commands
+		repo *redirectrepository.RedirectsDefinitionRepository
+		l    *zap.Logger
 		//meter                      *cmrccommonmetric.Meter
 	}
 	Option func(api *API)
 )
 
 func NewAPI(
 	l *zap.Logger,
+	repo *redirectrepository.RedirectsDefinitionRepository,
 	opts ...Option,
 ) (*API, error) {
 
 	inst := &API{
-		l: l,
-		//repo: checkoutRepo,
+		l:    l,
+		repo: repo,
 		//meter:                      cmrccommonmetric.NewMeter(l, "checkout", telemetry.Meter()),
 	}
 	if inst.l == nil {
 		return nil, errors.New("missing logger")
 	}
+	if inst.repo == nil {
+		return nil, errors.New("missing cart repository")
+	}
+	inst.cmd = Commands{
+		CreateRedirects: redirectcommand.CreateRedirectsHandlerComposed(
+			redirectcommand.CreateRedirectsHandler(inst.repo),
+		),
+	}
 
 	for _, opt := range opts {
 		opt(inst)
 	}
 
 	return inst, nil
 }
+
+// ------------------------------------------------------------------------------------------------
+// ~ Public methods
+// ------------------------------------------------------------------------------------------------
+
+func (a *API) CreateRedirects(ctx context.Context, cmd redirectcommand.CreateRedirects) (err error) {
+	if err := a.cmd.CreateRedirects(ctx, a.l, cmd); err != nil {
+		return err
+	}
+	return nil
+}

domain/redirectdefinition/command/createredirectsfromcontentserver.go

@@ -0,0 +1,53 @@
+package redirectcommand
+
+import (
+	"context"
+	"reflect"
+	"runtime"
+	"strings"
+
+	"github.com/foomo/contentserver/content"
+	redirectrepository "github.com/foomo/redirects/domain/redirectdefinition/repository"
+	"go.opentelemetry.io/otel/trace"
+	"go.uber.org/zap"
+)
+
+type (
+	// CreateRedirects command
+	CreateRedirects struct {
+		OldState map[string]*content.RepoNode `json:"oldState"`
+		NewState map[string]*content.RepoNode `json:"newState"`
+	}
+	// CreateRedirectsHandlerFn handler
+	CreateRedirectsHandlerFn func(ctx context.Context, l *zap.Logger, cmd CreateRedirects) error
+	// CreateRedirectsMiddlewareFn middleware
+	CreateRedirectsMiddlewareFn func(next CreateRedirectsHandlerFn) CreateRedirectsHandlerFn
+)
+
+// CreateRedirectsHandler ...
+func CreateRedirectsHandler(repo *redirectrepository.RedirectsDefinitionRepository) CreateRedirectsHandlerFn {
+	return func(ctx context.Context, l *zap.Logger, cmd CreateRedirects) error {
+
+		return nil //repo.Upsert(ctx, entity)
+	}
+}
+
+// CreateRedirectsHandlerComposed returns the handler with middleware applied to it
+func CreateRedirectsHandlerComposed(handler CreateRedirectsHandlerFn, middlewares ...CreateRedirectsMiddlewareFn) CreateRedirectsHandlerFn {
+	composed := func(next CreateRedirectsHandlerFn) CreateRedirectsHandlerFn {
+		for _, middleware := range middlewares {
+			localNext := next
+			middlewareName := strings.Split(runtime.FuncForPC(reflect.ValueOf(middleware).Pointer()).Name(), ".")[2]
+			next = middleware(func(ctx context.Context, l *zap.Logger, cmd CreateRedirects) error {
+				trace.SpanFromContext(ctx).AddEvent(middlewareName)
+				return localNext(ctx, l, cmd)
+			})
+		}
+		return next
+	}
+	handlerName := strings.Split(runtime.FuncForPC(reflect.ValueOf(handler).Pointer()).Name(), ".")[2]
+	return composed(func(ctx context.Context, l *zap.Logger, cmd CreateRedirects) error {
+		trace.SpanFromContext(ctx).AddEvent(handlerName)
+		return handler(ctx, l, cmd)
+	})
+}

domain/redirectdefinition/commands.go

@@ -1,4 +1,9 @@
 package redirectdefinition
 
+import (
+	redirectcommand "github.com/foomo/redirects/domain/redirectdefinition/command"
+)
+
 type Commands struct {
+	CreateRedirects redirectcommand.CreateRedirectsHandlerFn
 }

domain/redirectdefinition/repository/redirectdefinition.go

@@ -22,7 +22,7 @@ type (
 	}
 )
 
-func NewRedirectsStore(l *zap.Logger, persistor *keelmongo.Persistor) (rs *RedirectsDefinitionRepository, err error) {
+func NewRedirectsDefinitionRepository(l *zap.Logger, persistor *keelmongo.Persistor) (rs *RedirectsDefinitionRepository, err error) {
 	collection, cErr := persistor.Collection(
 		"redirects",
 		keelmongo.CollectionWithIndexes(

domain/redirectdefinition/service.go

@@ -1,25 +1,38 @@
 package redirectdefinition
 
 import (
+	"context"
+
 	"github.com/foomo/contentserver/content"
 	keelmongo "github.com/foomo/keel/persistence/mongo"
+	redirectcommand "github.com/foomo/redirects/domain/redirectdefinition/command"
 	redirectstore "github.com/foomo/redirects/domain/redirectdefinition/store"
 	"go.uber.org/zap"
 )
 
 // Potentially add Nats to service (still not sure)
 type Service struct {
-	l *zap.Logger
+	l   *zap.Logger
+	api *API
 }
 
-func NewService(l *zap.Logger, p *keelmongo.Persistor) (*Service, error) {
+func NewService(l *zap.Logger, p *keelmongo.Persistor, api *API) (*Service, error) {
 	return &Service{
-		l: l,
+		l:   l,
+		api: api,
 	}, nil
 }
 
 func (rs *Service) CreateRedirectsFromContentserverexport(old, new map[string]*content.RepoNode) error {
 	// TODO: Implement
+	err := rs.api.CreateRedirects(context.Background(),
+		redirectcommand.CreateRedirects{
+			OldState: old,
+			NewState: new,
+		})
+	if err != nil {
+		return err
+	}
 	return nil
 }