foomo/sesamy-cli
1
0
Fork 0
mirror of https://github.com/foomo/sesamy-cli.git synced 2025-10-16 12:35:36 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

feat: dynamic workspace id

Browse Source
This commit is contained in:
Kevin Franklin Kim 2025-03-17 11:04:04 +01:00
parent 7aa4f843e5
commit ac8f7298b7
No known key found for this signature in database
30 changed files with 310 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
README.md
View File

@ -80,7 +80,7 @@ googleTagManager:
tagId: GTM-57BHX34G tagId: GTM-57BHX34G
# The container id # The container id
containerId: '175355532' containerId: '175355532'
# The workspace id that should be used by the api # (Optional) The workspace id that should be used by the api
workspaceId: '23' workspaceId: '23'
# Server container settings # Server container settings
serverContainer: serverContainer:
@ -88,7 +88,7 @@ googleTagManager:
tagId: GTM-5NWPR4QW tagId: GTM-5NWPR4QW
# The container id # The container id
containerId: '175348980' containerId: '175348980'
# The workspace id that should be used by the api # (Optional) The workspace id that should be used by the api
workspaceId: '10' workspaceId: '10'
# Web container variables # Web container variables
webContainerVariables: webContainerVariables:

29
cmd/list/list.go
View File

@ -2,6 +2,7 @@ package list
import ( import (
"bytes" "bytes"
"context"
"fmt" "fmt"
"log/slog" "log/slog"
"os" "os"
@ -32,24 +33,26 @@ func dump(i interface{ MarshalJSON() ([]byte, error) }, err error) error {
return quick.Highlight(os.Stdout, output.String(), "yaml", "terminal", "monokai") return quick.Highlight(os.Stdout, output.String(), "yaml", "terminal", "monokai")
} }
func list(l *slog.Logger, tm *tagmanager.TagManager, resource string) error { func list(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, resource string) error {
switch resource { switch resource {
case "environments":
return dump(tm.Service().Accounts.Containers.Environments.List(tm.ContainerPath()).Context(ctx).Do())
case "status": case "status":
return dump(tm.Service().Accounts.Containers.Workspaces.GetStatus(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.GetStatus(tm.WorkspacePath()).Context(ctx).Do())
case "clients": case "clients":
return dump(tm.Service().Accounts.Containers.Workspaces.Clients.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Clients.List(tm.WorkspacePath()).Context(ctx).Do())
case "tags": case "tags":
return dump(tm.Service().Accounts.Containers.Workspaces.Tags.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Tags.List(tm.WorkspacePath()).Context(ctx).Do())
case "built-in-variables": case "built-in-variables":
return dump(tm.Service().Accounts.Containers.Workspaces.BuiltInVariables.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.BuiltInVariables.List(tm.WorkspacePath()).Context(ctx).Do())
case "folders": case "folders":
return dump(tm.Service().Accounts.Containers.Workspaces.Folders.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Folders.List(tm.WorkspacePath()).Context(ctx).Do())
case "variables": case "variables":
return dump(tm.Service().Accounts.Containers.Workspaces.Variables.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Variables.List(tm.WorkspacePath()).Context(ctx).Do())
case "templates": case "templates":
return dump(tm.Service().Accounts.Containers.Workspaces.Templates.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Templates.List(tm.WorkspacePath()).Context(ctx).Do())
case "templates-data": case "templates-data":
r, err := tm.Service().Accounts.Containers.Workspaces.Templates.List(tm.WorkspacePath()).Do() r, err := tm.Service().Accounts.Containers.Workspaces.Templates.List(tm.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return err return err
} }
@ -59,13 +62,13 @@ func list(l *slog.Logger, tm *tagmanager.TagManager, resource string) error {
} }
return nil return nil
case "gtag-config": case "gtag-config":
return dump(tm.Service().Accounts.Containers.Workspaces.GtagConfig.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.GtagConfig.List(tm.WorkspacePath()).Context(ctx).Do())
case "triggers": case "triggers":
return dump(tm.Service().Accounts.Containers.Workspaces.Triggers.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Triggers.List(tm.WorkspacePath()).Context(ctx).Do())
case "transformations": case "transformations":
return dump(tm.Service().Accounts.Containers.Workspaces.Transformations.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Transformations.List(tm.WorkspacePath()).Context(ctx).Do())
case "zones": case "zones":
return dump(tm.Service().Accounts.Containers.Workspaces.Zones.List(tm.WorkspacePath()).Do()) return dump(tm.Service().Accounts.Containers.Workspaces.Zones.List(tm.WorkspacePath()).Context(ctx).Do())
default: default:
return fmt.Errorf("unknown resource %s", resource) return fmt.Errorf("unknown resource %s", resource)
} }

7
cmd/list/server.go
View File

@ -15,6 +15,7 @@ func NewServer(root *cobra.Command) {
ValidArgs: []cobra.Completion{ ValidArgs: []cobra.Completion{
"built-in-variables", "built-in-variables",
"clients", "clients",
"environments",
"folders", "folders",
"gtag-config", "gtag-config",
"status", "status",
@ -48,7 +49,11 @@ func NewServer(root *cobra.Command) {
return err return err
} }
return list(l, tm, resource) if err := tm.EnsureWorkspaceID(cmd.Context()); err != nil {
return err
}
return list(cmd.Context(), l, tm, resource)
}, },
} }

7
cmd/list/web.go
View File

@ -14,6 +14,7 @@ func NewWeb(root *cobra.Command) {
Args: cobra.OnlyValidArgs, Args: cobra.OnlyValidArgs,
ValidArgs: []cobra.Completion{ ValidArgs: []cobra.Completion{
"built-in-variables", "built-in-variables",
"environments",
"folders", "folders",
"gtag-config", "gtag-config",
"status", "status",
@ -47,7 +48,11 @@ func NewWeb(root *cobra.Command) {
return err return err
} }
return list(l, tm, resource) if err := tm.EnsureWorkspaceID(cmd.Context()); err != nil {
return err
}
return list(cmd.Context(), l, tm, resource)
}, },
} }

10
cmd/provision/server.go
View File

@ -51,14 +51,18 @@ func NewServer(root *cobra.Command) {
return err return err
} }
if err := tm.EnsureWorkspaceID(cmd.Context()); err != nil {
return err
}
if pkgcmd.Tag(googletagprovider.Tag, tags) { if pkgcmd.Tag(googletagprovider.Tag, tags) {
if err := googletagprovider.Server(tm, cfg.GoogleTag); err != nil { if err := googletagprovider.Server(cmd.Context(), tm, cfg.GoogleTag); err != nil {
return errors.Wrap(err, "failed to provision google tag provider") return errors.Wrap(err, "failed to provision google tag provider")
} }
} }
if pkgcmd.Tag(googletagmanagerprovider.Tag, tags) { if pkgcmd.Tag(googletagmanagerprovider.Tag, tags) {
if err := googletagmanagerprovider.Server(tm, cfg.GoogleTagManager, cfg.EnableGeoResolution); err != nil { if err := googletagmanagerprovider.Server(cmd.Context(), tm, cfg.GoogleTagManager, cfg.EnableGeoResolution); err != nil {
return errors.Wrap(err, "failed to provision google tag manager") return errors.Wrap(err, "failed to provision google tag manager")
} }
} }
@ -72,7 +76,7 @@ func NewServer(root *cobra.Command) {
if cfg.ConversionLinker.Enabled && pkgcmd.Tag(conversionlinkerprovider.Tag, tags) { if cfg.ConversionLinker.Enabled && pkgcmd.Tag(conversionlinkerprovider.Tag, tags) {
l.Info("🅿️ Running provider", "name", conversionlinkerprovider.Name, "tag", conversionlinkerprovider.Tag) l.Info("🅿️ Running provider", "name", conversionlinkerprovider.Name, "tag", conversionlinkerprovider.Tag)
if err := conversionlinkerprovider.Server(tm, cfg.ConversionLinker); err != nil { if err := conversionlinkerprovider.Server(cmd.Context(), tm, cfg.ConversionLinker); err != nil {
return errors.Wrap(err, "failed to provision conversion linker") return errors.Wrap(err, "failed to provision conversion linker")
} }
} }

4
cmd/provision/web.go
View File

@ -47,6 +47,10 @@ func NewWeb(root *cobra.Command) {
return err return err
} }
if err := tm.EnsureWorkspaceID(cmd.Context()); err != nil {
return err
}
if pkgcmd.Tag(googletagprovider.Tag, tags) { if pkgcmd.Tag(googletagprovider.Tag, tags) {
l.Info("🅿️ Running provider", "name", googletagprovider.Name, "tag", googletagprovider.Tag) l.Info("🅿️ Running provider", "name", googletagprovider.Name, "tag", googletagprovider.Tag)
if err := googletagprovider.Web(cmd.Context(), tm, cfg.GoogleTag); err != nil { if err := googletagprovider.Web(cmd.Context(), tm, cfg.GoogleTag); err != nil {

2
pkg/config/googletagmanagercontainer.go
View File

@ -5,6 +5,6 @@ type GoogleTagManagerContainer struct {
TagID string `json:"tagId" yaml:"tagId"` TagID string `json:"tagId" yaml:"tagId"`
// The container id // The container id
ContainerID string `json:"containerId" yaml:"containerId"` ContainerID string `json:"containerId" yaml:"containerId"`
// The workspace id that should be used by the api // (Optional) The workspace id that should be used by the api
WorkspaceID string `json:"workspaceId" yaml:"workspaceId"` WorkspaceID string `json:"workspaceId" yaml:"workspaceId"`
} }

14
pkg/provider/conversionlinker/server.go
View File

@ -1,6 +1,8 @@
package conversionlinker package conversionlinker
import ( import (
"context"
"github.com/foomo/sesamy-cli/pkg/config" "github.com/foomo/sesamy-cli/pkg/config"
containertag "github.com/foomo/sesamy-cli/pkg/provider/conversionlinker/server/tag" containertag "github.com/foomo/sesamy-cli/pkg/provider/conversionlinker/server/tag"
"github.com/foomo/sesamy-cli/pkg/provider/conversionlinker/server/trigger" "github.com/foomo/sesamy-cli/pkg/provider/conversionlinker/server/trigger"
@ -10,30 +12,30 @@ import (
"github.com/pkg/errors" "github.com/pkg/errors"
) )
func Server(tm *tagmanager.TagManager, cfg config.ConversionLinker) error { func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.ConversionLinker) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
var eventTriggerOpts []trigger.ConversionLinkerEventOption var eventTriggerOpts []trigger.ConversionLinkerEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.ConversionLinkerEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.ConversionLinkerEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewConversionLinkerEvent(NameConversionLinkerTrigger, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewConversionLinkerEvent(NameConversionLinkerTrigger, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+NameConversionLinkerTrigger) return errors.Wrap(err, "failed to upsert event trigger: "+NameConversionLinkerTrigger)
} }
if _, err := tm.UpsertTag(folder, containertag.NewConversionLinker(Name, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, containertag.NewConversionLinker(Name, eventTrigger)); err != nil {
return err return err
} }

6
pkg/provider/cookiebot/web.go
View File

@ -10,18 +10,18 @@ import (
) )
func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Cookiebot) error { func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Cookiebot) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // create event tags { // create event tags
temmplate, err := tm.LookupTemplate(cfg.TemplateName) temmplate, err := tm.LookupTemplate(ctx, cfg.TemplateName)
if err != nil { if err != nil {
return errors.Wrapf(err, "Failed to lookup `%s`, please install the `%s` gallery tag template first (%s)", cfg.TemplateName, "Cookiebot CMP", "https://tagmanager.google.com/gallery/#/owners/cybotcorp/templates/gtm-templates-cookiebot-cmp") return errors.Wrapf(err, "Failed to lookup `%s`, please install the `%s` gallery tag template first (%s)", cfg.TemplateName, "Cookiebot CMP", "https://tagmanager.google.com/gallery/#/owners/cybotcorp/templates/gtm-templates-cookiebot-cmp")
} }
if _, err := tm.UpsertTag(folder, tag.NewCookiebotInitialization(NameCookiebotTag, cfg, temmplate)); err != nil { if _, err := tm.UpsertTag(ctx, folder, tag.NewCookiebotInitialization(NameCookiebotTag, cfg, temmplate)); err != nil {
return err return err
} }
} }

