Merge branch 'main' into dependabot/go_modules/gomod-update-b1a4fa3428

README.md

@@ -146,10 +146,19 @@ googleTag:
           - ViewPromotion
           - WorkingLead
 
+
 # --- Google Analytics settings
 googleAnalytics:
   # Enable provider
   enabled: true
+  # Google GTag.js settings
+  googleGTag:
+    # Provision custom client
+    enabled: true
+    # Client priority
+    priority: 10
+    # Patch ecommerce items
+    ecommerceItems: true
   # Google Tag Manager web container settings
   webContainer:
     # Contemplate package config for generated events
@@ -236,6 +245,24 @@ facebook:
           - BeginCheckout
           - GenerateLead
           - ViewItem
+
+# --- Emarsys
+emarsys:
+  # Enable provider
+  enabled: true
+  # Emarsys merchant id
+  merchantId: ''
+  # Name of the event to mark as new page view
+  newPageViewEvent: '''
+  # Google Tag Manager server container settings
+  serverContainer:
+    # Contemplate package config for generated events
+    packages:
+      - path: github.com/foomo/sesamy-go/pkg/event
+        types:
+          - Purchase
+          - ViewItem
+          - ViewItemList
 ```
 
 ## Caveats

cmd/tagmanager/server.go

@@ -3,6 +3,7 @@ package tagmanager
 import (
 	pkgcmd "github.com/foomo/sesamy-cli/pkg/cmd"
 	conversionlinkerprovider "github.com/foomo/sesamy-cli/pkg/provider/conversionlinker"
+	emarsysprovider "github.com/foomo/sesamy-cli/pkg/provider/emarsys"
 	facebookprovider "github.com/foomo/sesamy-cli/pkg/provider/facebook"
 	googleadsprovider "github.com/foomo/sesamy-cli/pkg/provider/googleads"
 	googleanalyticsprovider "github.com/foomo/sesamy-cli/pkg/provider/googleanalytics"
@@ -58,40 +59,47 @@ func NewServer(root *cobra.Command) {
 			}
 
 			if cfg.GoogleAnalytics.Enabled && pkgcmd.Tag(googleanalyticsprovider.Tag, tags) {
-				l.Info("🅿️ Running provider", "name", googleanalyticsprovider.Name)
+				l.Info("🅿️ Running provider", "name", googleanalyticsprovider.Name, "tag", googleanalyticsprovider.Tag)
 				if err := googleanalyticsprovider.Server(tm, cfg.GoogleAnalytics, cfg.RedactVisitorIP); err != nil {
 					return errors.Wrap(err, "failed to provision google analytics")
 				}
 			}
 
 			if cfg.ConversionLinker.Enabled && pkgcmd.Tag(conversionlinkerprovider.Tag, tags) {
-				l.Info("🅿️ Running provider", "name", conversionlinkerprovider.Name)
+				l.Info("🅿️ Running provider", "name", conversionlinkerprovider.Name, "tag", conversionlinkerprovider.Tag)
 				if err := conversionlinkerprovider.Server(tm, cfg.ConversionLinker); err != nil {
 					return errors.Wrap(err, "failed to provision conversion linker")
 				}
 			}
 
 			if cfg.Umami.Enabled && pkgcmd.Tag(umamiprovider.Tag, tags) {
-				l.Info("🅿️ Running provider", "name", umamiprovider.Name)
+				l.Info("🅿️ Running provider", "name", umamiprovider.Name, "tag", umamiprovider.Tag)
 				if err := umamiprovider.Server(tm, cfg.Umami); err != nil {
 					return errors.Wrap(err, "failed to provision umammi")
 				}
 			}
 
 			if cfg.Facebook.Enabled && pkgcmd.Tag(facebookprovider.Tag, tags) {
-				l.Info("🅿️ Running provider", "name", facebookprovider.Name)
+				l.Info("🅿️ Running provider", "name", facebookprovider.Name, "tag", facebookprovider.Tag)
 				if err := facebookprovider.Server(l, tm, cfg.Facebook); err != nil {
 					return errors.Wrap(err, "failed to provision facebook")
 				}
 			}
 
 			if cfg.GoogleAds.Enabled && pkgcmd.Tag(googleadsprovider.Tag, tags) {
-				l.Info("🅿️ Running provider", "name", googleadsprovider.Name)
+				l.Info("🅿️ Running provider", "name", googleadsprovider.Name, "tag", googleadsprovider.Tag)
 				if err := googleadsprovider.Server(l, tm, cfg.GoogleAds); err != nil {
 					return errors.Wrap(err, "failed to provision google ads")
 				}
 			}
 
+			if cfg.Emarsys.Enabled && pkgcmd.Tag(emarsysprovider.Tag, tags) {
+				l.Info("🅿️ Running provider", "name", emarsysprovider.Name, "tag", emarsysprovider.Tag)
+				if err := emarsysprovider.Server(l, tm, cfg.Emarsys); err != nil {
+					return errors.Wrap(err, "failed to provision emarsys")
+				}
+			}
+
 			return nil
 		},
 	}

cmd/tagmanager/web.go

@@ -2,6 +2,7 @@ package tagmanager
 
 import (
 	pkgcmd "github.com/foomo/sesamy-cli/pkg/cmd"
+	emarsysprovider "github.com/foomo/sesamy-cli/pkg/provider/emarsys"
 	googleanaylticsprovider "github.com/foomo/sesamy-cli/pkg/provider/googleanalytics"
 	googletagprovider "github.com/foomo/sesamy-cli/pkg/provider/googletag"
 	"github.com/foomo/sesamy-cli/pkg/tagmanager"
@@ -52,6 +53,12 @@ func NewWeb(root *cobra.Command) {
 				}
 			}
 
+			if cfg.Emarsys.Enabled && pkgcmd.Tag(emarsysprovider.Tag, tags) {
+				if err := emarsysprovider.Web(tm, cfg.Emarsys); err != nil {
+					return errors.Wrap(err, "failed to provision emarsys tag")
+				}
+			}
+
 			return nil
 		},
 	}

pkg/code/section.go

@@ -11,6 +11,13 @@ type Section struct {
 	Parts []string
 }
 
+func (s *Section) Sprint(a ...any) {
+	value := fmt.Sprint(a...)
+	if !slices.Contains(s.Parts, value) {
+		s.Parts = append(s.Parts, value)
+	}
+}
+
 func (s *Section) Sprintf(format string, a ...any) {
 	value := fmt.Sprintf(format, a...)
 	if !slices.Contains(s.Parts, value) {

pkg/config/config.go

@@ -11,5 +11,6 @@ type Config struct {
 	GoogleAnalytics  GoogleAnalytics  `json:"googleAnalytics" yaml:"googleAnalytics"`
 	ConversionLinker ConversionLinker `json:"conversionLinker" yaml:"conversionLinker"`
 	Facebook         Facebook         `json:"facebook" yaml:"facebook"`
+	Emarsys          Emarsys          `json:"emarsys" yaml:"emarsys"`
 	Umami            Umami            `json:"umami" yaml:"umami"`
 }

pkg/config/emarsys.go

@@ -0,0 +1,13 @@
+package config
+
+import (
+	"github.com/foomo/gocontemplate/pkg/contemplate"
+)
+
+type Emarsys struct {
+	Enabled          bool               `json:"enabled" yaml:"enabled"`
+	MerchantID       string             `json:"merchantId" yaml:"merchantId"`
+	NewPageViewEvent string             `json:"newPageViewEvent" yaml:"newPageViewEvent"`
+	WebContainer     contemplate.Config `json:"webContainer" yaml:"webContainer"`
+	ServerContainer  contemplate.Config `json:"serverContainer" yaml:"serverContainer"`
+}

pkg/config/googleanalytics.go

@@ -6,6 +6,7 @@ import (
 
 type GoogleAnalytics struct {
 	Enabled         bool               `json:"enabled" yaml:"enabled"`
+	GoogleGTag      GoogleGTag         `json:"googleGTag" yaml:"googleGTag"`
 	WebContainer    contemplate.Config `json:"webContainer" yaml:"webContainer"`
 	ServerContainer contemplate.Config `json:"serverContainer" yaml:"serverContainer"`
 }

pkg/config/googlegtag.go

@@ -0,0 +1,7 @@
+package config
+
+type GoogleGTag struct {
+	Enabled        bool  `json:"enabled" yaml:"enabled"`
+	Priority       int64 `json:"priority" yaml:"priority"`
+	EcommerceItems bool  `json:"ecommerceItems" yaml:"ecommerceItems"`
+}

pkg/config/googletag.go

@@ -1,10 +1,8 @@
 package config
 
 type GoogleTag struct {
-	TagID        string `json:"tagId" yaml:"tagId"`
-	DebugMode    bool   `json:"debugMode" yaml:"debugMode"`
-	SendPageView bool   `json:"sendPageView" yaml:"sendPageView"`
-	// WebContainer    contemplate.Config `json:"webContainer" yaml:"webContainer"`
-	// ServerContainer contemplate.Config `json:"serverContainer" yaml:"serverContainer"`
-	TypeScript TypeScript `json:"typeScript" yaml:"typeScript"`
+	TagID        string     `json:"tagId" yaml:"tagId"`
+	DebugMode    bool       `json:"debugMode" yaml:"debugMode"`
+	SendPageView bool       `json:"sendPageView" yaml:"sendPageView"`
+	TypeScript   TypeScript `json:"typeScript" yaml:"typeScript"`
 }

pkg/provider/emarsys/constants.go

@@ -0,0 +1,12 @@
+package emarsys
+
+const (
+	Tag                                          = "emarsys"
+	Name                                         = "Emarsys"
+	NameMerchantIDConstant                       = "Emarsys Merchant ID"
+	NameWebEmarsysInitalizationTag               = "Emarsys Initialization"
+	NameWebEmarsysInitalizationTagTemplate       = "Emarsys Initialization"
+	NameServerEmarsysClient                      = "Emarsys Initialization"
+	NameServerEmarsysWebExtendTagTemplate        = "Emarsys Web Extend"
+	NameServerEmarsysInitalizationClientTemplate = "Emarsys Initialization"
+)

pkg/provider/emarsys/server.go

@@ -0,0 +1,67 @@
+package emarsys
+
+import (
+	"log/slog"
+
+	"github.com/foomo/sesamy-cli/pkg/config"
+	serverclientx "github.com/foomo/sesamy-cli/pkg/provider/emarsys/server/client"
+	servertagx "github.com/foomo/sesamy-cli/pkg/provider/emarsys/server/tag"
+	"github.com/foomo/sesamy-cli/pkg/provider/emarsys/server/template"
+	"github.com/foomo/sesamy-cli/pkg/provider/googletag"
+	"github.com/foomo/sesamy-cli/pkg/tagmanager"
+	commontrigger "github.com/foomo/sesamy-cli/pkg/tagmanager/common/trigger"
+	commonvariable "github.com/foomo/sesamy-cli/pkg/tagmanager/common/variable"
+	"github.com/pkg/errors"
+)
+
+func Server(l *slog.Logger, tm *tagmanager.TagManager, cfg config.Emarsys) error {
+	{ // create folder
+		if folder, err := tm.UpsertFolder("Sesamy - " + Name); err != nil {
+			return err
+		} else {
+			tm.SetFolderName(folder.Name)
+		}
+	}
+
+	{ // conversion
+		merchantID, err := tm.UpsertVariable(commonvariable.NewConstant(NameMerchantIDConstant, cfg.MerchantID))
+		if err != nil {
+			return err
+		}
+
+		tagTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysWebExtendTag(NameServerEmarsysWebExtendTagTemplate))
+		if err != nil {
+			return err
+		}
+
+		clientTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysInitializationClient(NameServerEmarsysInitalizationClientTemplate))
+		if err != nil {
+			return err
+		}
+
+		_, err = tm.UpsertClient(serverclientx.NewEmarsys(NameServerEmarsysClient, cfg, clientTemplate))
+		if err != nil {
+			return err
+		}
+
+		{ // create tags
+			eventParameters, err := googletag.CreateServerEventTriggers(tm, cfg.ServerContainer)
+			if err != nil {
+				return err
+			}
+
+			for event := range eventParameters {
+				eventTrigger, err := tm.LookupTrigger(commontrigger.EventName(event))
+				if err != nil {
+					return errors.Wrap(err, "failed to lookup event trigger: "+event)
+				}
+
+				if _, err := tm.UpsertTag(servertagx.NewEmarsys(event, cfg.NewPageViewEvent == eventTrigger.Name, merchantID, tagTemplate, eventTrigger)); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	return nil
+}

pkg/provider/emarsys/server/client/emarsys.go

@@ -0,0 +1,21 @@
+package client
+
+import (
+	"github.com/foomo/sesamy-cli/pkg/config"
+	"github.com/foomo/sesamy-cli/pkg/utils"
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func NewEmarsys(name string, cfg config.Emarsys, template *tagmanager.CustomTemplate) *tagmanager.Client {
+	return &tagmanager.Client{
+		Name: name,
+		Parameter: []*tagmanager.Parameter{
+			{
+				Key:   "merchantId",
+				Type:  "template",
+				Value: cfg.MerchantID,
+			},
+		},
+		Type: utils.TemplateType(template),
+	}
+}

pkg/provider/emarsys/server/tag/emarsys.go

@@ -0,0 +1,48 @@
+package tag
+
+import (
+	"strconv"
+
+	"github.com/foomo/sesamy-cli/pkg/utils"
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func EmarsysName(v string) string {
+	return "Emarsys - " + v
+}
+
+func NewEmarsys(name string, isNewPageView bool, merchantID *tagmanager.Variable, template *tagmanager.CustomTemplate, triggers ...*tagmanager.Trigger) *tagmanager.Tag {
+	return &tagmanager.Tag{
+		FiringTriggerId: utils.TriggerIDs(triggers),
+		Name:            EmarsysName(name),
+		TagFiringOption: "oncePerEvent",
+		Parameter: []*tagmanager.Parameter{
+			{
+				Key:   "adStorageConsent",
+				Type:  "template",
+				Value: "optional",
+			},
+			{
+				Key:   "isNewPageView",
+				Type:  "boolean",
+				Value: strconv.FormatBool(isNewPageView),
+			},
+			{
+				Key:   "merchantId",
+				Type:  "template",
+				Value: "{{" + merchantID.Name + "}}",
+			},
+			{
+				Key:   "isTestMode",
+				Type:  "boolean",
+				Value: "false",
+			},
+			{
+				Key:   "isDebugMode",
+				Type:  "boolean",
+				Value: "false",
+			},
+		},
+		Type: utils.TemplateType(template),
+	}
+}

pkg/provider/emarsys/server/template/emarsysinitalizationclient.go

@@ -0,0 +1,14 @@
+package template
+
+import (
+	"fmt"
+
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func NewEmarsysInitializationClient(name string) *tagmanager.CustomTemplate {
+	return &tagmanager.CustomTemplate{
+		Name:         name,
+		TemplateData: fmt.Sprintf(EmarsysInitializationClientData, name),
+	}
+}

pkg/provider/emarsys/server/template/emarsyswebextendtag.go

@@ -0,0 +1,14 @@
+package template
+
+import (
+	"fmt"
+
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func NewEmarsysWebExtendTag(name string) *tagmanager.CustomTemplate {
+	return &tagmanager.CustomTemplate{
+		Name:         name,
+		TemplateData: fmt.Sprintf(EmarsysWebExtendTagData, name),
+	}
+}

pkg/provider/emarsys/web.go

@@ -0,0 +1,64 @@
+package emarsys
+
+import (
+	"github.com/foomo/sesamy-cli/pkg/config"
+	"github.com/foomo/sesamy-cli/pkg/provider/emarsys/web/tag"
+	"github.com/foomo/sesamy-cli/pkg/provider/emarsys/web/template"
+	containertag "github.com/foomo/sesamy-cli/pkg/provider/googleanalytics/web/tag"
+	"github.com/foomo/sesamy-cli/pkg/provider/googletag"
+	commonvariable "github.com/foomo/sesamy-cli/pkg/provider/googletag/web/variable"
+	"github.com/foomo/sesamy-cli/pkg/tagmanager"
+	commontrigger "github.com/foomo/sesamy-cli/pkg/tagmanager/common/trigger"
+	"github.com/pkg/errors"
+)
+
+func Web(tm *tagmanager.TagManager, cfg config.Emarsys) error {
+	{ // create folder
+		if folder, err := tm.UpsertFolder("Sesamy - " + Name); err != nil {
+			return err
+		} else {
+			tm.SetFolderName(folder.Name)
+		}
+	}
+
+	{ // create initialization tag
+		tagTemplate, err := tm.UpsertCustomTemplate(template.NewEmarsysInitializationTag(NameWebEmarsysInitalizationTagTemplate))
+		if err != nil {
+			return err
+		}
+
+		if _, err = tm.UpsertTag(tag.NewEmarsysInitialization(NameWebEmarsysInitalizationTag, tagTemplate)); err != nil {
+			return err
+		}
+	}
+
+	{ // create event tags
+		tagID, err := tm.LookupVariable(googletag.NameGoogleTagID)
+		if err != nil {
+			return err
+		}
+
+		eventParameters, err := googletag.CreateWebEventTriggers(tm, cfg.WebContainer)
+		if err != nil {
+			return err
+		}
+
+		for event := range eventParameters {
+			eventTrigger, err := tm.LookupTrigger(commontrigger.EventName(event))
+			if err != nil {
+				return errors.Wrap(err, "failed to lookup event trigger: "+event)
+			}
+
+			eventSettings, err := tm.LookupVariable(commonvariable.GoogleTagEventSettingsName(event))
+			if err != nil {
+				return errors.Wrap(err, "failed to lookup google tag event setting: "+event)
+			}
+
+			if _, err := tm.UpsertTag(containertag.NewGoogleAnalyticsGA4Event(event, tagID, eventSettings, eventTrigger)); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}

pkg/provider/emarsys/web/tag/emarsysinitialization.go

@@ -0,0 +1,17 @@
+package tag
+
+import (
+	"github.com/foomo/sesamy-cli/pkg/tagmanager/web/trigger"
+	"github.com/foomo/sesamy-cli/pkg/utils"
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func NewEmarsysInitialization(name string, template *tagmanager.CustomTemplate) *tagmanager.Tag {
+	ret := &tagmanager.Tag{
+		Name:            name,
+		FiringTriggerId: []string{trigger.IDConsentInitializtion},
+		TagFiringOption: "oncePerEvent",
+		Type:            utils.TemplateType(template),
+	}
+	return ret
+}

pkg/provider/emarsys/web/template/emarsysinitializationtag.go

@@ -0,0 +1,14 @@
+package template
+
+import (
+	"fmt"
+
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func NewEmarsysInitializationTag(name string) *tagmanager.CustomTemplate {
+	return &tagmanager.CustomTemplate{
+		Name:         name,
+		TemplateData: fmt.Sprintf(EmarsysInitializationTagData, name),
+	}
+}

pkg/provider/googleanalytics/constants.go

@@ -5,6 +5,8 @@ const (
 	Name                                    = "Google Analytics"
 	NameGoogleAnalyticsGA4Client            = "Google Analytics GA4"
 	NameGoogleAnalyticsGA4ClientTrigger     = "Google Analytics GA4 Client"
+	NameGoogleGTagClientTemplate            = "Google gtag.js"
+	NameGoogleGTagClient                    = "Google gtag.js"
 	NameMeasurementProtocolGA4Client        = "Measurement Protocol GA4"
 	NameMeasurementProtocolGA4ClientTrigger = "Measurement Protocol GA4 Client"
 )

pkg/provider/googleanalytics/server.go

@@ -2,7 +2,9 @@ package googleanalytics
 
 import (
 	"github.com/foomo/sesamy-cli/pkg/config"
+	client2 "github.com/foomo/sesamy-cli/pkg/provider/googleanalytics/server/client"
 	containertag "github.com/foomo/sesamy-cli/pkg/provider/googleanalytics/server/tag"
+	template2 "github.com/foomo/sesamy-cli/pkg/provider/googleanalytics/server/template"
 	"github.com/foomo/sesamy-cli/pkg/provider/googletag"
 	"github.com/foomo/sesamy-cli/pkg/tagmanager"
 	commontrigger "github.com/foomo/sesamy-cli/pkg/tagmanager/common/trigger"
@@ -40,6 +42,18 @@ func Server(tm *tagmanager.TagManager, cfg config.GoogleAnalytics, redactVisitor
 				return err
 			}
 		}
+
+		if cfg.GoogleGTag.Enabled {
+			template, err := tm.UpsertCustomTemplate(template2.NewGoogleGTagClient(NameGoogleGTagClientTemplate))
+			if err != nil {
+				return err
+			}
+
+			_, err = tm.UpsertClient(client2.NewGoogleGTag(NameGoogleGTagClient, cfg.GoogleGTag, template))
+			if err != nil {
+				return err
+			}
+		}
 	}
 
 	{ // create tags

pkg/provider/googleanalytics/server/client/googlegtag.go

@@ -0,0 +1,24 @@
+package client
+
+import (
+	"strconv"
+
+	"github.com/foomo/sesamy-cli/pkg/config"
+	"github.com/foomo/sesamy-cli/pkg/utils"
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func NewGoogleGTag(name string, cfg config.GoogleGTag, template *tagmanager.CustomTemplate) *tagmanager.Client {
+	return &tagmanager.Client{
+		Name:     name,
+		Priority: cfg.Priority,
+		Parameter: []*tagmanager.Parameter{
+			{
+				Key:   "patchEcommerceItems",
+				Type:  "boolean",
+				Value: strconv.FormatBool(cfg.EcommerceItems),
+			},
+		},
+		Type: utils.TemplateType(template),
+	}
+}

pkg/provider/googleanalytics/server/template/googlegtagclient.go

@@ -0,0 +1,14 @@
+package template
+
+import (
+	"fmt"
+
+	"google.golang.org/api/tagmanager/v2"
+)
+
+func NewGoogleGTagClient(name string) *tagmanager.CustomTemplate {
+	return &tagmanager.CustomTemplate{
+		Name:         name,
+		TemplateData: fmt.Sprintf(GoogleGTagClientData, name),
+	}
+}

pkg/provider/googletag/server.go

@@ -18,7 +18,7 @@ func Server(tm *tagmanager.TagManager) error {
 	return nil
 }
 
-func CreateServerEventTriggers(tm *tagmanager.TagManager, cfg contemplate.Config) (map[string][]string, error) {
+func CreateServerEventTriggers(tm *tagmanager.TagManager, cfg contemplate.Config) (map[string]map[string]string, error) {
 	previousFolderName := tm.FolderName()
 	tm.SetFolderName("Sesamy - " + Name)
 	defer tm.SetFolderName(previousFolderName)

pkg/provider/googletag/web.go

@@ -50,7 +50,7 @@ func Web(tm *tagmanager.TagManager, cfg config.GoogleTag) error {
 	return nil
 }
 
-func CreateWebEventTriggers(tm *tagmanager.TagManager, cfg contemplate.Config) (map[string][]string, error) {
+func CreateWebEventTriggers(tm *tagmanager.TagManager, cfg contemplate.Config) (map[string]map[string]string, error) {
 	previousFolderName := tm.FolderName()
 	tm.SetFolderName("Sesamy - " + Name)
 	defer tm.SetFolderName(previousFolderName)
@@ -65,14 +65,14 @@ func CreateWebEventTriggers(tm *tagmanager.TagManager, cfg contemplate.Config) (
 			return nil, err
 		}
 
-		settings := make(map[string]*api.Variable, len(parameters))
-		for _, parameter := range parameters {
-			if settings[parameter], err = tm.UpsertVariable(variable.NewDataLayerVariable(parameter)); err != nil {
+		variables := make(map[string]*api.Variable, len(parameters))
+		for parameterName, parameterValue := range parameters {
+			if variables[parameterName], err = tm.UpsertVariable(variable.NewDataLayerVariable(parameterValue)); err != nil {
 				return nil, err
 			}
 		}
 
-		if _, err := tm.UpsertVariable(containervariable.NewGoogleTagEventSettings(event, settings)); err != nil {
+		if _, err := tm.UpsertVariable(containervariable.NewGoogleTagEventSettings(event, variables)); err != nil {
 			return nil, err
 		}
 	}

pkg/provider/googletag/web/variable/googletageventmodel.go

@@ -1,14 +0,0 @@
-package variable
-
-import (
-	"github.com/foomo/sesamy-cli/pkg/tagmanager/web/variable"
-	"google.golang.org/api/tagmanager/v2"
-)
-
-func GoogleTagEventModelName(v string) string {
-	return variable.DataLayerVariableName("eventModel." + v)
-}
-
-func NewGoogleTagEventModel(v string) *tagmanager.Variable {
-	return variable.NewDataLayerVariable("eventModel." + v)
-}

pkg/provider/microsoft/server/template/data/conversion/code.js

@@ -0,0 +1,200 @@
+const sendHttpGet = require('sendHttpGet');
+const getEventData = require('getEventData');
+const generateRandom = require('generateRandom');
+const logToConsole = require('logToConsole');
+const Math = require('Math');
+const encodeUriComponent = require('encodeUriComponent');
+const JSON = require('JSON');
+const getCookieValues = require('getCookieValues');
+const setCookie = require('setCookie');
+const parseUrl = require('parseUrl');
+
+
+let clickid;
+function isNotEmpty(obj) {
+	if (obj === undefined || obj === null || obj.toString() === "" ) {
+		return false;
+	} else {
+		return obj;
+	}
+}
+
+let msquery = () => {
+	const url = parseUrl(getEventData('page_location'));
+	if (url && url.searchParams.msclkid) {
+			return url.searchParams.msclkid;
+	} else {
+		return false;
+	}
+};
+
+function setUETCookie(clickid) {
+	setCookie('_uetmsclkid', "_uet"+clickid, {"expires":7776000000, httpOnly: false});
+	logToConsole("Cookie set: " + clickid);
+}
+
+if(data.first_click) {
+	if (isNotEmpty(data.msclkidCookie) || isNotEmpty(getCookieValues('_uetmsclkid'))) {
+		let clickid_cookie = getCookieValues('_uetmsclkid')[0];
+		clickid = (isNotEmpty(data.msclkidCookie) || (clickid_cookie.substring(4)));
+		clickid += "-0";
+	} else { //cookie not present
+		if (isNotEmpty(data.msclkidQuery) || msquery()) {
+			clickid = (isNotEmpty(data.msclkidQuery) || msquery());
+			setUETCookie(clickid);
+			clickid += "-1";
+		} else {
+			clickid = "N";
+		}
+	}
+} else {
+	if (isNotEmpty(data.msclkidQuery) || msquery()) {
+		clickid = (isNotEmpty(data.msclkidQuery) || msquery());
+		setUETCookie(clickid);
+		clickid += "-1";
+	} else {
+		if(isNotEmpty(data.msclkidCookie) || isNotEmpty(getCookieValues('_uetmsclkid'))){
+			let clickid_cookie = getCookieValues('_uetmsclkid')[0];
+			clickid = (isNotEmpty(data.msclkidCookie) || (clickid_cookie.substring(4)));
+			clickid += "-0";
+		} else {
+			clickid = "N";
+		}
+	}
+}
+
+
+const screen = data.screen || getEventData('screen_resolution');
+
+let width, height = "";
+if (isNotEmpty(screen)){
+	width = screen.split('x')[0];
+	height = screen.split('x')[1];
+
+}
+let rn = generateRandom(100000, 999999);
+function s4() {
+	return Math.floor(((1 + (generateRandom(1, 9999999)/10000000))) * 65536)
+	.toString(16)
+	.substring(1);
+}
+
+let mid = (s4() + s4() + "-" + s4() + "-" + s4() + "-" + s4() + "-" + s4() + s4() + s4());
+let items_data;
+if(isNotEmpty(getEventData('items'))){
+	items_data = getEventData('items');
+}
+
+let items = () => {
+	let result = "";
+	if(isNotEmpty(data.prodid)){
+		items_data = data.prodid;
+	}
+	if (data.itemsGa) {
+		if(items_data) {
+			items_data.forEach(function(item, i) {
+				result += "id=" + item.item_id + 'quantity=' + item.quantity + 'price=' + item.price;
+				if (i < items_data.length - 1) {
+					result += ',';
+				}
+			});
+		}
+	} else {
+		result = items_data;
+	}
+	return result;
+};
+
+
+let items_id = () => {
+	let result = "";
+	if(isNotEmpty(data.items)){
+		items_data = data.items;
+	}
+	if(data.prodidGa) {
+		if (items_data) {
+			items_data.forEach(function(item, i) {
+				result += item.item_id;
+				if (i < items_data.length - 1) {
+					result += ',';
+				}
+			});
+		}
+	}
+	return result;
+};
+
+let spa = () => {
+	if(data.spa) {
+		return "Y";
+	} else {
+		return "N";
+	}
+};
+
+let params = {
+	rn: rn,
+	ti: data.ti,
+	ver: '2.3',
+	mid: mid,
+	uid: isNotEmpty(data.userId) || getEventData('user_id'),
+	evt: data.evt,
+	p: getEventData('page_location'),
+	r: getEventData('page_referrer'),
+	tl: isNotEmpty(data.pageTitle) || getEventData('page_title'),
+	pagetype: data.pagetype,
+	items:  items(),
+	prodid: items_id(),
+	search_term: isNotEmpty(data.searchTerm) || getEventData('search_term'),
+	transaction_id: isNotEmpty(data.transactionId) || getEventData('transaction_id'),
+	lg: isNotEmpty(data.lg) || getEventData('language'),
+	sw: width,
+	sh: height,
+	sc: data.sc || getEventData('screen_color_depth'),
+	spa: spa(),
+	msclkid: clickid,
+	sid: isNotEmpty(data.sid) || getEventData('uet_session_id'),
+	vid: isNotEmpty(data.vid) || getEventData('vid'),
+	page_path: isNotEmpty(data.pagePath) || getEventData('page_path'),
+	gc: getEventData('currency'),
+	gv: getEventData('value'),
+	ec: isNotEmpty(data.ec) || getEventData('event_category'),
+	ea: isNotEmpty(data.ea) || getEventData('event_action'),
+	el: isNotEmpty(data.el) || getEventData('event_label'),
+	ev: isNotEmpty(data.ev) || getEventData('event_value'),
+};
+
+
+if (data.activateLogs) {
+	logToConsole("Params: " + JSON.stringify(params));
+}
+
+
+let url = 'https://bat.bing.com/action/0?';
+let all_params = "";
+if(isNotEmpty(params)){
+	for (var key in params){
+		if (params[key] == undefined || params[key] == null) {
+			continue;
+		}
+		all_params += key + "=" + encodeUriComponent(params[key]) + "&";
+	}
+	url += all_params;
+}
+if (data.activateLogs) {
+	logToConsole('URL: ' + url);
+}
+
+
+return sendHttpGet(url, {
+	headers: {key: 'value'},
+	timeout: 500,
+}).then((result) => {
+	if (result.statusCode >= 200 && result.statusCode < 300) {
+		logToConsole('Result: ' + data.gtmOnSuccess());
+		data.gtmOnSuccess();
+	} else {
+		logToConsole('Error: ' + result.statusCode);
+		data.gtmOnFailure();
+	}
+});

pkg/tagmanager/web/trigger/builtin.go

@@ -1,3 +1,6 @@
 package trigger
 
-const IDInitialization = "2147479573"
+const (
+	IDInitialization       = "2147479573"
+	IDConsentInitializtion = "2147479572"
+)

pkg/tagmanager/web/variable/datalayervariable.go

@@ -25,7 +25,7 @@ func NewDataLayerVariable(name string) *tagmanager.Variable {
 			{
 				Key:   "name",
 				Type:  "template",
-				Value: "eventModel." + name,
+				Value: name,
 			},
 		},
 		Type: "v",

pkg/typescript/imports.go

@@ -31,6 +31,6 @@ func (i *Imports) Import(location string) *Import {
 
 func (i *Imports) Write(f *code.Section) {
 	for key := range i.imports {
-		f.Sprintf(i.imports[key].String())
+		f.Sprint(i.imports[key].String())
 	}
 }

pkg/utils/contemplate.go

@@ -9,13 +9,13 @@ import (
 	"github.com/stoewer/go-strcase"
 )
 
-func LoadEventParams(cfg contemplate.Config) (map[string][]string, error) {
+func LoadEventParams(cfg contemplate.Config) (map[string]map[string]string, error) {
 	parser, err := contemplate.Load(&cfg)
 	if err != nil {
 		return nil, err
 	}
 
-	ret := map[string][]string{}
+	ret := map[string]map[string]string{}
 	for _, cfgPkg := range cfg.Packages {
 		pkg := parser.Package(cfgPkg.Path)
 		for _, typ := range cfgPkg.Types {
@@ -30,18 +30,28 @@ func LoadEventParams(cfg contemplate.Config) (map[string][]string, error) {
 	return ret, nil
 }
 
-func getEventParams(obj types.Object) ([]string, error) {
-	var ret []string
+func getEventParams(obj types.Object) (map[string]string, error) {
+	ret := map[string]string{}
 	if eventStruct := assume.T[*types.Struct](obj.Type().Underlying()); eventStruct != nil {
 		for i := range eventStruct.NumFields() {
 			if eventField := eventStruct.Field(i); eventField.Name() == "Params" {
 				if paramsStruct := assume.T[*types.Struct](eventField.Type().Underlying()); paramsStruct != nil {
 					for j := range paramsStruct.NumFields() {
-						tag, err := ParseStructTagName(paramsStruct.Tag(j))
+						var name string
+						var value string
+
+						tag, err := ParseStructTagName(paramsStruct.Tag(j), "json")
 						if err != nil {
 							return nil, errors.Wrapf(err, "failed to parse tag `%s`", paramsStruct.Tag(j))
 						}
-						ret = append(ret, tag)
+						name = tag
+						value = "eventModel." + tag
+
+						// check if there is a custom dlv tag
+						if tag, err := ParseStructTagName(paramsStruct.Tag(j), "dlv"); err == nil {
+							value = tag
+						}
+						ret[name] = value
 					}
 				}
 			}

pkg/utils/structtag.go

@@ -6,31 +6,13 @@ import (
 	"github.com/fatih/structtag"
 )
 
-func ParseStructTagName(value string) (string, error) {
+func ParseStructTagName(value, key string) (string, error) {
 	tags, err := structtag.Parse(strings.Trim(value, "`"))
 	if err != nil {
 		return "", err
 	}
 
-	tag, err := tags.Get("json")
-	if err != nil {
-		return "", err
-	}
-
-	if tag.Value() != "" && tag.Value() != "-" {
-		return strings.Split(tag.Value(), ",")[0], nil
-	}
-
-	return "", nil
-}
-
-func ParseStructTagOmitempty(value string) (string, error) {
-	tags, err := structtag.Parse(strings.Trim(value, "`"))
-	if err != nil {
-		return "", err
-	}
-
-	tag, err := tags.Get("json")
+	tag, err := tags.Get(key)
 	if err != nil {
 		return "", err
 	}

test/tagmanager/client_test.go

@@ -104,18 +104,17 @@ func TestNewClient_Server(t *testing.T) {
 		})
 	}
 
-	{ // --- Tags ---
+	{ // --- Templates ---
 		// t.Run("upsert template", func(t *testing.T) {
 		// 	obj, err := c.UpsertCustomTemplate(template2.NewConversionsAPITag("Facebook"))
 		// 	require.NoError(t, err)
 		// 	dump(t, obj)
 		// })
-
 		t.Run("list templates", func(t *testing.T) {
 			cmd := c.Service().Accounts.Containers.Workspaces.Templates.List(c.WorkspacePath())
 			if r, err := cmd.Do(); assert.NoError(t, err) {
 				// dump(t, r)
-				fmt.Println(r.Template[0].TemplateData)
+				fmt.Println(r.Template[4].TemplateData)
 			}
 		})
 	}
@@ -370,6 +369,16 @@ func TestNewClient_Web(t *testing.T) {
 		//	t.Log("ID: " + obj.TagId)
 		// })
 	}
+
+	{ // --- Templates ---
+		t.Run("list templates", func(t *testing.T) {
+			cmd := c.Service().Accounts.Containers.Workspaces.Templates.List(c.WorkspacePath())
+			if r, err := cmd.Do(); assert.NoError(t, err) {
+				// dump(t, r)
+				fmt.Println(r.Template[0].TemplateData)
+			}
+		})
+	}
 }
 
 // ------------------------------------------------------------------------------------------------