settings/cmd/microsettingsd/settingshandler/handler.go

package settingshandler

import (
	"context"

	"github.com/urfave/cli/v2"
	"google.golang.org/protobuf/types/known/timestamppb"
	"jochum.dev/jo-micro/auth2"
	"jochum.dev/jo-micro/auth2/plugins/verifier/endpointroles"
	"jochum.dev/jo-micro/components"
	"jochum.dev/jo-micro/logruscomponent"
	"jochum.dev/jo-micro/router"
	"jochum.dev/jo-micro/settings/cmd/microsettingsd/db"
	"jochum.dev/jo-micro/settings/proto/settingspb"
)

const Name = "settingsHandler"

type Handler struct {
	cReg        *components.Registry
	initialized bool
}

func New() *Handler {
	return &Handler{}
}

func MustReg(cReg *components.Registry) *Handler {
	return cReg.Must(Name).(*Handler)
}

func (h *Handler) Name() string {
	return Name
}

func (h *Handler) Priority() int {
	return 100
}

func (h *Handler) Initialized() bool {
	return h.initialized
}

func (h *Handler) Init(components *components.Registry, cli *cli.Context) error {
	if h.initialized {
		return nil
	}

	h.cReg = components

	r := router.MustReg(h.cReg)
	r.Add(
		router.NewRoute(
			router.Method(router.MethodGet),
			router.Path("/"),
			router.Endpoint(settingspb.SettingsService.List),
			router.Params("id", "ownerId", "service", "name", "limit", "offset"),
		),
		router.NewRoute(
			router.Method(router.MethodPost),
			router.Path("/"),
			router.Endpoint(settingspb.SettingsService.Create),
		),
		router.NewRoute(
			router.Method(router.MethodGet),
			router.Path("/:id"),
			router.Endpoint(settingspb.SettingsService.Get),
			router.Params("id", "ownerId", "service", "name"),
		),
		router.NewRoute(
			router.Method(router.MethodPut),
			router.Path("/:id"),
			router.Endpoint(settingspb.SettingsService.Update),
			router.Params("id"),
		),
	)

	authVerifier := endpointroles.NewVerifier(
		endpointroles.WithLogrus(logruscomponent.MustReg(h.cReg).Logger()),
	)
	authVerifier.AddRules(
		endpointroles.NewRule(
			endpointroles.Endpoint(settingspb.SettingsService.List),
			endpointroles.RolesAllow(auth2.RolesServiceAndUsersAndAdmin),
		),
		endpointroles.NewRule(
			endpointroles.Endpoint(settingspb.SettingsService.Create),
			endpointroles.RolesAllow(auth2.RolesServiceAndAdmin),
		),
		endpointroles.NewRule(
			endpointroles.Endpoint(settingspb.SettingsService.Get),
			endpointroles.RolesAllow(auth2.RolesServiceAndUsersAndAdmin),
		),
		endpointroles.NewRule(
			endpointroles.Endpoint(settingspb.SettingsService.Update),
			endpointroles.RolesAllow(auth2.RolesServiceAndUsersAndAdmin),
		),
		endpointroles.NewRule(
			endpointroles.Endpoint(settingspb.SettingsService.Upsert),
			endpointroles.RolesAllow(auth2.RolesServiceAndUsersAndAdmin),
		),
	)
	auth2.ClientAuthMustReg(h.cReg).Plugin().AddVerifier(authVerifier)

	settingspb.RegisterSettingsServiceHandler(h.cReg.Service().Server(), h)

	h.initialized = true
	return nil
}

func (h *Handler) Stop() error {
	return nil
}

func (h *Handler) Flags(r *components.Registry) []cli.Flag {
	return []cli.Flag{}
}

func (h *Handler) Health(context context.Context) error {
	return nil
}

func (h *Handler) translateDBSettingToPB(dbs *db.Setting, out *settingspb.Setting) error {
	out.Id = dbs.ID.String()
	out.OwnerId = dbs.OwnerID.String()
	out.Service = dbs.Service
	out.Name = dbs.Name
	out.Content = dbs.Content
	out.CreatedAt = timestamppb.New(dbs.CreatedAt)
	if !dbs.UpdatedAt.IsZero() {
		out.UpdatedAt = timestamppb.New(dbs.UpdatedAt.Time)
	}

	return nil
}

func (h *Handler) Create(ctx context.Context, in *settingspb.CreateRequest, out *settingspb.Setting) error {
	result, err := db.SettingsCreate(h.cReg, ctx, in)
	if err != nil {
		return err
	}

	return h.translateDBSettingToPB(result, out)
}

func (h *Handler) Update(ctx context.Context, in *settingspb.UpdateRequest, out *settingspb.Setting) error {
	result, err := db.SettingsUpdate(h.cReg, ctx, in.Id, "", "", "", in.Content)
	if err != nil {
		return err
	}

	return h.translateDBSettingToPB(result, out)
}

func (h *Handler) Upsert(ctx context.Context, in *settingspb.UpsertRequest, out *settingspb.Setting) error {
	result, err := db.SettingsUpsert(h.cReg, ctx, in)
	if err != nil {
		return err
	}

	return h.translateDBSettingToPB(result, out)
}

func (h *Handler) Get(ctx context.Context, in *settingspb.GetRequest, out *settingspb.Setting) error {
	result, err := db.SettingsGet(h.cReg, ctx, in.Id, in.OwnerId, in.Service, in.Name)
	if err != nil {
		return err
	}

	return h.translateDBSettingToPB(result, out)
}

func (h *Handler) List(ctx context.Context, in *settingspb.ListRequest, out *settingspb.SettingsList) error {
	results, err := db.SettingsList(h.cReg, ctx, in.Id, in.OwnerId, in.Service, in.Name, in.Limit, in.Offset)
	if err != nil {
		return err
	}

	// Copy the data to the result
	for _, result := range results {
		row := &settingspb.Setting{}
		if err := h.translateDBSettingToPB(&result, row); err != nil {
			continue
		}
		out.Data = append(out.Data, row)
	}

	return nil
}