18
pkg/provider/criteo/server.go
View File

@ -16,12 +16,12 @@ import (
) )
func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Criteo) error { func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Criteo) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
template, err := tm.LookupTemplate(NameCriteoEventsAPITemplate) template, err := tm.LookupTemplate(ctx, NameCriteoEventsAPITemplate)
if err != nil { if err != nil {
if errors.Is(err, tagmanager.ErrNotFound) { if errors.Is(err, tagmanager.ErrNotFound) {
l.Warn("Please install the 'Criteo Events API' template manually first") l.Warn("Please install the 'Criteo Events API' template manually first")
@ -30,17 +30,17 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
} }
{ // create tags { // create tags
callerID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID)) callerID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID))
if err != nil { if err != nil {
return err return err
} }
partnerID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NamePartnerID, cfg.PartnerID)) partnerID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NamePartnerID, cfg.PartnerID))
if err != nil { if err != nil {
return err return err
} }
applicationID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameApplicationID, cfg.ApplicationID)) applicationID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameApplicationID, cfg.ApplicationID))
if err != nil { if err != nil {
return err return err
} }
@ -53,22 +53,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.CriteoEventOption var eventTriggerOpts []trigger.CriteoEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.CriteoEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.CriteoEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewCriteoEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewCriteoEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, servertagx.NewEventsAPITag(event, callerID, partnerID, applicationID, template, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, servertagx.NewEventsAPITag(event, callerID, partnerID, applicationID, template, eventTrigger)); err != nil {
return err return err
} }
} }

10
pkg/provider/criteo/web.go
View File

@ -12,12 +12,12 @@ import (
) )
func Web(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Criteo) error { func Web(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Criteo) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
template, err := tm.LookupTemplate(NameCriteoUserIdentificationTemplate) template, err := tm.LookupTemplate(ctx, NameCriteoUserIdentificationTemplate)
if err != nil { if err != nil {
if errors.Is(err, tagmanager.ErrNotFound) { if errors.Is(err, tagmanager.ErrNotFound) {
l.Warn("Please install the 'Criteo User Identification' template manually first") l.Warn("Please install the 'Criteo User Identification' template manually first")
@ -26,17 +26,17 @@ func Web(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg con
} }
{ // setup criteo { // setup criteo
callerID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID)) callerID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID))
if err != nil { if err != nil {
return err return err
} }
partnerID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NamePartnerID, cfg.PartnerID)) partnerID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NamePartnerID, cfg.PartnerID))
if err != nil { if err != nil {
return err return err
} }
if _, err = tm.UpsertTag(folder, client.NewUserIdentification(NameCriteoUserIdentificationTag, callerID, partnerID, template)); err != nil { if _, err = tm.UpsertTag(ctx, folder, client.NewUserIdentification(NameCriteoUserIdentificationTag, callerID, partnerID, template)); err != nil {
return err return err
} }
} }

18
pkg/provider/emarsys/server.go
View File

@ -18,28 +18,28 @@ import (
) )
func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Emarsys) error { func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Emarsys) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // conversion { // conversion
merchantID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameMerchantIDConstant, cfg.MerchantID)) merchantID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameMerchantIDConstant, cfg.MerchantID))
if err != nil { if err != nil {
return err return err
} }
tagTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysWebExtendTag(NameServerEmarsysWebExtendTagTemplate)) tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewEmarsysWebExtendTag(NameServerEmarsysWebExtendTagTemplate))
if err != nil { if err != nil {
return err return err
} }
clientTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysInitializationClient(NameServerEmarsysInitalizationClientTemplate)) clientTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewEmarsysInitializationClient(NameServerEmarsysInitalizationClientTemplate))
if err != nil { if err != nil {
return err return err
} }
_, err = tm.UpsertClient(folder, serverclientx.NewEmarsys(NameServerEmarsysClient, cfg, clientTemplate)) _, err = tm.UpsertClient(ctx, folder, serverclientx.NewEmarsys(NameServerEmarsysClient, cfg, clientTemplate))
if err != nil { if err != nil {
return err return err
} }
@ -53,22 +53,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.EmarsysEventOption var eventTriggerOpts []trigger.EmarsysEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.EmarsysEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.EmarsysEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewEmarsysEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewEmarsysEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, servertagx.NewEmarsys(event, merchantID, cfg.TestMode, cfg.DebugMode, tagTemplate, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, servertagx.NewEmarsys(event, merchantID, cfg.TestMode, cfg.DebugMode, tagTemplate, eventTrigger)); err != nil {
return err return err
} }
} }

16
pkg/provider/emarsys/web.go
View File

@ -15,30 +15,30 @@ import (
) )
func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Emarsys) error { func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Emarsys) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // create initialization tag { // create initialization tag
tagTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysInitializationTag(NameWebEmarsysInitalizationTagTemplate)) tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewEmarsysInitializationTag(NameWebEmarsysInitalizationTagTemplate))
if err != nil { if err != nil {
return err return err
} }
if _, err = tm.UpsertTag(folder, tag.NewEmarsysInitialization(NameWebEmarsysInitalizationTag, tagTemplate)); err != nil { if _, err = tm.UpsertTag(ctx, folder, tag.NewEmarsysInitialization(NameWebEmarsysInitalizationTag, tagTemplate)); err != nil {
return err return err
} }
} }
if _, err := googletag.CreateWebDatalayerVariables(tm, map[string]string{ if _, err := googletag.CreateWebDatalayerVariables(ctx, tm, map[string]string{
"emarsys_page_view_id": "emarsys.page_view_id", "emarsys_page_view_id": "emarsys.page_view_id",
}); err != nil { }); err != nil {
return err return err
} }
{ // create event tags { // create event tags
tagID, err := tm.LookupVariable(googletag.NameGoogleTagID) tagID, err := tm.LookupVariable(ctx, googletag.NameGoogleTagID)
if err != nil { if err != nil {
return err return err
} }
@ -49,17 +49,17 @@ func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Emarsys) err
} }
for event := range eventParameters { for event := range eventParameters {
eventTrigger, err := tm.LookupTrigger(commontrigger.EventName(event)) eventTrigger, err := tm.LookupTrigger(ctx, commontrigger.EventName(event))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to lookup event trigger: "+event) return errors.Wrap(err, "failed to lookup event trigger: "+event)
} }
eventSettings, err := tm.LookupVariable(commonvariable.GoogleTagEventSettingsName(event)) eventSettings, err := tm.LookupVariable(ctx, commonvariable.GoogleTagEventSettingsName(event))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to lookup google tag event setting: "+event) return errors.Wrap(err, "failed to lookup google tag event setting: "+event)
} }
if _, err := tm.UpsertTag(folder, containertag.NewGoogleAnalyticsEvent(event, tagID, eventSettings, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, containertag.NewGoogleAnalyticsEvent(event, tagID, eventSettings, eventTrigger)); err != nil {
return err return err
} }
} }

18
pkg/provider/facebook/server.go
View File

