7e385fc126
Some checks failed
SonarQube / SonarQube (push) Failing after 5m28s
E2e test on main branch push / server and client test (map[name:admin port:8080]) (push) Failing after 3m33s
Server and lib tests / Library test (js) (push) Failing after 1m36s
Server and lib tests / Library test (vue) (push) Successful in 2m24s
Server and lib tests / Web client test (admin) (push) Successful in 2m52s
Server and lib tests / Web client test (compose) (push) Successful in 3m23s
Server and lib tests / Web client test (discovery) (push) Successful in 2m49s
Server and lib tests / Web client test (one) (push) Successful in 2m52s
Server and lib tests / Web client test (privacy) (push) Successful in 2m44s
Server and lib tests / Web client test (reporter) (push) Successful in 2m56s
Server and lib tests / Web client test (workflow) (push) Successful in 3m0s
Server and lib tests / Server tests (push) Failing after 4m55s
E2e test on main branch push / notify-failure (push) Failing after 9s
Server and lib tests / Send matrix testing notification (push) Successful in 2s
Mark stale issues and pull requests / stale (push) Successful in 40s
1122 lines
27 KiB
Go
Generated
1122 lines
27 KiB
Go
Generated
package envoy
|
|
|
|
// This file is auto-generated.
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
//
|
|
|
|
import (
|
|
"context"
|
|
"io"
|
|
"time"
|
|
|
|
"github.com/cortezaproject/corteza/server/pkg/envoyx"
|
|
"github.com/cortezaproject/corteza/server/pkg/y7s"
|
|
"github.com/cortezaproject/corteza/server/system/types"
|
|
"github.com/pkg/errors"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
type (
|
|
// YamlEncoder is responsible for encoding Corteza resources into
|
|
// a YAML supported format
|
|
YamlEncoder struct{}
|
|
)
|
|
|
|
const (
|
|
paramsKeyWriter = "writer"
|
|
)
|
|
|
|
// Encode encodes the given Corteza resources into some YAML supported format
|
|
//
|
|
// Encoding should not do any additional processing apart from matching with
|
|
// dependencies and runtime validation
|
|
//
|
|
// Preparation runs validation, default value initialization, matching with
|
|
// already existing instances, ...
|
|
//
|
|
// The prepare function receives a set of nodes grouped by the resource type.
|
|
// This enables some batching optimization and simplifications when it comes to
|
|
// matching with existing resources.
|
|
//
|
|
// Prepare does not receive any placeholder nodes which are used solely
|
|
// for dependency resolution.
|
|
func (e YamlEncoder) Encode(ctx context.Context, p envoyx.EncodeParams, rt string, nodes envoyx.NodeSet, tt envoyx.Traverser) (err error) {
|
|
var (
|
|
out *yaml.Node
|
|
aux *yaml.Node
|
|
)
|
|
_ = aux
|
|
|
|
w, err := e.getWriter(p)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
switch rt {
|
|
case types.ApplicationResourceType:
|
|
aux, err = e.encodeApplications(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "application", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case types.ApigwRouteResourceType:
|
|
aux, err = e.encodeApigwRoutes(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "apigwRoute", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
case types.AuthClientResourceType:
|
|
aux, err = e.encodeAuthClients(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "authClient", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
case types.QueueResourceType:
|
|
aux, err = e.encodeQueues(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "queue", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
case types.ReportResourceType:
|
|
aux, err = e.encodeReports(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "report", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
case types.RoleResourceType:
|
|
aux, err = e.encodeRoles(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "role", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
case types.TemplateResourceType:
|
|
aux, err = e.encodeTemplates(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "template", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case types.UserResourceType:
|
|
aux, err = e.encodeUsers(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "user", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case types.DalConnectionResourceType:
|
|
aux, err = e.encodeDalConnections(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "dalConnection", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
case types.DalSensitivityLevelResourceType:
|
|
aux, err = e.encodeDalSensitivityLevels(ctx, p, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
// Root level resources are always encoded as a map
|
|
out, err = y7s.AddMap(out, "dalSensitivityLevel", aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
default:
|
|
out, err = e.encode(ctx, out, p, rt, nodes, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
// Don't output nil values since that will produce broken yaml docs
|
|
if out == nil {
|
|
return
|
|
}
|
|
|
|
return yaml.NewEncoder(w).Encode(out)
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource application
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeApplications(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeApplication(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeApplication focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeApplication(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.Application)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxOwnerID, err := e.encodeRef(p, res.OwnerID, "OwnerID", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"createdAt", auxCreatedAt,
|
|
"deletedAt", auxDeletedAt,
|
|
"enabled", res.Enabled,
|
|
"id", res.ID,
|
|
"name", res.Name,
|
|
"ownerID", auxOwnerID,
|
|
"unify", res.Unify,
|
|
"updatedAt", auxUpdatedAt,
|
|
"weight", res.Weight,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource apigwRoute
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeApigwRoutes(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeApigwRoute(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeApigwRoute focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeApigwRoute(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.ApigwRoute)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedBy, err := e.encodeRef(p, res.CreatedBy, "CreatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedBy, err := e.encodeRef(p, res.DeletedBy, "DeletedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxGroup, err := e.encodeRef(p, res.Group, "Group", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedBy, err := e.encodeRef(p, res.UpdatedBy, "UpdatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"createdAt", auxCreatedAt,
|
|
"createdBy", auxCreatedBy,
|
|
"deletedAt", auxDeletedAt,
|
|
"deletedBy", auxDeletedBy,
|
|
"enabled", res.Enabled,
|
|
"endpoint", res.Endpoint,
|
|
"group", auxGroup,
|
|
"id", res.ID,
|
|
"meta", res.Meta,
|
|
"method", res.Method,
|
|
"updatedAt", auxUpdatedAt,
|
|
"updatedBy", auxUpdatedBy,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
aux, err = e.encodeApigwFilters(ctx, p, tt.ChildrenForResourceType(node, types.ApigwFilterResourceType), tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
out, err = y7s.AddMap(out,
|
|
"filters", aux,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource apigwFilter
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeApigwFilters(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeApigwFilter(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeApigwFilter focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeApigwFilter(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.ApigwFilter)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedBy, err := e.encodeRef(p, res.CreatedBy, "CreatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedBy, err := e.encodeRef(p, res.DeletedBy, "DeletedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxRoute, err := e.encodeRef(p, res.Route, "Route", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedBy, err := e.encodeRef(p, res.UpdatedBy, "UpdatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"createdAt", auxCreatedAt,
|
|
"createdBy", auxCreatedBy,
|
|
"deletedAt", auxDeletedAt,
|
|
"deletedBy", auxDeletedBy,
|
|
"enabled", res.Enabled,
|
|
"id", res.ID,
|
|
"kind", res.Kind,
|
|
"params", res.Params,
|
|
"ref", res.Ref,
|
|
"route", auxRoute,
|
|
"updatedAt", auxUpdatedAt,
|
|
"updatedBy", auxUpdatedBy,
|
|
"weight", res.Weight,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource authClient
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeAuthClients(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeAuthClient(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeAuthClient focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeAuthClient(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.AuthClient)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedBy, err := e.encodeRef(p, res.CreatedBy, "CreatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedBy, err := e.encodeRef(p, res.DeletedBy, "DeletedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxExpiresAt, err := e.encodeTimestampNil(p, res.ExpiresAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxOwnedBy, err := e.encodeRef(p, res.OwnedBy, "OwnedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxSecurity, err := e.encodeAuthClientSecurityC(ctx, p, tt, node, res, res.Security)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedBy, err := e.encodeRef(p, res.UpdatedBy, "UpdatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxValidFrom, err := e.encodeTimestampNil(p, res.ValidFrom)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"createdAt", auxCreatedAt,
|
|
"createdBy", auxCreatedBy,
|
|
"deletedAt", auxDeletedAt,
|
|
"deletedBy", auxDeletedBy,
|
|
"enabled", res.Enabled,
|
|
"expiresAt", auxExpiresAt,
|
|
"handle", res.Handle,
|
|
"id", res.ID,
|
|
"meta", res.Meta,
|
|
"ownedBy", auxOwnedBy,
|
|
"redirectURI", res.RedirectURI,
|
|
"scope", res.Scope,
|
|
"secret", res.Secret,
|
|
"security", auxSecurity,
|
|
"trusted", res.Trusted,
|
|
"updatedAt", auxUpdatedAt,
|
|
"updatedBy", auxUpdatedBy,
|
|
"validFrom", auxValidFrom,
|
|
"validGrant", res.ValidGrant,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource queue
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeQueues(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeQueue(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeQueue focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeQueue(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.Queue)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedBy, err := e.encodeRef(p, res.CreatedBy, "CreatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedBy, err := e.encodeRef(p, res.DeletedBy, "DeletedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedBy, err := e.encodeRef(p, res.UpdatedBy, "UpdatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"consumer", res.Consumer,
|
|
"createdAt", auxCreatedAt,
|
|
"createdBy", auxCreatedBy,
|
|
"deletedAt", auxDeletedAt,
|
|
"deletedBy", auxDeletedBy,
|
|
"id", res.ID,
|
|
"meta", res.Meta,
|
|
"queue", res.Queue,
|
|
"updatedAt", auxUpdatedAt,
|
|
"updatedBy", auxUpdatedBy,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource report
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeReports(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeReport(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeReport focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeReport(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.Report)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedBy, err := e.encodeRef(p, res.CreatedBy, "CreatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedBy, err := e.encodeRef(p, res.DeletedBy, "DeletedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxOwnedBy, err := e.encodeRef(p, res.OwnedBy, "OwnedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedBy, err := e.encodeRef(p, res.UpdatedBy, "UpdatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"blocks", res.Blocks,
|
|
"createdAt", auxCreatedAt,
|
|
"createdBy", auxCreatedBy,
|
|
"deletedAt", auxDeletedAt,
|
|
"deletedBy", auxDeletedBy,
|
|
"handle", res.Handle,
|
|
"id", res.ID,
|
|
"meta", res.Meta,
|
|
"ownedBy", auxOwnedBy,
|
|
"scenarios", res.Scenarios,
|
|
"sources", res.Sources,
|
|
"updatedAt", auxUpdatedAt,
|
|
"updatedBy", auxUpdatedBy,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource role
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeRoles(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeRole(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeRole focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeRole(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.Role)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxArchivedAt, err := e.encodeTimestampNil(p, res.ArchivedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"archivedAt", auxArchivedAt,
|
|
"createdAt", auxCreatedAt,
|
|
"deletedAt", auxDeletedAt,
|
|
"handle", res.Handle,
|
|
"id", res.ID,
|
|
"meta", res.Meta,
|
|
"name", res.Name,
|
|
"updatedAt", auxUpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource template
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeTemplates(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeTemplate(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeTemplate focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeTemplate(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.Template)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxLastUsedAt, err := e.encodeTimestampNil(p, res.LastUsedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxOwnerID, err := e.encodeRef(p, res.OwnerID, "OwnerID", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"createdAt", auxCreatedAt,
|
|
"deletedAt", auxDeletedAt,
|
|
"handle", res.Handle,
|
|
"id", res.ID,
|
|
"language", res.Language,
|
|
"lastUsedAt", auxLastUsedAt,
|
|
"meta", res.Meta,
|
|
"ownerID", auxOwnerID,
|
|
"partial", res.Partial,
|
|
"template", res.Template,
|
|
"type", res.Type,
|
|
"updatedAt", auxUpdatedAt,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource user
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeUsers(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeUser(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeUser focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeUser(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.User)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxSuspendedAt, err := e.encodeTimestampNil(p, res.SuspendedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUserGroupID, err := e.encodeRef(p, res.UserGroupID, "UserGroupID", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"createdAt", auxCreatedAt,
|
|
"deletedAt", auxDeletedAt,
|
|
"email", res.Email,
|
|
"emailConfirmed", res.EmailConfirmed,
|
|
"handle", res.Handle,
|
|
"id", res.ID,
|
|
"kind", res.Kind,
|
|
"meta", res.Meta,
|
|
"name", res.Name,
|
|
"suspendedAt", auxSuspendedAt,
|
|
"updatedAt", auxUpdatedAt,
|
|
"userGroupID", auxUserGroupID,
|
|
"username", res.Username,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource dalConnection
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeDalConnections(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeDalConnection(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeDalConnection focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeDalConnection(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.DalConnection)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedBy, err := e.encodeRef(p, res.CreatedBy, "CreatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedBy, err := e.encodeRef(p, res.DeletedBy, "DeletedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedBy, err := e.encodeRef(p, res.UpdatedBy, "UpdatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"config", res.Config,
|
|
"createdAt", auxCreatedAt,
|
|
"createdBy", auxCreatedBy,
|
|
"deletedAt", auxDeletedAt,
|
|
"deletedBy", auxDeletedBy,
|
|
"handle", res.Handle,
|
|
"id", res.ID,
|
|
"meta", res.Meta,
|
|
"type", res.Type,
|
|
"updatedAt", auxUpdatedAt,
|
|
"updatedBy", auxUpdatedBy,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Functions for resource dalSensitivityLevel
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeDalSensitivityLevels(ctx context.Context, p envoyx.EncodeParams, nodes envoyx.NodeSet, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
var aux *yaml.Node
|
|
for _, n := range nodes {
|
|
aux, err = e.encodeDalSensitivityLevel(ctx, p, n, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddSeq(out, aux)
|
|
if err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// encodeDalSensitivityLevel focuses on the specific resource invoked by the Encode method
|
|
func (e YamlEncoder) encodeDalSensitivityLevel(ctx context.Context, p envoyx.EncodeParams, node *envoyx.Node, tt envoyx.Traverser) (out *yaml.Node, err error) {
|
|
res := node.Resource.(*types.DalSensitivityLevel)
|
|
|
|
// Pre-compute some map values so we can omit error checking when encoding yaml nodes
|
|
auxCreatedAt, err := e.encodeTimestamp(p, res.CreatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxCreatedBy, err := e.encodeRef(p, res.CreatedBy, "CreatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedAt, err := e.encodeTimestampNil(p, res.DeletedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxDeletedBy, err := e.encodeRef(p, res.DeletedBy, "DeletedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
auxUpdatedAt, err := e.encodeTimestampNil(p, res.UpdatedAt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
auxUpdatedBy, err := e.encodeRef(p, res.UpdatedBy, "UpdatedBy", node, tt)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
out, err = y7s.AddMap(out,
|
|
"createdAt", auxCreatedAt,
|
|
"createdBy", auxCreatedBy,
|
|
"deletedAt", auxDeletedAt,
|
|
"deletedBy", auxDeletedBy,
|
|
"handle", res.Handle,
|
|
"id", res.ID,
|
|
"level", res.Level,
|
|
"meta", res.Meta,
|
|
"updatedAt", auxUpdatedAt,
|
|
"updatedBy", auxUpdatedBy,
|
|
)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
// Handle nested resources
|
|
var aux *yaml.Node
|
|
_ = aux
|
|
|
|
return
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Encoding utils
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) encodeTimestamp(p envoyx.EncodeParams, t time.Time) (any, error) {
|
|
if t.IsZero() {
|
|
return nil, nil
|
|
}
|
|
|
|
tz := p.Encoder.PreferredTimezone
|
|
if tz != "" {
|
|
tzL, err := time.LoadLocation(tz)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
t = t.In(tzL)
|
|
}
|
|
|
|
ly := p.Encoder.PreferredTimeLayout
|
|
if ly == "" {
|
|
ly = time.RFC3339
|
|
}
|
|
|
|
return t.Format(ly), nil
|
|
}
|
|
|
|
func (e YamlEncoder) encodeTimestampNil(p envoyx.EncodeParams, t *time.Time) (any, error) {
|
|
if t == nil {
|
|
return nil, nil
|
|
}
|
|
|
|
return e.encodeTimestamp(p, *t)
|
|
}
|
|
|
|
func (e YamlEncoder) encodeRef(p envoyx.EncodeParams, id uint64, field string, node *envoyx.Node, tt envoyx.Traverser) (any, error) {
|
|
parent := tt.ParentForRef(node, node.References[field])
|
|
|
|
// @todo should we panic instead?
|
|
// for now gracefully fallback to the ID
|
|
if parent == nil {
|
|
return id, nil
|
|
}
|
|
|
|
return parent.Identifiers.FriendlyIdentifier(), nil
|
|
}
|
|
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
// Utility functions
|
|
// // // // // // // // // // // // // // // // // // // // // // // // //
|
|
|
|
func (e YamlEncoder) getWriter(p envoyx.EncodeParams) (out io.Writer, err error) {
|
|
aux, ok := p.Params[paramsKeyWriter]
|
|
if ok {
|
|
out, ok = aux.(io.Writer)
|
|
if ok {
|
|
return
|
|
}
|
|
}
|
|
|
|
// @todo consider adding support for managing files from a location
|
|
err = errors.Errorf("YAML encoder expects a writer conforming to io.Writer interface")
|
|
return
|
|
}
|
|
|
|
func safeParentIdentifier(tt envoyx.Traverser, n *envoyx.Node, ref envoyx.Ref) (out string) {
|
|
aux := tt.ParentForRef(n, ref)
|
|
if aux == nil {
|
|
return ref.Identifiers.FriendlyIdentifier()
|
|
}
|
|
|
|
return aux.Identifiers.FriendlyIdentifier()
|
|
}
|