snapshot of https://github.com/cortezaproject/corteza.git (2024.9.x, 2026-09-18; blobs > 131072B omitted)

server/system/rest/actionlog.go

@@ -0,0 +1,194 @@
+package rest
+
+import (
+	"context"
+	"strconv"
+	"strings"
+
+	"github.com/cortezaproject/corteza/server/pkg/actionlog"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	pkgid "github.com/cortezaproject/corteza/server/pkg/id"
+	"github.com/cortezaproject/corteza/server/store"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-oauth2/oauth2/v4/errors"
+)
+
+type (
+	Actionlog struct {
+		actionSvc actionlog.Recorder
+		store     store.Users
+		ac        interface {
+			CanReadActionLog(ctx context.Context) bool
+		}
+	}
+
+	// Extend actionlog.Action so we can
+	// provide user's email
+	actionlogActionPayload struct {
+		*actionlog.Action
+		Actor string                 `json:"actor,omitempty"`
+		Meta  map[string]interface{} `json:"meta,omitempty"`
+	}
+
+	actionlogPayload struct {
+		Filter actionlog.Filter          `json:"filter"`
+		Set    []*actionlogActionPayload `json:"set"`
+	}
+)
+
+func (Actionlog) New() *Actionlog {
+	return &Actionlog{
+		actionSvc: service.DefaultActionlog,
+		ac:        service.DefaultAccessControl,
+		store:     service.DefaultStore,
+	}
+}
+
+func (ctrl *Actionlog) List(ctx context.Context, r *request.ActionlogList) (interface{}, error) {
+	if !ctrl.ac.CanReadActionLog(ctx) {
+		return nil, errors.ErrAccessDenied
+	}
+
+	var (
+		err error
+		f   = actionlog.Filter{
+			FromTimestamp:  r.From,
+			ToTimestamp:    r.To,
+			BeforeActionID: r.BeforeActionID,
+			ActorID:        r.ActorID,
+			Resource:       r.Resource,
+			Action:         r.Action,
+			Limit:          r.Limit,
+		}
+	)
+
+	ee, f, err := ctrl.actionSvc.Find(ctx, f)
+
+	return ctrl.makeFilterPayload(ctx, ee, f, err)
+}
+
+func (ctrl Actionlog) makeFilterPayload(ctx context.Context, ee []*actionlog.Action, f actionlog.Filter, err error) (*actionlogPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	var (
+		pp = make([]*actionlogActionPayload, len(ee))
+	)
+
+	// Remap events to payload structs
+	for e := range ee {
+		pp[e] = &actionlogActionPayload{Action: ee[e]}
+		pp[e].Meta = ee[e].Meta
+
+		sanitizeMapStringInterface(pp[e].Meta)
+	}
+
+	err = userPreloader(
+		ctx,
+		ctrl.store,
+		func(c chan uint64) {
+			for e := range ee {
+				c <- ee[e].ActorID
+			}
+
+			close(c)
+		},
+		types.UserFilter{
+			Deleted:   filter.StateInclusive,
+			Suspended: filter.StateInclusive,
+		},
+		func(u *types.User) error {
+			for p := range pp {
+				if pp[p].ActorID == u.ID {
+					pp[p].Actor = u.Name
+					if pp[p].Actor == "" {
+						pp[p].Actor = u.Email
+					}
+				}
+			}
+
+			return nil
+		},
+	)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &actionlogPayload{Filter: f, Set: pp}, nil
+}
+
+// Making sure JS can read old entries that were encoded
+// as numeric. When decoded from the JSON stored in the DB
+// they are of type float64. We'll cast them and store as uint64
+//
+// We do not want to do that to any numeric values just for the keys ending with
+// "ID" or "By"
+func sanitizeMapStringInterface(m map[string]interface{}) {
+	for k := range m {
+		switch v := m[k].(type) {
+		case float64:
+			if strings.HasSuffix(k, "ID") || strings.HasSuffix(k, "By") {
+				// make sure uint64 values on fields ending with ID
+				// are properly encoded as strings
+				m[k] = strconv.FormatUint(uint64(v), 10)
+			}
+
+		case map[string]interface{}:
+			sanitizeMapStringInterface(v)
+		}
+	}
+}
+
+// Preloader collects all ids of users, loads them and sets them back
+//
+// We'll be accessing the store directly since this is protected with action-log.read operation check.
+//
+// @todo move action log collection and user merging to dedicated service
+func userPreloader(ctx context.Context, s store.Users, g func(chan uint64), f types.UserFilter, collect func(*types.User) error) error {
+	var (
+		// channel that will collect the IDs in the getter
+		ch = make(chan uint64, 0)
+
+		// unique index for IDs
+		unq = make(map[uint64]bool)
+	)
+
+	// Reset the collection of the IDs
+	f.UserID = make([]string, 0)
+
+	// Call getter and collect the IDs
+	go g(ch)
+
+rangeLoop:
+	for {
+		select {
+		case <-ctx.Done():
+			close(ch)
+			break rangeLoop
+		case id, ok := <-ch:
+			if !ok {
+				// Channel closed
+				break rangeLoop
+			}
+
+			if !unq[id] {
+				unq[id] = true
+				f.UserID = append(f.UserID, pkgid.String(id))
+			}
+		}
+
+	}
+
+	// Load all users (even if deleted, suspended) from the given list of IDs
+	uu, _, err := store.SearchUsers(ctx, s, f)
+
+	if err != nil {
+		return err
+	}
+
+	return uu.Walk(collect)
+}

server/system/rest/apigw_filter.go