@ -16,27 +16,27 @@ import (
) )
func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Facebook) error { func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Facebook) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
pixelID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NamePixelIDConstant, cfg.PixelID)) pixelID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NamePixelIDConstant, cfg.PixelID))
if err != nil { if err != nil {
return err return err
} }
apiAccessToken, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameAPIAcessTokenConstant, cfg.APIAccessToken)) apiAccessToken, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameAPIAcessTokenConstant, cfg.APIAccessToken))
if err != nil { if err != nil {
return err return err
} }
testEventToken, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameTestEventTokenConstant, cfg.TestEventToken)) testEventToken, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameTestEventTokenConstant, cfg.TestEventToken))
if err != nil { if err != nil {
return err return err
} }
template, err := tm.LookupTemplate(NameConversionsAPITagTemplate) template, err := tm.LookupTemplate(ctx, NameConversionsAPITagTemplate)
if err != nil { if err != nil {
if errors.Is(err, tagmanager.ErrNotFound) { if errors.Is(err, tagmanager.ErrNotFound) {
l.Warn("Please install the 'Conversion API' template manually first") l.Warn("Please install the 'Conversion API' template manually first")
@ -53,22 +53,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.FacebookEventOption var eventTriggerOpts []trigger.FacebookEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.FacebookEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.FacebookEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewFacebookEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewFacebookEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, servertagx.NewConversionsAPITag(event, pixelID, apiAccessToken, testEventToken, cfg.ServerContainer.Setting(event), template, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, servertagx.NewConversionsAPITag(event, pixelID, apiAccessToken, testEventToken, cfg.ServerContainer.Setting(event), template, eventTrigger)); err != nil {
return err return err
} }
} }

24
pkg/provider/googleads/server.go
View File

@ -17,24 +17,24 @@ import (
) )
func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.GoogleAds) error { func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.GoogleAds) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
conversionID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameConversionIDConstant, cfg.ConversionID)) conversionID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameConversionIDConstant, cfg.ConversionID))
if err != nil { if err != nil {
return err return err
} }
// conversion // conversion
if cfg.Conversion.Enabled { if cfg.Conversion.Enabled {
value, err := tm.UpsertVariable(folder, variable.NewEventData("value")) value, err := tm.UpsertVariable(ctx, folder, variable.NewEventData("value"))
if err != nil { if err != nil {
return err return err
} }
currency, err := tm.UpsertVariable(folder, variable.NewEventData("currency")) currency, err := tm.UpsertVariable(ctx, folder, variable.NewEventData("currency"))
if err != nil { if err != nil {
return err return err
} }
@ -48,22 +48,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.GoogleAdsEventOption var eventTriggerOpts []trigger.GoogleAdsEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.GoogleAdsEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.GoogleAdsEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewGoogleAdsEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewGoogleAdsEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, servertagx.NewGoogleAdsConversionTracking(event, value, currency, conversionID, cfg.Conversion.ServerContainer.Setting(event), eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, servertagx.NewGoogleAdsConversionTracking(event, value, currency, conversionID, cfg.Conversion.ServerContainer.Setting(event), eventTrigger)); err != nil {
return err return err
} }
} }
@ -73,22 +73,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
if cfg.Remarketing.Enabled { if cfg.Remarketing.Enabled {
var eventTriggerOpts []trigger.GoogleAdsRemarketingEventOption var eventTriggerOpts []trigger.GoogleAdsRemarketingEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.GoogleAdsRemarketingEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.GoogleAdsRemarketingEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewGoogleAdsRemarketingEvent(NameGoogleAdsRemarketingTrigger, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewGoogleAdsRemarketingEvent(NameGoogleAdsRemarketingTrigger, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+NameGoogleAdsRemarketingTrigger) return errors.Wrap(err, "failed to upsert event trigger: "+NameGoogleAdsRemarketingTrigger)
} }
if _, err := tm.UpsertTag(folder, servertagx.NewGoogleAdsRemarketing(NameGoogleAdsRemarketingTag, conversionID, cfg.Remarketing, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, servertagx.NewGoogleAdsRemarketing(NameGoogleAdsRemarketingTag, conversionID, cfg.Remarketing, eventTrigger)); err != nil {
return err return err
} }
} }

34
pkg/provider/googleanalytics/server.go
View File

@ -23,58 +23,58 @@ import (
) )
func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAnalytics, redactVisitorIP, enableGeoResolution bool) error { func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAnalytics, redactVisitorIP, enableGeoResolution bool) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // create clients { // create clients
{ {
measurementID, err := tm.LookupVariable(googletag.NameGoogleTagMeasurementID) measurementID, err := tm.LookupVariable(ctx, googletag.NameGoogleTagMeasurementID)
if err != nil { if err != nil {
return err return err
} }
visitorRegion, err := tm.LookupVariable(googletagmanager.NameGoogleTagManagerVisitorRegion) visitorRegion, err := tm.LookupVariable(ctx, googletagmanager.NameGoogleTagManagerVisitorRegion)
if err != nil { if err != nil {
return err return err
} }
client, err := tm.UpsertClient(folder, googleanalyticsclient.NewGoogleAnalyticsGA4(NameGoogleAnalyticsGA4Client, enableGeoResolution, visitorRegion, measurementID)) client, err := tm.UpsertClient(ctx, folder, googleanalyticsclient.NewGoogleAnalyticsGA4(NameGoogleAnalyticsGA4Client, enableGeoResolution, visitorRegion, measurementID))
if err != nil { if err != nil {
return err return err
} }
if _, err = tm.UpsertTrigger(folder, servertrigger.NewClient(NameGoogleAnalyticsGA4ClientTrigger, client)); err != nil { if _, err = tm.UpsertTrigger(ctx, folder, servertrigger.NewClient(NameGoogleAnalyticsGA4ClientTrigger, client)); err != nil {
return err return err
} }
} }
{ {
client, err := tm.UpsertClient(folder, googleanalyticsclient.NewMeasurementProtocolGA4(NameMeasurementProtocolGA4Client)) client, err := tm.UpsertClient(ctx, folder, googleanalyticsclient.NewMeasurementProtocolGA4(NameMeasurementProtocolGA4Client))
if err != nil { if err != nil {
return err return err
} }
if _, err = tm.UpsertTrigger(folder, servertrigger.NewClient(NameMeasurementProtocolGA4ClientTrigger, client)); err != nil { if _, err = tm.UpsertTrigger(ctx, folder, servertrigger.NewClient(NameMeasurementProtocolGA4ClientTrigger, client)); err != nil {
return err return err
} }
userDataTemplate, err := tm.UpsertCustomTemplate(servertemplate.NewJSONRequestValue(NameJSONRequestValueTemplate)) userDataTemplate, err := tm.UpsertCustomTemplate(ctx, servertemplate.NewJSONRequestValue(NameJSONRequestValueTemplate))
if err != nil { if err != nil {
return err return err
} }
userDataVariable, err := tm.UpsertVariable(folder, servervariable.NewMPv2Data("user_data", userDataTemplate)) userDataVariable, err := tm.UpsertVariable(ctx, folder, servervariable.NewMPv2Data("user_data", userDataTemplate))
if err != nil { if err != nil {
return err return err
} }
debugModeVariable, err := tm.UpsertVariable(folder, servervariable.NewMPv2Data("debug_mode", userDataTemplate)) debugModeVariable, err := tm.UpsertVariable(ctx, folder, servervariable.NewMPv2Data("debug_mode", userDataTemplate))
if err != nil { if err != nil {
return err return err
} }
_, err = tm.UpsertTransformation(folder, servertransformation.NewMPv2UserData(NameMPv2UserDataTransformation, map[string]*api.Variable{ _, err = tm.UpsertTransformation(ctx, folder, servertransformation.NewMPv2UserData(NameMPv2UserDataTransformation, map[string]*api.Variable{
"user_data": userDataVariable, "user_data": userDataVariable,
"debug_mode": debugModeVariable, "debug_mode": debugModeVariable,
}, client)) }, client))
@ -84,12 +84,12 @@ func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAna
} }
if cfg.GoogleGTagJSOverride.Enabled { if cfg.GoogleGTagJSOverride.Enabled {
template, err := tm.UpsertCustomTemplate(googleanalyticstemplate.NewGoogleGTagClient(NameGoogleGTagClientTemplate)) template, err := tm.UpsertCustomTemplate(ctx, googleanalyticstemplate.NewGoogleGTagClient(NameGoogleGTagClientTemplate))
if err != nil { if err != nil {
return err return err
} }
_, err = tm.UpsertClient(folder, googleanalyticsclient.NewGoogleGTag(NameGoogleGTagClient, cfg.GoogleGTagJSOverride, template)) _, err = tm.UpsertClient(ctx, folder, googleanalyticsclient.NewGoogleGTag(NameGoogleGTagClient, cfg.GoogleGTagJSOverride, template))
if err != nil { if err != nil {
return err return err
} }
@ -105,22 +105,22 @@ func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAna
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.GoogleAnalyticsEventOption var eventTriggerOpts []trigger.GoogleAnalyticsEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.GoogleAnalyticsEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.GoogleAnalyticsEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewGoogleAnalyticsEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewGoogleAnalyticsEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, containertag.NewGoogleAnalytics(event, redactVisitorIP, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, containertag.NewGoogleAnalytics(event, redactVisitorIP, eventTrigger)); err != nil {
return errors.Wrap(err, "failed to upsert google analytics ga4 tag: "+event) return errors.Wrap(err, "failed to upsert google analytics ga4 tag: "+event)
} }
} }

10
pkg/provider/googleanalytics/web.go
View File

