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
# The container id
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'
# Server container settings
serverContainer:
@ -88,7 +88,7 @@ googleTagManager:
tagId: GTM-5NWPR4QW
# The container id
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'
# Web container variables
webContainerVariables:

29
cmd/list/list.go
View File

@ -2,6 +2,7 @@ package list
import (
"bytes"
"context"
"fmt"
"log/slog"
"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")
}
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 {
case "environments":
return dump(tm.Service().Accounts.Containers.Environments.List(tm.ContainerPath()).Context(ctx).Do())
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":
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":
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":
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":
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":
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":
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":
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 {
return err
}
@ -59,13 +62,13 @@ func list(l *slog.Logger, tm *tagmanager.TagManager, resource string) error {
}
return nil
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":
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":
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":
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:
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{
"built-in-variables",
"clients",
"environments",
"folders",
"gtag-config",
"status",
@ -48,7 +49,11 @@ func NewServer(root *cobra.Command) {
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,
ValidArgs: []cobra.Completion{
"built-in-variables",
"environments",
"folders",
"gtag-config",
"status",
@ -47,7 +48,11 @@ func NewWeb(root *cobra.Command) {
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
}
if err := tm.EnsureWorkspaceID(cmd.Context()); err != nil {
return err
}
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")
}
}
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")
}
}
@ -72,7 +76,7 @@ func NewServer(root *cobra.Command) {
if cfg.ConversionLinker.Enabled && pkgcmd.Tag(conversionlinkerprovider.Tag, tags) {
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")
}
}

4
cmd/provision/web.go
View File

@ -47,6 +47,10 @@ func NewWeb(root *cobra.Command) {
return err
}
if err := tm.EnsureWorkspaceID(cmd.Context()); err != nil {
return err
}
if pkgcmd.Tag(googletagprovider.Tag, tags) {
l.Info("🅿️ Running provider", "name", googletagprovider.Name, "tag", googletagprovider.Tag)
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"`
// The container id
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"`
}

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