@@ -0,0 +1,156 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	ApigwFilter struct {
+		svc filterService
+		ac  templateAccessController
+	}
+
+	functionPayload struct {
+		*types.ApigwFilter
+	}
+
+	functionSetPayload struct {
+		Filter types.ApigwFilterFilter `json:"filter"`
+		Set    []*functionPayload      `json:"set"`
+	}
+
+	filterService interface {
+		FindByID(ctx context.Context, ID uint64) (*types.ApigwFilter, error)
+		Search(ctx context.Context, filter types.ApigwFilterFilter) (types.ApigwFilterSet, types.ApigwFilterFilter, error)
+		Create(ctx context.Context, new *types.ApigwFilter) (*types.ApigwFilter, error)
+		Update(ctx context.Context, upd *types.ApigwFilter) (*types.ApigwFilter, error)
+		DeleteByID(ctx context.Context, ID uint64) error
+		UndeleteByID(ctx context.Context, ID uint64) error
+
+		DefFilter(context.Context, string) (interface{}, error)
+		DefProxyAuth(context.Context) (interface{}, error)
+	}
+)
+
+func (ApigwFilter) New() *ApigwFilter {
+	return &ApigwFilter{
+		svc: service.DefaultApigwFilter,
+		ac:  service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *ApigwFilter) List(ctx context.Context, r *request.ApigwFilterList) (interface{}, error) {
+	var (
+		err error
+		f   = types.ApigwFilterFilter{
+			RouteID: r.RouteID,
+			Deleted: filter.State(r.Deleted),
+
+			// todo: this should dynamic as Delete
+			//		but making it default to `1`, until UI is aligned with this
+			Disabled: filter.StateInclusive,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.svc.Search(ctx, f)
+
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl *ApigwFilter) Create(ctx context.Context, r *request.ApigwFilterCreate) (interface{}, error) {
+	var (
+		err error
+		q   = &types.ApigwFilter{
+			Route:   r.RouteID,
+			Weight:  r.Weight,
+			Kind:    r.Kind,
+			Ref:     r.Ref,
+			Enabled: r.Enabled,
+			Params:  r.Params,
+		}
+	)
+
+	q, err = ctrl.svc.Create(ctx, q)
+
+	return ctrl.makePayload(ctx, q, err)
+}
+
+func (ctrl *ApigwFilter) Read(ctx context.Context, r *request.ApigwFilterRead) (interface{}, error) {
+	return ctrl.svc.FindByID(ctx, r.FilterID)
+}
+
+func (ctrl *ApigwFilter) Update(ctx context.Context, r *request.ApigwFilterUpdate) (interface{}, error) {
+	var (
+		err error
+		q   = &types.ApigwFilter{
+			ID:        r.FilterID,
+			Route:     r.RouteID,
+			Weight:    r.Weight,
+			Kind:      r.Kind,
+			Ref:       r.Ref,
+			Enabled:   r.Enabled,
+			Params:    r.Params,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	q, err = ctrl.svc.Update(ctx, q)
+
+	return ctrl.makePayload(ctx, q, err)
+}
+
+func (ctrl *ApigwFilter) Delete(ctx context.Context, r *request.ApigwFilterDelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.DeleteByID(ctx, r.FilterID)
+}
+
+func (ctrl *ApigwFilter) DefFilter(ctx context.Context, r *request.ApigwFilterDefFilter) (interface{}, error) {
+	return ctrl.svc.DefFilter(ctx, r.Kind)
+}
+
+func (ctrl *ApigwFilter) DefProxyAuth(ctx context.Context, r *request.ApigwFilterDefProxyAuth) (interface{}, error) {
+	return ctrl.svc.DefProxyAuth(ctx)
+}
+
+func (ctrl *ApigwFilter) Undelete(ctx context.Context, r *request.ApigwFilterUndelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.UndeleteByID(ctx, r.FilterID)
+}
+
+func (ctrl *ApigwFilter) makePayload(ctx context.Context, q *types.ApigwFilter, err error) (*functionPayload, error) {
+	if err != nil || q == nil {
+		return nil, err
+	}
+
+	qq := &functionPayload{
+		ApigwFilter: q,
+	}
+
+	return qq, nil
+}
+
+func (ctrl *ApigwFilter) makeFilterPayload(ctx context.Context, nn types.ApigwFilterSet, f types.ApigwFilterFilter, err error) (*functionSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &functionSetPayload{Filter: f, Set: make([]*functionPayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/system/rest/apigw_profiler.go

@@ -0,0 +1,180 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/apigw/profiler"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	profilerService interface {
+		Hits(context.Context, types.ApigwProfilerFilter) (types.ApigwProfilerHitSet, types.ApigwProfilerFilter, error)
+		HitsAggregated(context.Context, types.ApigwProfilerFilter) (types.ApigwProfilerAggregationSet, types.ApigwProfilerFilter, error)
+		Purge(context.Context, *profiler.PurgeFilter)
+	}
+
+	ApigwProfiler struct {
+		svc profilerService
+		ac  templateAccessController
+	}
+
+	profilerRoutePayload struct {
+		*types.ApigwProfilerHit
+	}
+
+	profilerHitPayload struct {
+		*types.ApigwProfilerAggregation
+	}
+
+	profilerRouteSetPayload struct {
+		Filter types.ApigwProfilerFilter `json:"filter"`
+		Set    []*profilerRoutePayload   `json:"set"`
+	}
+
+	profilerHitSetPayload struct {
+		Filter types.ApigwProfilerFilter `json:"filter"`
+		Set    []*profilerHitPayload     `json:"set"`
+	}
+)
+
+func (ApigwProfiler) New() *ApigwProfiler {
+	return &ApigwProfiler{
+		svc: service.DefaultApigwProfiler,
+		ac:  service.DefaultAccessControl,
+	}
+}
+
+// List displays the the aggregated list of routes
+func (ctrl *ApigwProfiler) Aggregation(ctx context.Context, r *request.ApigwProfilerAggregation) (interface{}, error) {
+	var (
+		err error
+		f   = types.ApigwProfilerFilter{
+			Path:   r.Path,
+			Before: r.Before,
+		}
+	)
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	if f.Paging, err = filter.NewPaging(r.Limit, ""); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.svc.HitsAggregated(ctx, f)
+
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+// Route displays the list of hits per-route
+func (ctrl *ApigwProfiler) Route(ctx context.Context, r *request.ApigwProfilerRoute) (interface{}, error) {
+	var (
+		err error
+		f   = types.ApigwProfilerFilter{
+			Path:   r.RouteID,
+			Before: r.Before,
+		}
+	)
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	if f.Paging, err = filter.NewPaging(r.Limit, ""); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.svc.Hits(ctx, f)
+
+	return ctrl.makeRouteFilterPayload(ctx, set, f, err)
+}
+
+// Hit displays the details of a certain hit on a route
+func (ctrl *ApigwProfiler) Hit(ctx context.Context, r *request.ApigwProfilerHit) (interface{}, error) {
+	var (
+		f = types.ApigwProfilerFilter{
+			Hit: r.HitID,
+		}
+	)
+
+	set, f, err := ctrl.svc.Hits(ctx, f)
+
+	if len(set) != 1 {
+		return nil, nil
+	}
+
+	return ctrl.makeRoutePayload(ctx, set[0], err)
+}
+
+func (ctrl *ApigwProfiler) PurgeAll(ctx context.Context, r *request.ApigwProfilerPurgeAll) (_ interface{}, _ error) {
+	var (
+		f = &profiler.PurgeFilter{}
+	)
+
+	ctrl.svc.Purge(ctx, f)
+	return
+}
+
+func (ctrl *ApigwProfiler) Purge(ctx context.Context, r *request.ApigwProfilerPurge) (_ interface{}, _ error) {
+	var (
+		f = &profiler.PurgeFilter{
+			RouteID: r.RouteID,
+		}
+	)
+
+	ctrl.svc.Purge(ctx, f)
+	return
+}
+
+func (ctrl *ApigwProfiler) makePayload(ctx context.Context, q *types.ApigwProfilerAggregation, err error) (*profilerHitPayload, error) {
+	if err != nil || q == nil {
+		return nil, err
+	}
+
+	qq := &profilerHitPayload{
+		ApigwProfilerAggregation: q,
+	}
+
+	return qq, nil
+}
+
+func (ctrl *ApigwProfiler) makeFilterPayload(ctx context.Context, nn types.ApigwProfilerAggregationSet, f types.ApigwProfilerFilter, err error) (*profilerHitSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &profilerHitSetPayload{Filter: f, Set: make([]*profilerHitPayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}
+
+func (ctrl *ApigwProfiler) makeRoutePayload(ctx context.Context, q *types.ApigwProfilerHit, err error) (*profilerRoutePayload, error) {
+	if err != nil || q == nil {
+		return nil, err
+	}
+
+	return &profilerRoutePayload{q}, nil
+}
+
+func (ctrl *ApigwProfiler) makeRouteFilterPayload(ctx context.Context, nn types.ApigwProfilerHitSet, f types.ApigwProfilerFilter, err error) (*profilerRouteSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &profilerRouteSetPayload{Filter: f, Set: make([]*profilerRoutePayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makeRoutePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/system/rest/apigw_route.go

@@ -0,0 +1,162 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	ApigwRoute struct {
+		svc routeService
+		ac  apiGwRouteAccessController
+	}
+
+	routePayload struct {
+		*types.ApigwRoute
+
+		CanGrant            bool `json:"canGrant"`
+		CanUpdateApigwRoute bool `json:"canUpdateApigwRoute"`
+		CanDeleteApigwRoute bool `json:"canDeleteApigwRoute"`
+	}
+
+	routeSetPayload struct {
+		Filter types.ApigwRouteFilter `json:"filter"`
+		Set    []*routePayload        `json:"set"`
+	}
+
+	routeService interface {
+		FindByID(ctx context.Context, ID uint64) (*types.ApigwRoute, error)
+		Create(ctx context.Context, new *types.ApigwRoute) (*types.ApigwRoute, error)
+		Update(ctx context.Context, upd *types.ApigwRoute) (*types.ApigwRoute, error)
+		DeleteByID(ctx context.Context, ID uint64) error
+		UndeleteByID(ctx context.Context, ID uint64) error
+		Search(ctx context.Context, filter types.ApigwRouteFilter) (types.ApigwRouteSet, types.ApigwRouteFilter, error)
+	}
+
+	apiGwRouteAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanCreateApigwRoute(context.Context) bool
+		CanUpdateApigwRoute(context.Context, *types.ApigwRoute) bool
+		CanDeleteApigwRoute(context.Context, *types.ApigwRoute) bool
+	}
+)
+
+func (ApigwRoute) New() *ApigwRoute {
+	return &ApigwRoute{
+		svc: service.DefaultApigwRoute,
+		ac:  service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *ApigwRoute) List(ctx context.Context, r *request.ApigwRouteList) (interface{}, error) {
+	var (
+		err error
+		f   = types.ApigwRouteFilter{
+			// todo: this should renamed to r.Endpoint after UI is aligned with this
+			Endpoint: r.Query,
+			Deleted:  filter.State(r.Deleted),
+
+			// todo: this should dynamic as Delete
+			//		but making it default to `1`, until UI is aligned with this
+			Disabled: filter.StateInclusive,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.svc.Search(ctx, f)
+
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl *ApigwRoute) Create(ctx context.Context, r *request.ApigwRouteCreate) (interface{}, error) {
+	var (
+		err error
+		q   = &types.ApigwRoute{
+			Endpoint: r.Endpoint,
+			Method:   r.Method,
+			Enabled:  r.Enabled,
+		}
+	)
+
+	q, err = ctrl.svc.Create(ctx, q)
+
+	return ctrl.makePayload(ctx, q, err)
+}
+
+func (ctrl *ApigwRoute) Read(ctx context.Context, r *request.ApigwRouteRead) (interface{}, error) {
+	res, err := ctrl.svc.FindByID(ctx, r.RouteID)
+	return ctrl.makePayload(ctx, res, err)
+}
+
+func (ctrl *ApigwRoute) Update(ctx context.Context, r *request.ApigwRouteUpdate) (interface{}, error) {
+	var (
+		err error
+		q   = &types.ApigwRoute{
+			ID:        r.RouteID,
+			Endpoint:  r.Endpoint,
+			Method:    r.Method,
+			Group:     r.Group,
+			Enabled:   r.Enabled,
+			Meta:      r.Meta,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	q, err = ctrl.svc.Update(ctx, q)
+
+	return ctrl.makePayload(ctx, q, err)
+}
+
+func (ctrl *ApigwRoute) Delete(ctx context.Context, r *request.ApigwRouteDelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.DeleteByID(ctx, r.RouteID)
+}
+
+func (ctrl *ApigwRoute) Undelete(ctx context.Context, r *request.ApigwRouteUndelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.UndeleteByID(ctx, r.RouteID)
+}
+
+func (ctrl *ApigwRoute) makePayload(ctx context.Context, q *types.ApigwRoute, err error) (*routePayload, error) {
+	if err != nil || q == nil {
+		return nil, err
+	}
+
+	qq := &routePayload{
+		ApigwRoute: q,
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanUpdateApigwRoute: ctrl.ac.CanUpdateApigwRoute(ctx, q),
+		CanDeleteApigwRoute: ctrl.ac.CanDeleteApigwRoute(ctx, q),
+	}
+
+	return qq, nil
+}
+
+func (ctrl *ApigwRoute) makeFilterPayload(ctx context.Context, nn types.ApigwRouteSet, f types.ApigwRouteFilter, err error) (*routeSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &routeSetPayload{Filter: f, Set: make([]*routePayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/system/rest/application.go

@@ -0,0 +1,254 @@
+package rest
+
+import (
+	"context"
+	"strconv"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/flag"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/service/event"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Application struct {
+		application applicationService
+		attachment  service.AttachmentService
+		ac          applicationAccessController
+	}
+
+	applicationService interface {
+		LookupByID(ctx context.Context, ID uint64) (app *types.Application, err error)
+		Search(ctx context.Context, filter types.ApplicationFilter) (aa types.ApplicationSet, f types.ApplicationFilter, err error)
+		Create(ctx context.Context, new *types.Application) (app *types.Application, err error)
+		Update(ctx context.Context, upd *types.Application) (app *types.Application, err error)
+		Delete(ctx context.Context, ID uint64) (err error)
+		Undelete(ctx context.Context, ID uint64) (err error)
+		Reorder(ctx context.Context, order []uint64) (err error)
+		Flag(ctx context.Context, app *types.Application, ownedBy uint64, f string) error
+		Unflag(ctx context.Context, app *types.Application, ownedBy uint64, f string) error
+	}
+
+	applicationAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanUpdateApplication(context.Context, *types.Application) bool
+		CanDeleteApplication(context.Context, *types.Application) bool
+	}
+
+	applicationPayload struct {
+		*types.Application
+
+		CanGrant             bool `json:"canGrant"`
+		CanUpdateApplication bool `json:"canUpdateApplication"`
+		CanDeleteApplication bool `json:"canDeleteApplication"`
+	}
+
+	applicationSetPayload struct {
+		Filter types.ApplicationFilter `json:"filter"`
+		Set    []*applicationPayload   `json:"set"`
+	}
+)
+
+func (Application) New() *Application {
+	return &Application{
+		application: service.DefaultApplication,
+		attachment:  service.DefaultAttachment,
+		ac:          service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *Application) List(ctx context.Context, r *request.ApplicationList) (interface{}, error) {
+	var (
+		err error
+		f   = types.ApplicationFilter{
+			Name:     r.Name,
+			Query:    r.Query,
+			Labels:   r.Labels,
+			Flags:    r.Flags,
+			IncFlags: r.IncFlags,
+
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.application.Search(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *Application) Create(ctx context.Context, r *request.ApplicationCreate) (interface{}, error) {
+	var (
+		err error
+		app = &types.Application{
+			Name:    r.Name,
+			Enabled: r.Enabled,
+			Weight:  r.Weight,
+			Labels:  r.Labels,
+		}
+	)
+
+	if r.Unify != nil {
+		app.Unify = &types.ApplicationUnify{}
+		if err := r.Unify.Unmarshal(app.Unify); err != nil {
+			return nil, err
+		}
+	}
+
+	app, err = ctrl.application.Create(ctx, app)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *Application) Update(ctx context.Context, r *request.ApplicationUpdate) (interface{}, error) {
+	var (
+		err error
+		app = &types.Application{
+			ID:        r.ApplicationID,
+			Name:      r.Name,
+			Enabled:   r.Enabled,
+			Weight:    r.Weight,
+			Labels:    r.Labels,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	if r.Unify != nil {
+		app.Unify = &types.ApplicationUnify{}
+		if err := r.Unify.Unmarshal(app.Unify); err != nil {
+			return nil, err
+		}
+	}
+
+	app, err = ctrl.application.Update(ctx, app)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *Application) Read(ctx context.Context, r *request.ApplicationRead) (interface{}, error) {
+	app, err := ctrl.application.LookupByID(ctx, r.ApplicationID)
+	if err != nil {
+		return ctrl.makePayload(ctx, app, err)
+	}
+
+	err = flag.Load(ctx, service.DefaultStore, r.IncFlags, auth.GetIdentityFromContext(ctx).Identity(), app)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *Application) Delete(ctx context.Context, r *request.ApplicationDelete) (interface{}, error) {
+	return api.OK(), ctrl.application.Delete(ctx, r.ApplicationID)
+}
+
+func (ctrl *Application) Undelete(ctx context.Context, r *request.ApplicationUndelete) (interface{}, error) {
+	return api.OK(), ctrl.application.Undelete(ctx, r.ApplicationID)
+}
+
+func (ctrl *Application) Upload(ctx context.Context, r *request.ApplicationUpload) (interface{}, error) {
+	file, err := r.Upload.Open()
+	if err != nil {
+		return nil, err
+	}
+	defer file.Close()
+
+	a, err := ctrl.attachment.CreateApplicationAttachment(
+		ctx,
+		r.Upload.Filename,
+		r.Upload.Size,
+		file,
+		nil,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return makeAttachmentPayload(ctx, a, err)
+}
+
+func (ctrl *Application) TriggerScript(ctx context.Context, r *request.ApplicationTriggerScript) (rsp interface{}, err error) {
+	var (
+		application *types.Application
+	)
+
+	if application, err = ctrl.application.LookupByID(ctx, r.ApplicationID); err != nil {
+		return
+	}
+
+	// @todo implement same behaviour as we have on record - Application+oldApplication
+	err = corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.ApplicationOnManual(application, application), r.Args))
+	return application, err
+}
+
+func (ctrl *Application) Reorder(ctx context.Context, r *request.ApplicationReorder) (interface{}, error) {
+	order := make([]uint64, len(r.ApplicationIDs))
+
+	for i, aid := range r.ApplicationIDs {
+		parsed, err := strconv.ParseUint(aid, 10, 64)
+		if err != nil {
+			return nil, err
+		}
+
+		order[i] = parsed
+	}
+
+	return api.OK(), ctrl.application.Reorder(ctx, order)
+}
+
+func (ctrl *Application) FlagCreate(ctx context.Context, r *request.ApplicationFlagCreate) (interface{}, error) {
+	app, err := ctrl.application.LookupByID(ctx, r.ApplicationID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.application.Flag(ctx, app, r.OwnedBy, r.Flag)
+
+}
+
+func (ctrl *Application) FlagDelete(ctx context.Context, r *request.ApplicationFlagDelete) (interface{}, error) {
+	app, err := ctrl.application.LookupByID(ctx, r.ApplicationID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.application.Unflag(ctx, app, r.OwnedBy, r.Flag)
+}
+
+func (ctrl Application) makePayload(ctx context.Context, m *types.Application, err error) (*applicationPayload, error) {
+	if err != nil || m == nil {
+		return nil, err
+	}
+
+	return &applicationPayload{
+		Application: m,
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanUpdateApplication: ctrl.ac.CanUpdateApplication(ctx, m),
+		CanDeleteApplication: ctrl.ac.CanDeleteApplication(ctx, m),
+	}, nil
+}
+
+func (ctrl Application) makeFilterPayload(ctx context.Context, nn types.ApplicationSet, f types.ApplicationFilter, err error) (*applicationSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &applicationSetPayload{Filter: f, Set: make([]*applicationPayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/system/rest/attachment.go

@@ -0,0 +1,187 @@
+package rest
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	attachmentPayload struct {
+		*types.Attachment
+	}
+
+	attachmentSetPayload struct {
+		Filter types.AttachmentFilter `json:"filter"`
+		Set    []*attachmentPayload   `json:"set"`
+	}
+
+	Attachment struct {
+		attachment service.AttachmentService
+	}
+)
+
+func (Attachment) New() *Attachment {
+	return &Attachment{
+		attachment: service.DefaultAttachment,
+	}
+}
+
+func (ctrl Attachment) Read(ctx context.Context, r *request.AttachmentRead) (interface{}, error) {
+	if !auth.GetIdentityFromContext(ctx).Valid() {
+		return nil, fmt.Errorf("Unauthorized")
+	}
+
+	a, err := ctrl.attachment.FindByID(ctx, r.AttachmentID)
+	return makeAttachmentPayload(ctx, a, err)
+}
+
+func (ctrl Attachment) Delete(ctx context.Context, r *request.AttachmentDelete) (interface{}, error) {
+	if !auth.GetIdentityFromContext(ctx).Valid() {
+		return nil, fmt.Errorf("Unauthorized")
+	}
+
+	_, err := ctrl.attachment.FindByID(ctx, r.AttachmentID)
+	if err != nil {
+		return nil, err
+	}
+
+	return api.OK(), ctrl.attachment.DeleteByID(ctx, r.AttachmentID)
+}
+
+func (ctrl Attachment) Original(ctx context.Context, r *request.AttachmentOriginal) (interface{}, error) {
+	if err := ctrl.isAccessible(r.Kind, r.AttachmentID, r.UserID, r.Sign); err != nil {
+		return nil, err
+	}
+
+	return ctrl.serve(ctx, r.AttachmentID, false, r.Download)
+}
+
+func (ctrl Attachment) Preview(ctx context.Context, r *request.AttachmentPreview) (interface{}, error) {
+	if err := ctrl.isAccessible(r.Kind, r.AttachmentID, r.UserID, r.Sign); err != nil {
+		return nil, err
+	}
+
+	return ctrl.serve(ctx, r.AttachmentID, true, false)
+}
+
+func (ctrl Attachment) isAccessible(kind string, attachmentID, userID uint64, signature string) error {
+	if kind == types.AttachmentKindSettings || kind == types.AttachmentKindAvatar {
+		// Attachments on settings are public
+		return nil
+	}
+
+	if signature == "" {
+		return fmt.Errorf("Unauthorized")
+	}
+
+	if userID == 0 {
+		return fmt.Errorf("missing or invalid user ID")
+	}
+
+	if attachmentID == 0 {
+		return fmt.Errorf("missing or invalid attachment ID")
+	}
+
+	if !auth.DefaultSigner.Verify(signature, userID, attachmentID) {
+		return fmt.Errorf("missing or invalid signature")
+	}
+
+	return nil
+}
+
+func (ctrl Attachment) serve(ctx context.Context, attachmentID uint64, preview, download bool) (interface{}, error) {
+	return func(w http.ResponseWriter, req *http.Request) {
+		att, err := ctrl.attachment.FindByID(ctx, attachmentID)
+		if err != nil {
+			// Simplify error handling for now
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+
+		var fh io.ReadSeekCloser
+
+		if preview {
+			fh, err = ctrl.attachment.OpenPreview(att)
+		} else {
+			fh, err = ctrl.attachment.OpenOriginal(att)
+		}
+
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		defer fh.Close()
+
+		name := url.QueryEscape(att.Name)
+
+		if download {
+			w.Header().Add("Content-Disposition", "attachment; filename="+name)
+		} else {
+			w.Header().Add("Content-Disposition", "inline; filename="+name)
+			w.Header().Add("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; sandbox")
+		}
+
+		http.ServeContent(w, req, name, att.CreatedAt, fh)
+	}, nil
+}
+
+func (ctrl Attachment) makeFilterPayload(ctx context.Context, aa types.AttachmentSet, f types.AttachmentFilter, err error) (*attachmentSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	asp := &attachmentSetPayload{Filter: f, Set: make([]*attachmentPayload, len(aa))}
+
+	for i := range aa {
+		asp.Set[i], _ = makeAttachmentPayload(ctx, aa[i], nil)
+	}
+
+	return asp, nil
+}
+
+func makeAttachmentPayload(ctx context.Context, a *types.Attachment, err error) (*attachmentPayload, error) {
+	if err != nil || a == nil {
+		return nil, err
+	}
+
+	var (
+		userID     = auth.GetIdentityFromContext(ctx).Identity()
+		signParams = ""
+
+		preview string
+		baseURL = fmt.Sprintf("/attachment/%s/%d/", a.Kind, a.ID)
+	)
+
+	if a.Meta.Preview != nil {
+		var ext = a.Meta.Preview.Extension
+		if ext == "" {
+			ext = "jpg"
+		}
+
+		preview = baseURL + fmt.Sprintf("preview.%s", ext)
+	}
+
+	switch a.Kind {
+	case types.AttachmentKindSettings:
+		// No URL signing, settings attachments are public.
+	default:
+		signParams = fmt.Sprintf("?sign=%s&userID=%d", auth.DefaultSigner.Sign(userID, a.ID), userID)
+	}
+
+	ap := &attachmentPayload{a}
+
+	ap.Url = baseURL + fmt.Sprintf("original/%s", url.PathEscape(a.Name)) + signParams
+	ap.PreviewUrl = preview + signParams
+
+	return ap, nil
+}

server/system/rest/auth.go

@@ -0,0 +1,81 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Auth struct {
+		settings *types.AppSettings
+		authSvc  authUserService
+	}
+
+	authUserResponse struct {
+		JWT  string           `json:"jwt"`
+		User *authUserPayload `json:"user"`
+	}
+
+	authUserPayload struct {
+		ID       uint64 `json:"userID,string"`
+		Name     string `json:"name"`
+		Email    string `json:"email"`
+		Username string `json:"username"`
+		Handle   string `json:"handle"`
+
+		Roles []string `json:"roles"`
+	}
+
+	authUserService interface {
+		Impersonate(ctx context.Context, userID uint64) (*types.User, error)
+		LoadRoleMemberships(ctx context.Context, user *types.User) error
+	}
+)
+
+func (Auth) New() *Auth {
+	return &Auth{
+		settings: service.CurrentSettings,
+		authSvc:  service.DefaultAuth,
+	}
+}
+
+// Impersonate implements impersonation functionality
+//
+// This is experimental and internals will most likely change in the future:
+func (ctrl *Auth) Impersonate(ctx context.Context, r *request.AuthImpersonate) (interface{}, error) {
+	u, err := ctrl.authSvc.Impersonate(ctx, r.UserID)
+	if err != nil {
+		return nil, err
+	}
+
+	return ctrl.makePayload(ctx, u)
+}
+
+func (ctrl *Auth) makePayload(ctx context.Context, user *types.User) (*authUserResponse, error) {
+	if err := ctrl.authSvc.LoadRoleMemberships(ctx, user); err != nil {
+		return nil, err
+	}
+
+	// Generate and save the token
+	t, err := auth.TokenIssuer.Issue(ctx, auth.WithIdentity(user))
+	if err != nil {
+		return nil, nil
+	}
+
+	return &authUserResponse{
+		JWT: string(t),
+		User: &authUserPayload{
+			ID:       user.ID,
+			Name:     user.Name,
+			Handle:   user.Handle,
+			Username: user.Username,
+			Email:    user.Email,
+			Roles:    payload.Uint64stoa(user.Roles()),
+		},
+	}, nil
+}

server/system/rest/auth_client.go

@@ -0,0 +1,183 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/options"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	AuthClient struct {
+		authClient authClientService
+		ac         authClientAccessController
+		opt        options.AuthOpt
+	}
+
+	authClientService interface {
+		LookupByID(ctx context.Context, ID uint64) (app *types.AuthClient, err error)
+		Search(ctx context.Context, filter types.AuthClientFilter) (aa types.AuthClientSet, f types.AuthClientFilter, err error)
+		Create(ctx context.Context, new *types.AuthClient) (app *types.AuthClient, err error)
+		Update(ctx context.Context, upd *types.AuthClient) (app *types.AuthClient, err error)
+		Delete(ctx context.Context, ID uint64) (err error)
+		Undelete(ctx context.Context, ID uint64) (err error)
+		ExposeSecret(ctx context.Context, ID uint64) (secret string, err error)
+		RegenerateSecret(ctx context.Context, ID uint64) (secret string, err error)
+		IsDefaultClient(c *types.AuthClient) bool
+	}
+
+	authClientAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanUpdateAuthClient(context.Context, *types.AuthClient) bool
+		CanDeleteAuthClient(context.Context, *types.AuthClient) bool
+	}
+
+	authClientPayload struct {
+		*types.AuthClient
+
+		IsDefault bool `json:"isDefault"`
+
+		CanGrant            bool `json:"canGrant"`
+		CanUpdateAuthClient bool `json:"canUpdateAuthClient"`
+		CanDeleteAuthClient bool `json:"canDeleteAuthClient"`
+	}
+
+	authClientSetPayload struct {
+		Filter types.AuthClientFilter `json:"filter"`
+		Set    []*authClientPayload   `json:"set"`
+	}
+)
+
+func (AuthClient) New() *AuthClient {
+	return &AuthClient{
+		authClient: service.DefaultAuthClient,
+		ac:         service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *AuthClient) List(ctx context.Context, r *request.AuthClientList) (interface{}, error) {
+	var (
+		err error
+		f   = types.AuthClientFilter{
+			Handle:  r.Handle,
+			Labels:  r.Labels,
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.authClient.Search(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *AuthClient) Create(ctx context.Context, r *request.AuthClientCreate) (interface{}, error) {
+	var (
+		err error
+		app = &types.AuthClient{
+			Handle:      r.Handle,
+			Meta:        r.Meta,
+			ValidGrant:  r.ValidGrant,
+			RedirectURI: r.RedirectURI,
+			Scope:       r.Scope,
+			Trusted:     r.Trusted,
+			Enabled:     r.Enabled,
+			ValidFrom:   r.ValidFrom,
+			ExpiresAt:   r.ExpiresAt,
+			Security:    r.Security,
+			Labels:      r.Labels,
+		}
+	)
+
+	app, err = ctrl.authClient.Create(ctx, app)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *AuthClient) Update(ctx context.Context, r *request.AuthClientUpdate) (interface{}, error) {
+	var (
+		err error
+		app = &types.AuthClient{
+			ID:          r.ClientID,
+			Handle:      r.Handle,
+			Meta:        r.Meta,
+			ValidGrant:  r.ValidGrant,
+			RedirectURI: r.RedirectURI,
+			Scope:       r.Scope,
+			Trusted:     r.Trusted,
+			Enabled:     r.Enabled,
+			ValidFrom:   r.ValidFrom,
+			ExpiresAt:   r.ExpiresAt,
+			Security:    r.Security,
+			Labels:      r.Labels,
+			UpdatedAt:   r.UpdatedAt,
+		}
+	)
+
+	app, err = ctrl.authClient.Update(ctx, app)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *AuthClient) Read(ctx context.Context, r *request.AuthClientRead) (interface{}, error) {
+	app, err := ctrl.authClient.LookupByID(ctx, r.ClientID)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *AuthClient) ExposeSecret(ctx context.Context, r *request.AuthClientExposeSecret) (interface{}, error) {
+	return ctrl.authClient.ExposeSecret(ctx, r.ClientID)
+}
+
+func (ctrl *AuthClient) RegenerateSecret(ctx context.Context, r *request.AuthClientRegenerateSecret) (interface{}, error) {
+	return ctrl.authClient.RegenerateSecret(ctx, r.ClientID)
+}
+
+func (ctrl *AuthClient) Delete(ctx context.Context, r *request.AuthClientDelete) (interface{}, error) {
+	return api.OK(), ctrl.authClient.Delete(ctx, r.ClientID)
+}
+
+func (ctrl *AuthClient) Undelete(ctx context.Context, r *request.AuthClientUndelete) (interface{}, error) {
+	return api.OK(), ctrl.authClient.Undelete(ctx, r.ClientID)
+}
+
+func (ctrl AuthClient) makePayload(ctx context.Context, m *types.AuthClient, err error) (*authClientPayload, error) {
+	if err != nil || m == nil {
+		return nil, err
+	}
+
+	return &authClientPayload{
+		AuthClient: m,
+
+		IsDefault: ctrl.authClient.IsDefaultClient(m),
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanUpdateAuthClient: ctrl.ac.CanUpdateAuthClient(ctx, m),
+		CanDeleteAuthClient: ctrl.ac.CanDeleteAuthClient(ctx, m),
+	}, nil
+}
+
+func (ctrl AuthClient) makeFilterPayload(ctx context.Context, nn types.AuthClientSet, f types.AuthClientFilter, err error) (*authClientSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &authClientSetPayload{Filter: f, Set: make([]*authClientPayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/system/rest/automation.go

@@ -0,0 +1,48 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service/event"
+)
+
+type (
+	Automation struct{}
+)
+
+func (Automation) New() *Automation {
+	return &Automation{}
+}
+
+func (ctrl *Automation) List(ctx context.Context, r *request.AutomationList) (interface{}, error) {
+	return corredor.GenericListHandler(
+		ctx,
+		corredor.Service(),
+		corredor.Filter{
+			ResourceTypePrefixes: r.ResourceTypePrefixes,
+			ExcludeInvalid:       r.ExcludeInvalid,
+			ResourceTypes:        r.ResourceTypes,
+			EventTypes:           r.EventTypes,
+			ExcludeServerScripts: r.ExcludeServerScripts,
+			ExcludeClientScripts: r.ExcludeClientScripts,
+		},
+		"system",
+	)
+}
+
+func (ctrl *Automation) Bundle(ctx context.Context, r *request.AutomationBundle) (interface{}, error) {
+	return corredor.GenericBundleHandler(
+		ctx,
+		corredor.Service(),
+		r.Bundle,
+		r.Type,
+		r.Ext,
+	)
+}
+
+func (ctrl *Automation) TriggerScript(ctx context.Context, r *request.AutomationTriggerScript) (interface{}, error) {
+	return api.OK(), corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.SystemOnManual(), r.Args))
+}

server/system/rest/dal_connection.go

@@ -0,0 +1,295 @@
+package rest
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"time"
+
+	federationService "github.com/cortezaproject/corteza/server/federation/service"
+	federationTypes "github.com/cortezaproject/corteza/server/federation/types"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/handle"
+	"github.com/cortezaproject/corteza/server/pkg/id"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/modern-go/reflect2"
+)
+
+type (
+	DalConnection struct {
+		svc           connectionService
+		federationSvc federationNodeService
+
+		connectionAc connectionAccessController
+	}
+
+	connectionPayload struct {
+		*types.DalConnection
+
+		CanGrant            bool `json:"canGrant"`
+		CanUpdateConnection bool `json:"canUpdateConnection"`
+		CanDeleteConnection bool `json:"canDeleteConnection"`
+		CanManageDalConfig  bool `json:"canManageDalConfig"`
+	}
+
+	connectionSetPayload struct {
+		Filter types.DalConnectionFilter `json:"filter"`
+		Set    []*connectionPayload      `json:"set"`
+	}
+
+	connectionAccessController interface {
+		CanGrant(context.Context) bool
+		CanCreateDalConnection(context.Context) bool
+		CanUpdateDalConnection(context.Context, *types.DalConnection) bool
+		CanDeleteDalConnection(context.Context, *types.DalConnection) bool
+		CanManageDalConfigOnDalConnection(context.Context, *types.DalConnection) bool
+	}
+
+	connectionService interface {
+		FindByID(ctx context.Context, ID uint64) (*types.DalConnection, error)
+		Create(ctx context.Context, new *types.DalConnection) (*types.DalConnection, error)
+		Update(ctx context.Context, upd *types.DalConnection) (*types.DalConnection, error)
+		DeleteByID(ctx context.Context, ID uint64) error
+		UndeleteByID(ctx context.Context, ID uint64) error
+		Search(ctx context.Context, filter types.DalConnectionFilter) (types.DalConnectionSet, types.DalConnectionFilter, error)
+	}
+
+	federationNodeService interface {
+		Search(ctx context.Context, filter federationTypes.NodeFilter) (set federationTypes.NodeSet, f federationTypes.NodeFilter, err error)
+	}
+)
+
+func (DalConnection) New() *DalConnection {
+	return &DalConnection{
+		svc:           service.DefaultDalConnection,
+		federationSvc: federationService.DefaultNode,
+
+		connectionAc: service.DefaultAccessControl,
+	}
+}
+
+func (ctrl DalConnection) List(ctx context.Context, r *request.DalConnectionList) (interface{}, error) {
+	var (
+		err            error
+		dalConnections types.DalConnectionSet
+
+		f = types.DalConnectionFilter{
+			DalConnectionID: r.ConnectionID,
+			Handle:          r.Handle,
+			Type:            r.Type,
+
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Deleted == 0 {
+		f.Deleted = filter.StateExcluded
+	}
+
+	f.IncTotal = r.IncTotal
+
+	dalConnections, f, err = ctrl.collectConnections(ctx, f)
+	if err != nil {
+		return nil, err
+	}
+
+	return ctrl.makeFilterPayload(ctx, dalConnections, f)
+}
+
+func (ctrl DalConnection) Create(ctx context.Context, r *request.DalConnectionCreate) (interface{}, error) {
+	connection := &types.DalConnection{
+		Handle: r.Handle,
+		Type:   r.Type,
+		Meta:   r.Meta,
+		Config: r.Config,
+	}
+
+	res, err := ctrl.svc.Create(ctx, connection)
+	if err != nil {
+		return nil, err
+	}
+
+	return ctrl.makePayload(ctx, res), nil
+}
+
+func (ctrl DalConnection) Update(ctx context.Context, r *request.DalConnectionUpdate) (interface{}, error) {
+	connection := &types.DalConnection{
+		ID:        r.ConnectionID,
+		Handle:    r.Handle,
+		Type:      r.Type,
+		Meta:      r.Meta,
+		Config:    r.Config,
+		UpdatedAt: r.UpdatedAt,
+	}
+
+	res, err := ctrl.svc.Update(ctx, connection)
+	if err != nil {
+		return nil, err
+	}
+
+	return ctrl.makePayload(ctx, res), nil
+}
+
+func (ctrl DalConnection) Read(ctx context.Context, r *request.DalConnectionRead) (interface{}, error) {
+	res, err := ctrl.svc.FindByID(ctx, r.ConnectionID)
+	if err != nil {
+		return nil, err
+	}
+
+	return ctrl.makePayload(ctx, res), nil
+}
+
+func (ctrl DalConnection) Delete(ctx context.Context, r *request.DalConnectionDelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.DeleteByID(ctx, r.ConnectionID)
+}
+
+func (ctrl DalConnection) Undelete(ctx context.Context, r *request.DalConnectionUndelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.UndeleteByID(ctx, r.ConnectionID)
+}
+
+func (ctrl DalConnection) makeFilterPayload(ctx context.Context, connections types.DalConnectionSet, f types.DalConnectionFilter) (out *connectionSetPayload, err error) {
+	out = &connectionSetPayload{
+		Filter: f,
+		Set:    make([]*connectionPayload, 0, len(connections)),
+	}
+
+	for _, c := range connections {
+		out.Set = append(out.Set, ctrl.makePayload(ctx, c))
+	}
+
+	return
+}
+
+// Make payload for dal-connection
+//
+// # Payload is without connection params on the config prop
+//
+// An explicit call to /params
+func (ctrl DalConnection) makePayload(ctx context.Context, c *types.DalConnection) *connectionPayload {
+	return &connectionPayload{
+		DalConnection: c,
+
+		CanGrant:            ctrl.connectionAc.CanGrant(ctx),
+		CanUpdateConnection: ctrl.connectionAc.CanUpdateDalConnection(ctx, c),
+		CanDeleteConnection: ctrl.connectionAc.CanDeleteDalConnection(ctx, c),
+		CanManageDalConfig:  ctrl.connectionAc.CanManageDalConfigOnDalConnection(ctx, c),
+	}
+}
+
+func (ctrl DalConnection) federatedNodeToConnection(f *federationTypes.Node) *types.DalConnection {
+	h, _ := handle.Cast(nil, f.Name)
+
+	return &types.DalConnection{
+		ID: f.ID,
+
+		Meta: types.ConnectionMeta{
+			Name:      f.Name,
+			Ownership: f.Contact,
+		},
+
+		Handle: h,
+		Type:   federationTypes.NodeResourceType,
+
+		//Config: types.ConnectionConfig{
+		//	Connection: dal.NewFederatedNodeConnection(f.BaseURL, f.PairToken, f.AuthToken),
+		//},
+
+		CreatedAt: f.CreatedAt,
+		CreatedBy: f.CreatedBy,
+		UpdatedAt: f.UpdatedAt,
+		UpdatedBy: f.UpdatedBy,
+		DeletedAt: f.DeletedAt,
+		DeletedBy: f.DeletedBy,
+	}
+}
+
+func (ctrl DalConnection) collectConnections(ctx context.Context, filter types.DalConnectionFilter) (out types.DalConnectionSet, f types.DalConnectionFilter, err error) {
+	var (
+		dalConnections types.DalConnectionSet
+		federatedNodes federationTypes.NodeSet
+	)
+
+	if dalConnections, f, err = ctrl.svc.Search(ctx, filter); err != nil {
+		return nil, f, err
+	}
+
+	if !reflect2.IsNil(ctrl.federationSvc) {
+		if federatedNodes, _, err = ctrl.federationSvc.Search(ctx, federationTypes.NodeFilter{
+			// @todo IDs?
+			Deleted: f.Deleted,
+		}); err != nil {
+			return nil, f, err
+		}
+	}
+
+	out = append(out, dalConnections...)
+
+	// We're converting federation nodes to DAL connection structs so that we have
+	// a unified output.
+	//
+	// Eventually federation nodes will become connections, so this is ok
+	for _, nn := range federatedNodes {
+		out = append(out, ctrl.federatedNodeToConnection(nn))
+	}
+
+	out = ctrl.filterConnections(out, f)
+
+	return
+}
+
+func (ctrl DalConnection) filterConnections(baseConnections types.DalConnectionSet, f types.DalConnectionFilter) (out types.DalConnectionSet) {
+	for _, conn := range baseConnections {
+		include := true
+
+		if len(f.DalConnectionID) > 0 {
+			include = include && ctrl.inIDSet(id.Uints(f.DalConnectionID...), conn.ID)
+		}
+
+		if f.Handle != "" {
+			include = include && f.Handle == conn.Handle
+		}
+
+		if f.Type != "" {
+			include = include && f.Type == conn.Type
+		}
+
+		{
+			if f.Deleted == filter.StateExcluded {
+				include = include && conn.DeletedAt == nil
+			}
+
+			if f.Deleted == filter.StateExclusive {
+				include = include && conn.DeletedAt != nil
+			}
+		}
+
+		if include {
+			out = append(out, conn)
+		}
+	}
+
+	return
+}
+
+func (ctrl DalConnection) inIDSet(set []uint64, target uint64) (out bool) {
+	for _, id := range set {
+		out = out || id == target
+	}
+
+	return
+}
+
+func (ctrl DalConnection) serve(ctx context.Context, fn string, archive io.ReadSeeker, err error) (interface{}, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	return func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Add("Content-Disposition", "attachment; filename="+fn)
+
+		http.ServeContent(w, req, fn, time.Now(), archive)
+	}, nil
+}

server/system/rest/dal_drivers.go

@@ -0,0 +1,47 @@
+package rest
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/cortezaproject/corteza/server/pkg/dal"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+)
+
+type (
+	DalDriver struct{}
+
+	dalDriverSetPayload struct {
+		Set []dal.Driver `json:"set"`
+	}
+)
+
+func (DalDriver) New() *DalDriver {
+	return &DalDriver{}
+}
+
+func (ctrl DalDriver) List(ctx context.Context, r *request.DalDriverList) (interface{}, error) {
+	return ctrl.makeFilterPayload(ctx, dal.Service().Drivers())
+}
+
+func (ctrl DalDriver) makeFilterPayload(ctx context.Context, drivers []dal.Driver) (out *dalDriverSetPayload, err error) {
+	out = &dalDriverSetPayload{
+		Set: drivers,
+	}
+
+	return
+}
+
+func (ctrl DalDriver) serve(ctx context.Context, fn string, archive io.ReadSeeker, err error) (interface{}, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	return func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Add("Content-Disposition", "attachment; filename="+fn)
+
+		http.ServeContent(w, req, fn, time.Now(), archive)
+	}, nil
+}

server/system/rest/dal_schema_alteration.go

@@ -0,0 +1,129 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/id"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	DalSchemaAlteration struct {
+		svc           alterationService
+		federationSvc federationNodeService
+
+		alterationAc alterationAccessController
+	}
+
+	alterationPayload struct {
+		*types.DalSchemaAlteration
+
+		CanGrant                  bool `json:"canGrant"`
+		CanUpdateSchemaAlteration bool `json:"canUpdateSchemaAlteration"`
+		CanDeleteSchemaAlteration bool `json:"canDeleteSchemaAlteration"`
+		CanManageDalConfig        bool `json:"canManageDalConfig"`
+	}
+
+	alterationSetPayload struct {
+		Filter types.DalSchemaAlterationFilter `json:"filter"`
+		Set    []*alterationPayload            `json:"set"`
+	}
+
+	alterationAccessController interface {
+		CanGrant(context.Context) bool
+		// @todo?
+	}
+
+	alterationService interface {
+		Search(ctx context.Context, filter types.DalSchemaAlterationFilter) (types.DalSchemaAlterationSet, types.DalSchemaAlterationFilter, error)
+		FindByID(ctx context.Context, ID uint64) (*types.DalSchemaAlteration, error)
+		Apply(context.Context, ...uint64) error
+		Dismiss(context.Context, ...uint64) error
+	}
+)
+
+func (DalSchemaAlteration) New() *DalSchemaAlteration {
+	return &DalSchemaAlteration{
+		svc: service.DefaultDalSchemaAlteration,
+
+		alterationAc: service.DefaultAccessControl,
+	}
+}
+
+func (ctrl DalSchemaAlteration) List(ctx context.Context, r *request.DalSchemaAlterationList) (interface{}, error) {
+	var (
+		err error
+		set types.DalSchemaAlterationSet
+
+		f = types.DalSchemaAlterationFilter{
+			AlterationID: r.AlterationID,
+			BatchID:      id.Uints(r.BatchID...),
+			Kind:         r.Kind,
+			Resource:     r.Resource,
+			ResourceType: r.ResourceType,
+
+			Deleted:   filter.State(r.Deleted),
+			Dismissed: filter.State(r.Dismissed),
+			Completed: filter.State(r.Completed),
+		}
+	)
+
+	if f.Deleted == 0 {
+		f.Deleted = filter.StateExcluded
+	}
+	if f.Dismissed == 0 {
+		f.Dismissed = filter.StateExcluded
+	}
+	if f.Completed == 0 {
+		f.Completed = filter.StateExcluded
+	}
+
+	f.IncTotal = r.IncTotal
+
+	set, f, err = ctrl.svc.Search(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl DalSchemaAlteration) Read(ctx context.Context, r *request.DalSchemaAlterationRead) (interface{}, error) {
+	res, err := ctrl.svc.FindByID(ctx, r.AlterationID)
+	return ctrl.makePayload(ctx, res, err)
+}
+
+func (ctrl DalSchemaAlteration) Apply(ctx context.Context, r *request.DalSchemaAlterationApply) (interface{}, error) {
+	return api.OK(), ctrl.svc.Apply(ctx, r.AlterationID...)
+}
+
+func (ctrl DalSchemaAlteration) Dismiss(ctx context.Context, r *request.DalSchemaAlterationDismiss) (interface{}, error) {
+	return api.OK(), ctrl.svc.Dismiss(ctx, r.AlterationID...)
+}
+
+func (ctrl DalSchemaAlteration) makePayload(ctx context.Context, res *types.DalSchemaAlteration, err error) (*alterationPayload, error) {
+	if err != nil || res == nil {
+		return nil, err
+	}
+
+	pl := &alterationPayload{
+		DalSchemaAlteration: res,
+
+		CanGrant: ctrl.alterationAc.CanGrant(ctx),
+	}
+
+	return pl, nil
+}
+
+func (ctrl DalSchemaAlteration) makeFilterPayload(ctx context.Context, rr types.DalSchemaAlterationSet, f types.DalSchemaAlterationFilter, err error) (*alterationSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	out := &alterationSetPayload{Filter: f, Set: make([]*alterationPayload, len(rr))}
+	for i := range rr {
+		out.Set[i], _ = ctrl.makePayload(ctx, rr[i], nil)
+	}
+
+	return out, nil
+}

server/system/rest/data_privacy.go

@@ -0,0 +1,163 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/id"
+
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	DataPrivacy struct {
+		privacy service.DataPrivacyService
+		ac      privacyAccessController
+	}
+
+	privacyAccessController interface {
+		CanGrant(context.Context) bool
+	}
+
+	privacyConnectionSetPayload struct {
+		Filter types.DalConnectionFilter     `json:"filter"`
+		Set    types.PrivacyDalConnectionSet `json:"set"`
+	}
+)
+
+func (DataPrivacy) New() *DataPrivacy {
+	return &DataPrivacy{
+		privacy: service.DefaultDataPrivacy,
+		ac:      service.DefaultAccessControl,
+	}
+}
+
+func (ctrl DataPrivacy) ConnectionList(ctx context.Context, r *request.DataPrivacyConnectionList) (interface{}, error) {
+	var (
+		err error
+		set types.PrivacyDalConnectionSet
+
+		f = types.DalConnectionFilter{
+			DalConnectionID: r.ConnectionID,
+			Handle:          r.Handle,
+			Type:            r.Type,
+
+			Deleted: r.Deleted,
+		}
+	)
+
+	set, f, err = ctrl.privacy.FindConnections(ctx, f)
+	return ctrl.makeFilterConnectionPayload(ctx, set, f, err)
+}
+
+func (ctrl DataPrivacy) makeFilterConnectionPayload(_ context.Context, rr types.PrivacyDalConnectionSet, f types.DalConnectionFilter, err error) (*privacyConnectionSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	if len(rr) == 0 {
+		rr = make([]*types.PrivacyDalConnection, 0)
+	}
+
+	return &privacyConnectionSetPayload{Filter: f, Set: rr}, nil
+}
+
+func (ctrl DataPrivacy) RequestList(ctx context.Context, r *request.DataPrivacyRequestList) (interface{}, error) {
+	var (
+		err error
+		f   = types.DataPrivacyRequestFilter{
+			RequestedBy: r.RequestedBy,
+			Query:       r.Query,
+			Kind:        r.Kind,
+			Status:      r.Status,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.privacy.FindRequests(ctx, f)
+	return ctrl.makeFilterRequestPayload(ctx, set, f, err)
+}
+
+func (ctrl DataPrivacy) makeFilterRequestPayload(_ context.Context, rr types.DataPrivacyRequestSet, f types.DataPrivacyRequestFilter, err error) (*dataPrivacyRequestSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	if len(rr) == 0 {
+		rr = make([]*types.DataPrivacyRequest, 0)
+	}
+
+	return &dataPrivacyRequestSetPayload{Filter: f, Set: rr}, nil
+}
+
+func (ctrl DataPrivacy) RequestCreate(ctx context.Context, r *request.DataPrivacyRequestCreate) (interface{}, error) {
+	req := &types.DataPrivacyRequest{
+		Kind:    types.CastToRequestKind(r.Kind),
+		Payload: r.Payload,
+	}
+
+	return ctrl.privacy.CreateRequest(ctx, req)
+}
+
+func (ctrl DataPrivacy) RequestRead(ctx context.Context, r *request.DataPrivacyRequestRead) (interface{}, error) {
+	return ctrl.privacy.FindRequestByID(ctx, r.RequestID)
+}
+
+func (ctrl DataPrivacy) RequestUpdateStatus(ctx context.Context, r *request.DataPrivacyRequestUpdateStatus) (interface{}, error) {
+	req := &types.DataPrivacyRequest{
+		ID:     r.RequestID,
+		Status: types.CastToRequestStatus(r.Status),
+	}
+
+	return ctrl.privacy.UpdateRequestStatus(ctx, req)
+}
+
+func (ctrl DataPrivacy) RequestCommentList(ctx context.Context, r *request.DataPrivacyRequestCommentList) (interface{}, error) {
+	var (
+		err error
+		f   = types.DataPrivacyRequestCommentFilter{
+			RequestID: id.Strings(r.RequestID),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.privacy.FindRequestComments(ctx, f)
+	return ctrl.makeFilterRequestCommentPayload(ctx, set, f, err)
+}
+
+func (ctrl DataPrivacy) makeFilterRequestCommentPayload(_ context.Context, rr types.DataPrivacyRequestCommentSet, f types.DataPrivacyRequestCommentFilter, err error) (*dataPrivacyRequestCommentSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	if len(rr) == 0 {
+		rr = make([]*types.DataPrivacyRequestComment, 0)
+	}
+
+	return &dataPrivacyRequestCommentSetPayload{Filter: f, Set: rr}, nil
+}
+
+func (ctrl DataPrivacy) RequestCommentCreate(ctx context.Context, r *request.DataPrivacyRequestCommentCreate) (interface{}, error) {
+	req := &types.DataPrivacyRequestComment{
+		RequestID: r.RequestID,
+		Comment:   r.Comment,
+	}
+
+	return ctrl.privacy.CreateRequestComment(ctx, req)
+}

server/system/rest/data_privacy_request.go

@@ -0,0 +1,146 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	DataPrivacyRequest struct {
+		dataPrivacy service.DataPrivacyService
+		ac          dataPrivacyAccessController
+	}
+
+	dataPrivacyRequestSetPayload struct {
+		Filter types.DataPrivacyRequestFilter `json:"filter"`
+		Set    types.DataPrivacyRequestSet    `json:"set"`
+	}
+
+	dataPrivacyAccessController interface {
+		CanGrant(context.Context) bool
+	}
+
+	DataPrivacyRequestComment struct {
+		dataPrivacy service.DataPrivacyService
+		ac          dataPrivacyAccessController
+	}
+
+	dataPrivacyRequestCommentSetPayload struct {
+		Filter types.DataPrivacyRequestCommentFilter `json:"filter"`
+		Set    types.DataPrivacyRequestCommentSet    `json:"set"`
+	}
+)
+
+func (DataPrivacyRequest) New() *DataPrivacyRequest {
+	return &DataPrivacyRequest{
+		dataPrivacy: service.DefaultDataPrivacy,
+		ac:          service.DefaultAccessControl,
+	}
+}
+
+// func (ctrl DataPrivacyRequest) List(ctx context.Context, r *request.DataPrivacyRequestList) (interface{}, error) {
+// 	var (
+// 		err error
+// 		f   = types.DataPrivacyRequestFilter{
+// 			RequestedBy: payload.ParseUint64s(r.RequestedBy),
+// 			Query:       r.Query,
+// 			Kind:        r.Kind,
+// 			Status:      r.Status,
+// 		}
+// 	)
+//
+// 	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+// 		return nil, err
+// 	}
+//
+// 	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+// 		return nil, err
+// 	}
+//
+// 	set, f, err := ctrl.dataPrivacy.FindRequests(ctx, f)
+// 	return ctrl.makeFilterPayload(ctx, set, f, err)
+// }
+//
+// func (ctrl DataPrivacyRequest) makeFilterPayload(_ context.Context, rr types.DataPrivacyRequestSet, f types.DataPrivacyRequestFilter, err error) (*dataPrivacyRequestSetPayload, error) {
+// 	if err != nil {
+// 		return nil, err
+// 	}
+//
+// 	if len(rr) == 0 {
+// 		rr = make([]*types.DataPrivacyRequest, 0)
+// 	}
+//
+// 	return &dataPrivacyRequestSetPayload{Filter: f, Set: rr}, nil
+// }
+//
+// func (ctrl DataPrivacyRequest) Create(ctx context.Context, r *request.DataPrivacyRequestCreate) (interface{}, error) {
+// 	req := &types.DataPrivacyRequest{
+// 		Kind:    types.CastToRequestKind(r.Kind),
+// 		Payload: r.Payload,
+// 	}
+//
+// 	return ctrl.dataPrivacy.CreateRequest(ctx, req)
+// }
+//
+// func (ctrl DataPrivacyRequest) UpdateStatus(ctx context.Context, r *request.DataPrivacyRequestUpdateStatus) (interface{}, error) {
+// 	req := &types.DataPrivacyRequest{
+// 		ID:     r.RequestID,
+// 		Status: types.CastToRequestStatus(r.Status),
+// 	}
+//
+// 	return ctrl.dataPrivacy.UpdateRequestStatus(ctx, req)
+// }
+//
+// func (ctrl DataPrivacyRequest) Read(ctx context.Context, r *request.DataPrivacyRequestRead) (interface{}, error) {
+// 	return ctrl.dataPrivacy.FindRequestByID(ctx, r.RequestID)
+// }
+
+func (DataPrivacyRequestComment) New() *DataPrivacyRequestComment {
+	return &DataPrivacyRequestComment{
+		dataPrivacy: service.DefaultDataPrivacy,
+		ac:          service.DefaultAccessControl,
+	}
+}
+
+// func (ctrl DataPrivacyRequestComment) List(ctx context.Context, r *request.DataPrivacyRequestCommentList) (interface{}, error) {
+// 	var (
+// 		err error
+// 		f   = types.DataPrivacyRequestCommentFilter{
+// 			RequestID: []uint64{r.RequestID},
+// 		}
+// 	)
+//
+// 	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+// 		return nil, err
+// 	}
+//
+// 	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+// 		return nil, err
+// 	}
+//
+// 	set, f, err := ctrl.dataPrivacy.FindRequestComments(ctx, f)
+// 	return ctrl.makeFilterPayload(ctx, set, f, err)
+// }
+//
+// func (ctrl DataPrivacyRequestComment) makeFilterPayload(_ context.Context, rr types.DataPrivacyRequestCommentSet, f types.DataPrivacyRequestCommentFilter, err error) (*dataPrivacyRequestCommentSetPayload, error) {
+// 	if err != nil {
+// 		return nil, err
+// 	}
+//
+// 	if len(rr) == 0 {
+// 		rr = make([]*types.DataPrivacyRequestComment, 0)
+// 	}
+//
+// 	return &dataPrivacyRequestCommentSetPayload{Filter: f, Set: rr}, nil
+// }
+//
+// func (ctrl DataPrivacyRequestComment) Create(ctx context.Context, r *request.DataPrivacyRequestCommentCreate) (interface{}, error) {
+// 	req := &types.DataPrivacyRequestComment{
+// 		RequestID: r.RequestID,
+// 		Comment:   r.Comment,
+// 	}
+//
+// 	return ctrl.dataPrivacy.CreateRequestComment(ctx, req)
+// }

server/system/rest/expression.go

@@ -0,0 +1,38 @@
+package rest
+
+import (
+	"context"
+	"strings"
+
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+)
+
+type (
+	Expression struct {
+		svc exprService
+	}
+
+	exprService interface {
+		Evaluate(context.Context, map[string]string, map[string]any) (map[string]any, error)
+	}
+)
+
+func (Expression) New() *Expression {
+	return &Expression{
+		svc: service.DefaultExpression,
+	}
+}
+
+func (ctrl *Expression) Evaluate(ctx context.Context, r *request.ExpressionEvaluate) (interface{}, error) {
+	expressions := make(map[string]string, len(r.Expressions))
+	for k, v := range r.Expressions {
+		if v.Val != "" {
+			expressions[k] = v.Val
+		} else if len(v.Values) > 0 {
+			expressions[k] = strings.Join(v.Values, ",")
+		}
+	}
+
+	return ctrl.svc.Evaluate(ctx, expressions, r.Variables)
+}

server/system/rest/handlers/actionlog.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ActionlogAPI interface {
+		List(context.Context, *request.ActionlogList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Actionlog struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewActionlog(h ActionlogAPI) *Actionlog {
+	return &Actionlog{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewActionlogList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Actionlog) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/actionlog/", h.List)
+	})
+}

server/system/rest/handlers/apigwFilter.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApigwFilterAPI interface {
+		List(context.Context, *request.ApigwFilterList) (interface{}, error)
+		Create(context.Context, *request.ApigwFilterCreate) (interface{}, error)
+		Update(context.Context, *request.ApigwFilterUpdate) (interface{}, error)
+		Read(context.Context, *request.ApigwFilterRead) (interface{}, error)
+		Delete(context.Context, *request.ApigwFilterDelete) (interface{}, error)
+		Undelete(context.Context, *request.ApigwFilterUndelete) (interface{}, error)
+		DefFilter(context.Context, *request.ApigwFilterDefFilter) (interface{}, error)
+		DefProxyAuth(context.Context, *request.ApigwFilterDefProxyAuth) (interface{}, error)
+	}
+
+	// HTTP API interface
+	ApigwFilter struct {
+		List         func(http.ResponseWriter, *http.Request)
+		Create       func(http.ResponseWriter, *http.Request)
+		Update       func(http.ResponseWriter, *http.Request)
+		Read         func(http.ResponseWriter, *http.Request)
+		Delete       func(http.ResponseWriter, *http.Request)
+		Undelete     func(http.ResponseWriter, *http.Request)
+		DefFilter    func(http.ResponseWriter, *http.Request)
+		DefProxyAuth func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApigwFilter(h ApigwFilterAPI) *ApigwFilter {
+	return &ApigwFilter{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DefFilter: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterDefFilter()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DefFilter(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DefProxyAuth: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwFilterDefProxyAuth()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DefProxyAuth(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h ApigwFilter) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/apigw/filter/", h.List)
+		r.Put("/apigw/filter", h.Create)
+		r.Post("/apigw/filter/{filterID}", h.Update)
+		r.Get("/apigw/filter/{filterID}", h.Read)
+		r.Delete("/apigw/filter/{filterID}", h.Delete)
+		r.Post("/apigw/filter/{filterID}/undelete", h.Undelete)
+		r.Get("/apigw/filter/def", h.DefFilter)
+		r.Get("/apigw/filter/proxy_auth/def", h.DefProxyAuth)
+	})
+}

server/system/rest/handlers/apigwProfiler.go

@@ -0,0 +1,133 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApigwProfilerAPI interface {
+		Aggregation(context.Context, *request.ApigwProfilerAggregation) (interface{}, error)
+		Route(context.Context, *request.ApigwProfilerRoute) (interface{}, error)
+		Hit(context.Context, *request.ApigwProfilerHit) (interface{}, error)
+		PurgeAll(context.Context, *request.ApigwProfilerPurgeAll) (interface{}, error)
+		Purge(context.Context, *request.ApigwProfilerPurge) (interface{}, error)
+	}
+
+	// HTTP API interface
+	ApigwProfiler struct {
+		Aggregation func(http.ResponseWriter, *http.Request)
+		Route       func(http.ResponseWriter, *http.Request)
+		Hit         func(http.ResponseWriter, *http.Request)
+		PurgeAll    func(http.ResponseWriter, *http.Request)
+		Purge       func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApigwProfiler(h ApigwProfilerAPI) *ApigwProfiler {
+	return &ApigwProfiler{
+		Aggregation: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerAggregation()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Aggregation(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Route: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerRoute()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Route(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Hit: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerHit()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Hit(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		PurgeAll: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerPurgeAll()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.PurgeAll(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Purge: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwProfilerPurge()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Purge(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h ApigwProfiler) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/apigw/profiler/", h.Aggregation)
+		r.Get("/apigw/profiler/route/{routeID}", h.Route)
+		r.Get("/apigw/profiler/hit/{hitID}", h.Hit)
+		r.Post("/apigw/profiler/purge", h.PurgeAll)
+		r.Post("/apigw/profiler/purge/{routeID}", h.Purge)
+	})
+}

server/system/rest/handlers/apigwRoute.go

@@ -0,0 +1,152 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApigwRouteAPI interface {
+		List(context.Context, *request.ApigwRouteList) (interface{}, error)
+		Create(context.Context, *request.ApigwRouteCreate) (interface{}, error)
+		Update(context.Context, *request.ApigwRouteUpdate) (interface{}, error)
+		Read(context.Context, *request.ApigwRouteRead) (interface{}, error)
+		Delete(context.Context, *request.ApigwRouteDelete) (interface{}, error)
+		Undelete(context.Context, *request.ApigwRouteUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	ApigwRoute struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApigwRoute(h ApigwRouteAPI) *ApigwRoute {
+	return &ApigwRoute{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApigwRouteUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h ApigwRoute) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/apigw/route/", h.List)
+		r.Post("/apigw/route", h.Create)
+		r.Put("/apigw/route/{routeID}", h.Update)
+		r.Get("/apigw/route/{routeID}", h.Read)
+		r.Delete("/apigw/route/{routeID}", h.Delete)
+		r.Post("/apigw/route/{routeID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/application.go

@@ -0,0 +1,247 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ApplicationAPI interface {
+		List(context.Context, *request.ApplicationList) (interface{}, error)
+		Create(context.Context, *request.ApplicationCreate) (interface{}, error)
+		Update(context.Context, *request.ApplicationUpdate) (interface{}, error)
+		Upload(context.Context, *request.ApplicationUpload) (interface{}, error)
+		FlagCreate(context.Context, *request.ApplicationFlagCreate) (interface{}, error)
+		FlagDelete(context.Context, *request.ApplicationFlagDelete) (interface{}, error)
+		Read(context.Context, *request.ApplicationRead) (interface{}, error)
+		Delete(context.Context, *request.ApplicationDelete) (interface{}, error)
+		Undelete(context.Context, *request.ApplicationUndelete) (interface{}, error)
+		TriggerScript(context.Context, *request.ApplicationTriggerScript) (interface{}, error)
+		Reorder(context.Context, *request.ApplicationReorder) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Application struct {
+		List          func(http.ResponseWriter, *http.Request)
+		Create        func(http.ResponseWriter, *http.Request)
+		Update        func(http.ResponseWriter, *http.Request)
+		Upload        func(http.ResponseWriter, *http.Request)
+		FlagCreate    func(http.ResponseWriter, *http.Request)
+		FlagDelete    func(http.ResponseWriter, *http.Request)
+		Read          func(http.ResponseWriter, *http.Request)
+		Delete        func(http.ResponseWriter, *http.Request)
+		Undelete      func(http.ResponseWriter, *http.Request)
+		TriggerScript func(http.ResponseWriter, *http.Request)
+		Reorder       func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewApplication(h ApplicationAPI) *Application {
+	return &Application{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Upload: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationUpload()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Upload(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		FlagCreate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationFlagCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.FlagCreate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		FlagDelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationFlagDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.FlagDelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Reorder: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewApplicationReorder()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Reorder(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Application) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/application/", h.List)
+		r.Post("/application/", h.Create)
+		r.Put("/application/{applicationID}", h.Update)
+		r.Post("/application/upload", h.Upload)
+		r.Post("/application/{applicationID}/flag/{ownedBy}/{flag}", h.FlagCreate)
+		r.Delete("/application/{applicationID}/flag/{ownedBy}/{flag}", h.FlagDelete)
+		r.Get("/application/{applicationID}", h.Read)
+		r.Delete("/application/{applicationID}", h.Delete)
+		r.Post("/application/{applicationID}/undelete", h.Undelete)
+		r.Post("/application/{applicationID}/trigger", h.TriggerScript)
+		r.Post("/application/reorder", h.Reorder)
+	})
+}

server/system/rest/handlers/attachment.go

@@ -0,0 +1,114 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AttachmentAPI interface {
+		Read(context.Context, *request.AttachmentRead) (interface{}, error)
+		Delete(context.Context, *request.AttachmentDelete) (interface{}, error)
+		Original(context.Context, *request.AttachmentOriginal) (interface{}, error)
+		Preview(context.Context, *request.AttachmentPreview) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Attachment struct {
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Original func(http.ResponseWriter, *http.Request)
+		Preview  func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAttachment(h AttachmentAPI) *Attachment {
+	return &Attachment{
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Original: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentOriginal()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Original(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Preview: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAttachmentPreview()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Preview(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Attachment) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/attachment/{kind}/{attachmentID}", h.Read)
+		r.Delete("/attachment/{kind}/{attachmentID}", h.Delete)
+		r.Get("/attachment/{kind}/{attachmentID}/original/{name}", h.Original)
+		r.Get("/attachment/{kind}/{attachmentID}/preview.{ext}", h.Preview)
+	})
+}

server/system/rest/handlers/auth.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AuthAPI interface {
+		Impersonate(context.Context, *request.AuthImpersonate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Auth struct {
+		Impersonate func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAuth(h AuthAPI) *Auth {
+	return &Auth{
+		Impersonate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthImpersonate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Impersonate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Auth) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/auth/impersonate", h.Impersonate)
+	})
+}

server/system/rest/handlers/authClient.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AuthClientAPI interface {
+		List(context.Context, *request.AuthClientList) (interface{}, error)
+		Create(context.Context, *request.AuthClientCreate) (interface{}, error)
+		Update(context.Context, *request.AuthClientUpdate) (interface{}, error)
+		Read(context.Context, *request.AuthClientRead) (interface{}, error)
+		Delete(context.Context, *request.AuthClientDelete) (interface{}, error)
+		Undelete(context.Context, *request.AuthClientUndelete) (interface{}, error)
+		RegenerateSecret(context.Context, *request.AuthClientRegenerateSecret) (interface{}, error)
+		ExposeSecret(context.Context, *request.AuthClientExposeSecret) (interface{}, error)
+	}
+
+	// HTTP API interface
+	AuthClient struct {
+		List             func(http.ResponseWriter, *http.Request)
+		Create           func(http.ResponseWriter, *http.Request)
+		Update           func(http.ResponseWriter, *http.Request)
+		Read             func(http.ResponseWriter, *http.Request)
+		Delete           func(http.ResponseWriter, *http.Request)
+		Undelete         func(http.ResponseWriter, *http.Request)
+		RegenerateSecret func(http.ResponseWriter, *http.Request)
+		ExposeSecret     func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAuthClient(h AuthClientAPI) *AuthClient {
+	return &AuthClient{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RegenerateSecret: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientRegenerateSecret()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RegenerateSecret(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ExposeSecret: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAuthClientExposeSecret()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ExposeSecret(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h AuthClient) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/auth/clients/", h.List)
+		r.Post("/auth/clients/", h.Create)
+		r.Put("/auth/clients/{clientID}", h.Update)
+		r.Get("/auth/clients/{clientID}", h.Read)
+		r.Delete("/auth/clients/{clientID}", h.Delete)
+		r.Post("/auth/clients/{clientID}/undelete", h.Undelete)
+		r.Post("/auth/clients/{clientID}/secret", h.RegenerateSecret)
+		r.Get("/auth/clients/{clientID}/secret", h.ExposeSecret)
+	})
+}

server/system/rest/handlers/automation.go

@@ -0,0 +1,95 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	AutomationAPI interface {
+		List(context.Context, *request.AutomationList) (interface{}, error)
+		Bundle(context.Context, *request.AutomationBundle) (interface{}, error)
+		TriggerScript(context.Context, *request.AutomationTriggerScript) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Automation struct {
+		List          func(http.ResponseWriter, *http.Request)
+		Bundle        func(http.ResponseWriter, *http.Request)
+		TriggerScript func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewAutomation(h AutomationAPI) *Automation {
+	return &Automation{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Bundle: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationBundle()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Bundle(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewAutomationTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Automation) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/automation/", h.List)
+		r.Get("/automation/{bundle}-{type}.{ext}", h.Bundle)
+		r.Post("/automation/trigger", h.TriggerScript)
+	})
+}

server/system/rest/handlers/dalConnection.go

@@ -0,0 +1,152 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalConnectionAPI interface {
+		List(context.Context, *request.DalConnectionList) (interface{}, error)
+		Create(context.Context, *request.DalConnectionCreate) (interface{}, error)
+		Update(context.Context, *request.DalConnectionUpdate) (interface{}, error)
+		Read(context.Context, *request.DalConnectionRead) (interface{}, error)
+		Delete(context.Context, *request.DalConnectionDelete) (interface{}, error)
+		Undelete(context.Context, *request.DalConnectionUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalConnection struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalConnection(h DalConnectionAPI) *DalConnection {
+	return &DalConnection{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalConnectionUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DalConnection) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/connections/", h.List)
+		r.Post("/dal/connections/", h.Create)
+		r.Put("/dal/connections/{connectionID}", h.Update)
+		r.Get("/dal/connections/{connectionID}", h.Read)
+		r.Delete("/dal/connections/{connectionID}", h.Delete)
+		r.Post("/dal/connections/{connectionID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/dalDriver.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalDriverAPI interface {
+		List(context.Context, *request.DalDriverList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalDriver struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalDriver(h DalDriverAPI) *DalDriver {
+	return &DalDriver{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalDriverList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DalDriver) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/drivers/", h.List)
+	})
+}

server/system/rest/handlers/dalSchemaAlteration.go

@@ -0,0 +1,114 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalSchemaAlterationAPI interface {
+		List(context.Context, *request.DalSchemaAlterationList) (interface{}, error)
+		Read(context.Context, *request.DalSchemaAlterationRead) (interface{}, error)
+		Apply(context.Context, *request.DalSchemaAlterationApply) (interface{}, error)
+		Dismiss(context.Context, *request.DalSchemaAlterationDismiss) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalSchemaAlteration struct {
+		List    func(http.ResponseWriter, *http.Request)
+		Read    func(http.ResponseWriter, *http.Request)
+		Apply   func(http.ResponseWriter, *http.Request)
+		Dismiss func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalSchemaAlteration(h DalSchemaAlterationAPI) *DalSchemaAlteration {
+	return &DalSchemaAlteration{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Apply: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationApply()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Apply(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Dismiss: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSchemaAlterationDismiss()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Dismiss(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DalSchemaAlteration) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/schema/alterations/", h.List)
+		r.Get("/dal/schema/alterations/{alterationID}", h.Read)
+		r.Post("/dal/schema/alterations/apply", h.Apply)
+		r.Post("/dal/schema/alterations/dismiss", h.Dismiss)
+	})
+}

server/system/rest/handlers/dalSensitivityLevel.go

@@ -0,0 +1,152 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DalSensitivityLevelAPI interface {
+		List(context.Context, *request.DalSensitivityLevelList) (interface{}, error)
+		Create(context.Context, *request.DalSensitivityLevelCreate) (interface{}, error)
+		Update(context.Context, *request.DalSensitivityLevelUpdate) (interface{}, error)
+		Read(context.Context, *request.DalSensitivityLevelRead) (interface{}, error)
+		Delete(context.Context, *request.DalSensitivityLevelDelete) (interface{}, error)
+		Undelete(context.Context, *request.DalSensitivityLevelUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DalSensitivityLevel struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDalSensitivityLevel(h DalSensitivityLevelAPI) *DalSensitivityLevel {
+	return &DalSensitivityLevel{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDalSensitivityLevelUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DalSensitivityLevel) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/dal/sensitivity-levels/", h.List)
+		r.Post("/dal/sensitivity-levels/", h.Create)
+		r.Put("/dal/sensitivity-levels/{sensitivityLevelID}", h.Update)
+		r.Get("/dal/sensitivity-levels/{sensitivityLevelID}", h.Read)
+		r.Delete("/dal/sensitivity-levels/{sensitivityLevelID}", h.Delete)
+		r.Post("/dal/sensitivity-levels/{sensitivityLevelID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/dataPrivacy.go

@@ -0,0 +1,171 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	DataPrivacyAPI interface {
+		ConnectionList(context.Context, *request.DataPrivacyConnectionList) (interface{}, error)
+		RequestList(context.Context, *request.DataPrivacyRequestList) (interface{}, error)
+		RequestCreate(context.Context, *request.DataPrivacyRequestCreate) (interface{}, error)
+		RequestRead(context.Context, *request.DataPrivacyRequestRead) (interface{}, error)
+		RequestUpdateStatus(context.Context, *request.DataPrivacyRequestUpdateStatus) (interface{}, error)
+		RequestCommentList(context.Context, *request.DataPrivacyRequestCommentList) (interface{}, error)
+		RequestCommentCreate(context.Context, *request.DataPrivacyRequestCommentCreate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	DataPrivacy struct {
+		ConnectionList       func(http.ResponseWriter, *http.Request)
+		RequestList          func(http.ResponseWriter, *http.Request)
+		RequestCreate        func(http.ResponseWriter, *http.Request)
+		RequestRead          func(http.ResponseWriter, *http.Request)
+		RequestUpdateStatus  func(http.ResponseWriter, *http.Request)
+		RequestCommentList   func(http.ResponseWriter, *http.Request)
+		RequestCommentCreate func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewDataPrivacy(h DataPrivacyAPI) *DataPrivacy {
+	return &DataPrivacy{
+		ConnectionList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyConnectionList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ConnectionList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestCreate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestCreate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestRead: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestRead(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestUpdateStatus: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestUpdateStatus()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestUpdateStatus(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestCommentList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestCommentList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestCommentList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RequestCommentCreate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewDataPrivacyRequestCommentCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RequestCommentCreate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h DataPrivacy) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/data-privacy/connection/", h.ConnectionList)
+		r.Get("/data-privacy/requests/", h.RequestList)
+		r.Post("/data-privacy/requests/", h.RequestCreate)
+		r.Get("/data-privacy/requests/{requestID}", h.RequestRead)
+		r.Patch("/data-privacy/requests/{requestID}/status/{status}", h.RequestUpdateStatus)
+		r.Get("/data-privacy/requests/{requestID}/comments/", h.RequestCommentList)
+		r.Post("/data-privacy/requests/{requestID}/comments/", h.RequestCommentCreate)
+	})
+}

server/system/rest/handlers/expression.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ExpressionAPI interface {
+		Evaluate(context.Context, *request.ExpressionEvaluate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Expression struct {
+		Evaluate func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewExpression(h ExpressionAPI) *Expression {
+	return &Expression{
+		Evaluate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewExpressionEvaluate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Evaluate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Expression) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/expressions/evaluate", h.Evaluate)
+	})
+}

server/system/rest/handlers/label.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	LabelAPI interface {
+		List(context.Context, *request.LabelList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Label struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewLabel(h LabelAPI) *Label {
+	return &Label{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLabelList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Label) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/label/", h.List)
+	})
+}

server/system/rest/handlers/locale.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	LocaleAPI interface {
+		ListResource(context.Context, *request.LocaleListResource) (interface{}, error)
+		CreateResource(context.Context, *request.LocaleCreateResource) (interface{}, error)
+		UpdateResource(context.Context, *request.LocaleUpdateResource) (interface{}, error)
+		ReadResource(context.Context, *request.LocaleReadResource) (interface{}, error)
+		DeleteResource(context.Context, *request.LocaleDeleteResource) (interface{}, error)
+		UndeleteResource(context.Context, *request.LocaleUndeleteResource) (interface{}, error)
+		List(context.Context, *request.LocaleList) (interface{}, error)
+		Get(context.Context, *request.LocaleGet) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Locale struct {
+		ListResource     func(http.ResponseWriter, *http.Request)
+		CreateResource   func(http.ResponseWriter, *http.Request)
+		UpdateResource   func(http.ResponseWriter, *http.Request)
+		ReadResource     func(http.ResponseWriter, *http.Request)
+		DeleteResource   func(http.ResponseWriter, *http.Request)
+		UndeleteResource func(http.ResponseWriter, *http.Request)
+		List             func(http.ResponseWriter, *http.Request)
+		Get              func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewLocale(h LocaleAPI) *Locale {
+	return &Locale{
+		ListResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleListResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		CreateResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleCreateResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.CreateResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UpdateResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleUpdateResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UpdateResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ReadResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleReadResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ReadResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DeleteResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleDeleteResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DeleteResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		UndeleteResource: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleUndeleteResource()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.UndeleteResource(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Get: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewLocaleGet()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Get(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Locale) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/locale/resource", h.ListResource)
+		r.Post("/locale/resource", h.CreateResource)
+		r.Put("/locale/resource/{translationID}", h.UpdateResource)
+		r.Get("/locale/resource/{translationID}", h.ReadResource)
+		r.Delete("/locale/resource/{translationID}", h.DeleteResource)
+		r.Post("/locale/resource/{translationID}/undelete", h.UndeleteResource)
+		r.Get("/locale/", h.List)
+		r.Get("/locale/{lang}/{application}", h.Get)
+	})
+}

server/system/rest/handlers/notification.go

@@ -0,0 +1,209 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	NotificationAPI interface {
+		List(context.Context, *request.NotificationList) (interface{}, error)
+		Create(context.Context, *request.NotificationCreate) (interface{}, error)
+		Update(context.Context, *request.NotificationUpdate) (interface{}, error)
+		Read(context.Context, *request.NotificationRead) (interface{}, error)
+		Delete(context.Context, *request.NotificationDelete) (interface{}, error)
+		MarkAsRead(context.Context, *request.NotificationMarkAsRead) (interface{}, error)
+		MarkAsUnread(context.Context, *request.NotificationMarkAsUnread) (interface{}, error)
+		MarkAllAsRead(context.Context, *request.NotificationMarkAllAsRead) (interface{}, error)
+		MarkAllAsUnread(context.Context, *request.NotificationMarkAllAsUnread) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Notification struct {
+		List            func(http.ResponseWriter, *http.Request)
+		Create          func(http.ResponseWriter, *http.Request)
+		Update          func(http.ResponseWriter, *http.Request)
+		Read            func(http.ResponseWriter, *http.Request)
+		Delete          func(http.ResponseWriter, *http.Request)
+		MarkAsRead      func(http.ResponseWriter, *http.Request)
+		MarkAsUnread    func(http.ResponseWriter, *http.Request)
+		MarkAllAsRead   func(http.ResponseWriter, *http.Request)
+		MarkAllAsUnread func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewNotification(h NotificationAPI) *Notification {
+	return &Notification{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MarkAsRead: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAsRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAsRead(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MarkAsUnread: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAsUnread()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAsUnread(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MarkAllAsRead: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAllAsRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAllAsRead(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MarkAllAsUnread: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewNotificationMarkAllAsUnread()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MarkAllAsUnread(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Notification) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/notification/", h.List)
+		r.Post("/notification/", h.Create)
+		r.Put("/notification/{notificationID}", h.Update)
+		r.Get("/notification/{notificationID}", h.Read)
+		r.Delete("/notification/{notificationID}", h.Delete)
+		r.Patch("/notification/{notificationID}/read", h.MarkAsRead)
+		r.Patch("/notification/{notificationID}/unread", h.MarkAsUnread)
+		r.Patch("/notification/all/read", h.MarkAllAsRead)
+		r.Patch("/notification/all/unread", h.MarkAllAsUnread)
+	})
+}

server/system/rest/handlers/permissions.go

@@ -0,0 +1,152 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	PermissionsAPI interface {
+		List(context.Context, *request.PermissionsList) (interface{}, error)
+		Effective(context.Context, *request.PermissionsEffective) (interface{}, error)
+		Trace(context.Context, *request.PermissionsTrace) (interface{}, error)
+		Read(context.Context, *request.PermissionsRead) (interface{}, error)
+		Delete(context.Context, *request.PermissionsDelete) (interface{}, error)
+		Update(context.Context, *request.PermissionsUpdate) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Permissions struct {
+		List      func(http.ResponseWriter, *http.Request)
+		Effective func(http.ResponseWriter, *http.Request)
+		Trace     func(http.ResponseWriter, *http.Request)
+		Read      func(http.ResponseWriter, *http.Request)
+		Delete    func(http.ResponseWriter, *http.Request)
+		Update    func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewPermissions(h PermissionsAPI) *Permissions {
+	return &Permissions{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Effective: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsEffective()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Effective(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Trace: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsTrace()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Trace(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewPermissionsUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Permissions) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/permissions/", h.List)
+		r.Get("/permissions/effective", h.Effective)
+		r.Get("/permissions/trace", h.Trace)
+		r.Get("/permissions/{roleID}/rules", h.Read)
+		r.Delete("/permissions/{roleID}/rules", h.Delete)
+		r.Patch("/permissions/{roleID}/rules", h.Update)
+	})
+}

server/system/rest/handlers/queues.go

@@ -0,0 +1,152 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	QueuesAPI interface {
+		List(context.Context, *request.QueuesList) (interface{}, error)
+		Create(context.Context, *request.QueuesCreate) (interface{}, error)
+		Read(context.Context, *request.QueuesRead) (interface{}, error)
+		Update(context.Context, *request.QueuesUpdate) (interface{}, error)
+		Delete(context.Context, *request.QueuesDelete) (interface{}, error)
+		Undelete(context.Context, *request.QueuesUndelete) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Queues struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewQueues(h QueuesAPI) *Queues {
+	return &Queues{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewQueuesUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Queues) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/queues/", h.List)
+		r.Post("/queues", h.Create)
+		r.Get("/queues/{queueID}", h.Read)
+		r.Put("/queues/{queueID}", h.Update)
+		r.Delete("/queues/{queueID}", h.Delete)
+		r.Post("/queues/{queueID}/undelete", h.Undelete)
+	})
+}

server/system/rest/handlers/reminder.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ReminderAPI interface {
+		List(context.Context, *request.ReminderList) (interface{}, error)
+		Create(context.Context, *request.ReminderCreate) (interface{}, error)
+		Update(context.Context, *request.ReminderUpdate) (interface{}, error)
+		Read(context.Context, *request.ReminderRead) (interface{}, error)
+		Delete(context.Context, *request.ReminderDelete) (interface{}, error)
+		Dismiss(context.Context, *request.ReminderDismiss) (interface{}, error)
+		Undismiss(context.Context, *request.ReminderUndismiss) (interface{}, error)
+		Snooze(context.Context, *request.ReminderSnooze) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Reminder struct {
+		List      func(http.ResponseWriter, *http.Request)
+		Create    func(http.ResponseWriter, *http.Request)
+		Update    func(http.ResponseWriter, *http.Request)
+		Read      func(http.ResponseWriter, *http.Request)
+		Delete    func(http.ResponseWriter, *http.Request)
+		Dismiss   func(http.ResponseWriter, *http.Request)
+		Undismiss func(http.ResponseWriter, *http.Request)
+		Snooze    func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewReminder(h ReminderAPI) *Reminder {
+	return &Reminder{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Dismiss: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderDismiss()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Dismiss(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undismiss: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderUndismiss()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undismiss(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Snooze: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReminderSnooze()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Snooze(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Reminder) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/reminder/", h.List)
+		r.Post("/reminder/", h.Create)
+		r.Put("/reminder/{reminderID}", h.Update)
+		r.Get("/reminder/{reminderID}", h.Read)
+		r.Delete("/reminder/{reminderID}", h.Delete)
+		r.Patch("/reminder/{reminderID}/dismiss", h.Dismiss)
+		r.Patch("/reminder/{reminderID}/undismiss", h.Undismiss)
+		r.Patch("/reminder/{reminderID}/snooze", h.Snooze)
+	})
+}

server/system/rest/handlers/report.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	ReportAPI interface {
+		List(context.Context, *request.ReportList) (interface{}, error)
+		Create(context.Context, *request.ReportCreate) (interface{}, error)
+		Update(context.Context, *request.ReportUpdate) (interface{}, error)
+		Read(context.Context, *request.ReportRead) (interface{}, error)
+		Delete(context.Context, *request.ReportDelete) (interface{}, error)
+		Undelete(context.Context, *request.ReportUndelete) (interface{}, error)
+		Describe(context.Context, *request.ReportDescribe) (interface{}, error)
+		Run(context.Context, *request.ReportRun) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Report struct {
+		List     func(http.ResponseWriter, *http.Request)
+		Create   func(http.ResponseWriter, *http.Request)
+		Update   func(http.ResponseWriter, *http.Request)
+		Read     func(http.ResponseWriter, *http.Request)
+		Delete   func(http.ResponseWriter, *http.Request)
+		Undelete func(http.ResponseWriter, *http.Request)
+		Describe func(http.ResponseWriter, *http.Request)
+		Run      func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewReport(h ReportAPI) *Report {
+	return &Report{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Describe: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportDescribe()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Describe(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Run: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewReportRun()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Run(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Report) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/reports/", h.List)
+		r.Post("/reports/", h.Create)
+		r.Put("/reports/{reportID}", h.Update)
+		r.Get("/reports/{reportID}", h.Read)
+		r.Delete("/reports/{reportID}", h.Delete)
+		r.Post("/reports/{reportID}/undelete", h.Undelete)
+		r.Post("/reports/describe", h.Describe)
+		r.Post("/reports/{reportID}/run", h.Run)
+	})
+}

server/system/rest/handlers/role.go

@@ -0,0 +1,361 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	RoleAPI interface {
+		List(context.Context, *request.RoleList) (interface{}, error)
+		Create(context.Context, *request.RoleCreate) (interface{}, error)
+		Update(context.Context, *request.RoleUpdate) (interface{}, error)
+		Read(context.Context, *request.RoleRead) (interface{}, error)
+		Delete(context.Context, *request.RoleDelete) (interface{}, error)
+		Archive(context.Context, *request.RoleArchive) (interface{}, error)
+		Unarchive(context.Context, *request.RoleUnarchive) (interface{}, error)
+		Undelete(context.Context, *request.RoleUndelete) (interface{}, error)
+		Move(context.Context, *request.RoleMove) (interface{}, error)
+		Merge(context.Context, *request.RoleMerge) (interface{}, error)
+		MemberList(context.Context, *request.RoleMemberList) (interface{}, error)
+		MemberAddGroup(context.Context, *request.RoleMemberAddGroup) (interface{}, error)
+		MemberAdd(context.Context, *request.RoleMemberAdd) (interface{}, error)
+		MemberRemove(context.Context, *request.RoleMemberRemove) (interface{}, error)
+		MemberRemoveGroup(context.Context, *request.RoleMemberRemoveGroup) (interface{}, error)
+		TriggerScript(context.Context, *request.RoleTriggerScript) (interface{}, error)
+		CloneRules(context.Context, *request.RoleCloneRules) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Role struct {
+		List              func(http.ResponseWriter, *http.Request)
+		Create            func(http.ResponseWriter, *http.Request)
+		Update            func(http.ResponseWriter, *http.Request)
+		Read              func(http.ResponseWriter, *http.Request)
+		Delete            func(http.ResponseWriter, *http.Request)
+		Archive           func(http.ResponseWriter, *http.Request)
+		Unarchive         func(http.ResponseWriter, *http.Request)
+		Undelete          func(http.ResponseWriter, *http.Request)
+		Move              func(http.ResponseWriter, *http.Request)
+		Merge             func(http.ResponseWriter, *http.Request)
+		MemberList        func(http.ResponseWriter, *http.Request)
+		MemberAddGroup    func(http.ResponseWriter, *http.Request)
+		MemberAdd         func(http.ResponseWriter, *http.Request)
+		MemberRemove      func(http.ResponseWriter, *http.Request)
+		MemberRemoveGroup func(http.ResponseWriter, *http.Request)
+		TriggerScript     func(http.ResponseWriter, *http.Request)
+		CloneRules        func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewRole(h RoleAPI) *Role {
+	return &Role{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Archive: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleArchive()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Archive(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Unarchive: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleUnarchive()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Unarchive(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Move: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Move(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Merge: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMerge()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Merge(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberAddGroup: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberAddGroup()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberAddGroup(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberAdd: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberAdd()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberAdd(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberRemove: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberRemove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberRemove(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberRemoveGroup: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleMemberRemoveGroup()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberRemoveGroup(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		CloneRules: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewRoleCloneRules()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.CloneRules(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Role) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/roles/", h.List)
+		r.Post("/roles/", h.Create)
+		r.Put("/roles/{roleID}", h.Update)
+		r.Get("/roles/{roleID}", h.Read)
+		r.Delete("/roles/{roleID}", h.Delete)
+		r.Post("/roles/{roleID}/archive", h.Archive)
+		r.Post("/roles/{roleID}/unarchive", h.Unarchive)
+		r.Post("/roles/{roleID}/undelete", h.Undelete)
+		r.Post("/roles/{roleID}/move", h.Move)
+		r.Post("/roles/{roleID}/merge", h.Merge)
+		r.Get("/roles/{roleID}/members", h.MemberList)
+		r.Post("/roles/{roleID}/member-g/{userGroupID}", h.MemberAddGroup)
+		r.Post("/roles/{roleID}/member/{userID}", h.MemberAdd)
+		r.Delete("/roles/{roleID}/member/{userID}", h.MemberRemove)
+		r.Delete("/roles/{roleID}/member-g/{userGroupID}", h.MemberRemoveGroup)
+		r.Post("/roles/{roleID}/trigger", h.TriggerScript)
+		r.Post("/roles/{roleID}/rules/clone", h.CloneRules)
+	})
+}

server/system/rest/handlers/settings.go

@@ -0,0 +1,133 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	SettingsAPI interface {
+		List(context.Context, *request.SettingsList) (interface{}, error)
+		Update(context.Context, *request.SettingsUpdate) (interface{}, error)
+		Get(context.Context, *request.SettingsGet) (interface{}, error)
+		Set(context.Context, *request.SettingsSet) (interface{}, error)
+		Current(context.Context, *request.SettingsCurrent) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Settings struct {
+		List    func(http.ResponseWriter, *http.Request)
+		Update  func(http.ResponseWriter, *http.Request)
+		Get     func(http.ResponseWriter, *http.Request)
+		Set     func(http.ResponseWriter, *http.Request)
+		Current func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewSettings(h SettingsAPI) *Settings {
+	return &Settings{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Get: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsGet()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Get(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Set: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsSet()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Set(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Current: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSettingsCurrent()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Current(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Settings) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/settings/", h.List)
+		r.Patch("/settings/", h.Update)
+		r.Get("/settings/{key}", h.Get)
+		r.Post("/settings/{key}", h.Set)
+		r.Get("/settings/current", h.Current)
+	})
+}

server/system/rest/handlers/smtpConfigurationChecker.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	SmtpConfigurationCheckerAPI interface {
+		Check(context.Context, *request.SmtpConfigurationCheckerCheck) (interface{}, error)
+	}
+
+	// HTTP API interface
+	SmtpConfigurationChecker struct {
+		Check func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewSmtpConfigurationChecker(h SmtpConfigurationCheckerAPI) *SmtpConfigurationChecker {
+	return &SmtpConfigurationChecker{
+		Check: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewSmtpConfigurationCheckerCheck()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Check(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h SmtpConfigurationChecker) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Post("/smtp/configuration-checker/", h.Check)
+	})
+}

server/system/rest/handlers/stats.go

@@ -0,0 +1,57 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	StatsAPI interface {
+		List(context.Context, *request.StatsList) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Stats struct {
+		List func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewStats(h StatsAPI) *Stats {
+	return &Stats{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewStatsList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Stats) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/stats/", h.List)
+	})
+}

server/system/rest/handlers/template.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	TemplateAPI interface {
+		List(context.Context, *request.TemplateList) (interface{}, error)
+		Create(context.Context, *request.TemplateCreate) (interface{}, error)
+		Read(context.Context, *request.TemplateRead) (interface{}, error)
+		Update(context.Context, *request.TemplateUpdate) (interface{}, error)
+		Delete(context.Context, *request.TemplateDelete) (interface{}, error)
+		Undelete(context.Context, *request.TemplateUndelete) (interface{}, error)
+		RenderDrivers(context.Context, *request.TemplateRenderDrivers) (interface{}, error)
+		Render(context.Context, *request.TemplateRender) (interface{}, error)
+	}
+
+	// HTTP API interface
+	Template struct {
+		List          func(http.ResponseWriter, *http.Request)
+		Create        func(http.ResponseWriter, *http.Request)
+		Read          func(http.ResponseWriter, *http.Request)
+		Update        func(http.ResponseWriter, *http.Request)
+		Delete        func(http.ResponseWriter, *http.Request)
+		Undelete      func(http.ResponseWriter, *http.Request)
+		RenderDrivers func(http.ResponseWriter, *http.Request)
+		Render        func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewTemplate(h TemplateAPI) *Template {
+	return &Template{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		RenderDrivers: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateRenderDrivers()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.RenderDrivers(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Render: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewTemplateRender()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Render(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h Template) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/template/", h.List)
+		r.Post("/template/", h.Create)
+		r.Get("/template/{templateID}", h.Read)
+		r.Put("/template/{templateID}", h.Update)
+		r.Delete("/template/{templateID}", h.Delete)
+		r.Post("/template/{templateID}/undelete", h.Undelete)
+		r.Get("/template/render/drivers", h.RenderDrivers)
+		r.Post("/template/{templateID}/render/{filename}.{ext}", h.Render)
+	})
+}

server/system/rest/handlers/user.go

@@ -0,0 +1,456 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	UserAPI interface {
+		List(context.Context, *request.UserList) (interface{}, error)
+		Create(context.Context, *request.UserCreate) (interface{}, error)
+		Update(context.Context, *request.UserUpdate) (interface{}, error)
+		PartialUpdate(context.Context, *request.UserPartialUpdate) (interface{}, error)
+		Read(context.Context, *request.UserRead) (interface{}, error)
+		Delete(context.Context, *request.UserDelete) (interface{}, error)
+		Suspend(context.Context, *request.UserSuspend) (interface{}, error)
+		Unsuspend(context.Context, *request.UserUnsuspend) (interface{}, error)
+		Undelete(context.Context, *request.UserUndelete) (interface{}, error)
+		SetPassword(context.Context, *request.UserSetPassword) (interface{}, error)
+		MembershipList(context.Context, *request.UserMembershipList) (interface{}, error)
+		MembershipAdd(context.Context, *request.UserMembershipAdd) (interface{}, error)
+		MembershipRemove(context.Context, *request.UserMembershipRemove) (interface{}, error)
+		TriggerScript(context.Context, *request.UserTriggerScript) (interface{}, error)
+		SessionsRemove(context.Context, *request.UserSessionsRemove) (interface{}, error)
+		ListCredentials(context.Context, *request.UserListCredentials) (interface{}, error)
+		DeleteCredentials(context.Context, *request.UserDeleteCredentials) (interface{}, error)
+		ProfileAvatar(context.Context, *request.UserProfileAvatar) (interface{}, error)
+		ProfileAvatarInitial(context.Context, *request.UserProfileAvatarInitial) (interface{}, error)
+		DeleteAvatar(context.Context, *request.UserDeleteAvatar) (interface{}, error)
+		Export(context.Context, *request.UserExport) (interface{}, error)
+		Import(context.Context, *request.UserImport) (interface{}, error)
+	}
+
+	// HTTP API interface
+	User struct {
+		List                 func(http.ResponseWriter, *http.Request)
+		Create               func(http.ResponseWriter, *http.Request)
+		Update               func(http.ResponseWriter, *http.Request)
+		PartialUpdate        func(http.ResponseWriter, *http.Request)
+		Read                 func(http.ResponseWriter, *http.Request)
+		Delete               func(http.ResponseWriter, *http.Request)
+		Suspend              func(http.ResponseWriter, *http.Request)
+		Unsuspend            func(http.ResponseWriter, *http.Request)
+		Undelete             func(http.ResponseWriter, *http.Request)
+		SetPassword          func(http.ResponseWriter, *http.Request)
+		MembershipList       func(http.ResponseWriter, *http.Request)
+		MembershipAdd        func(http.ResponseWriter, *http.Request)
+		MembershipRemove     func(http.ResponseWriter, *http.Request)
+		TriggerScript        func(http.ResponseWriter, *http.Request)
+		SessionsRemove       func(http.ResponseWriter, *http.Request)
+		ListCredentials      func(http.ResponseWriter, *http.Request)
+		DeleteCredentials    func(http.ResponseWriter, *http.Request)
+		ProfileAvatar        func(http.ResponseWriter, *http.Request)
+		ProfileAvatarInitial func(http.ResponseWriter, *http.Request)
+		DeleteAvatar         func(http.ResponseWriter, *http.Request)
+		Export               func(http.ResponseWriter, *http.Request)
+		Import               func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewUser(h UserAPI) *User {
+	return &User{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		PartialUpdate: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserPartialUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.PartialUpdate(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Suspend: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserSuspend()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Suspend(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Unsuspend: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserUnsuspend()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Unsuspend(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		SetPassword: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserSetPassword()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.SetPassword(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MembershipList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserMembershipList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MembershipList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MembershipAdd: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserMembershipAdd()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MembershipAdd(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MembershipRemove: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserMembershipRemove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MembershipRemove(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		TriggerScript: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserTriggerScript()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.TriggerScript(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		SessionsRemove: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserSessionsRemove()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.SessionsRemove(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ListCredentials: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserListCredentials()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ListCredentials(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DeleteCredentials: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserDeleteCredentials()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DeleteCredentials(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ProfileAvatar: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserProfileAvatar()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ProfileAvatar(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		ProfileAvatarInitial: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserProfileAvatarInitial()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.ProfileAvatarInitial(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		DeleteAvatar: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserDeleteAvatar()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.DeleteAvatar(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Export: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserExport()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Export(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Import: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserImport()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Import(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h User) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/users/", h.List)
+		r.Post("/users/", h.Create)
+		r.Put("/users/{userID}", h.Update)
+		r.Patch("/users/{userID}", h.PartialUpdate)
+		r.Get("/users/{userID}", h.Read)
+		r.Delete("/users/{userID}", h.Delete)
+		r.Post("/users/{userID}/suspend", h.Suspend)
+		r.Post("/users/{userID}/unsuspend", h.Unsuspend)
+		r.Post("/users/{userID}/undelete", h.Undelete)
+		r.Post("/users/{userID}/password", h.SetPassword)
+		r.Get("/users/{userID}/membership", h.MembershipList)
+		r.Post("/users/{userID}/membership/{roleID}", h.MembershipAdd)
+		r.Delete("/users/{userID}/membership/{roleID}", h.MembershipRemove)
+		r.Post("/users/{userID}/trigger", h.TriggerScript)
+		r.Delete("/users/{userID}/sessions", h.SessionsRemove)
+		r.Get("/users/{userID}/credentials", h.ListCredentials)
+		r.Delete("/users/{userID}/credentials/{credentialsID}", h.DeleteCredentials)
+		r.Post("/users/{userID}/avatar", h.ProfileAvatar)
+		r.Post("/users/{userID}/avatar-initial", h.ProfileAvatarInitial)
+		r.Delete("/users/{userID}/avatar", h.DeleteAvatar)
+		r.Get("/users/export/{filename}.zip", h.Export)
+		r.Post("/users/import", h.Import)
+	})
+}

server/system/rest/handlers/userGroup.go

@@ -0,0 +1,190 @@
+package handlers
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/go-chi/chi/v5"
+	"net/http"
+)
+
+type (
+	// Internal API interface
+	UserGroupAPI interface {
+		List(context.Context, *request.UserGroupList) (interface{}, error)
+		Create(context.Context, *request.UserGroupCreate) (interface{}, error)
+		Update(context.Context, *request.UserGroupUpdate) (interface{}, error)
+		Read(context.Context, *request.UserGroupRead) (interface{}, error)
+		Delete(context.Context, *request.UserGroupDelete) (interface{}, error)
+		Undelete(context.Context, *request.UserGroupUndelete) (interface{}, error)
+		MemberList(context.Context, *request.UserGroupMemberList) (interface{}, error)
+		MemberAdd(context.Context, *request.UserGroupMemberAdd) (interface{}, error)
+	}
+
+	// HTTP API interface
+	UserGroup struct {
+		List       func(http.ResponseWriter, *http.Request)
+		Create     func(http.ResponseWriter, *http.Request)
+		Update     func(http.ResponseWriter, *http.Request)
+		Read       func(http.ResponseWriter, *http.Request)
+		Delete     func(http.ResponseWriter, *http.Request)
+		Undelete   func(http.ResponseWriter, *http.Request)
+		MemberList func(http.ResponseWriter, *http.Request)
+		MemberAdd  func(http.ResponseWriter, *http.Request)
+	}
+)
+
+func NewUserGroup(h UserGroupAPI) *UserGroup {
+	return &UserGroup{
+		List: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.List(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Create: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupCreate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Create(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Update: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupUpdate()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Update(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Read: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupRead()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Read(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Delete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupDelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Delete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		Undelete: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupUndelete()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.Undelete(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberList: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupMemberList()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberList(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+		MemberAdd: func(w http.ResponseWriter, r *http.Request) {
+			defer r.Body.Close()
+			params := request.NewUserGroupMemberAdd()
+			if err := params.Fill(r); err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			value, err := h.MemberAdd(r.Context(), params)
+			if err != nil {
+				api.Send(w, r, err)
+				return
+			}
+
+			api.Send(w, r, value)
+		},
+	}
+}
+
+func (h UserGroup) MountRoutes(r chi.Router, middlewares ...func(http.Handler) http.Handler) {
+	r.Group(func(r chi.Router) {
+		r.Use(middlewares...)
+		r.Get("/user-groups/", h.List)
+		r.Post("/user-groups/", h.Create)
+		r.Put("/user-groups/{userGroupID}", h.Update)
+		r.Get("/user-groups/{userGroupID}", h.Read)
+		r.Delete("/user-groups/{userGroupID}", h.Delete)
+		r.Post("/user-groups/{userGroupID}/undelete", h.Undelete)
+		r.Get("/user-groups/{userGroupID}/members", h.MemberList)
+		r.Post("/user-groups/{userGroupID}/member/{userID}", h.MemberAdd)
+	})
+}

server/system/rest/label.go

@@ -0,0 +1,51 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/label/types"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+)
+
+type (
+	Label struct {
+		label service.LabelService
+	}
+	LabelSetPayload struct {
+		Filter types.LabelFilter `json:"filter"`
+		Set types.LabelSet `json:"set"`
+	}
+)
+
+func (Label) New() *Label {
+	return &Label{
+		label: service.Label(),
+	}
+}
+
+func (ctrl Label) List(ctx context.Context, r *request.LabelList) (interface{}, error) {
+	var (
+		err error
+		set types.LabelSet
+		f = types.LabelFilter{
+			Kind: r.Kind,
+			Limit: uint(r.Limit),
+		}
+	)
+
+	if r.Name != "" {
+		f.Name = r.Name
+	}
+
+	set, f, err = ctrl.label.List(ctx, f)
+	if err != nil {
+		return nil, err
+	}
+
+	return &LabelSetPayload{
+		Filter: f,
+		Set: set,
+	}, nil
+}
+

server/system/rest/locales.go

@@ -0,0 +1,197 @@
+package rest
+
+import (
+	"context"
+	"net/http"
+	"strings"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/errors"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/locale"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"golang.org/x/text/language"
+)
+
+type (
+	Locale struct {
+		svc service.ResourceTranslationService
+	}
+
+	resourceTranslationSetPayload struct {
+		Filter types.ResourceTranslationFilter `json:"filter"`
+		Set    []*resourceTranslationPayload   `json:"set"`
+	}
+
+	resourceTranslationPayload struct {
+		*types.ResourceTranslation
+	}
+)
+
+func (Locale) New() *Locale {
+	return &Locale{
+		svc: service.DefaultResourceTranslation,
+	}
+}
+
+func (ctrl Locale) List(ctx context.Context, r *request.LocaleList) (interface{}, error) {
+	return struct {
+		Set []*locale.Language `json:"set"`
+	}{locale.Global().LocalizedList(ctx)}, nil
+}
+
+func (ctrl Locale) Get(ctx context.Context, r *request.LocaleGet) (interface{}, error) {
+	svc := locale.Global()
+
+	// We're using + as a language delimiter
+	// because webapp client i18n lib does this by default
+	// (url encoded space becomes a +)
+	const langSplit = "+"
+
+	return func(w http.ResponseWriter, req *http.Request) {
+		if len(svc.List()) == 0 {
+			errors.ProperlyServeHTTP(w, req, errors.New(
+				errors.KindNotFound,
+				"no languages found",
+				errors.StackTrimAtFn("http.HandlerFunc.ServeHTTP"),
+			), true)
+			return
+		}
+
+		// default to 1st language
+		//var def = svc.List()[0].Tag
+		var ll = []language.Tag{}
+
+		for _, candidate := range strings.Split(r.Lang, langSplit) {
+			ll = append(ll, language.Make(candidate))
+			//if svc.HasLanguage(tmp) {
+			//	ll = append(ll, lang)
+			//	break
+			//}
+		}
+
+		//if !svc.HasLanguage(lang) {
+		//	errors.ProperlyServeHTTP(w, req, errors.New(
+		//		errors.KindNotFound,
+		//		"no such language",
+		//		errors.StackTrimAtFn("http.HandlerFunc.ServeHTTP"),
+		//	), true)
+		//	return
+		//}
+
+		//if !svc.HasApplication(lang, r.Application) {
+		//	errors.ProperlyServeHTTP(w, req, errors.New(
+		//		errors.KindNotFound,
+		//		"no such application",
+		//		errors.StackTrimAtFn("http.HandlerFunc.ServeHTTP"),
+		//	), true)
+		//	return
+		//}
+
+		if err := locale.Global().EncodeExternal(w, r.Application, ll...); err != nil {
+			errors.ProperlyServeHTTP(w, req, err, true)
+		}
+
+		w.Header().Set("Content-Type", "application/json;charset=UTF-8")
+	}, nil
+}
+
+func (ctrl Locale) ListResource(ctx context.Context, r *request.LocaleListResource) (interface{}, error) {
+	var (
+		err error
+		f   = types.ResourceTranslationFilter{
+			Lang:         r.Lang,
+			Resource:     r.Resource,
+			ResourceType: r.ResourceType,
+			OwnerID:      r.OwnerID,
+			Deleted:      filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.svc.List(ctx, f)
+	return ctrl.makeResourceTranslationSetPayload(ctx, set, filter, err)
+}
+
+func (ctrl Locale) CreateResource(ctx context.Context, r *request.LocaleCreateResource) (interface{}, error) {
+	var (
+		err error
+		app = &types.ResourceTranslation{
+			Lang:     types.Lang{Tag: language.Make(r.Lang)},
+			Resource: r.Resource,
+			K:        r.Key,
+			Message:  r.Message,
+			OwnedBy:  r.OwnerID,
+		}
+	)
+
+	app, err = ctrl.svc.Create(ctx, app)
+	return ctrl.makeResourceTranslationPayload(ctx, app, err)
+}
+
+func (ctrl Locale) UpdateResource(ctx context.Context, r *request.LocaleUpdateResource) (interface{}, error) {
+	var (
+		err error
+		app = &types.ResourceTranslation{
+			ID:       r.TranslationID,
+			Lang:     types.Lang{Tag: language.Make(r.Lang)},
+			Resource: r.Resource,
+			K:        r.Key,
+			Message:  r.Message,
+			OwnedBy:  r.OwnerID,
+		}
+	)
+
+	app, err = ctrl.svc.Update(ctx, app)
+	return ctrl.makeResourceTranslationPayload(ctx, app, err)
+}
+
+func (ctrl Locale) ReadResource(ctx context.Context, r *request.LocaleReadResource) (interface{}, error) {
+	tpl, err := ctrl.svc.Read(ctx, r.TranslationID)
+	return ctrl.makeResourceTranslationPayload(ctx, tpl, err)
+}
+
+func (ctrl Locale) DeleteResource(ctx context.Context, r *request.LocaleDeleteResource) (interface{}, error) {
+	return api.OK(), ctrl.svc.Delete(ctx, r.TranslationID)
+}
+
+func (ctrl Locale) UndeleteResource(ctx context.Context, r *request.LocaleUndeleteResource) (interface{}, error) {
+	return api.OK(), ctrl.svc.Undelete(ctx, r.TranslationID)
+}
+
+// Utilities
+
+func (ctrl Locale) makeResourceTranslationSetPayload(ctx context.Context, tt types.ResourceTranslationSet, f types.ResourceTranslationFilter, err error) (*resourceTranslationSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &resourceTranslationSetPayload{Filter: f, Set: make([]*resourceTranslationPayload, len(tt))}
+
+	for i := range tt {
+		msp.Set[i], _ = ctrl.makeResourceTranslationPayload(ctx, tt[i], nil)
+	}
+
+	return msp, nil
+}
+
+func (ctrl Locale) makeResourceTranslationPayload(ctx context.Context, rt *types.ResourceTranslation, err error) (*resourceTranslationPayload, error) {
+	if err != nil || rt == nil {
+		return nil, err
+	}
+
+	pl := &resourceTranslationPayload{
+		ResourceTranslation: rt,
+	}
+
+	return pl, nil
+}

server/system/rest/notification.go

@@ -0,0 +1,138 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Notification struct {
+		notification service.NotificationService
+	}
+
+	notificationSetPayload struct {
+		Filter types.NotificationFilter `json:"filter"`
+		Set    types.NotificationSet    `json:"set,omitempty"`
+	}
+)
+
+func (Notification) New() *Notification {
+	ctrl := &Notification{}
+	ctrl.notification = service.DefaultNotification
+	return ctrl
+}
+
+func (ctrl *Notification) List(ctx context.Context, r *request.NotificationList) (interface{}, error) {
+	var (
+		err error
+		f   = types.NotificationFilter{
+			Kind:    []types.NotificationKind{types.NotificationKind(r.Kind)},
+			Read:    filter.State(r.Read),
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	if len(r.NotificationID) > 0 {
+		f.NotificationID = payload.ParseUint64s(r.NotificationID)
+	}
+
+	set, f, err := ctrl.notification.Find(ctx, f)
+	if err != nil {
+		return nil, err
+	}
+
+	// Ensure we have a valid empty set rather than nil
+	if set == nil {
+		set = make(types.NotificationSet, 0)
+	}
+
+	return ctrl.makeFilterPayload(ctx, set, f, nil)
+}
+
+func (ctrl *Notification) Create(ctx context.Context, r *request.NotificationCreate) (interface{}, error) {
+	ntf := &types.Notification{
+		Kind:      types.NotificationKind(r.Kind),
+		Config:    types.NotificationConfig{},
+		Recipient: r.Recipient,
+	}
+
+	// Convert sqlxTypes.JSONText to NotificationConfig
+	if len(r.Config) > 0 {
+		if err := r.Config.Unmarshal(&ntf.Config); err != nil {
+			return nil, err
+		}
+	}
+
+	return ctrl.notification.Create(ctx, ntf)
+}
+
+func (ctrl *Notification) Update(ctx context.Context, r *request.NotificationUpdate) (interface{}, error) {
+	ntf := &types.Notification{
+		ID:        r.NotificationID,
+		Kind:      types.NotificationKind(r.Kind),
+		Config:    types.NotificationConfig{},
+		Recipient: r.Recipient,
+	}
+
+	// Convert sqlxTypes.JSONText to NotificationConfig
+	if len(r.Config) > 0 {
+		if err := r.Config.Unmarshal(&ntf.Config); err != nil {
+			return nil, err
+		}
+	}
+
+	return ctrl.notification.Update(ctx, ntf)
+}
+
+func (ctrl *Notification) Read(ctx context.Context, r *request.NotificationRead) (interface{}, error) {
+	return ctrl.notification.FindByID(ctx, r.NotificationID)
+}
+
+func (ctrl *Notification) Delete(ctx context.Context, r *request.NotificationDelete) (interface{}, error) {
+	return api.OK(), ctrl.notification.Delete(ctx, r.NotificationID)
+}
+
+func (ctrl *Notification) MarkAsRead(ctx context.Context, r *request.NotificationMarkAsRead) (interface{}, error) {
+	return api.OK(), ctrl.notification.MarkAsRead(ctx, r.NotificationID)
+}
+
+func (ctrl *Notification) MarkAsUnread(ctx context.Context, r *request.NotificationMarkAsUnread) (interface{}, error) {
+	return api.OK(), ctrl.notification.MarkAsUnread(ctx, r.NotificationID)
+}
+
+func (ctrl *Notification) MarkAllAsRead(ctx context.Context, r *request.NotificationMarkAllAsRead) (interface{}, error) {
+	return api.OK(), ctrl.notification.MarkAllAsRead(ctx)
+}
+
+func (ctrl *Notification) MarkAllAsUnread(ctx context.Context, r *request.NotificationMarkAllAsUnread) (interface{}, error) {
+	return api.OK(), ctrl.notification.MarkAllAsUnread(ctx)
+}
+
+func (ctrl *Notification) makeFilterPayload(ctx context.Context, nn types.NotificationSet, f types.NotificationFilter, err error) (*notificationSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	// Ensure we never return nil, but an empty slice instead
+	if nn == nil {
+		nn = make(types.NotificationSet, 0)
+	}
+
+	return &notificationSetPayload{Filter: f, Set: nn}, nil
+}

server/system/rest/permissions.go

@@ -0,0 +1,69 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Permissions struct {
+		ac permissionsAccessController
+	}
+
+	permissionsAccessController interface {
+		Effective(context.Context, ...rbac.Resource) rbac.EffectiveSet
+		Trace(context.Context, uint64, []uint64, ...string) ([]*rbac.Trace, error)
+		List() []map[string]string
+		FindRulesByRoleID(context.Context, uint64) (rbac.RuleSet, error)
+		FindRules(ctx context.Context, roleID uint64, rr ...string) (rbac.RuleSet, error)
+		Grant(ctx context.Context, rr ...*rbac.Rule) error
+	}
+)
+
+func (Permissions) New() *Permissions {
+	return &Permissions{
+		ac: service.DefaultAccessControl,
+	}
+}
+
+func (ctrl Permissions) Effective(ctx context.Context, r *request.PermissionsEffective) (interface{}, error) {
+	return ctrl.ac.Effective(ctx, types.Component{}), nil
+}
+
+func (ctrl Permissions) Trace(ctx context.Context, r *request.PermissionsTrace) (interface{}, error) {
+	return ctrl.ac.Trace(ctx, r.UserID, r.RoleID, r.Resource...)
+}
+
+func (ctrl Permissions) List(ctx context.Context, r *request.PermissionsList) (interface{}, error) {
+	return ctrl.ac.List(), nil
+}
+
+func (ctrl Permissions) Read(ctx context.Context, r *request.PermissionsRead) (interface{}, error) {
+	return ctrl.ac.FindRules(ctx, r.RoleID, r.Resource...)
+}
+
+func (ctrl Permissions) Delete(ctx context.Context, r *request.PermissionsDelete) (interface{}, error) {
+	rr, err := ctrl.ac.FindRulesByRoleID(ctx, r.RoleID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, r := range rr {
+		r.Access = rbac.Inherit
+	}
+
+	return api.OK(), ctrl.ac.Grant(ctx, rr...)
+}
+
+func (ctrl Permissions) Update(ctx context.Context, r *request.PermissionsUpdate) (interface{}, error) {
+	for _, rule := range r.Rules {
+		// Make sure everything is properly set
+		rule.RoleID = r.RoleID
+	}
+
+	return api.OK(), ctrl.ac.Grant(ctx, r.Rules...)
+}

server/system/rest/queues.go

@@ -0,0 +1,154 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Queue struct {
+		svc queueService
+		ac  queueAccessController
+	}
+
+	queuePayload struct {
+		*types.Queue
+
+		CanGrant       bool `json:"canGrant"`
+		CanUpdateQueue bool `json:"canUpdateQueue"`
+		CanDeleteQueue bool `json:"canDeleteQueue"`
+	}
+
+	queueSetPayload struct {
+		Filter types.QueueFilter `json:"filter"`
+		Set    []*queuePayload   `json:"set"`
+	}
+
+	queueService interface {
+		FindByID(ctx context.Context, ID uint64) (q *types.Queue, err error)
+		Create(ctx context.Context, new *types.Queue) (q *types.Queue, err error)
+		Update(ctx context.Context, upd *types.Queue) (q *types.Queue, err error)
+		DeleteByID(ctx context.Context, ID uint64) (err error)
+		UndeleteByID(ctx context.Context, ID uint64) (err error)
+		Search(ctx context.Context, filter types.QueueFilter) (q types.QueueSet, f types.QueueFilter, err error)
+	}
+
+	queueAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanCreateQueue(context.Context) bool
+		CanUpdateQueue(context.Context, *types.Queue) bool
+		CanDeleteQueue(context.Context, *types.Queue) bool
+	}
+)
+
+func (Queue) New() *Queue {
+	return &Queue{
+		svc: service.DefaultQueue,
+		ac:  service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *Queue) List(ctx context.Context, r *request.QueuesList) (interface{}, error) {
+	var (
+		err error
+		f   = types.QueueFilter{
+			Query:   r.Query,
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.svc.Search(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *Queue) Create(ctx context.Context, r *request.QueuesCreate) (interface{}, error) {
+	var (
+		err error
+		q   = &types.Queue{
+			Consumer: r.Consumer,
+			Queue:    r.Queue,
+			Meta:     r.Meta,
+		}
+	)
+
+	q, err = ctrl.svc.Create(ctx, q)
+
+	return ctrl.makePayload(ctx, q, err)
+}
+
+func (ctrl *Queue) Read(ctx context.Context, r *request.QueuesRead) (interface{}, error) {
+	res, err := ctrl.svc.FindByID(ctx, r.QueueID)
+	return ctrl.makePayload(ctx, res, err)
+}
+
+func (ctrl *Queue) Update(ctx context.Context, r *request.QueuesUpdate) (interface{}, error) {
+	var (
+		err error
+		q   = &types.Queue{
+			ID:        r.QueueID,
+			Consumer:  r.Consumer,
+			Queue:     r.Queue,
+			Meta:      r.Meta,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	q, err = ctrl.svc.Update(ctx, q)
+
+	return ctrl.makePayload(ctx, q, err)
+}
+
+func (ctrl *Queue) Delete(ctx context.Context, r *request.QueuesDelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.DeleteByID(ctx, r.QueueID)
+}
+
+func (ctrl *Queue) Undelete(ctx context.Context, r *request.QueuesUndelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.UndeleteByID(ctx, r.QueueID)
+}
+
+func (ctrl *Queue) makePayload(ctx context.Context, q *types.Queue, err error) (*queuePayload, error) {
+	if err != nil || q == nil {
+		return nil, err
+	}
+
+	qq := &queuePayload{
+		Queue: q,
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanUpdateQueue: ctrl.ac.CanUpdateQueue(ctx, q),
+		CanDeleteQueue: ctrl.ac.CanDeleteQueue(ctx, q),
+	}
+
+	return qq, nil
+}
+
+func (ctrl *Queue) makeFilterPayload(ctx context.Context, nn types.QueueSet, f types.QueueFilter, err error) (*queueSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &queueSetPayload{Filter: f, Set: make([]*queuePayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/system/rest/reminder.go

@@ -0,0 +1,112 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"time"
+)
+
+type (
+	Reminder struct {
+		reminder service.ReminderService
+	}
+
+	reminderSetPayload struct {
+		Filter types.ReminderFilter `json:"filter"`
+		Set    types.ReminderSet    `json:"set,omitempty"`
+	}
+)
+
+func (Reminder) New() *Reminder {
+	ctrl := &Reminder{}
+	ctrl.reminder = service.DefaultReminder
+	return ctrl
+}
+
+func (ctrl *Reminder) List(ctx context.Context, r *request.ReminderList) (interface{}, error) {
+	var (
+		err error
+		f   = types.ReminderFilter{
+			AssignedTo:       r.AssignedTo,
+			Resource:         r.Resource,
+			ScheduledFrom:    r.ScheduledFrom,
+			ScheduledUntil:   r.ScheduledUntil,
+			ExcludeDismissed: r.ExcludeDismissed,
+			IncludeDeleted:   r.IncludeDeleted,
+			ScheduledOnly:    r.ScheduledOnly,
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, f, err := ctrl.reminder.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl *Reminder) Create(ctx context.Context, r *request.ReminderCreate) (interface{}, error) {
+	ntf := &types.Reminder{
+		AssignedAt: time.Now(),
+		AssignedBy: auth.GetIdentityFromContext(ctx).Identity(),
+
+		AssignedTo: r.AssignedTo,
+		Payload:    r.Payload,
+		Resource:   r.Resource,
+		RemindAt:   r.RemindAt,
+	}
+
+	return ctrl.reminder.Create(ctx, ntf)
+}
+
+func (ctrl *Reminder) Update(ctx context.Context, r *request.ReminderUpdate) (interface{}, error) {
+	ntf := &types.Reminder{
+		ID:         r.ReminderID,
+		AssignedAt: time.Now(),
+		AssignedBy: auth.GetIdentityFromContext(ctx).Identity(),
+
+		AssignedTo: r.AssignedTo,
+		Payload:    r.Payload,
+		Resource:   r.Resource,
+		RemindAt:   r.RemindAt,
+	}
+
+	return ctrl.reminder.Update(ctx, ntf)
+}
+
+func (ctrl *Reminder) Read(ctx context.Context, r *request.ReminderRead) (interface{}, error) {
+	return ctrl.reminder.FindByID(ctx, r.ReminderID)
+}
+
+func (ctrl *Reminder) Delete(ctx context.Context, r *request.ReminderDelete) (interface{}, error) {
+	return api.OK(), ctrl.reminder.Delete(ctx, r.ReminderID)
+}
+
+func (ctrl *Reminder) Dismiss(ctx context.Context, r *request.ReminderDismiss) (interface{}, error) {
+	return api.OK(), ctrl.reminder.Dismiss(ctx, r.ReminderID)
+}
+
+func (ctrl *Reminder) Undismiss(ctx context.Context, r *request.ReminderUndismiss) (interface{}, error) {
+	return api.OK(), ctrl.reminder.Undismiss(ctx, r.ReminderID)
+}
+
+func (ctrl *Reminder) Snooze(ctx context.Context, r *request.ReminderSnooze) (interface{}, error) {
+	return api.OK(), ctrl.reminder.Snooze(ctx, r.ReminderID, r.RemindAt)
+}
+
+func (ctrl *Reminder) makeFilterPayload(ctx context.Context, nn types.ReminderSet, f types.ReminderFilter, err error) (*reminderSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	return &reminderSetPayload{Filter: f, Set: nn}, nil
+}

server/system/rest/report.go

@@ -0,0 +1,189 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/reporting"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Report struct {
+		report reportService
+		ac     reportAccessController
+	}
+
+	reportService interface {
+		LookupByID(ctx context.Context, ID uint64) (app *types.Report, err error)
+		Search(ctx context.Context, filter types.ReportFilter) (aa types.ReportSet, f types.ReportFilter, err error)
+		Create(ctx context.Context, new *types.Report) (app *types.Report, err error)
+		Update(ctx context.Context, upd *types.Report) (app *types.Report, err error)
+		Delete(ctx context.Context, ID uint64) (err error)
+		Undelete(ctx context.Context, ID uint64) (err error)
+		Run(ctx context.Context, ID uint64, dd reporting.FrameDefinitionSet) (rr []*reporting.Frame, err error)
+		Describe(ctx context.Context, src types.ReportDataSourceSet, st types.ReportStepSet, sources ...string) (out []reporting.FrameDescription, err error)
+	}
+
+	reportAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanReadReport(context.Context, *types.Report) bool
+		CanUpdateReport(context.Context, *types.Report) bool
+		CanDeleteReport(context.Context, *types.Report) bool
+		CanRunReport(context.Context, *types.Report) bool
+	}
+
+	reportPayload struct {
+		*types.Report
+
+		CanGrant        bool `json:"canGrant"`
+		CanReadReport   bool `json:"canReadReport"`
+		CanUpdateReport bool `json:"canUpdateReport"`
+		CanDeleteReport bool `json:"canDeleteReport"`
+		CanRunReport    bool `json:"canRunReport"`
+	}
+
+	reportSetPayload struct {
+		Filter types.ReportFilter `json:"filter"`
+		Set    []*reportPayload   `json:"set"`
+	}
+
+	reportFramePayload struct {
+		Frames []*reporting.Frame `json:"frames"`
+	}
+)
+
+func (Report) New() *Report {
+	return &Report{
+		report: service.DefaultReport,
+		ac:     service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *Report) List(ctx context.Context, r *request.ReportList) (interface{}, error) {
+	var (
+		err error
+		f   = types.ReportFilter{
+			Handle:  r.Handle,
+			Query:   r.Query,
+			Labels:  r.Labels,
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.report.Search(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl *Report) Create(ctx context.Context, r *request.ReportCreate) (interface{}, error) {
+	var (
+		err error
+		app = &types.Report{
+			Handle:    r.Handle,
+			Meta:      r.Meta,
+			Scenarios: r.Scenarios,
+			Sources:   r.Sources,
+			Blocks:    r.Blocks,
+			Labels:    r.Labels,
+		}
+	)
+
+	app, err = ctrl.report.Create(ctx, app)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *Report) Update(ctx context.Context, r *request.ReportUpdate) (interface{}, error) {
+	var (
+		err error
+		app = &types.Report{
+			ID:        r.ReportID,
+			Handle:    r.Handle,
+			Meta:      r.Meta,
+			Scenarios: r.Scenarios,
+			Sources:   r.Sources,
+			Blocks:    r.Blocks,
+			Labels:    r.Labels,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	app, err = ctrl.report.Update(ctx, app)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *Report) Read(ctx context.Context, r *request.ReportRead) (interface{}, error) {
+	app, err := ctrl.report.LookupByID(ctx, r.ReportID)
+	return ctrl.makePayload(ctx, app, err)
+}
+
+func (ctrl *Report) Delete(ctx context.Context, r *request.ReportDelete) (interface{}, error) {
+	return api.OK(), ctrl.report.Delete(ctx, r.ReportID)
+}
+
+func (ctrl *Report) Undelete(ctx context.Context, r *request.ReportUndelete) (interface{}, error) {
+	return api.OK(), ctrl.report.Undelete(ctx, r.ReportID)
+}
+
+func (ctrl *Report) Describe(ctx context.Context, r *request.ReportDescribe) (interface{}, error) {
+	return ctrl.report.Describe(ctx, r.Sources, r.Steps, r.Describe...)
+}
+
+func (ctrl *Report) Run(ctx context.Context, r *request.ReportRun) (interface{}, error) {
+	rr, err := ctrl.report.Run(ctx, r.ReportID, r.Frames)
+	return ctrl.makeReportFramePayload(ctx, rr, err)
+}
+
+func (ctrl Report) makePayload(ctx context.Context, m *types.Report, err error) (*reportPayload, error) {
+	if err != nil || m == nil {
+		return nil, err
+	}
+
+	return &reportPayload{
+		Report: m,
+
+		CanGrant: ctrl.ac.CanGrant(ctx),
+
+		CanReadReport:   ctrl.ac.CanReadReport(ctx, m),
+		CanUpdateReport: ctrl.ac.CanUpdateReport(ctx, m),
+		CanDeleteReport: ctrl.ac.CanDeleteReport(ctx, m),
+		CanRunReport:    ctrl.ac.CanRunReport(ctx, m),
+	}, nil
+}
+
+func (ctrl Report) makeFilterPayload(ctx context.Context, nn types.ReportSet, f types.ReportFilter, err error) (*reportSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &reportSetPayload{Filter: f, Set: make([]*reportPayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}
+
+func (ctrl Report) makeReportFramePayload(ctx context.Context, ff []*reporting.Frame, err error) (*reportFramePayload, error) {
+	if err != nil || len(ff) == 0 {
+		return nil, err
+	}
+
+	return &reportFramePayload{
+		Frames: ff,
+	}, nil
+}

server/system/rest/request/actionlog.go

@@ -0,0 +1,185 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ActionlogList struct {
+		// From GET parameter
+		//
+		// From
+		From *time.Time
+
+		// To GET parameter
+		//
+		// To
+		To *time.Time
+
+		// BeforeActionID GET parameter
+		//
+		// Entries before specified action ID
+		BeforeActionID uint64 `json:",string"`
+
+		// Resource GET parameter
+		//
+		// Resource
+		Resource string
+
+		// Action GET parameter
+		//
+		// Action
+		Action string
+
+		// ActorID GET parameter
+		//
+		// Filter by one or more actors
+		ActorID []string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+	}
+)
+
+// NewActionlogList request
+func NewActionlogList() *ActionlogList {
+	return &ActionlogList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"from":           r.From,
+		"to":             r.To,
+		"beforeActionID": r.BeforeActionID,
+		"resource":       r.Resource,
+		"action":         r.Action,
+		"actorID":        r.ActorID,
+		"limit":          r.Limit,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) GetFrom() *time.Time {
+	return r.From
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) GetTo() *time.Time {
+	return r.To
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) GetBeforeActionID() uint64 {
+	return r.BeforeActionID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) GetResource() string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) GetAction() string {
+	return r.Action
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) GetActorID() []string {
+	return r.ActorID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ActionlogList) GetLimit() uint {
+	return r.Limit
+}
+
+// Fill processes request and fills internal variables
+func (r *ActionlogList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["from"]; ok && len(val) > 0 {
+			r.From, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["to"]; ok && len(val) > 0 {
+			r.To, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["beforeActionID"]; ok && len(val) > 0 {
+			r.BeforeActionID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["action"]; ok && len(val) > 0 {
+			r.Action, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["actorID[]"]; ok {
+			r.ActorID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["actorID"]; ok {
+			r.ActorID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/system/rest/request/apigwFilter.go

@@ -0,0 +1,813 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ApigwFilterList struct {
+		// RouteID GET parameter
+		//
+		// Filter by route ID
+		RouteID uint64 `json:",string"`
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted filters
+		Deleted uint64 `json:",string"`
+
+		// Disabled GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) disabled filters
+		Disabled uint64 `json:",string"`
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	ApigwFilterCreate struct {
+		// RouteID POST parameter
+		//
+		// Route
+		RouteID uint64 `json:",string"`
+
+		// Weight POST parameter
+		//
+		// Filter priority
+		Weight uint64 `json:",string"`
+
+		// Kind POST parameter
+		//
+		// Filter kind
+		Kind string
+
+		// Ref POST parameter
+		//
+		// Filter ref
+		Ref string
+
+		// Enabled POST parameter
+		//
+		// Is Filter enabled
+		Enabled bool
+
+		// Params POST parameter
+		//
+		// Filter parameters
+		Params types.ApigwFilterParams
+	}
+
+	ApigwFilterUpdate struct {
+		// FilterID PATH parameter
+		//
+		// Filter ID
+		FilterID uint64 `json:",string"`
+
+		// RouteID POST parameter
+		//
+		// Route
+		RouteID uint64 `json:",string"`
+
+		// Weight POST parameter
+		//
+		// Filter priority
+		Weight uint64 `json:",string"`
+
+		// Kind POST parameter
+		//
+		// Filter kind
+		Kind string
+
+		// Ref POST parameter
+		//
+		// Filter ref
+		Ref string
+
+		// Enabled POST parameter
+		//
+		// Is Filter enabled
+		Enabled bool
+
+		// Params POST parameter
+		//
+		// Filter parameters
+		Params types.ApigwFilterParams
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	ApigwFilterRead struct {
+		// FilterID PATH parameter
+		//
+		// Filter ID
+		FilterID uint64 `json:",string"`
+	}
+
+	ApigwFilterDelete struct {
+		// FilterID PATH parameter
+		//
+		// Filter ID
+		FilterID uint64 `json:",string"`
+	}
+
+	ApigwFilterUndelete struct {
+		// FilterID PATH parameter
+		//
+		// Filter ID
+		FilterID uint64 `json:",string"`
+	}
+
+	ApigwFilterDefFilter struct {
+		// Kind GET parameter
+		//
+		// Filter filters by kind
+		Kind string
+	}
+
+	ApigwFilterDefProxyAuth struct {
+	}
+)
+
+// NewApigwFilterList request
+func NewApigwFilterList() *ApigwFilterList {
+	return &ApigwFilterList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID":    r.RouteID,
+		"deleted":    r.Deleted,
+		"disabled":   r.Disabled,
+		"limit":      r.Limit,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterList) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterList) GetDeleted() uint64 {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterList) GetDisabled() uint64 {
+	return r.Disabled
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["routeID"]; ok && len(val) > 0 {
+			r.RouteID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["disabled"]; ok && len(val) > 0 {
+			r.Disabled, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewApigwFilterCreate request
+func NewApigwFilterCreate() *ApigwFilterCreate {
+	return &ApigwFilterCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID": r.RouteID,
+		"weight":  r.Weight,
+		"kind":    r.Kind,
+		"ref":     r.Ref,
+		"enabled": r.Enabled,
+		"params":  r.Params,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterCreate) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterCreate) GetWeight() uint64 {
+	return r.Weight
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterCreate) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterCreate) GetRef() string {
+	return r.Ref
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterCreate) GetEnabled() bool {
+	return r.Enabled
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterCreate) GetParams() types.ApigwFilterParams {
+	return r.Params
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["routeID"]; ok && len(val) > 0 {
+				r.RouteID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["weight"]; ok && len(val) > 0 {
+				r.Weight, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["kind"]; ok && len(val) > 0 {
+				r.Kind, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["ref"]; ok && len(val) > 0 {
+				r.Ref, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["enabled"]; ok && len(val) > 0 {
+				r.Enabled, err = payload.ParseBool(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["params[]"]; ok {
+				r.Params, err = types.ParseApigwfFilterParams(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["params"]; ok {
+				r.Params, err = types.ParseApigwfFilterParams(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["routeID"]; ok && len(val) > 0 {
+			r.RouteID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["weight"]; ok && len(val) > 0 {
+			r.Weight, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["ref"]; ok && len(val) > 0 {
+			r.Ref, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["enabled"]; ok && len(val) > 0 {
+			r.Enabled, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["params[]"]; ok {
+			r.Params, err = types.ParseApigwfFilterParams(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["params"]; ok {
+			r.Params, err = types.ParseApigwfFilterParams(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewApigwFilterUpdate request
+func NewApigwFilterUpdate() *ApigwFilterUpdate {
+	return &ApigwFilterUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"filterID":  r.FilterID,
+		"routeID":   r.RouteID,
+		"weight":    r.Weight,
+		"kind":      r.Kind,
+		"ref":       r.Ref,
+		"enabled":   r.Enabled,
+		"params":    r.Params,
+		"updatedAt": r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetFilterID() uint64 {
+	return r.FilterID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetWeight() uint64 {
+	return r.Weight
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetRef() string {
+	return r.Ref
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetEnabled() bool {
+	return r.Enabled
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetParams() types.ApigwFilterParams {
+	return r.Params
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["routeID"]; ok && len(val) > 0 {
+				r.RouteID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["weight"]; ok && len(val) > 0 {
+				r.Weight, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["kind"]; ok && len(val) > 0 {
+				r.Kind, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["ref"]; ok && len(val) > 0 {
+				r.Ref, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["enabled"]; ok && len(val) > 0 {
+				r.Enabled, err = payload.ParseBool(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["params[]"]; ok {
+				r.Params, err = types.ParseApigwfFilterParams(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["params"]; ok {
+				r.Params, err = types.ParseApigwfFilterParams(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["routeID"]; ok && len(val) > 0 {
+			r.RouteID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["weight"]; ok && len(val) > 0 {
+			r.Weight, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["ref"]; ok && len(val) > 0 {
+			r.Ref, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["enabled"]; ok && len(val) > 0 {
+			r.Enabled, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["params[]"]; ok {
+			r.Params, err = types.ParseApigwfFilterParams(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["params"]; ok {
+			r.Params, err = types.ParseApigwfFilterParams(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "filterID")
+		r.FilterID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwFilterRead request
+func NewApigwFilterRead() *ApigwFilterRead {
+	return &ApigwFilterRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"filterID": r.FilterID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterRead) GetFilterID() uint64 {
+	return r.FilterID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "filterID")
+		r.FilterID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwFilterDelete request
+func NewApigwFilterDelete() *ApigwFilterDelete {
+	return &ApigwFilterDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"filterID": r.FilterID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterDelete) GetFilterID() uint64 {
+	return r.FilterID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "filterID")
+		r.FilterID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwFilterUndelete request
+func NewApigwFilterUndelete() *ApigwFilterUndelete {
+	return &ApigwFilterUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"filterID": r.FilterID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterUndelete) GetFilterID() uint64 {
+	return r.FilterID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "filterID")
+		r.FilterID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwFilterDefFilter request
+func NewApigwFilterDefFilter() *ApigwFilterDefFilter {
+	return &ApigwFilterDefFilter{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterDefFilter) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind": r.Kind,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterDefFilter) GetKind() string {
+	return r.Kind
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterDefFilter) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewApigwFilterDefProxyAuth request
+func NewApigwFilterDefProxyAuth() *ApigwFilterDefProxyAuth {
+	return &ApigwFilterDefProxyAuth{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwFilterDefProxyAuth) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwFilterDefProxyAuth) Fill(req *http.Request) (err error) {
+
+	return err
+}

server/system/rest/request/apigwProfiler.go

@@ -0,0 +1,347 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ApigwProfilerAggregation struct {
+		// Path GET parameter
+		//
+		// Filter by request path
+		Path string
+
+		// Before GET parameter
+		//
+		// Entries before specified route
+		Before string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+	}
+
+	ApigwProfilerRoute struct {
+		// RouteID PATH parameter
+		//
+		// Route ID
+		RouteID string
+
+		// Path GET parameter
+		//
+		// Filter by request path
+		Path string
+
+		// Before GET parameter
+		//
+		// Entries before specified hit ID
+		Before string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+	}
+
+	ApigwProfilerHit struct {
+		// HitID PATH parameter
+		//
+		// Hit ID
+		HitID string
+	}
+
+	ApigwProfilerPurgeAll struct {
+	}
+
+	ApigwProfilerPurge struct {
+		// RouteID PATH parameter
+		//
+		// Route ID
+		RouteID uint64 `json:",string"`
+	}
+)
+
+// NewApigwProfilerAggregation request
+func NewApigwProfilerAggregation() *ApigwProfilerAggregation {
+	return &ApigwProfilerAggregation{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerAggregation) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"path":   r.Path,
+		"before": r.Before,
+		"sort":   r.Sort,
+		"limit":  r.Limit,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerAggregation) GetPath() string {
+	return r.Path
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerAggregation) GetBefore() string {
+	return r.Before
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerAggregation) GetSort() string {
+	return r.Sort
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerAggregation) GetLimit() uint {
+	return r.Limit
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwProfilerAggregation) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["path"]; ok && len(val) > 0 {
+			r.Path, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["before"]; ok && len(val) > 0 {
+			r.Before, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewApigwProfilerRoute request
+func NewApigwProfilerRoute() *ApigwProfilerRoute {
+	return &ApigwProfilerRoute{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerRoute) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID": r.RouteID,
+		"path":    r.Path,
+		"before":  r.Before,
+		"sort":    r.Sort,
+		"limit":   r.Limit,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerRoute) GetRouteID() string {
+	return r.RouteID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerRoute) GetPath() string {
+	return r.Path
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerRoute) GetBefore() string {
+	return r.Before
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerRoute) GetSort() string {
+	return r.Sort
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerRoute) GetLimit() uint {
+	return r.Limit
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwProfilerRoute) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["path"]; ok && len(val) > 0 {
+			r.Path, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["before"]; ok && len(val) > 0 {
+			r.Before, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "routeID")
+		r.RouteID, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwProfilerHit request
+func NewApigwProfilerHit() *ApigwProfilerHit {
+	return &ApigwProfilerHit{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerHit) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"hitID": r.HitID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerHit) GetHitID() string {
+	return r.HitID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwProfilerHit) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "hitID")
+		r.HitID, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwProfilerPurgeAll request
+func NewApigwProfilerPurgeAll() *ApigwProfilerPurgeAll {
+	return &ApigwProfilerPurgeAll{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerPurgeAll) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwProfilerPurgeAll) Fill(req *http.Request) (err error) {
+
+	return err
+}
+
+// NewApigwProfilerPurge request
+func NewApigwProfilerPurge() *ApigwProfilerPurge {
+	return &ApigwProfilerPurge{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerPurge) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID": r.RouteID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwProfilerPurge) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwProfilerPurge) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "routeID")
+		r.RouteID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/apigwRoute.go

@@ -0,0 +1,765 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/label"
+	labelTypes "github.com/cortezaproject/corteza/server/pkg/label/types"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ApigwRouteList struct {
+		// RouteID GET parameter
+		//
+		// Filter by route ID
+		RouteID []uint64
+
+		// Query GET parameter
+		//
+		// Filter routes
+		Query string
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted routes
+		Deleted uint64 `json:",string"`
+
+		// Disabled GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) disabled routes
+		Disabled uint64 `json:",string"`
+
+		// Labels GET parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	ApigwRouteCreate struct {
+		// Endpoint POST parameter
+		//
+		// Route endpoint
+		Endpoint string
+
+		// Method POST parameter
+		//
+		// Route method
+		Method string
+
+		// Enabled POST parameter
+		//
+		// Is route enabled
+		Enabled bool
+
+		// Group POST parameter
+		//
+		// Route group
+		Group uint64 `json:",string"`
+
+		// Meta POST parameter
+		//
+		// Route meta
+		Meta types.ApigwRouteMeta
+	}
+
+	ApigwRouteUpdate struct {
+		// RouteID PATH parameter
+		//
+		// Route ID
+		RouteID uint64 `json:",string"`
+
+		// Endpoint POST parameter
+		//
+		// Route endpoint
+		Endpoint string
+
+		// Method POST parameter
+		//
+		// Route method
+		Method string
+
+		// Enabled POST parameter
+		//
+		// Is route enabled
+		Enabled bool
+
+		// Group POST parameter
+		//
+		// Route group
+		Group uint64 `json:",string"`
+
+		// Meta POST parameter
+		//
+		// Route meta
+		Meta types.ApigwRouteMeta
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	ApigwRouteRead struct {
+		// RouteID PATH parameter
+		//
+		// Route ID
+		RouteID uint64 `json:",string"`
+	}
+
+	ApigwRouteDelete struct {
+		// RouteID PATH parameter
+		//
+		// Route ID
+		RouteID uint64 `json:",string"`
+	}
+
+	ApigwRouteUndelete struct {
+		// RouteID PATH parameter
+		//
+		// Route ID
+		RouteID uint64 `json:",string"`
+	}
+)
+
+// NewApigwRouteList request
+func NewApigwRouteList() *ApigwRouteList {
+	return &ApigwRouteList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID":    r.RouteID,
+		"query":      r.Query,
+		"deleted":    r.Deleted,
+		"disabled":   r.Disabled,
+		"labels":     r.Labels,
+		"limit":      r.Limit,
+		"incTotal":   r.IncTotal,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetRouteID() []uint64 {
+	return r.RouteID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetDeleted() uint64 {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetDisabled() uint64 {
+	return r.Disabled
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwRouteList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["routeID[]"]; ok {
+			r.RouteID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["routeID"]; ok {
+			r.RouteID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["disabled"]; ok && len(val) > 0 {
+			r.Disabled, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewApigwRouteCreate request
+func NewApigwRouteCreate() *ApigwRouteCreate {
+	return &ApigwRouteCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"endpoint": r.Endpoint,
+		"method":   r.Method,
+		"enabled":  r.Enabled,
+		"group":    r.Group,
+		"meta":     r.Meta,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteCreate) GetEndpoint() string {
+	return r.Endpoint
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteCreate) GetMethod() string {
+	return r.Method
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteCreate) GetEnabled() bool {
+	return r.Enabled
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteCreate) GetGroup() uint64 {
+	return r.Group
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteCreate) GetMeta() types.ApigwRouteMeta {
+	return r.Meta
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwRouteCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["endpoint"]; ok && len(val) > 0 {
+				r.Endpoint, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["method"]; ok && len(val) > 0 {
+				r.Method, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["enabled"]; ok && len(val) > 0 {
+				r.Enabled, err = payload.ParseBool(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["group"]; ok && len(val) > 0 {
+				r.Group, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseApigwRouteMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseApigwRouteMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["endpoint"]; ok && len(val) > 0 {
+			r.Endpoint, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["method"]; ok && len(val) > 0 {
+			r.Method, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["enabled"]; ok && len(val) > 0 {
+			r.Enabled, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["group"]; ok && len(val) > 0 {
+			r.Group, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseApigwRouteMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseApigwRouteMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewApigwRouteUpdate request
+func NewApigwRouteUpdate() *ApigwRouteUpdate {
+	return &ApigwRouteUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID":   r.RouteID,
+		"endpoint":  r.Endpoint,
+		"method":    r.Method,
+		"enabled":   r.Enabled,
+		"group":     r.Group,
+		"meta":      r.Meta,
+		"updatedAt": r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) GetEndpoint() string {
+	return r.Endpoint
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) GetMethod() string {
+	return r.Method
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) GetEnabled() bool {
+	return r.Enabled
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) GetGroup() uint64 {
+	return r.Group
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) GetMeta() types.ApigwRouteMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwRouteUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["endpoint"]; ok && len(val) > 0 {
+				r.Endpoint, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["method"]; ok && len(val) > 0 {
+				r.Method, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["enabled"]; ok && len(val) > 0 {
+				r.Enabled, err = payload.ParseBool(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["group"]; ok && len(val) > 0 {
+				r.Group, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseApigwRouteMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseApigwRouteMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["endpoint"]; ok && len(val) > 0 {
+			r.Endpoint, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["method"]; ok && len(val) > 0 {
+			r.Method, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["enabled"]; ok && len(val) > 0 {
+			r.Enabled, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["group"]; ok && len(val) > 0 {
+			r.Group, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseApigwRouteMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseApigwRouteMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "routeID")
+		r.RouteID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwRouteRead request
+func NewApigwRouteRead() *ApigwRouteRead {
+	return &ApigwRouteRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID": r.RouteID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteRead) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwRouteRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "routeID")
+		r.RouteID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwRouteDelete request
+func NewApigwRouteDelete() *ApigwRouteDelete {
+	return &ApigwRouteDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID": r.RouteID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteDelete) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwRouteDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "routeID")
+		r.RouteID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewApigwRouteUndelete request
+func NewApigwRouteUndelete() *ApigwRouteUndelete {
+	return &ApigwRouteUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"routeID": r.RouteID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ApigwRouteUndelete) GetRouteID() uint64 {
+	return r.RouteID
+}
+
+// Fill processes request and fills internal variables
+func (r *ApigwRouteUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "routeID")
+		r.RouteID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/attachment.go

@@ -0,0 +1,482 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	AttachmentRead struct {
+		// Kind PATH parameter
+		//
+		// Kind
+		Kind string
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+	}
+
+	AttachmentDelete struct {
+		// Kind PATH parameter
+		//
+		// Kind
+		Kind string
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+	}
+
+	AttachmentOriginal struct {
+		// Kind PATH parameter
+		//
+		// Kind
+		Kind string
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Name PATH parameter
+		//
+		// File name
+		Name string
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+
+		// Download GET parameter
+		//
+		// Force file download
+		Download bool
+	}
+
+	AttachmentPreview struct {
+		// Kind PATH parameter
+		//
+		// Kind
+		Kind string
+
+		// AttachmentID PATH parameter
+		//
+		// Attachment ID
+		AttachmentID uint64 `json:",string"`
+
+		// Ext PATH parameter
+		//
+		// Preview extension/format
+		Ext string
+
+		// Sign GET parameter
+		//
+		// Signature
+		Sign string
+
+		// UserID GET parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+	}
+)
+
+// NewAttachmentRead request
+func NewAttachmentRead() *AttachmentRead {
+	return &AttachmentRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"attachmentID": r.AttachmentID,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentRead) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentRead) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAttachmentDelete request
+func NewAttachmentDelete() *AttachmentDelete {
+	return &AttachmentDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"attachmentID": r.AttachmentID,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentDelete) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentDelete) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAttachmentOriginal request
+func NewAttachmentOriginal() *AttachmentOriginal {
+	return &AttachmentOriginal{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"attachmentID": r.AttachmentID,
+		"name":         r.Name,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+		"download":     r.Download,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentOriginal) GetDownload() bool {
+	return r.Download
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentOriginal) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["download"]; ok && len(val) > 0 {
+			r.Download, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "name")
+		r.Name, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAttachmentPreview request
+func NewAttachmentPreview() *AttachmentPreview {
+	return &AttachmentPreview{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":         r.Kind,
+		"attachmentID": r.AttachmentID,
+		"ext":          r.Ext,
+		"sign":         r.Sign,
+		"userID":       r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetAttachmentID() uint64 {
+	return r.AttachmentID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetExt() string {
+	return r.Ext
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetSign() string {
+	return r.Sign
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AttachmentPreview) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *AttachmentPreview) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sign"]; ok && len(val) > 0 {
+			r.Sign, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "kind")
+		r.Kind, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "attachmentID")
+		r.AttachmentID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "ext")
+		r.Ext, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/auth.go

@@ -0,0 +1,107 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	AuthImpersonate struct {
+		// UserID POST parameter
+		//
+		// ID of the impersonated user
+		UserID uint64 `json:",string"`
+	}
+)
+
+// NewAuthImpersonate request
+func NewAuthImpersonate() *AuthImpersonate {
+	return &AuthImpersonate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AuthImpersonate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"userID": r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AuthImpersonate) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *AuthImpersonate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["userID"]; ok && len(val) > 0 {
+				r.UserID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/system/rest/request/automation.go

@@ -0,0 +1,360 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	AutomationList struct {
+		// ResourceTypePrefixes GET parameter
+		//
+		// Filter by resource prefix
+		ResourceTypePrefixes []string
+
+		// ResourceTypes GET parameter
+		//
+		// Filter by resource type
+		ResourceTypes []string
+
+		// EventTypes GET parameter
+		//
+		// Filter by event type
+		EventTypes []string
+
+		// ExcludeInvalid GET parameter
+		//
+		// Exclude scripts that cannot be used (errors)
+		ExcludeInvalid bool
+
+		// ExcludeClientScripts GET parameter
+		//
+		// Do not include client scripts
+		ExcludeClientScripts bool
+
+		// ExcludeServerScripts GET parameter
+		//
+		// Do not include server scripts
+		ExcludeServerScripts bool
+	}
+
+	AutomationBundle struct {
+		// Bundle PATH parameter
+		//
+		// Name of the bundle
+		Bundle string
+
+		// Type PATH parameter
+		//
+		// Bundle type
+		Type string
+
+		// Ext PATH parameter
+		//
+		// Bundle extension
+		Ext string
+	}
+
+	AutomationTriggerScript struct {
+		// Script POST parameter
+		//
+		// Script to execute
+		Script string
+
+		// Args POST parameter
+		//
+		// Arguments to pass to the script
+		Args map[string]interface{}
+	}
+)
+
+// NewAutomationList request
+func NewAutomationList() *AutomationList {
+	return &AutomationList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resourceTypePrefixes": r.ResourceTypePrefixes,
+		"resourceTypes":        r.ResourceTypes,
+		"eventTypes":           r.EventTypes,
+		"excludeInvalid":       r.ExcludeInvalid,
+		"excludeClientScripts": r.ExcludeClientScripts,
+		"excludeServerScripts": r.ExcludeServerScripts,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetResourceTypePrefixes() []string {
+	return r.ResourceTypePrefixes
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetResourceTypes() []string {
+	return r.ResourceTypes
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetEventTypes() []string {
+	return r.EventTypes
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetExcludeInvalid() bool {
+	return r.ExcludeInvalid
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetExcludeClientScripts() bool {
+	return r.ExcludeClientScripts
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationList) GetExcludeServerScripts() bool {
+	return r.ExcludeServerScripts
+}
+
+// Fill processes request and fills internal variables
+func (r *AutomationList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resourceTypePrefixes[]"]; ok {
+			r.ResourceTypePrefixes, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resourceTypePrefixes"]; ok {
+			r.ResourceTypePrefixes, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resourceTypes[]"]; ok {
+			r.ResourceTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resourceTypes"]; ok {
+			r.ResourceTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["eventTypes[]"]; ok {
+			r.EventTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["eventTypes"]; ok {
+			r.EventTypes, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["excludeInvalid"]; ok && len(val) > 0 {
+			r.ExcludeInvalid, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["excludeClientScripts"]; ok && len(val) > 0 {
+			r.ExcludeClientScripts, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["excludeServerScripts"]; ok && len(val) > 0 {
+			r.ExcludeServerScripts, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewAutomationBundle request
+func NewAutomationBundle() *AutomationBundle {
+	return &AutomationBundle{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"bundle": r.Bundle,
+		"type":   r.Type,
+		"ext":    r.Ext,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) GetBundle() string {
+	return r.Bundle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) GetType() string {
+	return r.Type
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationBundle) GetExt() string {
+	return r.Ext
+}
+
+// Fill processes request and fills internal variables
+func (r *AutomationBundle) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "bundle")
+		r.Bundle, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "type")
+		r.Type, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "ext")
+		r.Ext, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewAutomationTriggerScript request
+func NewAutomationTriggerScript() *AutomationTriggerScript {
+	return &AutomationTriggerScript{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationTriggerScript) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"script": r.Script,
+		"args":   r.Args,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationTriggerScript) GetScript() string {
+	return r.Script
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r AutomationTriggerScript) GetArgs() map[string]interface{} {
+	return r.Args
+}
+
+// Fill processes request and fills internal variables
+func (r *AutomationTriggerScript) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["script"]; ok && len(val) > 0 {
+				r.Script, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["args[]"]; ok {
+				r.Args, err = parseMapStringInterface(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["args"]; ok {
+				r.Args, err = parseMapStringInterface(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["script"]; ok && len(val) > 0 {
+			r.Script, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["args[]"]; ok {
+			r.Args, err = parseMapStringInterface(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["args"]; ok {
+			r.Args, err = parseMapStringInterface(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/system/rest/request/dalConnection.go

@@ -0,0 +1,660 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	DalConnectionList struct {
+		// ConnectionID GET parameter
+		//
+		// Filter by connection ID
+		ConnectionID []string
+
+		// Handle GET parameter
+		//
+		// Search handle to match against connections
+		Handle string
+
+		// Type GET parameter
+		//
+		// Search type to match against connections
+		Type string
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted connections
+		Deleted uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+	}
+
+	DalConnectionCreate struct {
+		// Handle POST parameter
+		//
+		//
+		Handle string
+
+		// Type POST parameter
+		//
+		//
+		Type string
+
+		// Meta POST parameter
+		//
+		//
+		Meta types.ConnectionMeta
+
+		// Config POST parameter
+		//
+		//
+		Config types.ConnectionConfig
+	}
+
+	DalConnectionUpdate struct {
+		// ConnectionID PATH parameter
+		//
+		// Connection ID
+		ConnectionID uint64 `json:",string"`
+
+		// Handle POST parameter
+		//
+		//
+		Handle string
+
+		// Type POST parameter
+		//
+		//
+		Type string
+
+		// Meta POST parameter
+		//
+		//
+		Meta types.ConnectionMeta
+
+		// Config POST parameter
+		//
+		//
+		Config types.ConnectionConfig
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	DalConnectionRead struct {
+		// ConnectionID PATH parameter
+		//
+		// Connection ID
+		ConnectionID uint64 `json:",string"`
+	}
+
+	DalConnectionDelete struct {
+		// ConnectionID PATH parameter
+		//
+		// Connection ID
+		ConnectionID uint64 `json:",string"`
+	}
+
+	DalConnectionUndelete struct {
+		// ConnectionID PATH parameter
+		//
+		// Connection ID
+		ConnectionID uint64 `json:",string"`
+	}
+)
+
+// NewDalConnectionList request
+func NewDalConnectionList() *DalConnectionList {
+	return &DalConnectionList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"connectionID": r.ConnectionID,
+		"handle":       r.Handle,
+		"type":         r.Type,
+		"deleted":      r.Deleted,
+		"incTotal":     r.IncTotal,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionList) GetConnectionID() []string {
+	return r.ConnectionID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionList) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionList) GetType() string {
+	return r.Type
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionList) GetDeleted() uint {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Fill processes request and fills internal variables
+func (r *DalConnectionList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["connectionID[]"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["connectionID"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["type"]; ok && len(val) > 0 {
+			r.Type, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDalConnectionCreate request
+func NewDalConnectionCreate() *DalConnectionCreate {
+	return &DalConnectionCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"handle": r.Handle,
+		"type":   r.Type,
+		"meta":   r.Meta,
+		"config": r.Config,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionCreate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionCreate) GetType() string {
+	return r.Type
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionCreate) GetMeta() types.ConnectionMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionCreate) GetConfig() types.ConnectionConfig {
+	return r.Config
+}
+
+// Fill processes request and fills internal variables
+func (r *DalConnectionCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["type"]; ok && len(val) > 0 {
+				r.Type, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseConnectionMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseConnectionMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["config[]"]; ok {
+				r.Config, err = types.ParseConnectionConfig(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["config"]; ok {
+				r.Config, err = types.ParseConnectionConfig(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["type"]; ok && len(val) > 0 {
+			r.Type, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseConnectionMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseConnectionMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["config[]"]; ok {
+			r.Config, err = types.ParseConnectionConfig(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["config"]; ok {
+			r.Config, err = types.ParseConnectionConfig(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDalConnectionUpdate request
+func NewDalConnectionUpdate() *DalConnectionUpdate {
+	return &DalConnectionUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"connectionID": r.ConnectionID,
+		"handle":       r.Handle,
+		"type":         r.Type,
+		"meta":         r.Meta,
+		"config":       r.Config,
+		"updatedAt":    r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUpdate) GetConnectionID() uint64 {
+	return r.ConnectionID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUpdate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUpdate) GetType() string {
+	return r.Type
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUpdate) GetMeta() types.ConnectionMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUpdate) GetConfig() types.ConnectionConfig {
+	return r.Config
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *DalConnectionUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["type"]; ok && len(val) > 0 {
+				r.Type, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseConnectionMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseConnectionMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["config[]"]; ok {
+				r.Config, err = types.ParseConnectionConfig(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["config"]; ok {
+				r.Config, err = types.ParseConnectionConfig(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["type"]; ok && len(val) > 0 {
+			r.Type, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseConnectionMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseConnectionMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["config[]"]; ok {
+			r.Config, err = types.ParseConnectionConfig(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["config"]; ok {
+			r.Config, err = types.ParseConnectionConfig(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "connectionID")
+		r.ConnectionID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDalConnectionRead request
+func NewDalConnectionRead() *DalConnectionRead {
+	return &DalConnectionRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"connectionID": r.ConnectionID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionRead) GetConnectionID() uint64 {
+	return r.ConnectionID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalConnectionRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "connectionID")
+		r.ConnectionID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDalConnectionDelete request
+func NewDalConnectionDelete() *DalConnectionDelete {
+	return &DalConnectionDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"connectionID": r.ConnectionID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionDelete) GetConnectionID() uint64 {
+	return r.ConnectionID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalConnectionDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "connectionID")
+		r.ConnectionID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDalConnectionUndelete request
+func NewDalConnectionUndelete() *DalConnectionUndelete {
+	return &DalConnectionUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"connectionID": r.ConnectionID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalConnectionUndelete) GetConnectionID() uint64 {
+	return r.ConnectionID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalConnectionUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "connectionID")
+		r.ConnectionID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/dalDriver.go

@@ -0,0 +1,54 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	DalDriverList struct {
+	}
+)
+
+// NewDalDriverList request
+func NewDalDriverList() *DalDriverList {
+	return &DalDriverList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalDriverList) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *DalDriverList) Fill(req *http.Request) (err error) {
+
+	return err
+}

server/system/rest/request/dalSchemaAlteration.go

@@ -0,0 +1,364 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	DalSchemaAlterationList struct {
+		// AlterationID GET parameter
+		//
+		// Filter by alteration ID
+		AlterationID []string
+
+		// BatchID GET parameter
+		//
+		// Filter by batch ID
+		BatchID []string
+
+		// Resource GET parameter
+		//
+		// Search by resource
+		Resource []string
+
+		// ResourceType GET parameter
+		//
+		// Search by resource type
+		ResourceType string
+
+		// Kind GET parameter
+		//
+		// Search by kind
+		Kind string
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted alterations
+		Deleted uint
+
+		// Completed GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) completed alterations
+		Completed uint
+
+		// Dismissed GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) dismissed alterations
+		Dismissed uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+	}
+
+	DalSchemaAlterationRead struct {
+		// AlterationID PATH parameter
+		//
+		// Alteration ID
+		AlterationID uint64 `json:",string"`
+	}
+
+	DalSchemaAlterationApply struct {
+		// AlterationID GET parameter
+		//
+		// Alteration ID
+		AlterationID []uint64
+	}
+
+	DalSchemaAlterationDismiss struct {
+		// AlterationID GET parameter
+		//
+		// Alteration ID
+		AlterationID []uint64
+	}
+)
+
+// NewDalSchemaAlterationList request
+func NewDalSchemaAlterationList() *DalSchemaAlterationList {
+	return &DalSchemaAlterationList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"alterationID": r.AlterationID,
+		"batchID":      r.BatchID,
+		"resource":     r.Resource,
+		"resourceType": r.ResourceType,
+		"kind":         r.Kind,
+		"deleted":      r.Deleted,
+		"completed":    r.Completed,
+		"dismissed":    r.Dismissed,
+		"incTotal":     r.IncTotal,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetAlterationID() []string {
+	return r.AlterationID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetBatchID() []string {
+	return r.BatchID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetResource() []string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetResourceType() string {
+	return r.ResourceType
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetDeleted() uint {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetCompleted() uint {
+	return r.Completed
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetDismissed() uint {
+	return r.Dismissed
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSchemaAlterationList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["alterationID[]"]; ok {
+			r.AlterationID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["alterationID"]; ok {
+			r.AlterationID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["batchID[]"]; ok {
+			r.BatchID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["batchID"]; ok {
+			r.BatchID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resource[]"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resource"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resourceType"]; ok && len(val) > 0 {
+			r.ResourceType, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["completed"]; ok && len(val) > 0 {
+			r.Completed, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["dismissed"]; ok && len(val) > 0 {
+			r.Dismissed, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDalSchemaAlterationRead request
+func NewDalSchemaAlterationRead() *DalSchemaAlterationRead {
+	return &DalSchemaAlterationRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"alterationID": r.AlterationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationRead) GetAlterationID() uint64 {
+	return r.AlterationID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSchemaAlterationRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "alterationID")
+		r.AlterationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDalSchemaAlterationApply request
+func NewDalSchemaAlterationApply() *DalSchemaAlterationApply {
+	return &DalSchemaAlterationApply{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationApply) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"alterationID": r.AlterationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationApply) GetAlterationID() []uint64 {
+	return r.AlterationID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSchemaAlterationApply) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["alterationID[]"]; ok {
+			r.AlterationID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["alterationID"]; ok {
+			r.AlterationID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDalSchemaAlterationDismiss request
+func NewDalSchemaAlterationDismiss() *DalSchemaAlterationDismiss {
+	return &DalSchemaAlterationDismiss{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationDismiss) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"alterationID": r.AlterationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSchemaAlterationDismiss) GetAlterationID() []uint64 {
+	return r.AlterationID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSchemaAlterationDismiss) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["alterationID[]"]; ok {
+			r.AlterationID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["alterationID"]; ok {
+			r.AlterationID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/system/rest/request/dalSensitivityLevel.go

@@ -0,0 +1,556 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	DalSensitivityLevelList struct {
+		// SensitivityLevelID GET parameter
+		//
+		// Filter by sensitivity level ID
+		SensitivityLevelID []string
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted sensitivity levels
+		Deleted uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+	}
+
+	DalSensitivityLevelCreate struct {
+		// Handle POST parameter
+		//
+		//
+		Handle string
+
+		// Level POST parameter
+		//
+		//
+		Level int
+
+		// Meta POST parameter
+		//
+		//
+		Meta types.DalSensitivityLevelMeta
+	}
+
+	DalSensitivityLevelUpdate struct {
+		// SensitivityLevelID PATH parameter
+		//
+		// Connection ID
+		SensitivityLevelID uint64 `json:",string"`
+
+		// Handle POST parameter
+		//
+		//
+		Handle string
+
+		// Level POST parameter
+		//
+		//
+		Level int
+
+		// Meta POST parameter
+		//
+		//
+		Meta types.DalSensitivityLevelMeta
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	DalSensitivityLevelRead struct {
+		// SensitivityLevelID PATH parameter
+		//
+		// Connection ID
+		SensitivityLevelID uint64 `json:",string"`
+	}
+
+	DalSensitivityLevelDelete struct {
+		// SensitivityLevelID PATH parameter
+		//
+		// Connection ID
+		SensitivityLevelID uint64 `json:",string"`
+	}
+
+	DalSensitivityLevelUndelete struct {
+		// SensitivityLevelID PATH parameter
+		//
+		// Connection ID
+		SensitivityLevelID uint64 `json:",string"`
+	}
+)
+
+// NewDalSensitivityLevelList request
+func NewDalSensitivityLevelList() *DalSensitivityLevelList {
+	return &DalSensitivityLevelList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"sensitivityLevelID": r.SensitivityLevelID,
+		"deleted":            r.Deleted,
+		"incTotal":           r.IncTotal,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelList) GetSensitivityLevelID() []string {
+	return r.SensitivityLevelID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelList) GetDeleted() uint {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSensitivityLevelList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["sensitivityLevelID[]"]; ok {
+			r.SensitivityLevelID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["sensitivityLevelID"]; ok {
+			r.SensitivityLevelID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDalSensitivityLevelCreate request
+func NewDalSensitivityLevelCreate() *DalSensitivityLevelCreate {
+	return &DalSensitivityLevelCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"handle": r.Handle,
+		"level":  r.Level,
+		"meta":   r.Meta,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelCreate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelCreate) GetLevel() int {
+	return r.Level
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelCreate) GetMeta() types.DalSensitivityLevelMeta {
+	return r.Meta
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSensitivityLevelCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["level"]; ok && len(val) > 0 {
+				r.Level, err = payload.ParseInt(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["level"]; ok && len(val) > 0 {
+			r.Level, err = payload.ParseInt(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDalSensitivityLevelUpdate request
+func NewDalSensitivityLevelUpdate() *DalSensitivityLevelUpdate {
+	return &DalSensitivityLevelUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"sensitivityLevelID": r.SensitivityLevelID,
+		"handle":             r.Handle,
+		"level":              r.Level,
+		"meta":               r.Meta,
+		"updatedAt":          r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUpdate) GetSensitivityLevelID() uint64 {
+	return r.SensitivityLevelID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUpdate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUpdate) GetLevel() int {
+	return r.Level
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUpdate) GetMeta() types.DalSensitivityLevelMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSensitivityLevelUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["level"]; ok && len(val) > 0 {
+				r.Level, err = payload.ParseInt(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["level"]; ok && len(val) > 0 {
+			r.Level, err = payload.ParseInt(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseDalSensitivityLevelMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "sensitivityLevelID")
+		r.SensitivityLevelID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDalSensitivityLevelRead request
+func NewDalSensitivityLevelRead() *DalSensitivityLevelRead {
+	return &DalSensitivityLevelRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"sensitivityLevelID": r.SensitivityLevelID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelRead) GetSensitivityLevelID() uint64 {
+	return r.SensitivityLevelID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSensitivityLevelRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "sensitivityLevelID")
+		r.SensitivityLevelID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDalSensitivityLevelDelete request
+func NewDalSensitivityLevelDelete() *DalSensitivityLevelDelete {
+	return &DalSensitivityLevelDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"sensitivityLevelID": r.SensitivityLevelID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelDelete) GetSensitivityLevelID() uint64 {
+	return r.SensitivityLevelID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSensitivityLevelDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "sensitivityLevelID")
+		r.SensitivityLevelID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDalSensitivityLevelUndelete request
+func NewDalSensitivityLevelUndelete() *DalSensitivityLevelUndelete {
+	return &DalSensitivityLevelUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"sensitivityLevelID": r.SensitivityLevelID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DalSensitivityLevelUndelete) GetSensitivityLevelID() uint64 {
+	return r.SensitivityLevelID
+}
+
+// Fill processes request and fills internal variables
+func (r *DalSensitivityLevelUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "sensitivityLevelID")
+		r.SensitivityLevelID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/dataPrivacy.go

@@ -0,0 +1,696 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	DataPrivacyConnectionList struct {
+		// ConnectionID GET parameter
+		//
+		// Filter by connection ID
+		ConnectionID []string
+
+		// Handle GET parameter
+		//
+		// Search handle to match against connections
+		Handle string
+
+		// Type GET parameter
+		//
+		// Search type to match against connections
+		Type string
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted connections
+		Deleted filter.State
+	}
+
+	DataPrivacyRequestList struct {
+		// RequestedBy GET parameter
+		//
+		// Filter by user ID
+		RequestedBy []string
+
+		// Query GET parameter
+		//
+		// Filter requests
+		Query string
+
+		// Kind GET parameter
+		//
+		// Filter by kind: correct, delete, export
+		Kind []string
+
+		// Status GET parameter
+		//
+		// Filter by status: pending, cancel, approve, reject
+		Status []string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	DataPrivacyRequestCreate struct {
+		// Kind POST parameter
+		//
+		// Request Kind
+		Kind string
+
+		// Payload POST parameter
+		//
+		// Request
+		Payload types.DataPrivacyRequestPayloadSet
+	}
+
+	DataPrivacyRequestRead struct {
+		// RequestID PATH parameter
+		//
+		// Request ID
+		RequestID uint64 `json:",string"`
+	}
+
+	DataPrivacyRequestUpdateStatus struct {
+		// RequestID PATH parameter
+		//
+		// ID
+		RequestID uint64 `json:",string"`
+
+		// Status PATH parameter
+		//
+		// Request Status
+		Status string
+	}
+
+	DataPrivacyRequestCommentList struct {
+		// RequestID PATH parameter
+		//
+		// Request ID
+		RequestID uint64 `json:",string"`
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	DataPrivacyRequestCommentCreate struct {
+		// RequestID PATH parameter
+		//
+		// Request ID
+		RequestID uint64 `json:",string"`
+
+		// Comment POST parameter
+		//
+		// Comment description
+		Comment string
+	}
+)
+
+// NewDataPrivacyConnectionList request
+func NewDataPrivacyConnectionList() *DataPrivacyConnectionList {
+	return &DataPrivacyConnectionList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyConnectionList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"connectionID": r.ConnectionID,
+		"handle":       r.Handle,
+		"type":         r.Type,
+		"deleted":      r.Deleted,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyConnectionList) GetConnectionID() []string {
+	return r.ConnectionID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyConnectionList) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyConnectionList) GetType() string {
+	return r.Type
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyConnectionList) GetDeleted() filter.State {
+	return r.Deleted
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyConnectionList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["connectionID[]"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["connectionID"]; ok {
+			r.ConnectionID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["type"]; ok && len(val) > 0 {
+			r.Type, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseFilterState(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDataPrivacyRequestList request
+func NewDataPrivacyRequestList() *DataPrivacyRequestList {
+	return &DataPrivacyRequestList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"requestedBy": r.RequestedBy,
+		"query":       r.Query,
+		"kind":        r.Kind,
+		"status":      r.Status,
+		"limit":       r.Limit,
+		"pageCursor":  r.PageCursor,
+		"sort":        r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) GetRequestedBy() []string {
+	return r.RequestedBy
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) GetKind() []string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) GetStatus() []string {
+	return r.Status
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyRequestList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["requestedBy[]"]; ok {
+			r.RequestedBy, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["requestedBy"]; ok {
+			r.RequestedBy, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["kind[]"]; ok {
+			r.Kind, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["kind"]; ok {
+			r.Kind, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["status[]"]; ok {
+			r.Status, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["status"]; ok {
+			r.Status, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDataPrivacyRequestCreate request
+func NewDataPrivacyRequestCreate() *DataPrivacyRequestCreate {
+	return &DataPrivacyRequestCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":    r.Kind,
+		"payload": r.Payload,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCreate) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCreate) GetPayload() types.DataPrivacyRequestPayloadSet {
+	return r.Payload
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyRequestCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["kind"]; ok && len(val) > 0 {
+				r.Kind, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["payload[]"]; ok {
+				r.Payload, err = types.ParseDataPrivacyRequestPayload(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["payload"]; ok {
+				r.Payload, err = types.ParseDataPrivacyRequestPayload(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["payload[]"]; ok {
+			r.Payload, err = types.ParseDataPrivacyRequestPayload(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["payload"]; ok {
+			r.Payload, err = types.ParseDataPrivacyRequestPayload(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewDataPrivacyRequestRead request
+func NewDataPrivacyRequestRead() *DataPrivacyRequestRead {
+	return &DataPrivacyRequestRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"requestID": r.RequestID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestRead) GetRequestID() uint64 {
+	return r.RequestID
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyRequestRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "requestID")
+		r.RequestID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDataPrivacyRequestUpdateStatus request
+func NewDataPrivacyRequestUpdateStatus() *DataPrivacyRequestUpdateStatus {
+	return &DataPrivacyRequestUpdateStatus{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestUpdateStatus) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"requestID": r.RequestID,
+		"status":    r.Status,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestUpdateStatus) GetRequestID() uint64 {
+	return r.RequestID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestUpdateStatus) GetStatus() string {
+	return r.Status
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyRequestUpdateStatus) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "requestID")
+		r.RequestID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "status")
+		r.Status, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDataPrivacyRequestCommentList request
+func NewDataPrivacyRequestCommentList() *DataPrivacyRequestCommentList {
+	return &DataPrivacyRequestCommentList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"requestID":  r.RequestID,
+		"limit":      r.Limit,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentList) GetRequestID() uint64 {
+	return r.RequestID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyRequestCommentList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "requestID")
+		r.RequestID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewDataPrivacyRequestCommentCreate request
+func NewDataPrivacyRequestCommentCreate() *DataPrivacyRequestCommentCreate {
+	return &DataPrivacyRequestCommentCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"requestID": r.RequestID,
+		"comment":   r.Comment,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentCreate) GetRequestID() uint64 {
+	return r.RequestID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r DataPrivacyRequestCommentCreate) GetComment() string {
+	return r.Comment
+}
+
+// Fill processes request and fills internal variables
+func (r *DataPrivacyRequestCommentCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["comment"]; ok && len(val) > 0 {
+				r.Comment, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["comment"]; ok && len(val) > 0 {
+			r.Comment, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "requestID")
+		r.RequestID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/expression.go

@@ -0,0 +1,154 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/label"
+	labelTypes "github.com/cortezaproject/corteza/server/pkg/label/types"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ExpressionEvaluate struct {
+		// Variables POST parameter
+		//
+		// variables
+		Variables map[string]interface{}
+
+		// Expressions POST parameter
+		//
+		// expressions
+		Expressions map[string]labelTypes.LabelValue
+	}
+)
+
+// NewExpressionEvaluate request
+func NewExpressionEvaluate() *ExpressionEvaluate {
+	return &ExpressionEvaluate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ExpressionEvaluate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"variables":   r.Variables,
+		"expressions": r.Expressions,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ExpressionEvaluate) GetVariables() map[string]interface{} {
+	return r.Variables
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ExpressionEvaluate) GetExpressions() map[string]labelTypes.LabelValue {
+	return r.Expressions
+}
+
+// Fill processes request and fills internal variables
+func (r *ExpressionEvaluate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["variables[]"]; ok {
+				r.Variables, err = parseMapStringInterface(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["variables"]; ok {
+				r.Variables, err = parseMapStringInterface(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["expressions[]"]; ok {
+				r.Expressions, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["expressions"]; ok {
+				r.Expressions, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["variables[]"]; ok {
+			r.Variables, err = parseMapStringInterface(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["variables"]; ok {
+			r.Variables, err = parseMapStringInterface(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["expressions[]"]; ok {
+			r.Expressions, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["expressions"]; ok {
+			r.Expressions, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/system/rest/request/label.go

@@ -0,0 +1,133 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	LabelList struct {
+		// Kind GET parameter
+		//
+		// Filter by resource kind (namespace, module, etc)
+		Kind string
+
+		// Name GET parameter
+		//
+		// Filter by label key/name
+		Name string
+
+		// Value GET parameter
+		//
+		// Filter by value
+		Value []string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+	}
+)
+
+// NewLabelList request
+func NewLabelList() *LabelList {
+	return &LabelList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LabelList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":  r.Kind,
+		"name":  r.Name,
+		"value": r.Value,
+		"limit": r.Limit,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LabelList) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LabelList) GetName() string {
+	return r.Name
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LabelList) GetValue() []string {
+	return r.Value
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LabelList) GetLimit() uint {
+	return r.Limit
+}
+
+// Fill processes request and fills internal variables
+func (r *LabelList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["name"]; ok && len(val) > 0 {
+			r.Name, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["value[]"]; ok {
+			r.Value, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["value"]; ok {
+			r.Value, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/system/rest/request/locale.go

@@ -0,0 +1,843 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	LocaleListResource struct {
+		// Lang GET parameter
+		//
+		// Language
+		Lang string
+
+		// Resource GET parameter
+		//
+		// Resource
+		Resource string
+
+		// ResourceType GET parameter
+		//
+		// Resource type
+		ResourceType string
+
+		// OwnerID GET parameter
+		//
+		// OwnerID
+		OwnerID uint64 `json:",string"`
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted resource translations
+		Deleted uint64 `json:",string"`
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	LocaleCreateResource struct {
+		// Lang POST parameter
+		//
+		// Lang
+		Lang string
+
+		// Resource POST parameter
+		//
+		// Resource
+		Resource string
+
+		// Key POST parameter
+		//
+		// Key
+		Key string
+
+		// Place POST parameter
+		//
+		// place
+		Place int
+
+		// Message POST parameter
+		//
+		// Message
+		Message string
+
+		// OwnerID POST parameter
+		//
+		// OwnerID
+		OwnerID uint64 `json:",string"`
+	}
+
+	LocaleUpdateResource struct {
+		// TranslationID PATH parameter
+		//
+		// ID
+		TranslationID uint64 `json:",string"`
+
+		// Lang POST parameter
+		//
+		// Lang
+		Lang string
+
+		// Resource POST parameter
+		//
+		// Resource
+		Resource string
+
+		// Key POST parameter
+		//
+		// Key
+		Key string
+
+		// Place POST parameter
+		//
+		// place
+		Place int
+
+		// Message POST parameter
+		//
+		// Message
+		Message string
+
+		// OwnerID POST parameter
+		//
+		// OwnerID
+		OwnerID uint64 `json:",string"`
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	LocaleReadResource struct {
+		// TranslationID PATH parameter
+		//
+		// ID
+		TranslationID uint64 `json:",string"`
+	}
+
+	LocaleDeleteResource struct {
+		// TranslationID PATH parameter
+		//
+		// ID
+		TranslationID uint64 `json:",string"`
+	}
+
+	LocaleUndeleteResource struct {
+		// TranslationID PATH parameter
+		//
+		// ID
+		TranslationID uint64 `json:",string"`
+	}
+
+	LocaleList struct {
+	}
+
+	LocaleGet struct {
+		// Lang PATH parameter
+		//
+		// Language
+		Lang string
+
+		// Application PATH parameter
+		//
+		// Application name
+		Application string
+	}
+)
+
+// NewLocaleListResource request
+func NewLocaleListResource() *LocaleListResource {
+	return &LocaleListResource{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"lang":         r.Lang,
+		"resource":     r.Resource,
+		"resourceType": r.ResourceType,
+		"ownerID":      r.OwnerID,
+		"deleted":      r.Deleted,
+		"limit":        r.Limit,
+		"pageCursor":   r.PageCursor,
+		"sort":         r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetLang() string {
+	return r.Lang
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetResource() string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetResourceType() string {
+	return r.ResourceType
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetOwnerID() uint64 {
+	return r.OwnerID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetDeleted() uint64 {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleListResource) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleListResource) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["lang"]; ok && len(val) > 0 {
+			r.Lang, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resourceType"]; ok && len(val) > 0 {
+			r.ResourceType, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["ownerID"]; ok && len(val) > 0 {
+			r.OwnerID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewLocaleCreateResource request
+func NewLocaleCreateResource() *LocaleCreateResource {
+	return &LocaleCreateResource{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleCreateResource) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"lang":     r.Lang,
+		"resource": r.Resource,
+		"key":      r.Key,
+		"place":    r.Place,
+		"message":  r.Message,
+		"ownerID":  r.OwnerID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleCreateResource) GetLang() string {
+	return r.Lang
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleCreateResource) GetResource() string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleCreateResource) GetKey() string {
+	return r.Key
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleCreateResource) GetPlace() int {
+	return r.Place
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleCreateResource) GetMessage() string {
+	return r.Message
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleCreateResource) GetOwnerID() uint64 {
+	return r.OwnerID
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleCreateResource) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["lang"]; ok && len(val) > 0 {
+				r.Lang, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["resource"]; ok && len(val) > 0 {
+				r.Resource, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["key"]; ok && len(val) > 0 {
+				r.Key, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["place"]; ok && len(val) > 0 {
+				r.Place, err = payload.ParseInt(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["message"]; ok && len(val) > 0 {
+				r.Message, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["ownerID"]; ok && len(val) > 0 {
+				r.OwnerID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["lang"]; ok && len(val) > 0 {
+			r.Lang, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["key"]; ok && len(val) > 0 {
+			r.Key, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["place"]; ok && len(val) > 0 {
+			r.Place, err = payload.ParseInt(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["message"]; ok && len(val) > 0 {
+			r.Message, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["ownerID"]; ok && len(val) > 0 {
+			r.OwnerID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewLocaleUpdateResource request
+func NewLocaleUpdateResource() *LocaleUpdateResource {
+	return &LocaleUpdateResource{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"translationID": r.TranslationID,
+		"lang":          r.Lang,
+		"resource":      r.Resource,
+		"key":           r.Key,
+		"place":         r.Place,
+		"message":       r.Message,
+		"ownerID":       r.OwnerID,
+		"updatedAt":     r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetTranslationID() uint64 {
+	return r.TranslationID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetLang() string {
+	return r.Lang
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetResource() string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetKey() string {
+	return r.Key
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetPlace() int {
+	return r.Place
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetMessage() string {
+	return r.Message
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetOwnerID() uint64 {
+	return r.OwnerID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUpdateResource) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleUpdateResource) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["lang"]; ok && len(val) > 0 {
+				r.Lang, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["resource"]; ok && len(val) > 0 {
+				r.Resource, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["key"]; ok && len(val) > 0 {
+				r.Key, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["place"]; ok && len(val) > 0 {
+				r.Place, err = payload.ParseInt(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["message"]; ok && len(val) > 0 {
+				r.Message, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["ownerID"]; ok && len(val) > 0 {
+				r.OwnerID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["lang"]; ok && len(val) > 0 {
+			r.Lang, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["key"]; ok && len(val) > 0 {
+			r.Key, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["place"]; ok && len(val) > 0 {
+			r.Place, err = payload.ParseInt(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["message"]; ok && len(val) > 0 {
+			r.Message, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["ownerID"]; ok && len(val) > 0 {
+			r.OwnerID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "translationID")
+		r.TranslationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewLocaleReadResource request
+func NewLocaleReadResource() *LocaleReadResource {
+	return &LocaleReadResource{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleReadResource) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"translationID": r.TranslationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleReadResource) GetTranslationID() uint64 {
+	return r.TranslationID
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleReadResource) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "translationID")
+		r.TranslationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewLocaleDeleteResource request
+func NewLocaleDeleteResource() *LocaleDeleteResource {
+	return &LocaleDeleteResource{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleDeleteResource) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"translationID": r.TranslationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleDeleteResource) GetTranslationID() uint64 {
+	return r.TranslationID
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleDeleteResource) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "translationID")
+		r.TranslationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewLocaleUndeleteResource request
+func NewLocaleUndeleteResource() *LocaleUndeleteResource {
+	return &LocaleUndeleteResource{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUndeleteResource) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"translationID": r.TranslationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleUndeleteResource) GetTranslationID() uint64 {
+	return r.TranslationID
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleUndeleteResource) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "translationID")
+		r.TranslationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewLocaleList request
+func NewLocaleList() *LocaleList {
+	return &LocaleList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleList) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleList) Fill(req *http.Request) (err error) {
+
+	return err
+}
+
+// NewLocaleGet request
+func NewLocaleGet() *LocaleGet {
+	return &LocaleGet{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleGet) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"lang":        r.Lang,
+		"application": r.Application,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleGet) GetLang() string {
+	return r.Lang
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r LocaleGet) GetApplication() string {
+	return r.Application
+}
+
+// Fill processes request and fills internal variables
+func (r *LocaleGet) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "lang")
+		r.Lang, err = val, nil
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "application")
+		r.Application, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/notification.go

@@ -0,0 +1,675 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	sqlxTypes "github.com/jmoiron/sqlx/types"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	NotificationList struct {
+		// NotificationID GET parameter
+		//
+		// Filter by notification ID
+		NotificationID []string
+
+		// Kind GET parameter
+		//
+		// Only notifications of a specific kind
+		Kind string
+
+		// Read GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) read notifications
+		Read uint
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted notifications
+		Deleted uint
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	NotificationCreate struct {
+		// Kind POST parameter
+		//
+		// Kind
+		Kind string
+
+		// Config POST parameter
+		//
+		// Configuration data for the notification
+		Config sqlxTypes.JSONText
+
+		// Recipient POST parameter
+		//
+		// Recipient
+		Recipient uint64 `json:",string"`
+	}
+
+	NotificationUpdate struct {
+		// NotificationID PATH parameter
+		//
+		// Notification ID
+		NotificationID uint64 `json:",string"`
+
+		// Kind POST parameter
+		//
+		// Kind
+		Kind string
+
+		// Config POST parameter
+		//
+		// Configuration data for the notification
+		Config sqlxTypes.JSONText
+
+		// Recipient POST parameter
+		//
+		// Recipient
+		Recipient uint64 `json:",string"`
+	}
+
+	NotificationRead struct {
+		// NotificationID PATH parameter
+		//
+		// Notification ID
+		NotificationID uint64 `json:",string"`
+	}
+
+	NotificationDelete struct {
+		// NotificationID PATH parameter
+		//
+		// Notification ID
+		NotificationID uint64 `json:",string"`
+	}
+
+	NotificationMarkAsRead struct {
+		// NotificationID PATH parameter
+		//
+		// Notification ID
+		NotificationID uint64 `json:",string"`
+	}
+
+	NotificationMarkAsUnread struct {
+		// NotificationID PATH parameter
+		//
+		// Notification ID
+		NotificationID uint64 `json:",string"`
+	}
+
+	NotificationMarkAllAsRead struct {
+	}
+
+	NotificationMarkAllAsUnread struct {
+	}
+)
+
+// NewNotificationList request
+func NewNotificationList() *NotificationList {
+	return &NotificationList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"notificationID": r.NotificationID,
+		"kind":           r.Kind,
+		"read":           r.Read,
+		"deleted":        r.Deleted,
+		"limit":          r.Limit,
+		"incTotal":       r.IncTotal,
+		"pageCursor":     r.PageCursor,
+		"sort":           r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetNotificationID() []string {
+	return r.NotificationID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetRead() uint {
+	return r.Read
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetDeleted() uint {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["notificationID[]"]; ok {
+			r.NotificationID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["notificationID"]; ok {
+			r.NotificationID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["read"]; ok && len(val) > 0 {
+			r.Read, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewNotificationCreate request
+func NewNotificationCreate() *NotificationCreate {
+	return &NotificationCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"kind":      r.Kind,
+		"config":    r.Config,
+		"recipient": r.Recipient,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationCreate) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationCreate) GetConfig() sqlxTypes.JSONText {
+	return r.Config
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationCreate) GetRecipient() uint64 {
+	return r.Recipient
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["kind"]; ok && len(val) > 0 {
+				r.Kind, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["config"]; ok && len(val) > 0 {
+				r.Config, err = payload.ParseJSONTextWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["recipient"]; ok && len(val) > 0 {
+				r.Recipient, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["config"]; ok && len(val) > 0 {
+			r.Config, err = payload.ParseJSONTextWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["recipient"]; ok && len(val) > 0 {
+			r.Recipient, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewNotificationUpdate request
+func NewNotificationUpdate() *NotificationUpdate {
+	return &NotificationUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"notificationID": r.NotificationID,
+		"kind":           r.Kind,
+		"config":         r.Config,
+		"recipient":      r.Recipient,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationUpdate) GetNotificationID() uint64 {
+	return r.NotificationID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationUpdate) GetKind() string {
+	return r.Kind
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationUpdate) GetConfig() sqlxTypes.JSONText {
+	return r.Config
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationUpdate) GetRecipient() uint64 {
+	return r.Recipient
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["kind"]; ok && len(val) > 0 {
+				r.Kind, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["config"]; ok && len(val) > 0 {
+				r.Config, err = payload.ParseJSONTextWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["recipient"]; ok && len(val) > 0 {
+				r.Recipient, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["kind"]; ok && len(val) > 0 {
+			r.Kind, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["config"]; ok && len(val) > 0 {
+			r.Config, err = payload.ParseJSONTextWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["recipient"]; ok && len(val) > 0 {
+			r.Recipient, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "notificationID")
+		r.NotificationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNotificationRead request
+func NewNotificationRead() *NotificationRead {
+	return &NotificationRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"notificationID": r.NotificationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationRead) GetNotificationID() uint64 {
+	return r.NotificationID
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "notificationID")
+		r.NotificationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNotificationDelete request
+func NewNotificationDelete() *NotificationDelete {
+	return &NotificationDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"notificationID": r.NotificationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationDelete) GetNotificationID() uint64 {
+	return r.NotificationID
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "notificationID")
+		r.NotificationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNotificationMarkAsRead request
+func NewNotificationMarkAsRead() *NotificationMarkAsRead {
+	return &NotificationMarkAsRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationMarkAsRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"notificationID": r.NotificationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationMarkAsRead) GetNotificationID() uint64 {
+	return r.NotificationID
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationMarkAsRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "notificationID")
+		r.NotificationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNotificationMarkAsUnread request
+func NewNotificationMarkAsUnread() *NotificationMarkAsUnread {
+	return &NotificationMarkAsUnread{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationMarkAsUnread) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"notificationID": r.NotificationID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationMarkAsUnread) GetNotificationID() uint64 {
+	return r.NotificationID
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationMarkAsUnread) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "notificationID")
+		r.NotificationID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewNotificationMarkAllAsRead request
+func NewNotificationMarkAllAsRead() *NotificationMarkAllAsRead {
+	return &NotificationMarkAllAsRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationMarkAllAsRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationMarkAllAsRead) Fill(req *http.Request) (err error) {
+
+	return err
+}
+
+// NewNotificationMarkAllAsUnread request
+func NewNotificationMarkAllAsUnread() *NotificationMarkAllAsUnread {
+	return &NotificationMarkAllAsUnread{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r NotificationMarkAllAsUnread) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *NotificationMarkAllAsUnread) Fill(req *http.Request) (err error) {
+
+	return err
+}

server/system/rest/request/permissions.go

@@ -0,0 +1,384 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	PermissionsList struct {
+	}
+
+	PermissionsEffective struct {
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource string
+	}
+
+	PermissionsTrace struct {
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource []string
+
+		// UserID GET parameter
+		//
+		//
+		UserID uint64 `json:",string"`
+
+		// RoleID GET parameter
+		//
+		//
+		RoleID []uint64
+	}
+
+	PermissionsRead struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+
+		// Resource GET parameter
+		//
+		// Show only rules for a specific resource
+		Resource []string
+	}
+
+	PermissionsDelete struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+	}
+
+	PermissionsUpdate struct {
+		// RoleID PATH parameter
+		//
+		// Role ID
+		RoleID uint64 `json:",string"`
+
+		// Rules POST parameter
+		//
+		// List of permission rules to set
+		Rules rbac.RuleSet
+	}
+)
+
+// NewPermissionsList request
+func NewPermissionsList() *PermissionsList {
+	return &PermissionsList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsList) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsList) Fill(req *http.Request) (err error) {
+
+	return err
+}
+
+// NewPermissionsEffective request
+func NewPermissionsEffective() *PermissionsEffective {
+	return &PermissionsEffective{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsEffective) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resource": r.Resource,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsEffective) GetResource() string {
+	return r.Resource
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsEffective) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewPermissionsTrace request
+func NewPermissionsTrace() *PermissionsTrace {
+	return &PermissionsTrace{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resource": r.Resource,
+		"userID":   r.UserID,
+		"roleID":   r.RoleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetResource() []string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsTrace) GetRoleID() []uint64 {
+	return r.RoleID
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsTrace) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource[]"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resource"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userID"]; ok && len(val) > 0 {
+			r.UserID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["roleID[]"]; ok {
+			r.RoleID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["roleID"]; ok {
+			r.RoleID, err = payload.ParseUint64s(val), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewPermissionsRead request
+func NewPermissionsRead() *PermissionsRead {
+	return &PermissionsRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID":   r.RoleID,
+		"resource": r.Resource,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsRead) GetResource() []string {
+	return r.Resource
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsRead) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["resource[]"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["resource"]; ok {
+			r.Resource, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewPermissionsDelete request
+func NewPermissionsDelete() *PermissionsDelete {
+	return &PermissionsDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID": r.RoleID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsDelete) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewPermissionsUpdate request
+func NewPermissionsUpdate() *PermissionsUpdate {
+	return &PermissionsUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"roleID": r.RoleID,
+		"rules":  r.Rules,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) GetRoleID() uint64 {
+	return r.RoleID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r PermissionsUpdate) GetRules() rbac.RuleSet {
+	return r.Rules
+}
+
+// Fill processes request and fills internal variables
+func (r *PermissionsUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["rules[]"]; ok && len(val) > 0  {
+		//    r.Rules, err = rbac.RuleSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "roleID")
+		r.RoleID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/queues.go

@@ -0,0 +1,602 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	QueuesList struct {
+		// Query GET parameter
+		//
+		// Search query
+		Query string
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+
+		// Deleted GET parameter
+		//
+		// Exclude (0
+		Deleted uint
+	}
+
+	QueuesCreate struct {
+		// Queue POST parameter
+		//
+		// Name of queue
+		Queue string
+
+		// Consumer POST parameter
+		//
+		// Queue consumer
+		Consumer string
+
+		// Meta POST parameter
+		//
+		// Meta data for queue
+		Meta types.QueueMeta
+	}
+
+	QueuesRead struct {
+		// QueueID PATH parameter
+		//
+		// Queue ID
+		QueueID uint64 `json:",string"`
+	}
+
+	QueuesUpdate struct {
+		// QueueID PATH parameter
+		//
+		// Queue ID
+		QueueID uint64 `json:",string"`
+
+		// Queue POST parameter
+		//
+		// Name of queue
+		Queue string
+
+		// Consumer POST parameter
+		//
+		// Queue consumer
+		Consumer string
+
+		// Meta POST parameter
+		//
+		// Meta data for queue
+		Meta types.QueueMeta
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	QueuesDelete struct {
+		// QueueID PATH parameter
+		//
+		// Queue ID
+		QueueID uint64 `json:",string"`
+	}
+
+	QueuesUndelete struct {
+		// QueueID PATH parameter
+		//
+		// Queue ID
+		QueueID uint64 `json:",string"`
+	}
+)
+
+// NewQueuesList request
+func NewQueuesList() *QueuesList {
+	return &QueuesList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"query":      r.Query,
+		"limit":      r.Limit,
+		"incTotal":   r.IncTotal,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+		"deleted":    r.Deleted,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesList) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesList) GetSort() string {
+	return r.Sort
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesList) GetDeleted() uint {
+	return r.Deleted
+}
+
+// Fill processes request and fills internal variables
+func (r *QueuesList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewQueuesCreate request
+func NewQueuesCreate() *QueuesCreate {
+	return &QueuesCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"queue":    r.Queue,
+		"consumer": r.Consumer,
+		"meta":     r.Meta,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesCreate) GetQueue() string {
+	return r.Queue
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesCreate) GetConsumer() string {
+	return r.Consumer
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesCreate) GetMeta() types.QueueMeta {
+	return r.Meta
+}
+
+// Fill processes request and fills internal variables
+func (r *QueuesCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["queue"]; ok && len(val) > 0 {
+				r.Queue, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["consumer"]; ok && len(val) > 0 {
+				r.Consumer, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseQueueMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseQueueMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["queue"]; ok && len(val) > 0 {
+			r.Queue, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["consumer"]; ok && len(val) > 0 {
+			r.Consumer, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseQueueMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseQueueMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewQueuesRead request
+func NewQueuesRead() *QueuesRead {
+	return &QueuesRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"queueID": r.QueueID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesRead) GetQueueID() uint64 {
+	return r.QueueID
+}
+
+// Fill processes request and fills internal variables
+func (r *QueuesRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "queueID")
+		r.QueueID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewQueuesUpdate request
+func NewQueuesUpdate() *QueuesUpdate {
+	return &QueuesUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"queueID":   r.QueueID,
+		"queue":     r.Queue,
+		"consumer":  r.Consumer,
+		"meta":      r.Meta,
+		"updatedAt": r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUpdate) GetQueueID() uint64 {
+	return r.QueueID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUpdate) GetQueue() string {
+	return r.Queue
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUpdate) GetConsumer() string {
+	return r.Consumer
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUpdate) GetMeta() types.QueueMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *QueuesUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["queue"]; ok && len(val) > 0 {
+				r.Queue, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["consumer"]; ok && len(val) > 0 {
+				r.Consumer, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseQueueMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseQueueMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["queue"]; ok && len(val) > 0 {
+			r.Queue, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["consumer"]; ok && len(val) > 0 {
+			r.Consumer, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseQueueMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseQueueMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "queueID")
+		r.QueueID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewQueuesDelete request
+func NewQueuesDelete() *QueuesDelete {
+	return &QueuesDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"queueID": r.QueueID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesDelete) GetQueueID() uint64 {
+	return r.QueueID
+}
+
+// Fill processes request and fills internal variables
+func (r *QueuesDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "queueID")
+		r.QueueID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewQueuesUndelete request
+func NewQueuesUndelete() *QueuesUndelete {
+	return &QueuesUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"queueID": r.QueueID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r QueuesUndelete) GetQueueID() uint64 {
+	return r.QueueID
+}
+
+// Fill processes request and fills internal variables
+func (r *QueuesUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "queueID")
+		r.QueueID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/reminder.go

@@ -0,0 +1,834 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	sqlxTypes "github.com/jmoiron/sqlx/types"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ReminderList struct {
+		// ReminderID GET parameter
+		//
+		// Filter by reminder ID
+		ReminderID []string
+
+		// Resource GET parameter
+		//
+		// Only reminders of a specific resource
+		Resource string
+
+		// AssignedTo GET parameter
+		//
+		// Only reminders for a given user
+		AssignedTo uint64 `json:",string"`
+
+		// ScheduledFrom GET parameter
+		//
+		// Only reminders from this time (included)
+		ScheduledFrom *time.Time
+
+		// ScheduledUntil GET parameter
+		//
+		// Only reminders up to this time (included)
+		ScheduledUntil *time.Time
+
+		// ScheduledOnly GET parameter
+		//
+		// Only scheduled reminders
+		ScheduledOnly bool
+
+		// ExcludeDismissed GET parameter
+		//
+		// Filter out dismissed reminders
+		ExcludeDismissed bool
+
+		// IncludeDeleted GET parameter
+		//
+		// Includes deleted reminders
+		IncludeDeleted bool
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	ReminderCreate struct {
+		// Resource POST parameter
+		//
+		// Resource
+		Resource string
+
+		// AssignedTo POST parameter
+		//
+		// Assigned To
+		AssignedTo uint64 `json:",string"`
+
+		// Payload POST parameter
+		//
+		// Payload
+		Payload sqlxTypes.JSONText
+
+		// RemindAt POST parameter
+		//
+		// Remind At
+		RemindAt *time.Time
+	}
+
+	ReminderUpdate struct {
+		// ReminderID PATH parameter
+		//
+		// Reminder ID
+		ReminderID uint64 `json:",string"`
+
+		// Resource POST parameter
+		//
+		// Resource
+		Resource string
+
+		// AssignedTo POST parameter
+		//
+		// Assigned To
+		AssignedTo uint64 `json:",string"`
+
+		// Payload POST parameter
+		//
+		// Payload
+		Payload sqlxTypes.JSONText
+
+		// RemindAt POST parameter
+		//
+		// Remind At
+		RemindAt *time.Time
+	}
+
+	ReminderRead struct {
+		// ReminderID PATH parameter
+		//
+		// Reminder ID
+		ReminderID uint64 `json:",string"`
+	}
+
+	ReminderDelete struct {
+		// ReminderID PATH parameter
+		//
+		// Reminder ID
+		ReminderID uint64 `json:",string"`
+	}
+
+	ReminderDismiss struct {
+		// ReminderID PATH parameter
+		//
+		// reminder ID
+		ReminderID uint64 `json:",string"`
+	}
+
+	ReminderUndismiss struct {
+		// ReminderID PATH parameter
+		//
+		// reminder ID
+		ReminderID uint64 `json:",string"`
+	}
+
+	ReminderSnooze struct {
+		// ReminderID PATH parameter
+		//
+		// reminder ID
+		ReminderID uint64 `json:",string"`
+
+		// RemindAt POST parameter
+		//
+		// New Remind At Time
+		RemindAt *time.Time
+	}
+)
+
+// NewReminderList request
+func NewReminderList() *ReminderList {
+	return &ReminderList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reminderID":       r.ReminderID,
+		"resource":         r.Resource,
+		"assignedTo":       r.AssignedTo,
+		"scheduledFrom":    r.ScheduledFrom,
+		"scheduledUntil":   r.ScheduledUntil,
+		"scheduledOnly":    r.ScheduledOnly,
+		"excludeDismissed": r.ExcludeDismissed,
+		"includeDeleted":   r.IncludeDeleted,
+		"limit":            r.Limit,
+		"pageCursor":       r.PageCursor,
+		"sort":             r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetReminderID() []string {
+	return r.ReminderID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetResource() string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetAssignedTo() uint64 {
+	return r.AssignedTo
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetScheduledFrom() *time.Time {
+	return r.ScheduledFrom
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetScheduledUntil() *time.Time {
+	return r.ScheduledUntil
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetScheduledOnly() bool {
+	return r.ScheduledOnly
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetExcludeDismissed() bool {
+	return r.ExcludeDismissed
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetIncludeDeleted() bool {
+	return r.IncludeDeleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["reminderID[]"]; ok {
+			r.ReminderID, err = val, nil
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["reminderID"]; ok {
+			r.ReminderID, err = val, nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["assignedTo"]; ok && len(val) > 0 {
+			r.AssignedTo, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["scheduledFrom"]; ok && len(val) > 0 {
+			r.ScheduledFrom, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["scheduledUntil"]; ok && len(val) > 0 {
+			r.ScheduledUntil, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["scheduledOnly"]; ok && len(val) > 0 {
+			r.ScheduledOnly, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["excludeDismissed"]; ok && len(val) > 0 {
+			r.ExcludeDismissed, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["includeDeleted"]; ok && len(val) > 0 {
+			r.IncludeDeleted, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewReminderCreate request
+func NewReminderCreate() *ReminderCreate {
+	return &ReminderCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"resource":   r.Resource,
+		"assignedTo": r.AssignedTo,
+		"payload":    r.Payload,
+		"remindAt":   r.RemindAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderCreate) GetResource() string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderCreate) GetAssignedTo() uint64 {
+	return r.AssignedTo
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderCreate) GetPayload() sqlxTypes.JSONText {
+	return r.Payload
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderCreate) GetRemindAt() *time.Time {
+	return r.RemindAt
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["resource"]; ok && len(val) > 0 {
+				r.Resource, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["assignedTo"]; ok && len(val) > 0 {
+				r.AssignedTo, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["payload"]; ok && len(val) > 0 {
+				r.Payload, err = payload.ParseJSONTextWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["remindAt"]; ok && len(val) > 0 {
+				r.RemindAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["assignedTo"]; ok && len(val) > 0 {
+			r.AssignedTo, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["payload"]; ok && len(val) > 0 {
+			r.Payload, err = payload.ParseJSONTextWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["remindAt"]; ok && len(val) > 0 {
+			r.RemindAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewReminderUpdate request
+func NewReminderUpdate() *ReminderUpdate {
+	return &ReminderUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reminderID": r.ReminderID,
+		"resource":   r.Resource,
+		"assignedTo": r.AssignedTo,
+		"payload":    r.Payload,
+		"remindAt":   r.RemindAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUpdate) GetReminderID() uint64 {
+	return r.ReminderID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUpdate) GetResource() string {
+	return r.Resource
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUpdate) GetAssignedTo() uint64 {
+	return r.AssignedTo
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUpdate) GetPayload() sqlxTypes.JSONText {
+	return r.Payload
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUpdate) GetRemindAt() *time.Time {
+	return r.RemindAt
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["resource"]; ok && len(val) > 0 {
+				r.Resource, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["assignedTo"]; ok && len(val) > 0 {
+				r.AssignedTo, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["payload"]; ok && len(val) > 0 {
+				r.Payload, err = payload.ParseJSONTextWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["remindAt"]; ok && len(val) > 0 {
+				r.RemindAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["resource"]; ok && len(val) > 0 {
+			r.Resource, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["assignedTo"]; ok && len(val) > 0 {
+			r.AssignedTo, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["payload"]; ok && len(val) > 0 {
+			r.Payload, err = payload.ParseJSONTextWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["remindAt"]; ok && len(val) > 0 {
+			r.RemindAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reminderID")
+		r.ReminderID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReminderRead request
+func NewReminderRead() *ReminderRead {
+	return &ReminderRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reminderID": r.ReminderID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderRead) GetReminderID() uint64 {
+	return r.ReminderID
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reminderID")
+		r.ReminderID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReminderDelete request
+func NewReminderDelete() *ReminderDelete {
+	return &ReminderDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reminderID": r.ReminderID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderDelete) GetReminderID() uint64 {
+	return r.ReminderID
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reminderID")
+		r.ReminderID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReminderDismiss request
+func NewReminderDismiss() *ReminderDismiss {
+	return &ReminderDismiss{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderDismiss) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reminderID": r.ReminderID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderDismiss) GetReminderID() uint64 {
+	return r.ReminderID
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderDismiss) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reminderID")
+		r.ReminderID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReminderUndismiss request
+func NewReminderUndismiss() *ReminderUndismiss {
+	return &ReminderUndismiss{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUndismiss) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reminderID": r.ReminderID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderUndismiss) GetReminderID() uint64 {
+	return r.ReminderID
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderUndismiss) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reminderID")
+		r.ReminderID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReminderSnooze request
+func NewReminderSnooze() *ReminderSnooze {
+	return &ReminderSnooze{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderSnooze) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reminderID": r.ReminderID,
+		"remindAt":   r.RemindAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderSnooze) GetReminderID() uint64 {
+	return r.ReminderID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReminderSnooze) GetRemindAt() *time.Time {
+	return r.RemindAt
+}
+
+// Fill processes request and fills internal variables
+func (r *ReminderSnooze) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["remindAt"]; ok && len(val) > 0 {
+				r.RemindAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["remindAt"]; ok && len(val) > 0 {
+			r.RemindAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reminderID")
+		r.ReminderID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/report.go

@@ -0,0 +1,963 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/label"
+	labelTypes "github.com/cortezaproject/corteza/server/pkg/label/types"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/reporting"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	ReportList struct {
+		// Handle GET parameter
+		//
+		// Report handle
+		Handle string
+
+		// Query GET parameter
+		//
+		// Report query
+		Query string
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted reports
+		Deleted uint
+
+		// Labels GET parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	ReportCreate struct {
+		// Handle POST parameter
+		//
+		// Client handle
+		Handle string
+
+		// Meta POST parameter
+		//
+		// Additional info
+		Meta *types.ReportMeta
+
+		// Scenarios POST parameter
+		//
+		// Report scenarios
+		Scenarios types.ReportScenarioSet
+
+		// Sources POST parameter
+		//
+		// Report source definitions
+		Sources types.ReportDataSourceSet
+
+		// Blocks POST parameter
+		//
+		// Report blocks definition
+		Blocks types.ReportBlockSet
+
+		// Labels POST parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+	}
+
+	ReportUpdate struct {
+		// ReportID PATH parameter
+		//
+		// Report ID
+		ReportID uint64 `json:",string"`
+
+		// Handle POST parameter
+		//
+		// Client handle
+		Handle string
+
+		// Meta POST parameter
+		//
+		// Additional info
+		Meta *types.ReportMeta
+
+		// Scenarios POST parameter
+		//
+		// Report scenarios
+		Scenarios types.ReportScenarioSet
+
+		// Sources POST parameter
+		//
+		// Report sources definition
+		Sources types.ReportDataSourceSet
+
+		// Blocks POST parameter
+		//
+		// Report blocks definition
+		Blocks types.ReportBlockSet
+
+		// Labels POST parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	ReportRead struct {
+		// ReportID PATH parameter
+		//
+		// Report ID
+		ReportID uint64 `json:",string"`
+	}
+
+	ReportDelete struct {
+		// ReportID PATH parameter
+		//
+		// Report ID
+		ReportID uint64 `json:",string"`
+	}
+
+	ReportUndelete struct {
+		// ReportID PATH parameter
+		//
+		// Report ID
+		ReportID uint64 `json:",string"`
+	}
+
+	ReportDescribe struct {
+		// Sources POST parameter
+		//
+		// Report steps definition
+		Sources types.ReportDataSourceSet
+
+		// Steps POST parameter
+		//
+		// Report steps definition
+		Steps types.ReportStepSet
+
+		// Describe POST parameter
+		//
+		// The source descriptions to generate
+		Describe []string
+	}
+
+	ReportRun struct {
+		// ReportID PATH parameter
+		//
+		// Report ID
+		ReportID uint64 `json:",string"`
+
+		// Frames POST parameter
+		//
+		// Report data frame definitions
+		Frames reporting.FrameDefinitionSet
+	}
+)
+
+// NewReportList request
+func NewReportList() *ReportList {
+	return &ReportList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"handle":     r.Handle,
+		"query":      r.Query,
+		"deleted":    r.Deleted,
+		"labels":     r.Labels,
+		"limit":      r.Limit,
+		"incTotal":   r.IncTotal,
+		"pageCursor": r.PageCursor,
+		"sort":       r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetDeleted() uint {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewReportCreate request
+func NewReportCreate() *ReportCreate {
+	return &ReportCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"handle":    r.Handle,
+		"meta":      r.Meta,
+		"scenarios": r.Scenarios,
+		"sources":   r.Sources,
+		"blocks":    r.Blocks,
+		"labels":    r.Labels,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportCreate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportCreate) GetMeta() *types.ReportMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportCreate) GetScenarios() types.ReportScenarioSet {
+	return r.Scenarios
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportCreate) GetSources() types.ReportDataSourceSet {
+	return r.Sources
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportCreate) GetBlocks() types.ReportBlockSet {
+	return r.Blocks
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportCreate) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseReportMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseReportMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["labels[]"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["labels"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseReportMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseReportMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["scenarios[]"]; ok && len(val) > 0  {
+		//    r.Scenarios, err = types.ReportScenarioSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		//if val, ok := req.Form["sources[]"]; ok && len(val) > 0  {
+		//    r.Sources, err = types.ReportDataSourceSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		//if val, ok := req.Form["blocks[]"]; ok && len(val) > 0  {
+		//    r.Blocks, err = types.ReportBlockSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		if val, ok := req.Form["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewReportUpdate request
+func NewReportUpdate() *ReportUpdate {
+	return &ReportUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reportID":  r.ReportID,
+		"handle":    r.Handle,
+		"meta":      r.Meta,
+		"scenarios": r.Scenarios,
+		"sources":   r.Sources,
+		"blocks":    r.Blocks,
+		"labels":    r.Labels,
+		"updatedAt": r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetReportID() uint64 {
+	return r.ReportID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetMeta() *types.ReportMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetScenarios() types.ReportScenarioSet {
+	return r.Scenarios
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetSources() types.ReportDataSourceSet {
+	return r.Sources
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetBlocks() types.ReportBlockSet {
+	return r.Blocks
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseReportMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseReportMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["labels[]"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["labels"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseReportMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseReportMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["scenarios[]"]; ok && len(val) > 0  {
+		//    r.Scenarios, err = types.ReportScenarioSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		//if val, ok := req.Form["sources[]"]; ok && len(val) > 0  {
+		//    r.Sources, err = types.ReportDataSourceSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		//if val, ok := req.Form["blocks[]"]; ok && len(val) > 0  {
+		//    r.Blocks, err = types.ReportBlockSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		if val, ok := req.Form["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reportID")
+		r.ReportID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReportRead request
+func NewReportRead() *ReportRead {
+	return &ReportRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reportID": r.ReportID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportRead) GetReportID() uint64 {
+	return r.ReportID
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reportID")
+		r.ReportID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReportDelete request
+func NewReportDelete() *ReportDelete {
+	return &ReportDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reportID": r.ReportID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportDelete) GetReportID() uint64 {
+	return r.ReportID
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reportID")
+		r.ReportID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReportUndelete request
+func NewReportUndelete() *ReportUndelete {
+	return &ReportUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reportID": r.ReportID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportUndelete) GetReportID() uint64 {
+	return r.ReportID
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reportID")
+		r.ReportID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewReportDescribe request
+func NewReportDescribe() *ReportDescribe {
+	return &ReportDescribe{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportDescribe) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"sources":  r.Sources,
+		"steps":    r.Steps,
+		"describe": r.Describe,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportDescribe) GetSources() types.ReportDataSourceSet {
+	return r.Sources
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportDescribe) GetSteps() types.ReportStepSet {
+	return r.Steps
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportDescribe) GetDescribe() []string {
+	return r.Describe
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportDescribe) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["sources[]"]; ok && len(val) > 0  {
+		//    r.Sources, err = types.ReportDataSourceSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		//if val, ok := req.Form["steps[]"]; ok && len(val) > 0  {
+		//    r.Steps, err = types.ReportStepSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		//if val, ok := req.Form["describe[]"]; ok && len(val) > 0  {
+		//    r.Describe, err = val, nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	return err
+}
+
+// NewReportRun request
+func NewReportRun() *ReportRun {
+	return &ReportRun{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportRun) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"reportID": r.ReportID,
+		"frames":   r.Frames,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportRun) GetReportID() uint64 {
+	return r.ReportID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r ReportRun) GetFrames() reporting.FrameDefinitionSet {
+	return r.Frames
+}
+
+// Fill processes request and fills internal variables
+func (r *ReportRun) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["frames[]"]; ok && len(val) > 0  {
+		//    r.Frames, err = reporting.FrameDefinitionSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "reportID")
+		r.ReportID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/settings.go

@@ -0,0 +1,340 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	SettingsList struct {
+		// Prefix GET parameter
+		//
+		// Key prefix
+		Prefix string
+	}
+
+	SettingsUpdate struct {
+		// Values POST parameter
+		//
+		// Array of new settings: `[{ name: ..., value: ... }]`. Omit value to remove setting
+		Values types.SettingValueSet
+	}
+
+	SettingsGet struct {
+		// Key PATH parameter
+		//
+		// Setting key
+		Key string
+
+		// OwnerID GET parameter
+		//
+		// Owner ID
+		OwnerID uint64 `json:",string"`
+	}
+
+	SettingsSet struct {
+		// Key PATH parameter
+		//
+		// Key
+		Key string
+
+		// Upload POST parameter
+		//
+		// File to upload
+		Upload *multipart.FileHeader
+
+		// OwnerID POST parameter
+		//
+		// Owner ID
+		OwnerID uint64 `json:",string"`
+	}
+
+	SettingsCurrent struct {
+	}
+)
+
+// NewSettingsList request
+func NewSettingsList() *SettingsList {
+	return &SettingsList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"prefix": r.Prefix,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsList) GetPrefix() string {
+	return r.Prefix
+}
+
+// Fill processes request and fills internal variables
+func (r *SettingsList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["prefix"]; ok && len(val) > 0 {
+			r.Prefix, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewSettingsUpdate request
+func NewSettingsUpdate() *SettingsUpdate {
+	return &SettingsUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"values": r.Values,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsUpdate) GetValues() types.SettingValueSet {
+	return r.Values
+}
+
+// Fill processes request and fills internal variables
+func (r *SettingsUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		//if val, ok := req.Form["values[]"]; ok && len(val) > 0  {
+		//    r.Values, err = types.SettingValueSet(val), nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+	}
+
+	return err
+}
+
+// NewSettingsGet request
+func NewSettingsGet() *SettingsGet {
+	return &SettingsGet{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsGet) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"key":     r.Key,
+		"ownerID": r.OwnerID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsGet) GetKey() string {
+	return r.Key
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsGet) GetOwnerID() uint64 {
+	return r.OwnerID
+}
+
+// Fill processes request and fills internal variables
+func (r *SettingsGet) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["ownerID"]; ok && len(val) > 0 {
+			r.OwnerID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "key")
+		r.Key, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewSettingsSet request
+func NewSettingsSet() *SettingsSet {
+	return &SettingsSet{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsSet) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"key":     r.Key,
+		"upload":  r.Upload,
+		"ownerID": r.OwnerID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsSet) GetKey() string {
+	return r.Key
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsSet) GetUpload() *multipart.FileHeader {
+	return r.Upload
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsSet) GetOwnerID() uint64 {
+	return r.OwnerID
+}
+
+// Fill processes request and fills internal variables
+func (r *SettingsSet) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			// Ignoring upload as its handled in the POST params section
+
+			if val, ok := req.MultipartForm.Value["ownerID"]; ok && len(val) > 0 {
+				r.OwnerID, err = payload.ParseUint64(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if _, r.Upload, err = req.FormFile("upload"); err != nil {
+			return fmt.Errorf("error processing uploaded file: %w", err)
+		}
+
+		if val, ok := req.Form["ownerID"]; ok && len(val) > 0 {
+			r.OwnerID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "key")
+		r.Key, err = val, nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewSettingsCurrent request
+func NewSettingsCurrent() *SettingsCurrent {
+	return &SettingsCurrent{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SettingsCurrent) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *SettingsCurrent) Fill(req *http.Request) (err error) {
+
+	return err
+}

server/system/rest/request/smtpConfigurationChecker.go

@@ -0,0 +1,250 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	SmtpConfigurationCheckerCheck struct {
+		// Host POST parameter
+		//
+		// SMTP server host name
+		Host string
+
+		// Port POST parameter
+		//
+		// SMTP server port
+		Port uint
+
+		// Recipients POST parameter
+		//
+		// List of recipients email addresses that should recieve test email
+		Recipients []string
+
+		// Username POST parameter
+		//
+		// SMTP server authentication username
+		Username string
+
+		// Password POST parameter
+		//
+		// SMTP server authentication password
+		Password string
+
+		// TlsInsecure POST parameter
+		//
+		// TLS mode
+		TlsInsecure bool
+
+		// TlsServerName POST parameter
+		//
+		// TLS server name
+		TlsServerName string
+	}
+)
+
+// NewSmtpConfigurationCheckerCheck request
+func NewSmtpConfigurationCheckerCheck() *SmtpConfigurationCheckerCheck {
+	return &SmtpConfigurationCheckerCheck{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"host":          r.Host,
+		"port":          r.Port,
+		"recipients":    r.Recipients,
+		"username":      r.Username,
+		"password":      r.Password,
+		"tlsInsecure":   r.TlsInsecure,
+		"tlsServerName": r.TlsServerName,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) GetHost() string {
+	return r.Host
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) GetPort() uint {
+	return r.Port
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) GetRecipients() []string {
+	return r.Recipients
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) GetUsername() string {
+	return r.Username
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) GetPassword() string {
+	return r.Password
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) GetTlsInsecure() bool {
+	return r.TlsInsecure
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r SmtpConfigurationCheckerCheck) GetTlsServerName() string {
+	return r.TlsServerName
+}
+
+// Fill processes request and fills internal variables
+func (r *SmtpConfigurationCheckerCheck) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["host"]; ok && len(val) > 0 {
+				r.Host, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["port"]; ok && len(val) > 0 {
+				r.Port, err = payload.ParseUint(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["username"]; ok && len(val) > 0 {
+				r.Username, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["password"]; ok && len(val) > 0 {
+				r.Password, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["tlsInsecure"]; ok && len(val) > 0 {
+				r.TlsInsecure, err = payload.ParseBool(val[0]), nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["tlsServerName"]; ok && len(val) > 0 {
+				r.TlsServerName, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["host"]; ok && len(val) > 0 {
+			r.Host, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["port"]; ok && len(val) > 0 {
+			r.Port, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["recipients[]"]; ok && len(val) > 0  {
+		//    r.Recipients, err = val, nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		if val, ok := req.Form["username"]; ok && len(val) > 0 {
+			r.Username, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["password"]; ok && len(val) > 0 {
+			r.Password, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["tlsInsecure"]; ok && len(val) > 0 {
+			r.TlsInsecure, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["tlsServerName"]; ok && len(val) > 0 {
+			r.TlsServerName, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}

server/system/rest/request/stats.go

@@ -0,0 +1,54 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	StatsList struct {
+	}
+)
+
+// NewStatsList request
+func NewStatsList() *StatsList {
+	return &StatsList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r StatsList) Auditable() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+// Fill processes request and fills internal variables
+func (r *StatsList) Fill(req *http.Request) (err error) {
+
+	return err
+}

server/system/rest/request/userGroup.go

@@ -0,0 +1,910 @@
+package request
+
+// This file is auto-generated.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+//
+// Definitions file that controls how this file is generated:
+//
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/cortezaproject/corteza/server/pkg/id"
+	"github.com/cortezaproject/corteza/server/pkg/label"
+	labelTypes "github.com/cortezaproject/corteza/server/pkg/label/types"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/go-chi/chi/v5"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// dummy vars to prevent
+// unused imports complain
+var (
+	_ = chi.URLParam
+	_ = multipart.ErrMessageTooLarge
+	_ = payload.ParseUint64s
+	_ = strings.ToLower
+	_ = io.EOF
+	_ = fmt.Errorf
+	_ = json.NewEncoder
+)
+
+type (
+	// Internal API interface
+	UserGroupList struct {
+		// Query GET parameter
+		//
+		// Search query
+		Query string
+
+		// MemberID GET parameter
+		//
+		// Search roles for member
+		MemberID uint64 `json:",string"`
+
+		// UserGroupID GET parameter
+		//
+		// Search roles by ID
+		UserGroupID []id.ID
+
+		// Deleted GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) deleted user groups
+		Deleted uint
+
+		// Archived GET parameter
+		//
+		// Exclude (0, default), include (1) or return only (2) archived user groups
+		Archived uint
+
+		// Labels GET parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+
+		// Limit GET parameter
+		//
+		// Limit
+		Limit uint
+
+		// IncTotal GET parameter
+		//
+		// Include total counter
+		IncTotal bool
+
+		// PageCursor GET parameter
+		//
+		// Page cursor
+		PageCursor string
+
+		// Sort GET parameter
+		//
+		// Sort items
+		Sort string
+	}
+
+	UserGroupCreate struct {
+		// Handle POST parameter
+		//
+		// Handle for user group
+		Handle string
+
+		// Members POST parameter
+		//
+		// user group member IDs
+		Members []string
+
+		// Config POST parameter
+		//
+		// Config
+		Config *types.UserGroupConfig
+
+		// Meta POST parameter
+		//
+		// Meta
+		Meta *types.UserGroupMeta
+
+		// Labels POST parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+	}
+
+	UserGroupUpdate struct {
+		// UserGroupID PATH parameter
+		//
+		// User Group ID
+		UserGroupID id.ID
+
+		// Handle POST parameter
+		//
+		// Handle for user group
+		Handle string
+
+		// Members POST parameter
+		//
+		// user group member IDs
+		Members []string
+
+		// Config POST parameter
+		//
+		// Config
+		Config *types.UserGroupConfig
+
+		// Meta POST parameter
+		//
+		// Meta
+		Meta *types.UserGroupMeta
+
+		// Labels POST parameter
+		//
+		// Labels
+		Labels map[string]labelTypes.LabelValue
+
+		// UpdatedAt POST parameter
+		//
+		// Last update (or creation) date
+		UpdatedAt *time.Time
+	}
+
+	UserGroupRead struct {
+		// UserGroupID PATH parameter
+		//
+		// User group ID
+		UserGroupID id.ID
+	}
+
+	UserGroupDelete struct {
+		// UserGroupID PATH parameter
+		//
+		// User Group ID
+		UserGroupID id.ID
+	}
+
+	UserGroupUndelete struct {
+		// UserGroupID PATH parameter
+		//
+		// User group ID
+		UserGroupID id.ID
+	}
+
+	UserGroupMemberList struct {
+		// UserGroupID PATH parameter
+		//
+		// Source User Group ID
+		UserGroupID id.ID
+	}
+
+	UserGroupMemberAdd struct {
+		// UserGroupID PATH parameter
+		//
+		// Source User Group ID
+		UserGroupID id.ID
+
+		// UserID PATH parameter
+		//
+		// User ID
+		UserID uint64 `json:",string"`
+	}
+)
+
+// NewUserGroupList request
+func NewUserGroupList() *UserGroupList {
+	return &UserGroupList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"query":       r.Query,
+		"memberID":    r.MemberID,
+		"userGroupID": r.UserGroupID,
+		"deleted":     r.Deleted,
+		"archived":    r.Archived,
+		"labels":      r.Labels,
+		"limit":       r.Limit,
+		"incTotal":    r.IncTotal,
+		"pageCursor":  r.PageCursor,
+		"sort":        r.Sort,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetQuery() string {
+	return r.Query
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetMemberID() uint64 {
+	return r.MemberID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetUserGroupID() []id.ID {
+	return r.UserGroupID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetDeleted() uint {
+	return r.Deleted
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetArchived() uint {
+	return r.Archived
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetLimit() uint {
+	return r.Limit
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetIncTotal() bool {
+	return r.IncTotal
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetPageCursor() string {
+	return r.PageCursor
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupList) GetSort() string {
+	return r.Sort
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupList) Fill(req *http.Request) (err error) {
+
+	{
+		// GET params
+		tmp := req.URL.Query()
+
+		if val, ok := tmp["query"]; ok && len(val) > 0 {
+			r.Query, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["memberID"]; ok && len(val) > 0 {
+			r.MemberID, err = payload.ParseUint64(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["userGroupID[]"]; ok {
+			r.UserGroupID, err = id.ParseIDs(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["userGroupID"]; ok {
+			r.UserGroupID, err = id.ParseIDs(val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["deleted"]; ok && len(val) > 0 {
+			r.Deleted, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["archived"]; ok && len(val) > 0 {
+			r.Archived, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := tmp["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["limit"]; ok && len(val) > 0 {
+			r.Limit, err = payload.ParseUint(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["incTotal"]; ok && len(val) > 0 {
+			r.IncTotal, err = payload.ParseBool(val[0]), nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["pageCursor"]; ok && len(val) > 0 {
+			r.PageCursor, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+		if val, ok := tmp["sort"]; ok && len(val) > 0 {
+			r.Sort, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewUserGroupCreate request
+func NewUserGroupCreate() *UserGroupCreate {
+	return &UserGroupCreate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupCreate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"handle":  r.Handle,
+		"members": r.Members,
+		"config":  r.Config,
+		"meta":    r.Meta,
+		"labels":  r.Labels,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupCreate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupCreate) GetMembers() []string {
+	return r.Members
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupCreate) GetConfig() *types.UserGroupConfig {
+	return r.Config
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupCreate) GetMeta() *types.UserGroupMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupCreate) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupCreate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["config[]"]; ok {
+				r.Config, err = types.ParseUserGroupConfig(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["config"]; ok {
+				r.Config, err = types.ParseUserGroupConfig(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseUserGroupMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseUserGroupMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["labels[]"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["labels"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["members[]"]; ok && len(val) > 0  {
+		//    r.Members, err = val, nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		if val, ok := req.Form["config[]"]; ok {
+			r.Config, err = types.ParseUserGroupConfig(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["config"]; ok {
+			r.Config, err = types.ParseUserGroupConfig(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseUserGroupMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseUserGroupMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	return err
+}
+
+// NewUserGroupUpdate request
+func NewUserGroupUpdate() *UserGroupUpdate {
+	return &UserGroupUpdate{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"userGroupID": r.UserGroupID,
+		"handle":      r.Handle,
+		"members":     r.Members,
+		"config":      r.Config,
+		"meta":        r.Meta,
+		"labels":      r.Labels,
+		"updatedAt":   r.UpdatedAt,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) GetUserGroupID() id.ID {
+	return r.UserGroupID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) GetHandle() string {
+	return r.Handle
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) GetMembers() []string {
+	return r.Members
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) GetConfig() *types.UserGroupConfig {
+	return r.Config
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) GetMeta() *types.UserGroupMeta {
+	return r.Meta
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) GetLabels() map[string]labelTypes.LabelValue {
+	return r.Labels
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUpdate) GetUpdatedAt() *time.Time {
+	return r.UpdatedAt
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupUpdate) Fill(req *http.Request) (err error) {
+
+	if strings.HasPrefix(strings.ToLower(req.Header.Get("content-type")), "application/json") {
+		err = json.NewDecoder(req.Body).Decode(r)
+
+		switch {
+		case err == io.EOF:
+			err = nil
+		case err != nil:
+			return fmt.Errorf("error parsing http request body: %w", err)
+		}
+	}
+
+	{
+		// Caching 32MB to memory, the rest to disk
+		if err = req.ParseMultipartForm(32 << 20); err != nil && err != http.ErrNotMultipart {
+			return err
+		} else if err == nil {
+			// Multipart params
+
+			if val, ok := req.MultipartForm.Value["handle"]; ok && len(val) > 0 {
+				r.Handle, err = val[0], nil
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["config[]"]; ok {
+				r.Config, err = types.ParseUserGroupConfig(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["config"]; ok {
+				r.Config, err = types.ParseUserGroupConfig(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["meta[]"]; ok {
+				r.Meta, err = types.ParseUserGroupMeta(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["meta"]; ok {
+				r.Meta, err = types.ParseUserGroupMeta(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["labels[]"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			} else if val, ok := req.MultipartForm.Value["labels"]; ok {
+				r.Labels, err = label.ParseStrings(val)
+				if err != nil {
+					return err
+				}
+			}
+
+			if val, ok := req.MultipartForm.Value["updatedAt"]; ok && len(val) > 0 {
+				r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+				if err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	{
+		if err = req.ParseForm(); err != nil {
+			return err
+		}
+
+		// POST params
+
+		if val, ok := req.Form["handle"]; ok && len(val) > 0 {
+			r.Handle, err = val[0], nil
+			if err != nil {
+				return err
+			}
+		}
+
+		//if val, ok := req.Form["members[]"]; ok && len(val) > 0  {
+		//    r.Members, err = val, nil
+		//    if err != nil {
+		//        return err
+		//    }
+		//}
+
+		if val, ok := req.Form["config[]"]; ok {
+			r.Config, err = types.ParseUserGroupConfig(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["config"]; ok {
+			r.Config, err = types.ParseUserGroupConfig(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["meta[]"]; ok {
+			r.Meta, err = types.ParseUserGroupMeta(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["meta"]; ok {
+			r.Meta, err = types.ParseUserGroupMeta(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["labels[]"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		} else if val, ok := req.Form["labels"]; ok {
+			r.Labels, err = label.ParseStrings(val)
+			if err != nil {
+				return err
+			}
+		}
+
+		if val, ok := req.Form["updatedAt"]; ok && len(val) > 0 {
+			r.UpdatedAt, err = payload.ParseISODatePtrWithErr(val[0])
+			if err != nil {
+				return err
+			}
+		}
+	}
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "userGroupID")
+		r.UserGroupID, err = id.ParseID(val)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewUserGroupRead request
+func NewUserGroupRead() *UserGroupRead {
+	return &UserGroupRead{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupRead) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"userGroupID": r.UserGroupID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupRead) GetUserGroupID() id.ID {
+	return r.UserGroupID
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupRead) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "userGroupID")
+		r.UserGroupID, err = id.ParseID(val)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewUserGroupDelete request
+func NewUserGroupDelete() *UserGroupDelete {
+	return &UserGroupDelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupDelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"userGroupID": r.UserGroupID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupDelete) GetUserGroupID() id.ID {
+	return r.UserGroupID
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupDelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "userGroupID")
+		r.UserGroupID, err = id.ParseID(val)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewUserGroupUndelete request
+func NewUserGroupUndelete() *UserGroupUndelete {
+	return &UserGroupUndelete{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUndelete) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"userGroupID": r.UserGroupID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupUndelete) GetUserGroupID() id.ID {
+	return r.UserGroupID
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupUndelete) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "userGroupID")
+		r.UserGroupID, err = id.ParseID(val)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewUserGroupMemberList request
+func NewUserGroupMemberList() *UserGroupMemberList {
+	return &UserGroupMemberList{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupMemberList) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"userGroupID": r.UserGroupID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupMemberList) GetUserGroupID() id.ID {
+	return r.UserGroupID
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupMemberList) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "userGroupID")
+		r.UserGroupID, err = id.ParseID(val)
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}
+
+// NewUserGroupMemberAdd request
+func NewUserGroupMemberAdd() *UserGroupMemberAdd {
+	return &UserGroupMemberAdd{}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupMemberAdd) Auditable() map[string]interface{} {
+	return map[string]interface{}{
+		"userGroupID": r.UserGroupID,
+		"userID":      r.UserID,
+	}
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupMemberAdd) GetUserGroupID() id.ID {
+	return r.UserGroupID
+}
+
+// Auditable returns all auditable/loggable parameters
+func (r UserGroupMemberAdd) GetUserID() uint64 {
+	return r.UserID
+}
+
+// Fill processes request and fills internal variables
+func (r *UserGroupMemberAdd) Fill(req *http.Request) (err error) {
+
+	{
+		var val string
+		// path params
+
+		val = chi.URLParam(req, "userGroupID")
+		r.UserGroupID, err = id.ParseID(val)
+		if err != nil {
+			return err
+		}
+
+		val = chi.URLParam(req, "userID")
+		r.UserID, err = payload.ParseUint64(val), nil
+		if err != nil {
+			return err
+		}
+
+	}
+
+	return err
+}

server/system/rest/request/util.go

@@ -0,0 +1,25 @@
+package request
+
+import (
+	"encoding/json"
+)
+
+func parseMapStringInterface(ss []string) (map[string]interface{}, error) {
+	if len(ss) == 0 {
+		return nil, nil
+	}
+
+	out := make(map[string]interface{})
+
+	return out, json.Unmarshal([]byte(ss[0]), out)
+}
+
+func parseMapStringString(ss []string) (map[string]string, error) {
+	if len(ss) == 0 {
+		return nil, nil
+	}
+
+	out := make(map[string]string, 8)
+
+	return out, json.Unmarshal([]byte(ss[0]), out)
+}

server/system/rest/role.go

@@ -0,0 +1,264 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/pkg/rbac"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/service/event"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Role struct {
+		role service.RoleService
+		ac   roleAccessController
+	}
+
+	roleAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanCreateRole(context.Context) bool
+		CanUpdateRole(context.Context, *types.Role) bool
+		CanDeleteRole(context.Context, *types.Role) bool
+		CanManageMembersOnRole(context.Context, *types.Role) bool
+	}
+
+	rolePayload struct {
+		*types.Role
+
+		IsSystem bool `json:"isSystem"`
+		IsBypass bool `json:"isBypass"`
+		IsClosed bool `json:"isClosed"`
+
+		CanGrant               bool `json:"canGrant"`
+		CanUpdateRole          bool `json:"canUpdateRole"`
+		CanDeleteRole          bool `json:"canDeleteRole"`
+		CanManageMembersOnRole bool `json:"canManageMembersOnRole"`
+	}
+
+	roleSetPayload struct {
+		Filter types.RoleFilter `json:"filter"`
+		Set    []*rolePayload   `json:"set"`
+	}
+)
+
+func (Role) New() *Role {
+	return &Role{
+		role: service.DefaultRole,
+		ac:   service.DefaultAccessControl,
+	}
+}
+
+func (ctrl Role) Read(ctx context.Context, r *request.RoleRead) (interface{}, error) {
+	role, err := ctrl.role.FindByID(ctx, r.RoleID)
+	return ctrl.makePayload(ctx, role, err)
+}
+
+func (ctrl Role) List(ctx context.Context, r *request.RoleList) (interface{}, error) {
+	var (
+		err error
+		f   = types.RoleFilter{
+			Query:  r.Query,
+			Labels: r.Labels,
+			RoleID: r.RoleID,
+
+			MemberID:    r.MemberID,
+			UserGroupID: r.UserGroupID,
+
+			Archived: filter.State(r.Archived),
+			Deleted:  filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.role.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl Role) Create(ctx context.Context, r *request.RoleCreate) (interface{}, error) {
+	var (
+		err  error
+		role = &types.Role{
+			Name:   r.Name,
+			Handle: r.Handle,
+			Labels: r.Labels,
+			Meta:   r.Meta,
+		}
+	)
+
+	role, err = ctrl.role.Create(ctx, role)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, userID := range payload.ParseUint64s(r.Members) {
+		err := ctrl.role.MemberAdd(ctx, role.ID, userID)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return ctrl.makePayload(ctx, role, err)
+}
+
+func (ctrl Role) Update(ctx context.Context, r *request.RoleUpdate) (interface{}, error) {
+	var (
+		err  error
+		role = &types.Role{
+			ID:        r.RoleID,
+			Name:      r.Name,
+			Handle:    r.Handle,
+			Labels:    r.Labels,
+			Meta:      r.Meta,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	role, err = ctrl.role.Update(ctx, role)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(r.Members) > 0 {
+		members, err := ctrl.role.MemberList(ctx, r.RoleID)
+		if err != nil {
+			return nil, err
+		}
+		for _, member := range members {
+			err := ctrl.role.MemberRemove(ctx, role.ID, rbac.ResourceID(member.Resource))
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		for _, userID := range payload.ParseUint64s(r.Members) {
+			err := ctrl.role.MemberAdd(ctx, role.ID, userID)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return ctrl.makePayload(ctx, role, err)
+}
+
+func (ctrl Role) Delete(ctx context.Context, r *request.RoleDelete) (interface{}, error) {
+	return api.OK(), ctrl.role.Delete(ctx, r.RoleID)
+}
+
+func (ctrl Role) Undelete(ctx context.Context, r *request.RoleUndelete) (interface{}, error) {
+	return api.OK(), ctrl.role.Undelete(ctx, r.RoleID)
+}
+
+func (ctrl Role) Archive(ctx context.Context, r *request.RoleArchive) (interface{}, error) {
+	return api.OK(), ctrl.role.Archive(ctx, r.RoleID)
+}
+
+func (ctrl Role) Unarchive(ctx context.Context, r *request.RoleUnarchive) (interface{}, error) {
+	return api.OK(), ctrl.role.Unarchive(ctx, r.RoleID)
+}
+
+func (ctrl Role) CloneRules(ctx context.Context, r *request.RoleCloneRules) (interface{}, error) {
+	// Clone rules from role S to role T
+	return api.OK(), ctrl.role.CloneRules(ctx, r.RoleID, payload.ParseUint64s(r.CloneToRoleID)...)
+}
+
+// deprecated
+func (ctrl Role) Merge(ctx context.Context, r *request.RoleMerge) (interface{}, error) {
+	return api.OK(), nil
+}
+
+// deprecated
+func (ctrl Role) Move(ctx context.Context, r *request.RoleMove) (interface{}, error) {
+	return api.OK(), nil
+}
+
+func (ctrl Role) MemberList(ctx context.Context, r *request.RoleMemberList) (interface{}, error) {
+	if mm, err := ctrl.role.MemberList(ctx, r.RoleID); err != nil {
+		return nil, err
+	} else {
+		rval := make([]string, len(mm))
+		for i := range mm {
+			rval[i] = payload.Uint64toa(rbac.ResourceID(mm[i].Resource))
+		}
+		return rval, nil
+	}
+}
+
+func (ctrl Role) MemberAdd(ctx context.Context, r *request.RoleMemberAdd) (interface{}, error) {
+	return api.OK(), ctrl.role.MemberAdd(ctx, r.RoleID, r.UserID)
+}
+
+func (ctrl Role) MemberAddGroup(ctx context.Context, r *request.RoleMemberAddGroup) (interface{}, error) {
+	return api.OK(), ctrl.role.MemberAddGroup(ctx, r.RoleID, r.UserGroupID)
+}
+
+func (ctrl Role) MemberRemove(ctx context.Context, r *request.RoleMemberRemove) (interface{}, error) {
+	return api.OK(), ctrl.role.MemberRemove(ctx, r.RoleID, r.UserID)
+}
+
+func (ctrl Role) MemberRemoveGroup(ctx context.Context, r *request.RoleMemberRemoveGroup) (interface{}, error) {
+	return api.OK(), ctrl.role.MemberRemoveGroup(ctx, r.RoleID, r.UserGroupID)
+}
+
+func (ctrl *Role) TriggerScript(ctx context.Context, r *request.RoleTriggerScript) (rsp interface{}, err error) {
+	var (
+		role *types.Role
+	)
+
+	if role, err = ctrl.role.FindByID(ctx, r.RoleID); err != nil {
+		return
+	}
+
+	// @todo implement same behaviour as we have on record - role+oldRole
+	err = corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.RoleOnManual(role, role), r.Args))
+	return role, err
+}
+
+func (ctrl Role) makePayload(ctx context.Context, r *types.Role, err error) (*rolePayload, error) {
+	if err != nil || r == nil {
+		return nil, err
+	}
+
+	return &rolePayload{
+		Role: r,
+
+		CanGrant:               ctrl.ac.CanGrant(ctx),
+		CanUpdateRole:          ctrl.ac.CanUpdateRole(ctx, r),
+		CanDeleteRole:          ctrl.ac.CanDeleteRole(ctx, r),
+		CanManageMembersOnRole: ctrl.ac.CanManageMembersOnRole(ctx, r),
+
+		IsSystem: ctrl.role.IsSystem(r),
+		IsClosed: ctrl.role.IsClosed(r),
+		IsBypass: auth.BypassRoles().FindByID(r.ID) != nil,
+	}, nil
+}
+
+func (ctrl Role) makeFilterPayload(ctx context.Context, nn types.RoleSet, f types.RoleFilter, err error) (*roleSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &roleSetPayload{Filter: f, Set: make([]*rolePayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}

server/system/rest/router.go

@@ -0,0 +1,59 @@
+package rest
+
+import (
+	"github.com/go-chi/chi/v5"
+
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"github.com/cortezaproject/corteza/server/system/rest/handlers"
+	"github.com/cortezaproject/corteza/server/system/service"
+)
+
+func MountRoutes() func(r chi.Router) {
+	return func(r chi.Router) {
+		r.Group(func(r chi.Router) {
+			handlers.NewLocale(Locale{}.New()).MountRoutes(r)
+
+			handlers.NewAttachment(Attachment{}.New()).MountRoutes(r)
+			handlers.NewAuth((Auth{}).New()).MountRoutes(r)
+
+			// A special case that, we do not add this through standard request, handlers & controllers
+			// combo but directly -- we need access to r.Body
+			r.Handle(service.SinkBaseURL+"*", &Sink{
+				svc:  service.DefaultSink,
+				sign: auth.DefaultSigner,
+			})
+		})
+
+		// Protect all _private_ routes
+		r.Group(func(r chi.Router) {
+			r.Use(auth.HttpTokenValidator("api"))
+
+			handlers.NewAuthClient(AuthClient{}.New()).MountRoutes(r)
+			handlers.NewAutomation(Automation{}.New()).MountRoutes(r)
+			handlers.NewUser(User{}.New()).MountRoutes(r)
+			handlers.NewDalConnection(DalConnection{}.New()).MountRoutes(r)
+			handlers.NewDalSensitivityLevel(SensitivityLevel{}.New()).MountRoutes(r)
+			handlers.NewDalDriver(DalDriver{}.New()).MountRoutes(r)
+			handlers.NewDalSchemaAlteration(DalSchemaAlteration{}.New()).MountRoutes(r)
+			handlers.NewRole(Role{}.New()).MountRoutes(r)
+			handlers.NewUserGroup(UserGroup{}.New()).MountRoutes(r)
+			handlers.NewPermissions(Permissions{}.New()).MountRoutes(r)
+			handlers.NewLabel(Label{}.New()).MountRoutes(r)
+			handlers.NewApplication(Application{}.New()).MountRoutes(r)
+			handlers.NewTemplate(Template{}.New()).MountRoutes(r)
+			handlers.NewReport(Report{}.New()).MountRoutes(r)
+			handlers.NewSettings(Settings{}.New()).MountRoutes(r)
+			handlers.NewStats(Stats{}.New()).MountRoutes(r)
+			handlers.NewReminder(Reminder{}.New()).MountRoutes(r)
+			handlers.NewActionlog(Actionlog{}.New()).MountRoutes(r)
+			handlers.NewNotification(Notification{}.New()).MountRoutes(r)
+			handlers.NewQueues(Queue{}.New()).MountRoutes(r)
+			handlers.NewApigwRoute(ApigwRoute{}.New()).MountRoutes(r)
+			handlers.NewApigwFilter(ApigwFilter{}.New()).MountRoutes(r)
+			handlers.NewApigwProfiler(ApigwProfiler{}.New()).MountRoutes(r)
+			handlers.NewDataPrivacy(DataPrivacy{}.New()).MountRoutes(r)
+			handlers.NewSmtpConfigurationChecker(SmtpConfigurationChecker{}.New()).MountRoutes(r)
+			handlers.NewExpression(Expression{}.New()).MountRoutes(r)
+		})
+	}
+}

server/system/rest/sensitivity_level.go

@@ -0,0 +1,135 @@
+package rest
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	SensitivityLevel struct {
+		svc sensitivityLevelService
+	}
+
+	sensitivityLevelSetPayload struct {
+		Filter types.DalSensitivityLevelFilter `json:"filter"`
+		Set    []*sensitivityLevelPayload      `json:"set"`
+	}
+
+	sensitivityLevelPayload struct {
+		*types.DalSensitivityLevel
+	}
+
+	sensitivityLevelService interface {
+		FindByID(ctx context.Context, ID uint64) (*types.DalSensitivityLevel, error)
+		Create(ctx context.Context, new *types.DalSensitivityLevel) (*types.DalSensitivityLevel, error)
+		Update(ctx context.Context, upd *types.DalSensitivityLevel) (*types.DalSensitivityLevel, error)
+		DeleteByID(ctx context.Context, ID uint64) error
+		UndeleteByID(ctx context.Context, ID uint64) error
+		Search(ctx context.Context, filter types.DalSensitivityLevelFilter) (types.DalSensitivityLevelSet, types.DalSensitivityLevelFilter, error)
+	}
+)
+
+func (SensitivityLevel) New() *SensitivityLevel {
+	return &SensitivityLevel{
+		svc: service.DefaultDalSensitivityLevel,
+	}
+}
+
+func (ctrl SensitivityLevel) List(ctx context.Context, r *request.DalSensitivityLevelList) (interface{}, error) {
+	var (
+		err error
+		set types.DalSensitivityLevelSet
+
+		f = types.DalSensitivityLevelFilter{
+			DalSensitivityLevelID: r.SensitivityLevelID,
+
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Deleted == 0 {
+		f.Deleted = filter.StateExcluded
+	}
+
+	f.IncTotal = r.IncTotal
+
+	set, f, err = ctrl.svc.Search(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl SensitivityLevel) Create(ctx context.Context, r *request.DalSensitivityLevelCreate) (interface{}, error) {
+	sensitivityLevel := &types.DalSensitivityLevel{
+		Handle: r.Handle,
+		Level:  r.Level,
+		Meta:   r.Meta,
+	}
+
+	return ctrl.svc.Create(ctx, sensitivityLevel)
+}
+
+func (ctrl SensitivityLevel) Update(ctx context.Context, r *request.DalSensitivityLevelUpdate) (interface{}, error) {
+	sensitivityLevel := &types.DalSensitivityLevel{
+		ID:        r.SensitivityLevelID,
+		Handle:    r.Handle,
+		Level:     r.Level,
+		Meta:      r.Meta,
+		UpdatedAt: r.UpdatedAt,
+	}
+
+	return ctrl.svc.Update(ctx, sensitivityLevel)
+}
+
+func (ctrl SensitivityLevel) Read(ctx context.Context, r *request.DalSensitivityLevelRead) (interface{}, error) {
+	return ctrl.svc.FindByID(ctx, r.SensitivityLevelID)
+}
+
+func (ctrl SensitivityLevel) Delete(ctx context.Context, r *request.DalSensitivityLevelDelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.DeleteByID(ctx, r.SensitivityLevelID)
+}
+
+func (ctrl SensitivityLevel) Undelete(ctx context.Context, r *request.DalSensitivityLevelUndelete) (interface{}, error) {
+	return api.OK(), ctrl.svc.UndeleteByID(ctx, r.SensitivityLevelID)
+}
+
+func (ctrl SensitivityLevel) makePayload(ctx context.Context, res *types.DalSensitivityLevel, err error) (*sensitivityLevelPayload, error) {
+	if err != nil || res == nil {
+		return nil, err
+	}
+
+	pl := &sensitivityLevelPayload{res}
+
+	return pl, nil
+}
+
+func (ctrl SensitivityLevel) makeFilterPayload(ctx context.Context, rr types.DalSensitivityLevelSet, f types.DalSensitivityLevelFilter, err error) (*sensitivityLevelSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	out := &sensitivityLevelSetPayload{Filter: f, Set: make([]*sensitivityLevelPayload, len(rr))}
+
+	for i := range rr {
+		out.Set[i], _ = ctrl.makePayload(ctx, rr[i], nil)
+	}
+	return out, nil
+}
+
+func (ctrl SensitivityLevel) serve(ctx context.Context, fn string, archive io.ReadSeeker, err error) (interface{}, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	return func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Add("Content-Disposition", "attachment; filename="+fn)
+
+		http.ServeContent(w, req, fn, time.Now(), archive)
+	}, nil
+}

server/system/rest/settings.go

@@ -0,0 +1,103 @@
+package rest
+
+import (
+	"context"
+	"fmt"
+	"strconv"
+
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Settings struct {
+		svc struct {
+			settings settingsService
+			att      service.AttachmentService
+		}
+	}
+
+	settingsService interface {
+		FindByPrefix(context.Context, ...string) (types.SettingValueSet, error)
+		BulkSet(context.Context, types.SettingValueSet) error
+		Get(context.Context, string, uint64) (*types.SettingValue, error)
+		Set(context.Context, *types.SettingValue) error
+	}
+)
+
+func (Settings) New() *Settings {
+	ctrl := &Settings{}
+	ctrl.svc.settings = service.DefaultSettings
+	ctrl.svc.att = service.DefaultAttachment
+
+	return ctrl
+}
+
+func (ctrl *Settings) List(ctx context.Context, r *request.SettingsList) (interface{}, error) {
+	if vv, err := ctrl.svc.settings.FindByPrefix(ctx, r.Prefix); err != nil {
+		return nil, err
+	} else {
+		return vv, err
+	}
+}
+
+func (ctrl *Settings) Update(ctx context.Context, r *request.SettingsUpdate) (interface{}, error) {
+	if err := ctrl.svc.settings.BulkSet(ctx, r.Values); err != nil {
+		return nil, err
+	} else {
+		return true, nil
+	}
+}
+
+func (ctrl *Settings) Get(ctx context.Context, r *request.SettingsGet) (interface{}, error) {
+	if v, err := ctrl.svc.settings.Get(ctx, r.Key, r.OwnerID); err != nil {
+		return nil, err
+	} else {
+		return v, nil
+	}
+}
+
+func (ctrl *Settings) Set(ctx context.Context, r *request.SettingsSet) (interface{}, error) {
+	if r.Upload != nil {
+		file, err := r.Upload.Open()
+
+		if err != nil {
+			return nil, err
+		}
+
+		defer file.Close()
+
+		// @todo this whole attachment + settings logic must be moved to settings service
+		//       this can be done when we generalize attachment handling
+		//       and move that our of sys/msg/cmp to pkg
+		att, err := ctrl.svc.att.CreateSettingsAttachment(
+			ctx,
+			r.Upload.Filename,
+			r.Upload.Size,
+			file,
+			map[string]string{"key": r.Key, "ownedBy": strconv.FormatUint(r.OwnerID, 10)},
+		)
+
+		if err != nil {
+			return nil, err
+		}
+
+		s := &types.SettingValue{Name: r.Key, OwnedBy: r.OwnerID}
+
+		if err = s.SetSetting(fmt.Sprintf("attachment:%d", att.ID)); err != nil {
+			return nil, err
+		}
+
+		return s, ctrl.svc.settings.Set(ctx, s)
+	}
+
+	return nil, nil
+}
+
+// Current settings, structured
+//
+// This is available to all authenticated users
+func (ctrl *Settings) Current(ctx context.Context, r *request.SettingsCurrent) (interface{}, error) {
+	return service.CurrentSettings.WithDefaults(), nil
+}

server/system/rest/sink.go

@@ -0,0 +1,18 @@
+package rest
+
+import (
+	"github.com/cortezaproject/corteza/server/pkg/auth"
+	"net/http"
+)
+
+type Sink struct {
+	svc interface {
+		ProcessRequest(w http.ResponseWriter, r *http.Request)
+	}
+
+	sign auth.Signer
+}
+
+func (ctrl *Sink) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctrl.svc.ProcessRequest(w, r)
+}

server/system/rest/smtp_configuration_checker.go

@@ -0,0 +1,47 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	SmtpConfigurationChecker struct {
+		svc smtpConfigurationCheckerService
+	}
+
+	smtpConfigurationCheckerService interface {
+		Check(context.Context, *types.SmtpConfiguration) (*types.SmtpCheckResult, error)
+	}
+)
+
+func (SmtpConfigurationChecker) New() *SmtpConfigurationChecker {
+	return &SmtpConfigurationChecker{
+		svc: service.DefaultSMTPChecker,
+	}
+}
+
+func (ctrl *SmtpConfigurationChecker) Check(ctx context.Context, r *request.SmtpConfigurationCheckerCheck) (interface{}, error) {
+	var (
+		err          error
+		checkResults = &types.SmtpCheckResult{}
+		smtp         = &types.SmtpConfiguration{
+			Host:          r.Host,
+			Port:          r.Port,
+			Recipients:    r.Recipients,
+			Username:      r.Username,
+			Password:      r.Password,
+			TLSInsecure:   r.TlsInsecure,
+			TLSServerName: r.TlsServerName,
+		}
+	)
+
+	checkResults, err = ctrl.svc.Check(ctx, smtp)
+	if err != nil {
+		return nil, err
+	}
+
+	return checkResults, nil
+}

server/system/rest/stats.go

@@ -0,0 +1,27 @@
+package rest
+
+import (
+	"context"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+)
+
+type (
+	Stats struct {
+		svc statsService
+	}
+
+	statsService interface {
+		Metrics(context.Context) (*service.StatisticsMetricsPayload, error)
+	}
+)
+
+func (Stats) New() *Stats {
+	return &Stats{
+		svc: service.DefaultStatistics,
+	}
+}
+
+func (ctrl *Stats) List(ctx context.Context, r *request.StatsList) (interface{}, error) {
+	return ctrl.svc.Metrics(ctx)
+}

server/system/rest/template.go

@@ -0,0 +1,240 @@
+package rest
+
+import (
+	"context"
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/system/renderer"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	Template struct {
+		renderer service.TemplateService
+		ac       templateAccessController
+	}
+
+	templateSetPayload struct {
+		Filter types.TemplateFilter `json:"filter"`
+		Set    []*templatePayload   `json:"set"`
+	}
+
+	templatePayload struct {
+		*types.Template
+
+		CanGrant          bool `json:"canGrant"`
+		CanUpdateTemplate bool `json:"canUpdateTemplate"`
+		CanDeleteTemplate bool `json:"canDeleteTemplate"`
+	}
+
+	driverSetPayload struct {
+		Set []*driverPayload `json:"set"`
+	}
+
+	driverPayload struct {
+		renderer.DriverDefinition
+	}
+
+	templateAccessController interface {
+		CanGrant(context.Context) bool
+		CanCreateTemplate(context.Context) bool
+		CanReadTemplate(context.Context, *types.Template) bool
+		CanUpdateTemplate(context.Context, *types.Template) bool
+		CanDeleteTemplate(context.Context, *types.Template) bool
+	}
+)
+
+func (Template) New() *Template {
+	return &Template{
+		renderer: service.DefaultRenderer,
+		ac:       service.DefaultAccessControl,
+	}
+}
+
+func (ctrl *Template) Read(ctx context.Context, r *request.TemplateRead) (interface{}, error) {
+	tpl, err := ctrl.renderer.FindByID(ctx, r.TemplateID)
+	return ctrl.makeTemplatePayload(ctx, tpl, err)
+}
+
+func (ctrl *Template) List(ctx context.Context, r *request.TemplateList) (interface{}, error) {
+	var (
+		err error
+		f   = types.TemplateFilter{
+			Query:   r.Query,
+			Handle:  r.Handle,
+			Type:    r.Type,
+			OwnerID: r.OwnerID,
+			Partial: r.Partial,
+			Deleted: filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.renderer.Search(ctx, f)
+	return ctrl.makeFilterTemplatePayload(ctx, set, filter, err)
+}
+
+func (ctrl *Template) Create(ctx context.Context, r *request.TemplateCreate) (interface{}, error) {
+	var (
+		err error
+		app = &types.Template{
+			Handle:   r.Handle,
+			Language: r.Language,
+			Type:     types.DocumentType(r.Type),
+			Partial:  r.Partial,
+			Meta:     r.Meta,
+			Template: r.Template,
+			OwnerID:  r.OwnerID,
+		}
+	)
+
+	app, err = ctrl.renderer.Create(ctx, app)
+	return ctrl.makeTemplatePayload(ctx, app, err)
+}
+
+func (ctrl *Template) Update(ctx context.Context, r *request.TemplateUpdate) (interface{}, error) {
+	var (
+		err error
+		app = &types.Template{
+			ID:        r.TemplateID,
+			Handle:    r.Handle,
+			Language:  r.Language,
+			Type:      types.DocumentType(r.Type),
+			Partial:   r.Partial,
+			Meta:      r.Meta,
+			Template:  r.Template,
+			OwnerID:   r.OwnerID,
+			UpdatedAt: r.UpdatedAt,
+		}
+	)
+
+	app, err = ctrl.renderer.Update(ctx, app)
+	return ctrl.makeTemplatePayload(ctx, app, err)
+}
+
+func (ctrl *Template) Delete(ctx context.Context, r *request.TemplateDelete) (interface{}, error) {
+	return api.OK(), ctrl.renderer.DeleteByID(ctx, r.TemplateID)
+}
+
+func (ctrl *Template) Undelete(ctx context.Context, r *request.TemplateUndelete) (interface{}, error) {
+	return api.OK(), ctrl.renderer.UndeleteByID(ctx, r.TemplateID)
+}
+
+func (ctrl *Template) RenderDrivers(ctx context.Context, r *request.TemplateRenderDrivers) (interface{}, error) {
+	return ctrl.makeSetRenderDriverPayload(ctx, ctrl.renderer.Drivers()), nil
+}
+
+func (ctrl *Template) Render(ctx context.Context, r *request.TemplateRender) (interface{}, error) {
+	vars := make(map[string]interface{})
+	err := json.Unmarshal(r.Variables, &vars)
+	if err != nil {
+		return nil, err
+	}
+
+	opts := make(map[string]string)
+	if r.Options != nil {
+		err = json.Unmarshal(r.Options, &opts)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	ct := ctrl.getDestinationType(r.Ext)
+
+	doc, err := ctrl.renderer.Render(ctx, r.TemplateID, ct, vars, opts, types.TemplateRenderAux{})
+	return ctrl.serve(doc, ct, r, err)
+}
+
+// Utilities
+
+func (ctrl Template) makeFilterTemplatePayload(ctx context.Context, nn types.TemplateSet, f types.TemplateFilter, err error) (*templateSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &templateSetPayload{Filter: f, Set: make([]*templatePayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makeTemplatePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}
+
+func (ctrl Template) makeTemplatePayload(ctx context.Context, tpl *types.Template, err error) (*templatePayload, error) {
+	if err != nil || tpl == nil {
+		return nil, err
+	}
+
+	pl := &templatePayload{
+		Template: tpl,
+
+		CanGrant:          ctrl.ac.CanGrant(ctx),
+		CanUpdateTemplate: ctrl.ac.CanUpdateTemplate(ctx, tpl),
+		CanDeleteTemplate: ctrl.ac.CanDeleteTemplate(ctx, tpl),
+	}
+
+	return pl, nil
+}
+
+func (ctrl Template) makeSetRenderDriverPayload(ctx context.Context, nn []renderer.DriverDefinition) *driverSetPayload {
+	msp := &driverSetPayload{Set: make([]*driverPayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i] = &driverPayload{
+			DriverDefinition: nn[i],
+		}
+	}
+
+	return msp
+}
+
+func (ctrl *Template) serve(doc io.ReadSeeker, ct string, r *request.TemplateRender, err error) (interface{}, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	return func(w http.ResponseWriter, req *http.Request) {
+		if err != nil {
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		name := url.QueryEscape(strings.TrimSpace(r.Filename) + "." + strings.TrimSpace(r.Ext))
+		w.Header().Add("Content-Disposition", "attachment; filename="+name)
+		w.Header().Add("Content-Type", ct+"; charset=utf-8")
+
+		http.ServeContent(w, req, name, time.Now(), doc)
+	}, nil
+}
+
+func (ctrl *Template) getDestinationType(ext string) string {
+	switch ext {
+	case "txt":
+		return "text/plain"
+	case "html":
+		return "text/html"
+	case "pdf":
+		return "application/pdf"
+	}
+
+	return "text/plain"
+}

server/system/rest/user.go

@@ -0,0 +1,611 @@
+package rest
+
+import (
+	"archive/zip"
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/corredor"
+	"github.com/cortezaproject/corteza/server/pkg/dal"
+	"github.com/cortezaproject/corteza/server/pkg/envoy"
+	"github.com/cortezaproject/corteza/server/pkg/envoy/resource"
+	envoyStore "github.com/cortezaproject/corteza/server/pkg/envoy/store"
+	"github.com/cortezaproject/corteza/server/pkg/envoy/yaml"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/service/event"
+	"github.com/cortezaproject/corteza/server/system/types"
+	"github.com/gabriel-vasile/mimetype"
+	"github.com/spf13/cast"
+)
+
+type (
+	User struct {
+		user service.UserService
+		role service.RoleService
+		cred userCredentials
+
+		userAc userAccessController
+		roleAc roleAccessController
+	}
+
+	userPayload struct {
+		*types.User
+
+		CanGrant      bool `json:"canGrant"`
+		CanUpdateUser bool `json:"canUpdateUser"`
+		CanDeleteUser bool `json:"canDeleteUser"`
+	}
+
+	userSetPayload struct {
+		Filter types.UserFilter `json:"filter"`
+		Set    []*userPayload   `json:"set"`
+	}
+
+	credentialPayload struct {
+		ID          uint64     `json:"credentialsID,string"`
+		OwnerID     uint64     `json:"ownerID,string"`
+		Label       string     `json:"label"`
+		Kind        string     `json:"kind"`
+		Credentials string     `json:"credentials,omitempty"`
+		LastUsedAt  *time.Time `json:"lastUsedAt,omitempty"`
+		ExpiresAt   *time.Time `json:"expiresAt,omitempty"`
+		CreatedAt   time.Time  `json:"createdAt,omitempty"`
+		UpdatedAt   *time.Time `json:"updatedAt,omitempty"`
+		DeletedAt   *time.Time `json:"deletedAt,omitempty"`
+	}
+
+	credentialSetPayload []credentialPayload
+
+	userCredentials interface {
+		List(ctx context.Context, userID uint64) (cc types.CredentialSet, err error)
+		Delete(ctx context.Context, userID, credentialsID uint64) (err error)
+	}
+
+	userAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanCreateUser(context.Context) bool
+		CanUpdateUser(context.Context, *types.User) bool
+		CanDeleteUser(context.Context, *types.User) bool
+	}
+)
+
+func (User) New() *User {
+	return &User{
+		user: service.DefaultUser,
+		role: service.DefaultRole,
+		cred: service.DefaultCredentials,
+
+		userAc: service.DefaultAccessControl,
+		roleAc: service.DefaultAccessControl,
+	}
+}
+
+func (ctrl User) List(ctx context.Context, r *request.UserList) (interface{}, error) {
+	var (
+		err error
+		set types.UserSet
+		f   = types.UserFilter{
+			UserID:    r.UserID,
+			RoleID:    r.RoleID,
+			Query:     r.Query,
+			Email:     r.Email,
+			Username:  r.Username,
+			Handle:    r.Handle,
+			Kind:      r.Kind,
+			Labels:    r.Labels,
+			Suspended: filter.State(r.Suspended),
+			Deleted:   filter.State(r.Deleted),
+		}
+	)
+
+	// @todo improve this either on the request parsing stage or query building stage
+	if len(f.UserID) == 1 && f.UserID[0] == "" {
+		f.UserID = nil
+	}
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	if r.IncSuspended && f.Suspended == 0 {
+		f.Suspended = filter.StateInclusive
+	}
+
+	if r.IncDeleted && f.Deleted == 0 {
+		f.Deleted = filter.StateInclusive
+	}
+
+	set, f, err = ctrl.user.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, f, err)
+}
+
+func (ctrl User) Create(ctx context.Context, r *request.UserCreate) (interface{}, error) {
+	user := &types.User{
+		Email:  r.Email,
+		Name:   r.Name,
+		Handle: r.Handle,
+		Kind:   r.Kind,
+		Labels: r.Labels,
+		Meta:   r.Meta,
+
+		UserGroupID: r.UserGroupID,
+	}
+
+	res, err := ctrl.user.Create(ctx, user)
+	return ctrl.makePayload(ctx, res, err)
+}
+
+func (ctrl User) Update(ctx context.Context, r *request.UserUpdate) (interface{}, error) {
+	user := &types.User{
+		ID:        r.UserID,
+		Email:     r.Email,
+		Name:      r.Name,
+		Handle:    r.Handle,
+		Kind:      r.Kind,
+		Labels:    r.Labels,
+		Meta:      r.Meta,
+		UpdatedAt: r.UpdatedAt,
+
+		UserGroupID: r.UserGroupID,
+	}
+
+	res, err := ctrl.user.Update(ctx, user)
+	return ctrl.makePayload(ctx, res, err)
+}
+
+func (ctrl User) ProfileAvatar(ctx context.Context, r *request.UserProfileAvatar) (interface{}, error) {
+	return api.OK(), ctrl.user.UploadAvatar(ctx, r.UserID, r.Upload)
+}
+
+func (ctrl User) ProfileAvatarInitial(ctx context.Context, r *request.UserProfileAvatarInitial) (interface{}, error) {
+	return api.OK(), ctrl.user.GenerateAvatar(ctx, r.UserID, r.AvatarBgColor, r.AvatarColor)
+}
+
+func (ctrl User) DeleteAvatar(ctx context.Context, r *request.UserDeleteAvatar) (interface{}, error) {
+	return api.OK(), ctrl.user.DeleteAvatar(ctx, r.UserID)
+}
+
+type (
+	patchOp struct {
+		Operation string          `json:"op"`
+		Path      string          `json:"path"`
+		Value     json.RawMessage `json:"value"`
+	}
+)
+
+// PartialUpdate
+//
+// experimental resource management with partial updates (patching) using
+// JavaScript Object Notation (JSON) Patch standard (RFC 6902)
+//
+// If this proves useful, we'll use it on other resources & fields
+func (ctrl User) PartialUpdate(ctx context.Context, r *request.UserPartialUpdate) (interface{}, error) {
+	u, err := ctrl.user.FindByID(ctx, r.UserID)
+	if err != nil {
+		return nil, err
+	}
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		err = func() (err error) {
+			var (
+				ops = make([]*patchOp, 0)
+			)
+
+			if err = json.NewDecoder(r.Body).Decode(&ops); err != nil {
+				return err
+			}
+
+			for _, p := range ops {
+				if p.Operation != "replace" {
+					return fmt.Errorf("unsupported operation '%s'", p.Operation)
+				}
+
+				var aux interface{}
+				err = json.Unmarshal(p.Value, &aux)
+
+				switch p.Path {
+				case "/meta/preferredLanguage":
+					u.Meta.PreferredLanguage, err = cast.ToStringE(aux)
+
+				case "/meta/securityPolicy/mfa/enforcedEmailOTP":
+					u.Meta.SecurityPolicy.MFA.EnforcedEmailOTP, err = cast.ToBoolE(aux)
+
+				case "/meta/securityPolicy/mfa/enforcedTOTP":
+					u.Meta.SecurityPolicy.MFA.EnforcedTOTP, err = cast.ToBoolE(aux)
+
+				case "/emailConfirmed":
+					// unfortunately, this cannot be passed to update right now
+					// internal limitations
+					u.EmailConfirmed, err = cast.ToBoolE(aux)
+					err = ctrl.user.ToggleEmailConfirmation(ctx, u.ID, u.EmailConfirmed)
+
+				default:
+					return fmt.Errorf("unknown path: %s", p.Path)
+				}
+
+				if err != nil {
+					return fmt.Errorf("could not replace falue of %s: %w", p.Path, err)
+				}
+			}
+
+			u, err = ctrl.user.Update(ctx, u)
+			return err
+		}()
+
+		if err != nil {
+			api.Send(w, r, err)
+		}
+
+		api.Send(w, r, u)
+	}, nil
+}
+
+func (ctrl User) Read(ctx context.Context, r *request.UserRead) (interface{}, error) {
+	res, err := ctrl.user.FindByID(ctx, r.UserID)
+	return ctrl.makePayload(ctx, res, err)
+}
+
+func (ctrl User) Delete(ctx context.Context, r *request.UserDelete) (interface{}, error) {
+	return api.OK(), ctrl.user.Delete(ctx, r.UserID)
+}
+
+func (ctrl User) Suspend(ctx context.Context, r *request.UserSuspend) (interface{}, error) {
+	return api.OK(), ctrl.user.Suspend(ctx, r.UserID)
+}
+
+func (ctrl User) Unsuspend(ctx context.Context, r *request.UserUnsuspend) (interface{}, error) {
+	return api.OK(), ctrl.user.Unsuspend(ctx, r.UserID)
+}
+
+func (ctrl User) Undelete(ctx context.Context, r *request.UserUndelete) (interface{}, error) {
+	return api.OK(), ctrl.user.Undelete(ctx, r.UserID)
+}
+
+func (ctrl User) SetPassword(ctx context.Context, r *request.UserSetPassword) (interface{}, error) {
+	return api.OK(), ctrl.user.SetPassword(ctx, r.UserID, r.Password)
+}
+
+func (ctrl User) MembershipList(ctx context.Context, r *request.UserMembershipList) (interface{}, error) {
+	if mm, err := ctrl.role.Membership(ctx, r.UserID); err != nil {
+		return nil, err
+	} else {
+		rval := make([]string, len(mm))
+		for i := range mm {
+			rval[i] = payload.Uint64toa(mm[i].RoleID)
+		}
+		return rval, nil
+	}
+}
+
+func (ctrl User) MembershipAdd(ctx context.Context, r *request.UserMembershipAdd) (interface{}, error) {
+	return api.OK(), ctrl.role.MemberAdd(ctx, r.RoleID, r.UserID)
+}
+
+func (ctrl User) MembershipRemove(ctx context.Context, r *request.UserMembershipRemove) (interface{}, error) {
+	return api.OK(), ctrl.role.MemberRemove(ctx, r.RoleID, r.UserID)
+}
+
+func (ctrl *User) TriggerScript(ctx context.Context, r *request.UserTriggerScript) (rsp interface{}, err error) {
+	var (
+		user *types.User
+	)
+
+	if user, err = ctrl.user.FindByID(ctx, r.UserID); err != nil {
+		return
+	}
+
+	// @todo implement same behaviour as we have on record - user+oldUser
+	err = corredor.Service().Exec(ctx, r.Script, corredor.ExtendScriptArgs(event.UserOnManual(user, user), r.Args))
+	return user, err
+
+}
+
+func (ctrl *User) SessionsRemove(ctx context.Context, r *request.UserSessionsRemove) (rsp interface{}, err error) {
+	var (
+		user *types.User
+	)
+
+	if user, err = ctrl.user.FindByID(ctx, r.UserID); err != nil {
+		return
+	}
+
+	if err = ctrl.user.DeleteAuthSessionsByUserID(ctx, user.ID); err != nil {
+		return
+	}
+
+	if err = ctrl.user.DeleteAuthTokensByUserID(ctx, user.ID); err != nil {
+		return
+	}
+
+	return
+}
+
+func (ctrl *User) ListCredentials(ctx context.Context, r *request.UserListCredentials) (rsp interface{}, err error) {
+	cc, err := ctrl.cred.List(ctx, r.UserID)
+	if err != nil {
+		return
+	}
+
+	// @todo some credentials need to be accessible from the front-end; consider
+	// something less error prone, for now this is ok
+	out := make(credentialSetPayload, len(cc))
+	for i, c := range cc {
+		out[i] = credentialPayload{
+			ID:          c.ID,
+			OwnerID:     c.OwnerID,
+			Label:       c.Label,
+			Kind:        c.Kind,
+			Credentials: c.Credentials,
+			LastUsedAt:  c.LastUsedAt,
+			ExpiresAt:   c.ExpiresAt,
+			CreatedAt:   c.CreatedAt,
+			UpdatedAt:   c.UpdatedAt,
+			DeletedAt:   c.DeletedAt,
+		}
+		if !strings.HasPrefix(out[i].Kind, "access-") {
+			out[i].Credentials = ""
+		}
+	}
+
+	return out, nil
+}
+
+func (ctrl *User) DeleteCredentials(ctx context.Context, r *request.UserDeleteCredentials) (rsp interface{}, err error) {
+	return true, ctrl.cred.Delete(ctx, r.UserID, r.CredentialsID)
+}
+
+// Export exports users with optional role membership and related roles
+//
+// @note this is a temporary implementation; it will be reworked when we rework Envoy and related bits.
+func (ctrl *User) Export(ctx context.Context, r *request.UserExport) (rsp interface{}, err error) {
+	// Users
+	uu, _, err := ctrl.user.Find(ctx, types.UserFilter{})
+	if err != nil {
+		return
+	}
+
+	// Roles
+	roleIndex := make(map[uint64]*types.Role)
+	roleResIndex := make(map[uint64]resource.Interface)
+	rr, _, err := ctrl.role.Find(ctx, types.RoleFilter{Paging: filter.Paging{Limit: 0}})
+	if err != nil {
+		return
+	}
+	for _, r := range rr {
+		roleIndex[r.ID] = r
+	}
+
+	// Membership
+	resources := make(resource.InterfaceSet, 0, len(uu))
+	var membership types.RoleMemberSet
+	for _, u := range uu {
+		usrRes := resource.NewUser(u)
+
+		if r.InclRoleMembership {
+			membership, err = ctrl.role.Membership(ctx, u.ID)
+			if err != nil {
+				return
+			}
+
+			aux := make(types.RoleSet, 0, 2)
+
+			for _, m := range membership {
+				if _, ok := roleResIndex[m.RoleID]; !ok {
+					// If it's not here then it was probably deleted/archived
+					// @todo consider adding a flag to control what happens on
+					//       archived/deleted resources
+					if _, ok := roleIndex[m.RoleID]; !ok {
+						continue
+					}
+
+					roleResIndex[m.RoleID] = resource.NewRole(roleIndex[m.RoleID])
+					if r.InclRoles {
+						resources = append(resources, roleResIndex[m.RoleID])
+					}
+				}
+				aux = append(aux, roleIndex[m.RoleID])
+			}
+
+			usrRes.AddRoles(aux...)
+		}
+
+		resources = append(resources, usrRes)
+	}
+
+	// Encode
+	ye := yaml.NewYamlEncoder(&yaml.EncoderConfig{})
+	bld := envoy.NewBuilder(ye)
+	g, err := bld.Build(ctx, resources...)
+	if err != nil {
+		return nil, err
+	}
+
+	err = envoy.Encode(ctx, g, ye)
+	if err != nil {
+		return
+	}
+
+	// make archive
+	buf := bytes.NewBuffer(nil)
+	w := zip.NewWriter(buf)
+
+	var (
+		f  io.Writer
+		bb []byte
+	)
+	for _, s := range ye.Stream() {
+		// @todo generalize when needed
+		f, err = w.Create(fmt.Sprintf("%s.yaml", s.Resource))
+		if err != nil {
+			return
+		}
+
+		bb, err = ioutil.ReadAll(s.Source)
+		if err != nil {
+			return
+		}
+
+		_, err = f.Write(bb)
+		if err != nil {
+			return
+		}
+	}
+
+	err = w.Close()
+	if err != nil {
+		return
+	}
+	return ctrl.serve(ctx, fmt.Sprintf("%s.zip", r.Filename), bytes.NewReader(buf.Bytes()), nil)
+}
+
+// Import imports users with optional role membership and related roles
+//
+// @note this is a temporary implementation; it will be reworked when we rework Envoy and related bits.
+func (ctrl *User) Import(ctx context.Context, r *request.UserImport) (rsp interface{}, err error) {
+	// AC
+	// @todo refactor when we refactor this part of the sys
+	if !ctrl.userAc.CanCreateUser(ctx) {
+		err = fmt.Errorf("cannot import users: not allowed to create users")
+		return
+	}
+	if !ctrl.roleAc.CanCreateRole(ctx) {
+		err = fmt.Errorf("cannot import users: not allowed to create roles")
+		return
+	}
+
+	// Parse inputs
+	f, err := r.Upload.Open()
+	if err != nil {
+		return
+	}
+	defer f.Close()
+
+	mt, err := mimetype.DetectReader(f)
+	if err != nil {
+		return
+	}
+	_, err = f.Seek(0, 0)
+	if err != nil {
+		return
+	}
+
+	if !mt.Is("application/zip") {
+		err = fmt.Errorf("cannot import users: unsupported file format")
+		return
+	}
+
+	// un-archive
+	archive, err := zip.NewReader(f, r.Upload.Size)
+	if err != nil {
+		return
+	}
+
+	// decode with Envoy
+	yd := yaml.Decoder()
+	nn := make([]resource.Interface, 0, 10)
+	var mm []resource.Interface
+	for _, archF := range archive.File {
+		if archF.FileInfo().IsDir() {
+			continue
+		}
+		var f io.ReadCloser
+
+		f, err = archF.Open()
+		if err != nil {
+			return
+		}
+		defer f.Close()
+
+		mm, err = yd.Decode(ctx, f, nil)
+		if err != nil {
+			return
+		}
+		nn = append(nn, mm...)
+	}
+
+	// Validate
+	for _, n := range nn {
+		switch n.ResourceType() {
+		case types.UserResourceType,
+			types.RoleResourceType:
+			continue
+
+		default:
+			err = fmt.Errorf("cannot import users: invalid resource provided: %s", n.ResourceType())
+			return
+		}
+	}
+
+	se := envoyStore.NewStoreEncoder(service.DefaultStore, dal.Service(), &envoyStore.EncoderConfig{
+		OnExisting: resource.Skip,
+	})
+
+	bld := envoy.NewBuilder(se)
+	g, err := bld.Build(ctx, nn...)
+	if err != nil {
+		return
+	}
+
+	err = envoy.Encode(ctx, g, se)
+	return api.OK(), err
+}
+
+func (ctrl User) makePayload(ctx context.Context, res *types.User, err error) (*userPayload, error) {
+	if err != nil || res == nil {
+		return nil, err
+	}
+
+	pl := &userPayload{
+		User: res,
+
+		CanGrant: ctrl.userAc.CanGrant(ctx),
+
+		CanUpdateUser: ctrl.userAc.CanUpdateUser(ctx, res),
+		CanDeleteUser: ctrl.userAc.CanDeleteUser(ctx, res),
+	}
+
+	return pl, nil
+}
+
+func (ctrl User) makeFilterPayload(ctx context.Context, rr types.UserSet, f types.UserFilter, err error) (*userSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	out := &userSetPayload{Filter: f, Set: make([]*userPayload, len(rr))}
+	for i := range rr {
+		out.Set[i], _ = ctrl.makePayload(ctx, rr[i], nil)
+	}
+
+	return out, nil
+}
+
+func (ctrl User) serve(ctx context.Context, fn string, archive io.ReadSeeker, err error) (interface{}, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	return func(w http.ResponseWriter, req *http.Request) {
+		w.Header().Add("Content-Disposition", "attachment; filename="+fn)
+
+		http.ServeContent(w, req, fn, time.Now(), archive)
+	}, nil
+}

server/system/rest/user_group.go

@@ -0,0 +1,199 @@
+package rest
+
+import (
+	"context"
+
+	"github.com/cortezaproject/corteza/server/pkg/api"
+	"github.com/cortezaproject/corteza/server/pkg/filter"
+	"github.com/cortezaproject/corteza/server/pkg/id"
+	"github.com/cortezaproject/corteza/server/pkg/payload"
+	"github.com/cortezaproject/corteza/server/system/rest/request"
+	"github.com/cortezaproject/corteza/server/system/service"
+	"github.com/cortezaproject/corteza/server/system/types"
+)
+
+type (
+	UserGroup struct {
+		userGroup service.UserGroupService
+		ac        userGroupAccessController
+	}
+
+	userGroupAccessController interface {
+		CanGrant(context.Context) bool
+
+		CanCreateUserGroup(context.Context) bool
+		CanUpdateUserGroup(context.Context, *types.UserGroup) bool
+		CanDeleteUserGroup(context.Context, *types.UserGroup) bool
+		CanManageMembersOnUserGroup(context.Context, *types.UserGroup) bool
+	}
+
+	userGroupPayload struct {
+		*types.UserGroup
+
+		CanGrant                    bool `json:"canGrant"`
+		CanUpdateUserGroup          bool `json:"canUpdateUserGroup"`
+		CanDeleteUserGroup          bool `json:"canDeleteUserGroup"`
+		CanManageMembersOnUserGroup bool `json:"canManageMembersOnUserGroup"`
+	}
+
+	userGroupSetPayload struct {
+		Filter types.UserGroupFilter `json:"filter"`
+		Set    []*userGroupPayload   `json:"set"`
+	}
+)
+
+func (UserGroup) New() *UserGroup {
+	return &UserGroup{
+		userGroup: service.DefaultUserGroup,
+		ac:        service.DefaultAccessControl,
+	}
+}
+
+func (ctrl UserGroup) Read(ctx context.Context, r *request.UserGroupRead) (interface{}, error) {
+	userGroup, err := ctrl.userGroup.FindByID(ctx, r.UserGroupID.Number())
+	return ctrl.makePayload(ctx, userGroup, err)
+}
+
+func (ctrl UserGroup) List(ctx context.Context, r *request.UserGroupList) (interface{}, error) {
+	var (
+		err error
+		f   = types.UserGroupFilter{
+			Query:       r.Query,
+			Labels:      r.Labels,
+			MemberID:    r.MemberID,
+			UserGroupID: id.StringifySlice(r.UserGroupID...),
+
+			Archived: filter.State(r.Archived),
+			Deleted:  filter.State(r.Deleted),
+		}
+	)
+
+	if f.Paging, err = filter.NewPaging(r.Limit, r.PageCursor); err != nil {
+		return nil, err
+	}
+
+	f.IncTotal = r.IncTotal
+
+	if f.Sorting, err = filter.NewSorting(r.Sort); err != nil {
+		return nil, err
+	}
+
+	set, filter, err := ctrl.userGroup.Find(ctx, f)
+	return ctrl.makeFilterPayload(ctx, set, filter, err)
+}
+
+func (ctrl UserGroup) Create(ctx context.Context, r *request.UserGroupCreate) (interface{}, error) {
+	var (
+		err       error
+		userGroup = &types.UserGroup{
+			Handle: r.Handle,
+			Labels: r.Labels,
+			Config: r.Config,
+			Meta:   r.Meta,
+		}
+	)
+
+	userGroup, err = ctrl.userGroup.Create(ctx, userGroup)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, userID := range payload.ParseUint64s(r.Members) {
+		err := ctrl.userGroup.MemberAdd(ctx, userGroup.ID, userID)
+		if err != nil {
+			return nil, err
+		}
+	}
+	return ctrl.makePayload(ctx, userGroup, err)
+}
+
+func (ctrl UserGroup) Update(ctx context.Context, r *request.UserGroupUpdate) (interface{}, error) {
+	var (
+		err       error
+		userGroup = &types.UserGroup{
+			ID:        r.UserGroupID.Number(),
+			Handle:    r.Handle,
+			Labels:    r.Labels,
+			UpdatedAt: r.UpdatedAt,
+			Meta:      r.Meta,
+			Config:    r.Config,
+		}
+	)
+
+	userGroup, err = ctrl.userGroup.Update(ctx, userGroup)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(r.Members) > 0 {
+		for _, userID := range payload.ParseUint64s(r.Members) {
+			err := ctrl.userGroup.MemberAdd(ctx, userGroup.ID, userID)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return ctrl.makePayload(ctx, userGroup, err)
+}
+
+func (ctrl UserGroup) Delete(ctx context.Context, r *request.UserGroupDelete) (interface{}, error) {
+	return api.OK(), ctrl.userGroup.Delete(ctx, r.UserGroupID.Number())
+}
+
+func (ctrl UserGroup) Undelete(ctx context.Context, r *request.UserGroupUndelete) (interface{}, error) {
+	return api.OK(), ctrl.userGroup.Undelete(ctx, r.UserGroupID.Number())
+}
+
+func (ctrl UserGroup) MemberList(ctx context.Context, r *request.UserGroupMemberList) (interface{}, error) {
+	if mm, err := ctrl.userGroup.MemberList(ctx, r.UserGroupID.Number()); err != nil {
+		return nil, err
+	} else {
+		rval := make([]string, len(mm))
+		for i := range mm {
+			rval[i] = payload.Uint64toa(mm[i].ID)
+		}
+		return rval, nil
+	}
+}
+
+func (ctrl UserGroup) MemberAdd(ctx context.Context, r *request.UserGroupMemberAdd) (interface{}, error) {
+	return api.OK(), ctrl.userGroup.MemberAdd(ctx, r.UserGroupID.Number(), r.UserID)
+}
+
+func (ctrl UserGroup) makePayload(ctx context.Context, r *types.UserGroup, err error) (*userGroupPayload, error) {
+	if err != nil || r == nil {
+		return nil, err
+	}
+
+	if r.Config == nil {
+		r.Config = &types.UserGroupConfig{}
+	}
+
+	if len(r.Config.Paths) == 0 {
+		r.Config.Paths = []types.UserGroupPath{}
+	}
+
+	return &userGroupPayload{
+		UserGroup: r,
+
+		CanGrant:                    ctrl.ac.CanGrant(ctx),
+		CanUpdateUserGroup:          ctrl.ac.CanUpdateUserGroup(ctx, r),
+		CanDeleteUserGroup:          ctrl.ac.CanDeleteUserGroup(ctx, r),
+		CanManageMembersOnUserGroup: ctrl.ac.CanManageMembersOnUserGroup(ctx, r),
+	}, nil
+}
+
+func (ctrl UserGroup) makeFilterPayload(ctx context.Context, nn types.UserGroupSet, f types.UserGroupFilter, err error) (*userGroupSetPayload, error) {
+	if err != nil {
+		return nil, err
+	}
+
+	msp := &userGroupSetPayload{Filter: f, Set: make([]*userGroupPayload, len(nn))}
+
+	for i := range nn {
+		msp.Set[i], _ = ctrl.makePayload(ctx, nn[i], nil)
+	}
+
+	return msp, nil
+}