@ -13,13 +13,13 @@ import (
) )
func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAnalytics) error { func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAnalytics) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // create event tags { // create event tags
tagID, err := tm.LookupVariable(googletag.NameGoogleTagID) tagID, err := tm.LookupVariable(ctx, googletag.NameGoogleTagID)
if err != nil { if err != nil {
return err return err
} }
@ -30,17 +30,17 @@ func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAnalyt
} }
for event := range eventParameters { for event := range eventParameters {
eventTrigger, err := tm.LookupTrigger(commontrigger.EventName(event)) eventTrigger, err := tm.LookupTrigger(ctx, commontrigger.EventName(event))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to lookup event trigger: "+event) return errors.Wrap(err, "failed to lookup event trigger: "+event)
} }
eventSettings, err := tm.LookupVariable(commonvariable.GoogleTagEventSettingsName(event)) eventSettings, err := tm.LookupVariable(ctx, commonvariable.GoogleTagEventSettingsName(event))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to lookup google tag event setting: "+event) return errors.Wrap(err, "failed to lookup google tag event setting: "+event)
} }
if _, err := tm.UpsertTag(folder, containertag.NewGoogleAnalyticsEvent(event, tagID, eventSettings, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, containertag.NewGoogleAnalyticsEvent(event, tagID, eventSettings, eventTrigger)); err != nil {
return err return err
} }
} }

12
pkg/provider/googleconsent/server.go
View File

@ -1,26 +1,28 @@
package googleconsent package googleconsent
import ( import (
"context"
"github.com/foomo/sesamy-cli/pkg/provider/googleconsent/server/template" "github.com/foomo/sesamy-cli/pkg/provider/googleconsent/server/template"
"github.com/foomo/sesamy-cli/pkg/provider/googleconsent/server/variable" "github.com/foomo/sesamy-cli/pkg/provider/googleconsent/server/variable"
"github.com/foomo/sesamy-cli/pkg/tagmanager" "github.com/foomo/sesamy-cli/pkg/tagmanager"
) )
func ServerEnsure(tm *tagmanager.TagManager) error { func ServerEnsure(ctx context.Context, tm *tagmanager.TagManager) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // create clients { // create clients
consentTemplate, err := tm.UpsertCustomTemplate(template.NewGoogleConsentModeCheck(NameGoogleConsentModeCheckVariableTemplate)) consentTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewGoogleConsentModeCheck(NameGoogleConsentModeCheckVariableTemplate))
if err != nil { if err != nil {
return err return err
} }
if _, err = tm.UpsertVariable(folder, variable.NewGoogleConsentModeAdStorage(consentTemplate)); err != nil { if _, err = tm.UpsertVariable(ctx, folder, variable.NewGoogleConsentModeAdStorage(consentTemplate)); err != nil {
return err return err
} }
if _, err = tm.UpsertVariable(folder, variable.NewGoogleConsentModeAnalyticsStorage(consentTemplate)); err != nil { if _, err = tm.UpsertVariable(ctx, folder, variable.NewGoogleConsentModeAnalyticsStorage(consentTemplate)); err != nil {
return err return err
} }
} }

8
pkg/provider/googletag/server.go
View File

@ -1,19 +1,21 @@
package googletag package googletag
import ( import (
"context"
"github.com/foomo/sesamy-cli/pkg/config" "github.com/foomo/sesamy-cli/pkg/config"
"github.com/foomo/sesamy-cli/pkg/tagmanager" "github.com/foomo/sesamy-cli/pkg/tagmanager"
commonvariable "github.com/foomo/sesamy-cli/pkg/tagmanager/common/variable" commonvariable "github.com/foomo/sesamy-cli/pkg/tagmanager/common/variable"
) )
func Server(tm *tagmanager.TagManager, cfg config.GoogleTag) error { func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTag) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // create constants { // create constants
if _, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameGoogleTagMeasurementID, cfg.TagID)); err != nil { if _, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameGoogleTagMeasurementID, cfg.TagID)); err != nil {
return err return err
} }
} }

24
pkg/provider/googletag/web.go
View File

@ -16,7 +16,7 @@ import (
) )
func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTag) error { func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTag) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
@ -34,23 +34,23 @@ func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTag) e
eventSettings := map[string]*api.Variable{} eventSettings := map[string]*api.Variable{}
for k, v := range cfg.DataLayerVariables { for k, v := range cfg.DataLayerVariables {
dlv, err := tm.UpsertVariable(folder, variable.NewDataLayer(v)) dlv, err := tm.UpsertVariable(ctx, folder, variable.NewDataLayer(v))
if err != nil { if err != nil {
return err return err
} }
eventSettings[k] = dlv eventSettings[k] = dlv
} }
tagID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameGoogleTagID, cfg.TagID)) tagID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameGoogleTagID, cfg.TagID))
if err != nil { if err != nil {
return err return err
} }
settingsVariable, err := tm.UpsertVariable(folder, containervariable.NewGoogleTagConfigurationSettings(NameGoogleTagSettings, configSettings)) settingsVariable, err := tm.UpsertVariable(ctx, folder, containervariable.NewGoogleTagConfigurationSettings(NameGoogleTagSettings, configSettings))
if err != nil { if err != nil {
return err return err
} }
if _, err = tm.UpsertTag(folder, webtag.NewGoogleTag(NameGoogleTag, tagID, settingsVariable, eventSettings)); err != nil { if _, err = tm.UpsertTag(ctx, folder, webtag.NewGoogleTag(NameGoogleTag, tagID, settingsVariable, eventSettings)); err != nil {
return err return err
} }
} }
@ -59,7 +59,7 @@ func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTag) e
} }
func CreateWebEventTriggers(ctx context.Context, tm *tagmanager.TagManager, cfg contemplate.Config) (map[string]map[string]string, error) { func CreateWebEventTriggers(ctx context.Context, tm *tagmanager.TagManager, cfg contemplate.Config) (map[string]map[string]string, error) {
folder, err := tm.LookupFolder("Sesamy - " + Name) folder, err := tm.LookupFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -70,16 +70,16 @@ func CreateWebEventTriggers(ctx context.Context, tm *tagmanager.TagManager, cfg
} }
for event, parameters := range eventParameters { for event, parameters := range eventParameters {
if _, err = tm.UpsertTrigger(folder, commontrigger.NewEvent(event)); err != nil { if _, err = tm.UpsertTrigger(ctx, folder, commontrigger.NewEvent(event)); err != nil {
return nil, err return nil, err
} }
variables, err := CreateWebDatalayerVariables(tm, parameters) variables, err := CreateWebDatalayerVariables(ctx, tm, parameters)
if err != nil { if err != nil {
return nil, err return nil, err
} }
if _, err := tm.UpsertVariable(folder, containervariable.NewGoogleTagEventSettings(event, variables)); err != nil { if _, err := tm.UpsertVariable(ctx, folder, containervariable.NewGoogleTagEventSettings(event, variables)); err != nil {
return nil, err return nil, err
} }
} }
@ -87,15 +87,15 @@ func CreateWebEventTriggers(ctx context.Context, tm *tagmanager.TagManager, cfg
return eventParameters, nil return eventParameters, nil
} }
func CreateWebDatalayerVariables(tm *tagmanager.TagManager, parameters map[string]string) (map[string]*api.Variable, error) { func CreateWebDatalayerVariables(ctx context.Context, tm *tagmanager.TagManager, parameters map[string]string) (map[string]*api.Variable, error) {
folder, err := tm.LookupFolder("Sesamy - " + Name) folder, err := tm.LookupFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return nil, err return nil, err
} }
variables := make(map[string]*api.Variable, len(parameters)) variables := make(map[string]*api.Variable, len(parameters))
for parameterName, parameterValue := range parameters { for parameterName, parameterValue := range parameters {
if variables[parameterName], err = tm.UpsertVariable(folder, variable.NewDataLayer(parameterValue)); err != nil { if variables[parameterName], err = tm.UpsertVariable(ctx, folder, variable.NewDataLayer(parameterValue)); err != nil {
return nil, err return nil, err
} }
} }

16
pkg/provider/googletagmanager/server.go
View File