@ -1,6 +1,8 @@
package conversionlinker
import (
"context"
"github.com/foomo/sesamy-cli/pkg/config"
containertag "github.com/foomo/sesamy-cli/pkg/provider/conversionlinker/server/tag"
"github.com/foomo/sesamy-cli/pkg/provider/conversionlinker/server/trigger"
@ -10,30 +12,30 @@ import (
"github.com/pkg/errors"
)
func Server(tm *tagmanager.TagManager, cfg config.ConversionLinker) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.ConversionLinker) error {
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
var eventTriggerOpts []trigger.ConversionLinkerEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // create event tags
temmplate, err := tm.LookupTemplate(cfg.TemplateName)
temmplate, err := tm.LookupTemplate(ctx, cfg.TemplateName)
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")
}
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
template, err := tm.LookupTemplate(NameCriteoEventsAPITemplate)
template, err := tm.LookupTemplate(ctx, NameCriteoEventsAPITemplate)
if err != nil {
if errors.Is(err, tagmanager.ErrNotFound) {
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
callerID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID))
callerID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID))
if err != nil {
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 {
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 {
return err
}
@ -53,22 +53,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters {
var eventTriggerOpts []trigger.CriteoEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
template, err := tm.LookupTemplate(NameCriteoUserIdentificationTemplate)
template, err := tm.LookupTemplate(ctx, NameCriteoUserIdentificationTemplate)
if err != nil {
if errors.Is(err, tagmanager.ErrNotFound) {
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
callerID, err := tm.UpsertVariable(folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID))
callerID, err := tm.UpsertVariable(ctx, folder, commonvariable.NewConstant(NameCallerID, cfg.CallerID))
if err != nil {
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // 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 {
return err
}
tagTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysWebExtendTag(NameServerEmarsysWebExtendTagTemplate))
tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewEmarsysWebExtendTag(NameServerEmarsysWebExtendTagTemplate))
if err != nil {
return err
}
clientTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysInitializationClient(NameServerEmarsysInitalizationClientTemplate))
clientTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewEmarsysInitializationClient(NameServerEmarsysInitalizationClientTemplate))
if err != nil {
return err
}
_, err = tm.UpsertClient(folder, serverclientx.NewEmarsys(NameServerEmarsysClient, cfg, clientTemplate))
_, err = tm.UpsertClient(ctx, folder, serverclientx.NewEmarsys(NameServerEmarsysClient, cfg, clientTemplate))
if err != nil {
return err
}
@ -53,22 +53,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters {
var eventTriggerOpts []trigger.EmarsysEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // create initialization tag
tagTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysInitializationTag(NameWebEmarsysInitalizationTagTemplate))
tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewEmarsysInitializationTag(NameWebEmarsysInitalizationTagTemplate))
if err != nil {
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
}
}
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",
}); err != nil {
return err
}
{ // create event tags
tagID, err := tm.LookupVariable(googletag.NameGoogleTagID)
tagID, err := tm.LookupVariable(ctx, googletag.NameGoogleTagID)
if err != nil {
return err
}
@ -49,17 +49,17 @@ func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.Emarsys) err
}
for event := range eventParameters {
eventTrigger, err := tm.LookupTrigger(commontrigger.EventName(event))
eventTrigger, err := tm.LookupTrigger(ctx, commontrigger.EventName(event))
if err != nil {
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
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 {
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 {
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 {
return err
}
template, err := tm.LookupTemplate(NameConversionsAPITagTemplate)
template, err := tm.LookupTemplate(ctx, NameConversionsAPITagTemplate)
if err != nil {
if errors.Is(err, tagmanager.ErrNotFound) {
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 {
var eventTriggerOpts []trigger.FacebookEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
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 {
return err
}
// conversion
if cfg.Conversion.Enabled {
value, err := tm.UpsertVariable(folder, variable.NewEventData("value"))
value, err := tm.UpsertVariable(ctx, folder, variable.NewEventData("value"))
if err != nil {
return err
}
currency, err := tm.UpsertVariable(folder, variable.NewEventData("currency"))
currency, err := tm.UpsertVariable(ctx, folder, variable.NewEventData("currency"))
if err != nil {
return err
}
@ -48,22 +48,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters {
var eventTriggerOpts []trigger.GoogleAdsEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}
@ -73,22 +73,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
if cfg.Remarketing.Enabled {
var eventTriggerOpts []trigger.GoogleAdsRemarketingEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // create clients
{
measurementID, err := tm.LookupVariable(googletag.NameGoogleTagMeasurementID)
measurementID, err := tm.LookupVariable(ctx, googletag.NameGoogleTagMeasurementID)
if err != nil {
return err
}
visitorRegion, err := tm.LookupVariable(googletagmanager.NameGoogleTagManagerVisitorRegion)
visitorRegion, err := tm.LookupVariable(ctx, googletagmanager.NameGoogleTagManagerVisitorRegion)
if err != nil {
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 {
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
}
}
{
client, err := tm.UpsertClient(folder, googleanalyticsclient.NewMeasurementProtocolGA4(NameMeasurementProtocolGA4Client))
client, err := tm.UpsertClient(ctx, folder, googleanalyticsclient.NewMeasurementProtocolGA4(NameMeasurementProtocolGA4Client))
if err != nil {
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
}
userDataTemplate, err := tm.UpsertCustomTemplate(servertemplate.NewJSONRequestValue(NameJSONRequestValueTemplate))
userDataTemplate, err := tm.UpsertCustomTemplate(ctx, servertemplate.NewJSONRequestValue(NameJSONRequestValueTemplate))
if err != nil {
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 {
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 {
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,
"debug_mode": debugModeVariable,
}, client))
@ -84,12 +84,12 @@ func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAna
}
if cfg.GoogleGTagJSOverride.Enabled {
template, err := tm.UpsertCustomTemplate(googleanalyticstemplate.NewGoogleGTagClient(NameGoogleGTagClientTemplate))
template, err := tm.UpsertCustomTemplate(ctx, googleanalyticstemplate.NewGoogleGTagClient(NameGoogleGTagClientTemplate))
if err != nil {
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 {
return err
}
@ -105,22 +105,22 @@ func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAna
for event := range eventParameters {
var eventTriggerOpts []trigger.GoogleAnalyticsEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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)
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // create event tags
tagID, err := tm.LookupVariable(googletag.NameGoogleTagID)
tagID, err := tm.LookupVariable(ctx, googletag.NameGoogleTagID)
if err != nil {
return err
}
@ -30,17 +30,17 @@ func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleAnalyt
}
for event := range eventParameters {
eventTrigger, err := tm.LookupTrigger(commontrigger.EventName(event))
eventTrigger, err := tm.LookupTrigger(ctx, commontrigger.EventName(event))
if err != nil {
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 {
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
}
}

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

@ -1,26 +1,28 @@
package googleconsent
import (
"context"
"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/tagmanager"
)
func ServerEnsure(tm *tagmanager.TagManager) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
func ServerEnsure(ctx context.Context, tm *tagmanager.TagManager) error {
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // create clients
consentTemplate, err := tm.UpsertCustomTemplate(template.NewGoogleConsentModeCheck(NameGoogleConsentModeCheckVariableTemplate))
consentTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewGoogleConsentModeCheck(NameGoogleConsentModeCheckVariableTemplate))
if err != nil {
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
}
if _, err = tm.UpsertVariable(folder, variable.NewGoogleConsentModeAnalyticsStorage(consentTemplate)); err != nil {
if _, err = tm.UpsertVariable(ctx, folder, variable.NewGoogleConsentModeAnalyticsStorage(consentTemplate)); err != nil {
return err
}
}

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

@ -1,19 +1,21 @@
package googletag
import (
"context"
"github.com/foomo/sesamy-cli/pkg/config"
"github.com/foomo/sesamy-cli/pkg/tagmanager"
commonvariable "github.com/foomo/sesamy-cli/pkg/tagmanager/common/variable"
)
func Server(tm *tagmanager.TagManager, cfg config.GoogleTag) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTag) error {
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // 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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
@ -34,23 +34,23 @@ func Web(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTag) e
eventSettings := map[string]*api.Variable{}
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 {
return err
}
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 {
return err
}
settingsVariable, err := tm.UpsertVariable(folder, containervariable.NewGoogleTagConfigurationSettings(NameGoogleTagSettings, configSettings))
settingsVariable, err := tm.UpsertVariable(ctx, folder, containervariable.NewGoogleTagConfigurationSettings(NameGoogleTagSettings, configSettings))
if err != nil {
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
}
}
@ -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) {
folder, err := tm.LookupFolder("Sesamy - " + Name)
folder, err := tm.LookupFolder(ctx, "Sesamy - "+Name)
if err != nil {
return nil, err
}
@ -70,16 +70,16 @@ func CreateWebEventTriggers(ctx context.Context, tm *tagmanager.TagManager, cfg
}
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
}
variables, err := CreateWebDatalayerVariables(tm, parameters)
variables, err := CreateWebDatalayerVariables(ctx, tm, parameters)
if err != nil {
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
}
}
@ -87,15 +87,15 @@ func CreateWebEventTriggers(ctx context.Context, tm *tagmanager.TagManager, cfg
return eventParameters, nil
}
func CreateWebDatalayerVariables(tm *tagmanager.TagManager, parameters map[string]string) (map[string]*api.Variable, error) {
folder, err := tm.LookupFolder("Sesamy - " + Name)
func CreateWebDatalayerVariables(ctx context.Context, tm *tagmanager.TagManager, parameters map[string]string) (map[string]*api.Variable, error) {
folder, err := tm.LookupFolder(ctx, "Sesamy - "+Name)
if err != nil {
return nil, err
}
variables := make(map[string]*api.Variable, len(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
}
}

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

@ -1,6 +1,8 @@
package googletagmanager
import (
"context"
"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/variable"
@ -9,37 +11,37 @@ import (
servervariable "github.com/foomo/sesamy-cli/pkg/tagmanager/server/variable"
)
func Server(tm *tagmanager.TagManager, cfg config.GoogleTagManager, enableGeoResolution bool) error {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.GoogleTagManager, enableGeoResolution bool) error {
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // enable build in variables
if _, err := tm.EnableBuiltInVariable("clientName"); err != nil {
if _, err := tm.EnableBuiltInVariable(ctx, "clientName"); err != nil {
return err
}
}
{ // create client
visitorRegion, err := tm.UpsertVariable(folder, variable.NewVisitorRegion(NameGoogleTagManagerVisitorRegion))
visitorRegion, err := tm.UpsertVariable(ctx, folder, variable.NewVisitorRegion(NameGoogleTagManagerVisitorRegion))
if err != nil {
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
}
}
{ // create variables
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
}
}
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // create variables
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
}
}
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
{ // 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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
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 {
return err
}
if cfg.Conversion.Enabled {
tagTemplate, err := tm.UpsertCustomTemplate(template.NewConversionTag(NameConversionsTagTemplate))
tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewConversionTag(NameConversionsTagTemplate))
if err != nil {
return err
}
@ -42,22 +42,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters {
var eventTriggerOpts []trigger.ConversionEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Tracify - " + Name)
folder, err := tm.UpsertFolder(ctx, "Tracify - "+Name)
if err != nil {
return err
}
{ // 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 {
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 {
return err
}
tagTemplate, err := tm.UpsertCustomTemplate(template.NewTracifyTag(NameTracifyServerTagTemplate))
tagTemplate, err := tm.UpsertCustomTemplate(ctx, template.NewTracifyTag(NameTracifyServerTagTemplate))
if err != nil {
return err
}
@ -47,22 +47,22 @@ func Server(ctx context.Context, l *slog.Logger, tm *tagmanager.TagManager, cfg
for event := range eventParameters {
var eventTriggerOpts []trigger.TracifyEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}

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 {
folder, err := tm.UpsertFolder("Sesamy - " + Name)
folder, err := tm.UpsertFolder(ctx, "Sesamy - "+Name)
if err != nil {
return err
}
template, err := tm.UpsertCustomTemplate(containertemplate.NewUmami(Name))
template, err := tm.UpsertCustomTemplate(ctx, containertemplate.NewUmami(Name))
if err != nil {
return err
}
@ -34,22 +34,22 @@ func Server(ctx context.Context, tm *tagmanager.TagManager, cfg config.Umami) er
for event := range eventParameters {
var eventTriggerOpts []trigger.UmamiEventOption
if cfg.GoogleConsent.Enabled {
if err := googleconsent.ServerEnsure(tm); err != nil {
if err := googleconsent.ServerEnsure(ctx, tm); err != nil {
return err
}
consentVariable, err := tm.LookupVariable(googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
consentVariable, err := tm.LookupVariable(ctx, googleconsentvariable.GoogleConsentModeName(cfg.GoogleConsent.Mode))
if err != nil {
return err
}
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 {
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
}
}

197
pkg/tagmanager/tagmanager.go
View File

@ -28,6 +28,7 @@ type (
clients *AccessedMap[*tagmanager.Client]
folders *AccessedMap[*tagmanager.Folder]
variables *AccessedMap[*tagmanager.Variable]
environments *AccessedMap[*tagmanager.Environment]
builtInVariables *AccessedMap[*tagmanager.BuiltInVariable]
triggers *AccessedMap[*tagmanager.Trigger]
tags *AccessedMap[*tagmanager.Tag]
@ -198,14 +199,6 @@ func (t *TagManager) WorkspaceID() string {
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 {
if t.requestThrottler != nil {
<-t.requestThrottler.C
@ -241,8 +234,19 @@ func (t *TagManager) Notes(v any) string {
// ~ Public methods
// ------------------------------------------------------------------------------------------------
func (t *TagManager) LookupClient(name string) (*tagmanager.Client, error) {
elems, err := t.LoadClients()
func (t *TagManager) EnsureWorkspaceID(ctx context.Context) error {
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 {
return nil, err
}
@ -254,10 +258,10 @@ func (t *TagManager) LookupClient(name string) (*tagmanager.Client, error) {
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 {
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 {
return nil, err
}
@ -272,8 +276,8 @@ func (t *TagManager) LoadClients() (*AccessedMap[*tagmanager.Client], error) {
return t.clients, nil
}
func (t *TagManager) LookupFolder(name string) (*tagmanager.Folder, error) {
elems, err := t.LoadFolders()
func (t *TagManager) LookupFolder(ctx context.Context, name string) (*tagmanager.Folder, error) {
elems, err := t.LoadFolders(ctx)
if err != nil {
return nil, err
}
@ -285,10 +289,10 @@ func (t *TagManager) LookupFolder(name string) (*tagmanager.Folder, error) {
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 {
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 {
return nil, err
}
@ -302,8 +306,8 @@ func (t *TagManager) LoadFolders() (*AccessedMap[*tagmanager.Folder], error) {
return t.folders, nil
}
func (t *TagManager) LookupVariable(name string) (*tagmanager.Variable, error) {
elems, err := t.LoadVariables()
func (t *TagManager) LookupVariable(ctx context.Context, name string) (*tagmanager.Variable, error) {
elems, err := t.LoadVariables(ctx)
if err != nil {
return nil, err
}
@ -315,10 +319,10 @@ func (t *TagManager) LookupVariable(name string) (*tagmanager.Variable, error) {
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 {
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 {
return nil, err
}
@ -333,8 +337,8 @@ func (t *TagManager) LoadVariables() (*AccessedMap[*tagmanager.Variable], error)
return t.variables, nil
}
func (t *TagManager) GetBuiltInVariable(typeName string) (*tagmanager.BuiltInVariable, error) {
elems, err := t.LoadBuiltInVariables()
func (t *TagManager) GetEnvironment(ctx context.Context, typeName string) (*tagmanager.Environment, error) {
elems, err := t.LoadEnvironments(ctx)
if err != nil {
return nil, err
}
@ -346,10 +350,41 @@ func (t *TagManager) GetBuiltInVariable(typeName string) (*tagmanager.BuiltInVar
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 {
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 {
return nil, err
}
@ -364,8 +399,8 @@ func (t *TagManager) LoadBuiltInVariables() (*AccessedMap[*tagmanager.BuiltInVar
return t.builtInVariables, nil
}
func (t *TagManager) LookupTrigger(name string) (*tagmanager.Trigger, error) {
elems, err := t.LoadTriggers()
func (t *TagManager) LookupTrigger(ctx context.Context, name string) (*tagmanager.Trigger, error) {
elems, err := t.LoadTriggers(ctx)
if err != nil {
return nil, err
}
@ -377,8 +412,8 @@ func (t *TagManager) LookupTrigger(name string) (*tagmanager.Trigger, error) {
return elems.Get(name), nil
}
func (t *TagManager) LookupTemplate(name string) (*tagmanager.CustomTemplate, error) {
elems, err := t.LoadCustomTemplates()
func (t *TagManager) LookupTemplate(ctx context.Context, name string) (*tagmanager.CustomTemplate, error) {
elems, err := t.LoadCustomTemplates(ctx)
if err != nil {
return nil, err
}
@ -390,8 +425,8 @@ func (t *TagManager) LookupTemplate(name string) (*tagmanager.CustomTemplate, er
return elems.Get(name), nil
}
func (t *TagManager) LookupTransformation(name string) (*tagmanager.Transformation, error) {
elems, err := t.LoadTransformations()
func (t *TagManager) LookupTransformation(ctx context.Context, name string) (*tagmanager.Transformation, error) {
elems, err := t.LoadTransformations(ctx)
if err != nil {
return nil, err
}
@ -403,10 +438,10 @@ func (t *TagManager) LookupTransformation(name string) (*tagmanager.Transformati
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 {
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 {
return nil, err
}
@ -421,8 +456,8 @@ func (t *TagManager) LoadTriggers() (*AccessedMap[*tagmanager.Trigger], error) {
return t.triggers, nil
}
func (t *TagManager) LookupTag(name string) (*tagmanager.Tag, error) {
elems, err := t.LoadTags()
func (t *TagManager) LookupTag(ctx context.Context, name string) (*tagmanager.Tag, error) {
elems, err := t.LoadTags(ctx)
if err != nil {
return nil, err
}
@ -434,10 +469,10 @@ func (t *TagManager) LookupTag(name string) (*tagmanager.Tag, error) {
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 {
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 {
return nil, err
}
@ -452,8 +487,8 @@ func (t *TagManager) LoadTags() (*AccessedMap[*tagmanager.Tag], error) {
return t.tags, nil
}
func (t *TagManager) CustomTemplate(name string) (*tagmanager.CustomTemplate, error) {
elems, err := t.LoadCustomTemplates()
func (t *TagManager) CustomTemplate(ctx context.Context, name string) (*tagmanager.CustomTemplate, error) {
elems, err := t.LoadCustomTemplates(ctx)
if err != nil {
return nil, err
}
@ -465,10 +500,10 @@ func (t *TagManager) CustomTemplate(name string) (*tagmanager.CustomTemplate, er
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 {
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 {
return nil, err
}
@ -483,10 +518,10 @@ func (t *TagManager) LoadCustomTemplates() (*AccessedMap[*tagmanager.CustomTempl
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 {
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 {
return nil, err
}
@ -501,7 +536,7 @@ func (t *TagManager) LoadTransformations() (*AccessedMap[*tagmanager.Transformat
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)
item.ParentFolderId = folder.FolderId
@ -511,7 +546,7 @@ func (t *TagManager) UpsertClient(folder *tagmanager.Folder, item *tagmanager.Cl
item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupClient(item.Name)
cache, err := t.LookupClient(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err
}
@ -519,13 +554,13 @@ func (t *TagManager) UpsertClient(folder *tagmanager.Folder, item *tagmanager.Cl
var value *tagmanager.Client
if cache == nil {
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)
} else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.ClientId)
} else {
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)
}
if err != nil {
@ -535,10 +570,10 @@ func (t *TagManager) UpsertClient(folder *tagmanager.Folder, item *tagmanager.Cl
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)
item.ParentFolderId = folder.FolderId
@ -548,7 +583,7 @@ func (t *TagManager) UpsertTransformation(folder *tagmanager.Folder, item *tagma
item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupTransformation(item.Name)
cache, err := t.LookupTransformation(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err
}
@ -556,13 +591,13 @@ func (t *TagManager) UpsertTransformation(folder *tagmanager.Folder, item *tagma
var value *tagmanager.Transformation
if cache == nil {
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)
} else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.TransformationId)
} else {
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)
}
if err != nil {
@ -571,10 +606,10 @@ func (t *TagManager) UpsertTransformation(folder *tagmanager.Folder, item *tagma
}
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)
item := &tagmanager.Folder{
@ -586,7 +621,7 @@ func (t *TagManager) UpsertFolder(name string) (*tagmanager.Folder, error) {
item.ContainerId = t.ContainerID()
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) {
return nil, err
}
@ -594,13 +629,13 @@ func (t *TagManager) UpsertFolder(name string) (*tagmanager.Folder, error) {
var value *tagmanager.Folder
if cache == nil {
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)
} else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", item.FolderId)
} else {
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)
}
if err != nil {
@ -610,10 +645,10 @@ func (t *TagManager) UpsertFolder(name string) (*tagmanager.Folder, error) {
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)
item.ParentFolderId = folder.FolderId
@ -623,7 +658,7 @@ func (t *TagManager) UpsertVariable(folder *tagmanager.Folder, item *tagmanager.
item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupVariable(item.Name)
cache, err := t.LookupVariable(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err
}
@ -631,13 +666,13 @@ func (t *TagManager) UpsertVariable(folder *tagmanager.Folder, item *tagmanager.
var value *tagmanager.Variable
if cache == nil {
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)
} else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.VariableId)
} else {
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)
}
if err != nil {
@ -647,13 +682,13 @@ func (t *TagManager) UpsertVariable(folder *tagmanager.Folder, item *tagmanager.
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)
cache, err := t.GetBuiltInVariable(typeName)
cache, err := t.GetBuiltInVariable(ctx, typeName)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err
}
@ -664,7 +699,7 @@ func (t *TagManager) EnableBuiltInVariable(typeName string) (*tagmanager.BuiltIn
}
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 {
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)
}
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)
item.ParentFolderId = folder.FolderId
@ -686,7 +721,7 @@ func (t *TagManager) UpsertTrigger(folder *tagmanager.Folder, item *tagmanager.T
item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupTrigger(item.Name)
cache, err := t.LookupTrigger(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err
}
@ -694,13 +729,13 @@ func (t *TagManager) UpsertTrigger(folder *tagmanager.Folder, item *tagmanager.T
var value *tagmanager.Trigger
if cache == nil {
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)
} else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.TriggerId)
} else {
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)
}
if err != nil {
@ -710,10 +745,10 @@ func (t *TagManager) UpsertTrigger(folder *tagmanager.Folder, item *tagmanager.T
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)
item.ParentFolderId = folder.FolderId
@ -723,7 +758,7 @@ func (t *TagManager) UpsertTag(folder *tagmanager.Folder, item *tagmanager.Tag)
item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID()
cache, err := t.LookupTag(item.Name)
cache, err := t.LookupTag(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err
}
@ -731,13 +766,13 @@ func (t *TagManager) UpsertTag(folder *tagmanager.Folder, item *tagmanager.Tag)
var value *tagmanager.Tag
if cache == nil {
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)
} else if item.Notes == cache.Notes {
l.Info("└ ✔︎ OK", "id", cache.TagId)
} else {
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)
}
if err != nil {
@ -746,17 +781,17 @@ func (t *TagManager) UpsertTag(folder *tagmanager.Folder, item *tagmanager.Tag)
}
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)
item.AccountId = t.AccountID()
item.ContainerId = t.ContainerID()
item.WorkspaceId = t.WorkspaceID()
cache, err := t.CustomTemplate(item.Name)
cache, err := t.CustomTemplate(ctx, item.Name)
if err != nil && !errors.Is(err, ErrNotFound) {
return nil, err
}
@ -764,13 +799,13 @@ func (t *TagManager) UpsertCustomTemplate(item *tagmanager.CustomTemplate) (*tag
var value *tagmanager.CustomTemplate
if cache == nil {
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)
} else if item.TemplateData == cache.TemplateData {
l.Info("└ ✔︎ OK", "id", cache.TemplateId)
} else {
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)
}
if err != nil {
@ -779,5 +814,5 @@ func (t *TagManager) UpsertCustomTemplate(item *tagmanager.CustomTemplate) (*tag
}
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
# The container id
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'
# Server container settings
serverContainer:
@ -34,7 +34,7 @@ googleTagManager:
tagId: GTM-5NWPR4QW
# The container id
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'
# Web container variables
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, c.EnsureWorkspaceID(t.Context()))
{ // --- Folders ---
t.Run("upsert folder", func(t *testing.T) {
obj, err := c.UpsertFolder("Sesamy")
obj, err := c.UpsertFolder(t.Context(), "Sesamy")
require.NoError(t, err)
dump(t, obj)
})
@ -113,7 +114,7 @@ func TestNewClient_Server(t *testing.T) {
{ // --- Templates ---
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)
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, c.EnsureWorkspaceID(t.Context()))
{ // --- Containers ---
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) {
obj, err := c.UpsertFolder(name)
obj, err := c.UpsertFolder(t.Context(), name)
require.NoError(t, err)
t.Log("ID: " + obj.FolderId)
})