@ -1,6 +1,8 @@
package googletagmanager package googletagmanager
import ( import (
"context"
"github.com/foomo/sesamy-cli/pkg/config" "github.com/foomo/sesamy-cli/pkg/config"
"github.com/foomo/sesamy-cli/pkg/provider/googletagmanager/server/client" "github.com/foomo/sesamy-cli/pkg/provider/googletagmanager/server/client"
"github.com/foomo/sesamy-cli/pkg/provider/googletagmanager/server/variable" "github.com/foomo/sesamy-cli/pkg/provider/googletagmanager/server/variable"
@ -9,37 +11,37 @@ import (
servervariable "github.com/foomo/sesamy-cli/pkg/tagmanager/server/variable" servervariable "github.com/foomo/sesamy-cli/pkg/tagmanager/server/variable"
) )
func Server(tm *tagmanager.TagManager, cfg config.GoogleTagManager, enableGeoResolution bool) error { func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTagManager, enableGeoResolution bool) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // enable build in variables { // enable build in variables
if _, err := tm.EnableBuiltInVariable("clientName"); err != nil { if _, err := tm.EnableBuiltInVariable(ctx, "clientName"); err != nil {
return err return err
} }
} }
{ // create client { // create client
visitorRegion, err := tm.UpsertVariable(folder, variable.NewVisitorRegion(NameGoogleTagManagerVisitorRegion)) visitorRegion, err := tm.UpsertVariable(ctx, folder, variable.NewVisitorRegion(NameGoogleTagManagerVisitorRegion))
if err != nil { if err != nil {
return err return err
} }
if _, err := tm.UpsertClient(folder, client.NewGoogleTagManagerWebContainer(NameGoogleTagManagerWebContainerClient, cfg.WebContainer.TagID, enableGeoResolution, visitorRegion)); err != nil { if _, err := tm.UpsertClient(ctx, folder, client.NewGoogleTagManagerWebContainer(NameGoogleTagManagerWebContainerClient, cfg.WebContainer.TagID, enableGeoResolution, visitorRegion)); err != nil {
return err return err
} }
} }
{ // create variables { // create variables
for _, value := range cfg.ServerContaienrVariables.EventData { for _, value := range cfg.ServerContaienrVariables.EventData {
if _, err := tm.UpsertVariable(folder, servervariable.NewEventData(value)); err != nil { if _, err := tm.UpsertVariable(ctx, folder, servervariable.NewEventData(value)); err != nil {
return err return err
} }
} }
for key, value := range cfg.ServerContaienrVariables.LookupTables { for key, value := range cfg.ServerContaienrVariables.LookupTables {
if _, err := tm.UpsertVariable(folder, commonvariable.NewLookupTable(key, value)); err != nil { if _, err := tm.UpsertVariable(ctx, folder, commonvariable.NewLookupTable(key, value)); err != nil {
return err return err
} }
} }

6
pkg/provider/googletagmanager/web.go
View File

@ -10,19 +10,19 @@ import (
) )
func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTagManager) error { func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTagManager) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // create variables { // create variables
for _, value := range cfg.WebContaienrVariables.DataLayer { for _, value := range cfg.WebContaienrVariables.DataLayer {
if _, err := tm.UpsertVariable(folder, variable.NewDataLayer(value)); err != nil { if _, err := tm.UpsertVariable(ctx, folder, variable.NewDataLayer(value)); err != nil {
return err return err
} }
} }
for key, value := range cfg.WebContaienrVariables.LookupTables { for key, value := range cfg.WebContaienrVariables.LookupTables {
if _, err := tm.UpsertVariable(folder, commonvariable.NewLookupTable(key, value)); err != nil { if _, err := tm.UpsertVariable(ctx, folder, commonvariable.NewLookupTable(key, value)); err != nil {
return err return err
} }
} }

6
pkg/provider/hotjar/web.go
View File

@ -10,18 +10,18 @@ import (
) )
func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Hotjar) error { func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Hotjar) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // setup hotjar { // setup hotjar
siteID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameSiteID, cfg.SiteID)) siteID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameSiteID, cfg.SiteID))
if err != nil { if err != nil {
return err return err
} }
if _, err = tm.UpsertTag(folder, client.NewHotjar(NameHotjarTag, siteID)); err != nil { if _, err = tm.UpsertTag(ctx, folder, client.NewHotjar(NameHotjarTag, siteID)); err != nil {
return err return err
} }
} }

14
pkg/provider/microsoftads/server.go
View File

@ -17,18 +17,18 @@ import (
) )
func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.MicrosoftAds) error { func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.MicrosoftAds) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
tagID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameTagIDConstant, cfg.TagID)) tagID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameTagIDConstant, cfg.TagID))
if err != nil { if err != nil {
return err return err
} }
if cfg.Conversion.Enabled { if cfg.Conversion.Enabled {
tagTemplate, err := tm.UpsertCustomTemplate(template.NewConversionTag(NameConversionsTagTemplate)) tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewConversionTag(NameConversionsTagTemplate))
if err != nil { if err != nil {
return err return err
} }
@ -42,22 +42,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.ConversionEventOption var eventTriggerOpts []trigger.ConversionEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.ConversionEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.ConversionEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewConversionEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewConversionEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, servertagx.NewConversion(event, tagID, tagTemplate, cfg.Conversion.ServerContainer.Setting(event), eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, servertagx.NewConversion(event, tagID, tagTemplate, cfg.Conversion.ServerContainer.Setting(event), eventTrigger)); err != nil {
return err return err
} }
} }

16
pkg/provider/tracify/server.go
View File

@ -17,23 +17,23 @@ import (
) )
func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Tracify) error { func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg config.Tracify) error {
folder, err := tm.UpsertFolder("Tracify - " + Name) folder, err := tm.UpsertFolder(ctx, "Tracify - "+Name)
if err != nil { if err != nil {
return err return err
} }
{ // conversion { // conversion
token, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameTokenConstant, cfg.Token)) token, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameTokenConstant, cfg.Token))
if err != nil { if err != nil {
return err return err
} }
customerSiteID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameCustomerSiteIDConstant, cfg.CustomerSiteID)) customerSiteID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameCustomerSiteIDConstant, cfg.CustomerSiteID))
if err != nil { if err != nil {
return err return err
} }
tagTemplate, err := tm.UpsertCustomTemplate(template.NewTracifyTag(NameTracifyServerTagTemplate)) tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewTracifyTag(NameTracifyServerTagTemplate))
if err != nil { if err != nil {
return err return err
} }
@ -47,22 +47,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.TracifyEventOption var eventTriggerOpts []trigger.TracifyEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.TracifyEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.TracifyEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewTracifyEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewTracifyEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, servertagx.NewTracify(event, token, customerSiteID, tagTemplate, cfg, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, servertagx.NewTracify(event, token, customerSiteID, tagTemplate, cfg, eventTrigger)); err != nil {
return err return err
} }
} }

12
pkg/provider/umami/server.go
View File

@ -15,12 +15,12 @@ import (
) )
func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.Umami) error { func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.Umami) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name) folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil { if err != nil {
return err return err
} }
template, err := tm.UpsertCustomTemplate(containertemplate.NewUmami(Name)) template, err := tm.UpsertCustomTemplate(ctx, containertemplate.NewUmami(Name))
if err != nil { if err != nil {
return err return err
} }
@ -34,22 +34,22 @@ func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.Umami) er
for event := range eventParameters { for event := range eventParameters {
var eventTriggerOpts []trigger.UmamiEventOption var eventTriggerOpts []trigger.UmamiEventOption
if cfg.GoogleConsent.Enabled { if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil { if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err return err
} }
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode)) consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil { if err != nil {
return err return err
} }
eventTriggerOpts = append(eventTriggerOpts, trigger.UmamiEventWithConsentMode(consentVariable)) eventTriggerOpts = append(eventTriggerOpts, trigger.UmamiEventWithConsentMode(consentVariable))
} }
eventTrigger, err := tm.UpsertTrigger(folder, trigger.NewUmamiEvent(event, eventTriggerOpts...)) eventTrigger, err := tm.UpsertTrigger(ctx, folder, trigger.NewUmamiEvent(event, eventTriggerOpts...))
if err != nil { if err != nil {
return errors.Wrap(err, "failed to upsert event trigger: "+event) return errors.Wrap(err, "failed to upsert event trigger: "+event)
} }
if _, err := tm.UpsertTag(folder, containertag.NewUmami(event, cfg, template, eventTrigger)); err != nil { if _, err := tm.UpsertTag(ctx, folder, containertag.NewUmami(event, cfg, template, eventTrigger)); err != nil {
return err return err
} }
} }

197
pkg/tagmanager/tagmanager.go
View File

@ -28,6 +28,7 @@ type (
clients *AccessedMap[*tagmanager.Client] clients *AccessedMap[*tagmanager.Client]
folders *AccessedMap[*tagmanager.Folder] folders *AccessedMap[*tagmanager.Folder]
variables *AccessedMap[*tagmanager.Variable] variables *AccessedMap[*tagmanager.Variable]
environments *AccessedMap[*tagmanager.Environment]
builtInVariables *AccessedMap[*tagmanager.BuiltInVariable] builtInVariables *AccessedMap[*tagmanager.BuiltInVariable]
triggers *AccessedMap[*tagmanager.Trigger] triggers *AccessedMap[*tagmanager.Trigger]
tags *AccessedMap[*tagmanager.Tag] tags *AccessedMap[*tagmanager.Tag]
@ -198,14 +199,6 @@ func (t *TagManager) WorkspaceID() string {
return t.container.WorkspaceID return t.container.WorkspaceID
} }
// func (t *TagManager) FolderName() string {
// return t.folderName
// }
// func (t *TagManager) SetFolderName(v string) {
// t.folderName = v
// }
func (t *TagManager) Service() *tagmanager.Service { func (t *TagManager) Service() *tagmanager.Service {
if t.requestThrottler != nil { if t.requestThrottler != nil {
<-t.requestThrottler.C <-t.requestThrottler.C
@ -241,8 +234,19 @@ func (t *TagManager) Notes(v any) string {
// ~ Public methods // ~ Public methods
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
func (t *TagManager) LookupClient(name string) (*tagmanager.Client, error) { func (t *TagManager) EnsureWorkspaceID(ctx context.Context) error {
elems, err := t.LoadClients() if t.WorkspaceID() == "" {
environment, err := t.GetEnvironment(ctx, "workspace")
if err != nil {
return err
}
t.container.WorkspaceID = environment.WorkspaceId
}
return nil
}
func (t *TagManager) LookupClient(ctx context.Context, name string) (*tagmanager.Client, error) {
elems, err := t.LoadClients(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -254,10 +258,10 @@ func (t *TagManager) LookupClient(name string) (*tagmanager.Client, error) {
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LoadClients() (*AccessedMap[*tagmanager.Client], error) { func (t *TagManager) LoadClients(ctx context.Context) (*AccessedMap[*tagmanager.Client], error) {
if t.clients == nil { if t.clients == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "Client") t.l.Info("└ ⬇︎ Loading list", "type", "Client")
r, err := t.Service().Accounts.Containers.Workspaces.Clients.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.Clients.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -272,8 +276,8 @@ func (t *TagManager) LoadClients() (*AccessedMap[*tagmanager.Client], error) {
return t.clients, nil return t.clients, nil
} }
func (t *TagManager) LookupFolder(name string) (*tagmanager.Folder, error) { func (t *TagManager) LookupFolder(ctx context.Context, name string) (*tagmanager.Folder, error) {
elems, err := t.LoadFolders() elems, err := t.LoadFolders(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -285,10 +289,10 @@ func (t *TagManager) LookupFolder(name string) (*tagmanager.Folder, error) {
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LoadFolders() (*AccessedMap[*tagmanager.Folder], error) { func (t *TagManager) LoadFolders(ctx context.Context) (*AccessedMap[*tagmanager.Folder], error) {
if t.folders == nil { if t.folders == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "Folder") t.l.Info("└ ⬇︎ Loading list", "type", "Folder")
r, err := t.Service().Accounts.Containers.Workspaces.Folders.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.Folders.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -302,8 +306,8 @@ func (t *TagManager) LoadFolders() (*AccessedMap[*tagmanager.Folder], error) {
return t.folders, nil return t.folders, nil
} }
func (t *TagManager) LookupVariable(name string) (*tagmanager.Variable, error) { func (t *TagManager) LookupVariable(ctx context.Context, name string) (*tagmanager.Variable, error) {
elems, err := t.LoadVariables() elems, err := t.LoadVariables(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -315,10 +319,10 @@ func (t *TagManager) LookupVariable(name string) (*tagmanager.Variable, error) {
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LoadVariables() (*AccessedMap[*tagmanager.Variable], error) { func (t *TagManager) LoadVariables(ctx context.Context) (*AccessedMap[*tagmanager.Variable], error) {
if t.variables == nil { if t.variables == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "Variable") t.l.Info("└ ⬇︎ Loading list", "type", "Variable")
r, err := t.Service().Accounts.Containers.Workspaces.Variables.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.Variables.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -333,8 +337,8 @@ func (t *TagManager) LoadVariables() (*AccessedMap[*tagmanager.Variable], error)
return t.variables, nil return t.variables, nil
} }
func (t *TagManager) GetBuiltInVariable(typeName string) (*tagmanager.BuiltInVariable, error) { func (t *TagManager) GetEnvironment(ctx context.Context, typeName string) (*tagmanager.Environment, error) {
elems, err := t.LoadBuiltInVariables() elems, err := t.LoadEnvironments(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -346,10 +350,41 @@ func (t *TagManager) GetBuiltInVariable(typeName string) (*tagmanager.BuiltInVar
return elems.Get(typeName), nil return elems.Get(typeName), nil
} }
func (t *TagManager) LoadBuiltInVariables() (*AccessedMap[*tagmanager.BuiltInVariable], error) { func (t *TagManager) GetBuiltInVariable(ctx context.Context, typeName string) (*tagmanager.BuiltInVariable, error) {
elems, err := t.LoadBuiltInVariables(ctx)
if err != nil {
return nil, err
}
if !elems.Has(typeName) {
return nil, ErrNotFound
}
return elems.Get(typeName), nil
}
func (t *TagManager) LoadEnvironments(ctx context.Context) (*AccessedMap[*tagmanager.Environment], error) {
if t.builtInVariables == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "Environments")
r, err := t.Service().Accounts.Containers.Environments.List(t.ContainerPath()).Context(ctx).Do()
if err != nil {
return nil, err
}
res := map[string]*tagmanager.Environment{}
for _, value := range r.Environment {
res[value.Type] = value
}
t.environments = NewAccessedMap(res)
}
return t.environments, nil
}
func (t *TagManager) LoadBuiltInVariables(ctx context.Context) (*AccessedMap[*tagmanager.BuiltInVariable], error) {
if t.builtInVariables == nil { if t.builtInVariables == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "BuiltInVariable") t.l.Info("└ ⬇︎ Loading list", "type", "BuiltInVariable")
r, err := t.Service().Accounts.Containers.Workspaces.BuiltInVariables.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.BuiltInVariables.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -364,8 +399,8 @@ func (t *TagManager) LoadBuiltInVariables() (*AccessedMap[*tagmanager.BuiltInVar
return t.builtInVariables, nil return t.builtInVariables, nil
} }
func (t *TagManager) LookupTrigger(name string) (*tagmanager.Trigger, error) { func (t *TagManager) LookupTrigger(ctx context.Context, name string) (*tagmanager.Trigger, error) {
elems, err := t.LoadTriggers() elems, err := t.LoadTriggers(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -377,8 +412,8 @@ func (t *TagManager) LookupTrigger(name string) (*tagmanager.Trigger, error) {
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LookupTemplate(name string) (*tagmanager.CustomTemplate, error) { func (t *TagManager) LookupTemplate(ctx context.Context, name string) (*tagmanager.CustomTemplate, error) {
elems, err := t.LoadCustomTemplates() elems, err := t.LoadCustomTemplates(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -390,8 +425,8 @@ func (t *TagManager) LookupTemplate(name string) (*tagmanager.CustomTemplate, er
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LookupTransformation(name string) (*tagmanager.Transformation, error) { func (t *TagManager) LookupTransformation(ctx context.Context, name string) (*tagmanager.Transformation, error) {
elems, err := t.LoadTransformations() elems, err := t.LoadTransformations(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -403,10 +438,10 @@ func (t *TagManager) LookupTransformation(name string) (*tagmanager.Transformati
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LoadTriggers() (*AccessedMap[*tagmanager.Trigger], error) { func (t *TagManager) LoadTriggers(ctx context.Context) (*AccessedMap[*tagmanager.Trigger], error) {
if t.triggers == nil { if t.triggers == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "Trigger") t.l.Info("└ ⬇︎ Loading list", "type", "Trigger")
r, err := t.Service().Accounts.Containers.Workspaces.Triggers.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.Triggers.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -421,8 +456,8 @@ func (t *TagManager) LoadTriggers() (*AccessedMap[*tagmanager.Trigger], error) {
return t.triggers, nil return t.triggers, nil
} }
func (t *TagManager) LookupTag(name string) (*tagmanager.Tag, error) { func (t *TagManager) LookupTag(ctx context.Context, name string) (*tagmanager.Tag, error) {
elems, err := t.LoadTags() elems, err := t.LoadTags(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -434,10 +469,10 @@ func (t *TagManager) LookupTag(name string) (*tagmanager.Tag, error) {
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LoadTags() (*AccessedMap[*tagmanager.Tag], error) { func (t *TagManager) LoadTags(ctx context.Context) (*AccessedMap[*tagmanager.Tag], error) {
if t.tags == nil { if t.tags == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "Tag") t.l.Info("└ ⬇︎ Loading list", "type", "Tag")
r, err := t.Service().Accounts.Containers.Workspaces.Tags.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.Tags.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -452,8 +487,8 @@ func (t *TagManager) LoadTags() (*AccessedMap[*tagmanager.Tag], error) {
return t.tags, nil return t.tags, nil
} }
func (t *TagManager) CustomTemplate(name string) (*tagmanager.CustomTemplate, error) { func (t *TagManager) CustomTemplate(ctx context.Context, name string) (*tagmanager.CustomTemplate, error) {
elems, err := t.LoadCustomTemplates() elems, err := t.LoadCustomTemplates(ctx)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -465,10 +500,10 @@ func (t *TagManager) CustomTemplate(name string) (*tagmanager.CustomTemplate, er
return elems.Get(name), nil return elems.Get(name), nil
} }
func (t *TagManager) LoadCustomTemplates() (*AccessedMap[*tagmanager.CustomTemplate], error) { func (t *TagManager) LoadCustomTemplates(ctx context.Context) (*AccessedMap[*tagmanager.CustomTemplate], error) {
if t.customTemplates == nil { if t.customTemplates == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "CustomTemplate") t.l.Info("└ ⬇︎ Loading list", "type", "CustomTemplate")
r, err := t.Service().Accounts.Containers.Workspaces.Templates.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.Templates.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -483,10 +518,10 @@ func (t *TagManager) LoadCustomTemplates() (*AccessedMap[*tagmanager.CustomTempl
return t.customTemplates, nil return t.customTemplates, nil
} }
func (t *TagManager) LoadTransformations() (*AccessedMap[*tagmanager.Transformation], error) { func (t *TagManager) LoadTransformations(ctx context.Context) (*AccessedMap[*tagmanager.Transformation], error) {
if t.transformations == nil { if t.transformations == nil {
t.l.Info("└ ⬇︎ Loading list", "type", "Transformation") t.l.Info("└ ⬇︎ Loading list", "type", "Transformation")
r, err := t.Service().Accounts.Containers.Workspaces.Transformations.List(t.WorkspacePath()).Do() r, err := t.Service().Accounts.Containers.Workspaces.Transformations.List(t.WorkspacePath()).Context(ctx).Do()
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -501,7 +536,7 @@ func (t *TagManager) LoadTransformations() (*AccessedMap[*tagmanager.Transformat
return t.transformations, nil return t.transformations, nil
} }
func (t *TagManager) UpsertClient(folder *tagmanager.Folder, item *tagmanager.Client) (*tagmanager.Client, error) { func (t *TagManager) UpsertClient(ctx context.Context, folder *tagmanager.Folder, item *tagmanager.Client) (*tagmanager.Client, error) {
l := t.l.With("type", "Client", "name", item.Name) l := t.l.With("type", "Client", "name", item.Name)
item.ParentFolderId = folder.FolderId item.ParentFolderId = folder.FolderId
@ -511,7 +546,7 @@ func (t *TagManager) UpsertClient(folder *tagmanager.Folder, item *tagmanager.Cl
item.ContainerId = t.ContainerID() item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID() item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupClient(item.Name) cache, err := t.LookupClient(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -519,13 +554,13 @@ func (t *TagManager) UpsertClient(folder *tagmanager.Folder, item *tagmanager.Cl
var value *tagmanager.Client var value *tagmanager.Client
if cache == nil { if cache == nil {
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
value, err = t.Service().Accounts.Containers.Workspaces.Clients.Create(t.WorkspacePath(), item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Clients.Create(t.WorkspacePath(), item).Context(ctx).Do()
t.clients.Set(item.Name, value) t.clients.Set(item.Name, value)
} else if item.Notes == cache.Notes { } else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.ClientId) l.Info("└ ✔︎ OK", "id", cache.ClientId)
} else { } else {
l.Info("└ 🔄 Update", "id", cache.ClientId) l.Info("└ 🔄 Update", "id", cache.ClientId)
value, err = t.Service().Accounts.Containers.Workspaces.Clients.Update(t.WorkspacePath()+"/clients/"+cache.ClientId, item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Clients.Update(t.WorkspacePath()+"/clients/"+cache.ClientId, item).Context(ctx).Do()
t.clients.Set(item.Name, value) t.clients.Set(item.Name, value)
} }
if err != nil { if err != nil {
@ -535,10 +570,10 @@ func (t *TagManager) UpsertClient(folder *tagmanager.Folder, item *tagmanager.Cl
return nil, err return nil, err
} }
return t.LookupClient(item.Name) return t.LookupClient(ctx, item.Name)
} }
func (t *TagManager) UpsertTransformation(folder *tagmanager.Folder, item *tagmanager.Transformation) (*tagmanager.Transformation, error) { func (t *TagManager) UpsertTransformation(ctx context.Context, folder *tagmanager.Folder, item *tagmanager.Transformation) (*tagmanager.Transformation, error) {
l := t.l.With("type", "Transformation", "name", item.Name) l := t.l.With("type", "Transformation", "name", item.Name)
item.ParentFolderId = folder.FolderId item.ParentFolderId = folder.FolderId
@ -548,7 +583,7 @@ func (t *TagManager) UpsertTransformation(folder *tagmanager.Folder, item *tagma
item.ContainerId = t.ContainerID() item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID() item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupTransformation(item.Name) cache, err := t.LookupTransformation(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -556,13 +591,13 @@ func (t *TagManager) UpsertTransformation(folder *tagmanager.Folder, item *tagma
var value *tagmanager.Transformation var value *tagmanager.Transformation
if cache == nil { if cache == nil {
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
value, err = t.Service().Accounts.Containers.Workspaces.Transformations.Create(t.WorkspacePath(), item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Transformations.Create(t.WorkspacePath(), item).Context(ctx).Do()
t.transformations.Set(item.Name, value) t.transformations.Set(item.Name, value)
} else if item.Notes == cache.Notes { } else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.TransformationId) l.Info("└ ✔︎ OK", "id", cache.TransformationId)
} else { } else {
l.Info("└ 🔄 Update", "id", cache.TransformationId) l.Info("└ 🔄 Update", "id", cache.TransformationId)
value, err = t.Service().Accounts.Containers.Workspaces.Transformations.Update(t.WorkspacePath()+"/transformations/"+cache.TransformationId, item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Transformations.Update(t.WorkspacePath()+"/transformations/"+cache.TransformationId, item).Context(ctx).Do()
t.transformations.Set(item.Name, value) t.transformations.Set(item.Name, value)
} }
if err != nil { if err != nil {
@ -571,10 +606,10 @@ func (t *TagManager) UpsertTransformation(folder *tagmanager.Folder, item *tagma
} }
return nil, err return nil, err
} }
return t.LookupTransformation(item.Name) return t.LookupTransformation(ctx, item.Name)
} }
func (t *TagManager) UpsertFolder(name string) (*tagmanager.Folder, error) { func (t *TagManager) UpsertFolder(ctx context.Context, name string) (*tagmanager.Folder, error) {
l := t.l.With("type", "Folder", "name", name) l := t.l.With("type", "Folder", "name", name)
item := &tagmanager.Folder{ item := &tagmanager.Folder{
@ -586,7 +621,7 @@ func (t *TagManager) UpsertFolder(name string) (*tagmanager.Folder, error) {
item.ContainerId = t.ContainerID() item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID() item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupFolder(name) cache, err := t.LookupFolder(ctx, name)
if err != nil && !errors.Is(err, ErrNotFound) && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -594,13 +629,13 @@ func (t *TagManager) UpsertFolder(name string) (*tagmanager.Folder, error) {
var value *tagmanager.Folder var value *tagmanager.Folder
if cache == nil { if cache == nil {
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
value, err = t.Service().Accounts.Containers.Workspaces.Folders.Create(t.WorkspacePath(), item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Folders.Create(t.WorkspacePath(), item).Context(ctx).Do()
t.folders.Set(item.Name, value) t.folders.Set(item.Name, value)
} else if item.Notes == cache.Notes { } else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", item.FolderId) l.Info("└ ✔︎ OK", "id", item.FolderId)
} else { } else {
l.Info("└ 🔄 Update", "id", cache.FolderId) l.Info("└ 🔄 Update", "id", cache.FolderId)
value, err = t.Service().Accounts.Containers.Workspaces.Folders.Update(t.WorkspacePath()+"/folders/"+cache.FolderId, item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Folders.Update(t.WorkspacePath()+"/folders/"+cache.FolderId, item).Context(ctx).Do()
t.folders.Set(item.Name, value) t.folders.Set(item.Name, value)
} }
if err != nil { if err != nil {
@ -610,10 +645,10 @@ func (t *TagManager) UpsertFolder(name string) (*tagmanager.Folder, error) {
return nil, err return nil, err
} }
return t.LookupFolder(name) return t.LookupFolder(ctx, name)
} }
func (t *TagManager) UpsertVariable(folder *tagmanager.Folder, item *tagmanager.Variable) (*tagmanager.Variable, error) { func (t *TagManager) UpsertVariable(ctx context.Context, folder *tagmanager.Folder, item *tagmanager.Variable) (*tagmanager.Variable, error) {
l := t.l.With("type", "Variable", "name", item.Name) l := t.l.With("type", "Variable", "name", item.Name)
item.ParentFolderId = folder.FolderId item.ParentFolderId = folder.FolderId
@ -623,7 +658,7 @@ func (t *TagManager) UpsertVariable(folder *tagmanager.Folder, item *tagmanager.
item.ContainerId = t.ContainerID() item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID() item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupVariable(item.Name) cache, err := t.LookupVariable(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -631,13 +666,13 @@ func (t *TagManager) UpsertVariable(folder *tagmanager.Folder, item *tagmanager.
var value *tagmanager.Variable var value *tagmanager.Variable
if cache == nil { if cache == nil {
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
value, err = t.Service().Accounts.Containers.Workspaces.Variables.Create(t.WorkspacePath(), item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Variables.Create(t.WorkspacePath(), item).Context(ctx).Do()
t.variables.Set(item.Name, value) t.variables.Set(item.Name, value)
} else if item.Notes == cache.Notes { } else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.VariableId) l.Info("└ ✔︎ OK", "id", cache.VariableId)
} else { } else {
l.Info("└ 🔄 Update", "id", cache.VariableId) l.Info("└ 🔄 Update", "id", cache.VariableId)
value, err = t.Service().Accounts.Containers.Workspaces.Variables.Update(t.WorkspacePath()+"/variables/"+cache.VariableId, item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Variables.Update(t.WorkspacePath()+"/variables/"+cache.VariableId, item).Context(ctx).Do()
t.variables.Set(item.Name, value) t.variables.Set(item.Name, value)
} }
if err != nil { if err != nil {
@ -647,13 +682,13 @@ func (t *TagManager) UpsertVariable(folder *tagmanager.Folder, item *tagmanager.
return nil, err return nil, err
} }
return t.LookupVariable(item.Name) return t.LookupVariable(ctx, item.Name)
} }
func (t *TagManager) EnableBuiltInVariable(typeName string) (*tagmanager.BuiltInVariable, error) { func (t *TagManager) EnableBuiltInVariable(ctx context.Context, typeName string) (*tagmanager.BuiltInVariable, error) {
l := t.l.With("type", "Built-In Variable", "typeName", typeName) l := t.l.With("type", "Built-In Variable", "typeName", typeName)
cache, err := t.GetBuiltInVariable(typeName) cache, err := t.GetBuiltInVariable(ctx, typeName)
if err != nil && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -664,7 +699,7 @@ func (t *TagManager) EnableBuiltInVariable(typeName string) (*tagmanager.BuiltIn
} }
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
resp, err := t.Service().Accounts.Containers.Workspaces.BuiltInVariables.Create(t.WorkspacePath()).Type(typeName).Do() resp, err := t.Service().Accounts.Containers.Workspaces.BuiltInVariables.Create(t.WorkspacePath()).Type(typeName).Context(ctx).Do()
if err != nil { if err != nil {
return nil, errors.Wrap(err, "failed to create built-in variable") return nil, errors.Wrap(err, "failed to create built-in variable")
} }
@ -673,10 +708,10 @@ func (t *TagManager) EnableBuiltInVariable(typeName string) (*tagmanager.BuiltIn
t.builtInVariables.Set(builtInVariable.Type, builtInVariable) t.builtInVariables.Set(builtInVariable.Type, builtInVariable)
} }
return t.GetBuiltInVariable(typeName) return t.GetBuiltInVariable(ctx, typeName)
} }
func (t *TagManager) UpsertTrigger(folder *tagmanager.Folder, item *tagmanager.Trigger) (*tagmanager.Trigger, error) { func (t *TagManager) UpsertTrigger(ctx context.Context, folder *tagmanager.Folder, item *tagmanager.Trigger) (*tagmanager.Trigger, error) {
l := t.l.With("type", "Trigger", "name", item.Name) l := t.l.With("type", "Trigger", "name", item.Name)
item.ParentFolderId = folder.FolderId item.ParentFolderId = folder.FolderId
@ -686,7 +721,7 @@ func (t *TagManager) UpsertTrigger(folder *tagmanager.Folder, item *tagmanager.T
item.ContainerId = t.ContainerID() item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID() item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupTrigger(item.Name) cache, err := t.LookupTrigger(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -694,13 +729,13 @@ func (t *TagManager) UpsertTrigger(folder *tagmanager.Folder, item *tagmanager.T
var value *tagmanager.Trigger var value *tagmanager.Trigger
if cache == nil { if cache == nil {
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
value, err = t.Service().Accounts.Containers.Workspaces.Triggers.Create(t.WorkspacePath(), item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Triggers.Create(t.WorkspacePath(), item).Context(ctx).Do()
t.triggers.Set(item.Name, value) t.triggers.Set(item.Name, value)
} else if item.Notes == cache.Notes { } else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.TriggerId) l.Info("└ ✔︎ OK", "id", cache.TriggerId)
} else { } else {
l.Info("└ 🔄 Update", "id", cache.TriggerId) l.Info("└ 🔄 Update", "id", cache.TriggerId)
value, err = t.Service().Accounts.Containers.Workspaces.Triggers.Update(t.WorkspacePath()+"/triggers/"+cache.TriggerId, item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Triggers.Update(t.WorkspacePath()+"/triggers/"+cache.TriggerId, item).Context(ctx).Do()
t.triggers.Set(item.Name, value) t.triggers.Set(item.Name, value)
} }
if err != nil { if err != nil {
@ -710,10 +745,10 @@ func (t *TagManager) UpsertTrigger(folder *tagmanager.Folder, item *tagmanager.T
return nil, err return nil, err
} }
return t.LookupTrigger(item.Name) return t.LookupTrigger(ctx, item.Name)
} }
func (t *TagManager) UpsertTag(folder *tagmanager.Folder, item *tagmanager.Tag) (*tagmanager.Tag, error) { func (t *TagManager) UpsertTag(ctx context.Context, folder *tagmanager.Folder, item *tagmanager.Tag) (*tagmanager.Tag, error) {
l := t.l.With("type", "Tag", "name", item.Name) l := t.l.With("type", "Tag", "name", item.Name)
item.ParentFolderId = folder.FolderId item.ParentFolderId = folder.FolderId
@ -723,7 +758,7 @@ func (t *TagManager) UpsertTag(folder *tagmanager.Folder, item *tagmanager.Tag)
item.ContainerId = t.ContainerID() item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID() item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupTag(item.Name) cache, err := t.LookupTag(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -731,13 +766,13 @@ func (t *TagManager) UpsertTag(folder *tagmanager.Folder, item *tagmanager.Tag)
var value *tagmanager.Tag var value *tagmanager.Tag
if cache == nil { if cache == nil {
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
value, err = t.Service().Accounts.Containers.Workspaces.Tags.Create(t.WorkspacePath(), item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Tags.Create(t.WorkspacePath(), item).Context(ctx).Do()
t.tags.Set(item.Name, value) t.tags.Set(item.Name, value)
} else if item.Notes == cache.Notes { } else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.TagId) l.Info("└ ✔︎ OK", "id", cache.TagId)
} else { } else {
l.Info("└ 🔄 Update", "id", cache.TagId) l.Info("└ 🔄 Update", "id", cache.TagId)
value, err = t.Service().Accounts.Containers.Workspaces.Tags.Update(t.WorkspacePath()+"/tags/"+cache.TagId, item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Tags.Update(t.WorkspacePath()+"/tags/"+cache.TagId, item).Context(ctx).Do()
t.tags.Set(item.Name, value) t.tags.Set(item.Name, value)
} }
if err != nil { if err != nil {
@ -746,17 +781,17 @@ func (t *TagManager) UpsertTag(folder *tagmanager.Folder, item *tagmanager.Tag)
} }
return nil, err return nil, err
} }
return t.LookupTag(item.Name) return t.LookupTag(ctx, item.Name)
} }
func (t *TagManager) UpsertCustomTemplate(item *tagmanager.CustomTemplate) (*tagmanager.CustomTemplate, error) { func (t *TagManager) UpsertCustomTemplate(ctx context.Context, item *tagmanager.CustomTemplate) (*tagmanager.CustomTemplate, error) {
l := t.l.With("type", "CustomTemplate", "name", item.Name) l := t.l.With("type", "CustomTemplate", "name", item.Name)
item.AccountId = t.AccountID() item.AccountId = t.AccountID()
item.ContainerId = t.ContainerID() item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID() item.WorkspaceId = t.WorkspaceID()
cache, err := t.CustomTemplate(item.Name) cache, err := t.CustomTemplate(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) { if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err return nil, err
} }
@ -764,13 +799,13 @@ func (t *TagManager) UpsertCustomTemplate(item *tagmanager.CustomTemplate) (*tag
var value *tagmanager.CustomTemplate var value *tagmanager.CustomTemplate
if cache == nil { if cache == nil {
l.Info("└ 🚀 New") l.Info("└ 🚀 New")
value, err = t.Service().Accounts.Containers.Workspaces.Templates.Create(t.WorkspacePath(), item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Templates.Create(t.WorkspacePath(), item).Context(ctx).Do()
t.customTemplates.Set(item.Name, value) t.customTemplates.Set(item.Name, value)
} else if item.TemplateData == cache.TemplateData { } else if item.TemplateData == cache.TemplateData {
l.Info("└ ✔︎ OK", "id", cache.TemplateId) l.Info("└ ✔︎ OK", "id", cache.TemplateId)
} else { } else {
l.Info("└ 🔄 Update", "id", cache.TemplateId) l.Info("└ 🔄 Update", "id", cache.TemplateId)
value, err = t.Service().Accounts.Containers.Workspaces.Templates.Update(t.WorkspacePath()+"/templates/"+cache.TemplateId, item).Do() value, err = t.Service().Accounts.Containers.Workspaces.Templates.Update(t.WorkspacePath()+"/templates/"+cache.TemplateId, item).Context(ctx).Do()
t.customTemplates.Set(item.Name, value) t.customTemplates.Set(item.Name, value)
} }
if err != nil { if err != nil {
@ -779,5 +814,5 @@ func (t *TagManager) UpsertCustomTemplate(item *tagmanager.CustomTemplate) (*tag
} }
return nil, err return nil, err
} }
return t.CustomTemplate(item.Name) return t.CustomTemplate(ctx, item.Name)
} }

4
sesamy.yaml
View File

@ -26,7 +26,7 @@ googleTagManager:
tagId: GTM-57BHX34G tagId: GTM-57BHX34G
# The container id # The container id
containerId: '175355532' containerId: '175355532'
# The workspace id that should be used by the api # (Optional) The workspace id that should be used by the api
workspaceId: '23' workspaceId: '23'
# Server container settings # Server container settings
serverContainer: serverContainer:
@ -34,7 +34,7 @@ googleTagManager:
tagId: GTM-5NWPR4QW tagId: GTM-5NWPR4QW
# The container id # The container id
containerId: '175348980' containerId: '175348980'
# The workspace id that should be used by the api # (Optional) The workspace id that should be used by the api
workspaceId: '10' workspaceId: '10'
# Web container variables # Web container variables
webContainerVariables: webContainerVariables:

5
test/tagmanager/clientserver_test.go
View File

@ -35,10 +35,11 @@ func TestNewClient_Server(t *testing.T) {
), ),
) )
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, c.EnsureWorkspaceID(t.Context()))
{ // --- Folders --- { // --- Folders ---
t.Run("upsert folder", func(t *testing.T) { t.Run("upsert folder", func(t *testing.T) {
obj, err := c.UpsertFolder("Sesamy") obj, err := c.UpsertFolder(t.Context(), "Sesamy")
require.NoError(t, err) require.NoError(t, err)
dump(t, obj) dump(t, obj)
}) })
@ -113,7 +114,7 @@ func TestNewClient_Server(t *testing.T) {
{ // --- Templates --- { // --- Templates ---
t.Run("upsert template", func(t *testing.T) { t.Run("upsert template", func(t *testing.T) {
obj, err := c.UpsertCustomTemplate(template.NewGoogleConsentModeCheck("TESTOMAT")) obj, err := c.UpsertCustomTemplate(t.Context(), template.NewGoogleConsentModeCheck("TESTOMAT"))
require.NoError(t, err) require.NoError(t, err)
dump(t, obj) dump(t, obj)
}) })

3
test/tagmanager/clientweb_test.go
View File

@ -35,6 +35,7 @@ func TestNewClient_Web(t *testing.T) {
), ),
) )
require.NoError(t, err) require.NoError(t, err)
require.NoError(t, c.EnsureWorkspaceID(t.Context()))
{ // --- Containers --- { // --- Containers ---
t.Run("list containers", func(t *testing.T) { t.Run("list containers", func(t *testing.T) {
@ -91,7 +92,7 @@ func TestNewClient_Web(t *testing.T) {
}) })
t.Run("upsert folder", func(t *testing.T) { t.Run("upsert folder", func(t *testing.T) {
obj, err := c.UpsertFolder(name) obj, err := c.UpsertFolder(t.Context(), name)
require.NoError(t, err) require.NoError(t, err)
t.Log("ID: " + obj.FolderId) t.Log("ID: " + obj.FolderId)
}) })