SDK Elixir

alias Kameleoon.Client
alias Kameleoon.Data.CustomData

:ok = Client.add_data(client, visitor_code, CustomData.new!(42, ["new_visitor_code"]))

# Dans cet exemple, 91 représente l'index de la Custom Data configurée comme identifiant unique dans Kameleoon.
alias Kameleoon.Client
alias Kameleoon.Data.CustomData
alias Kameleoon.Data.UniqueIdentifier

mapping_index = 91
feature_key = "ff123"

anonymous_visitor_code = "anonymous-visitor"
user_id = "authenticated-user"

# 1. Avant l'authentification du visiteur

# Récupérer la variation pour un visiteur non authentifié.
# On suppose que anonymousVisitorCode est l'ID généré aléatoirement pour ce visiteur.
{:ok, anonymous_variation} = Client.get_variation(client, anonymous_visitor_code, feature_key)

# 2. Après l'authentification du visiteur

# On suppose que `userId` est le code visiteur du visiteur authentifié.
:ok = Client.add_data(client, anonymous_visitor_code, CustomData.new!(mapping_index, [user_id]))
:ok = Client.flush_instant(client, anonymous_visitor_code)

# Indiquer que `userId` est un identifiant unique.
:ok = Client.add_data(client, user_id, UniqueIdentifier.new!(true))

# 3. Après l'autorisation du visiteur

# Récupérer la variation pour le `userId`, qui correspondra à la variation du code visiteur anonyme.
{:ok, user_variation} = Client.get_variation(client, user_id, feature_key)
is_same_variation = user_variation.key == anonymous_variation.key # true

# `userId` et `anonymousVisitorCode` sont désormais liés et peuvent être suivis comme un seul visiteur.
:ok = Client.track_conversion(client, user_id, 123)

# De plus, les visiteurs liés partagent toutes les données distantes précédemment suivies et récupérées.
:ok = Client.get_remote_visitor_data(client, user_id)

alias Kameleoon.Logger

# Le niveau de log `:none` désactive la journalisation.
:ok = Logger.set_log_level(:none)

# Le niveau de log `:error` permet uniquement de journaliser les problèmes susceptibles d'affecter le comportement principal du SDK.
:ok = Logger.set_log_level(:error)

# Le niveau de log `:warning` permet de journaliser les problèmes nécessitant une attention.
# Il étend le niveau de log `:error`.
# Le niveau de log `:warning` est le niveau par défaut.
:ok = Logger.set_log_level(:warning)

# Le niveau de log `:info` permet de journaliser des informations générales sur les processus internes du SDK.
# Il étend le niveau de log `:warning`.
:ok = Logger.set_log_level(:info)

# Le niveau `:debug` consigne des détails supplémentaires sur les processus internes du SDK.
:ok = Logger.set_log_level(:debug)

defmodule MyKameleoonLogger do
  @behaviour Kameleoon.Logger
  require Logger

  @impl true
  def log(level, message) do
    Logger.log(level, message)
  end
end

# Le filtrage par niveau de log est appliqué séparément de la logique de gestion des logs.
# Le logger personnalisé n'acceptera que les logs qui correspondent ou dépassent le niveau de log spécifié.
:ok = Kameleoon.Logger.set_log_level(:debug)
:ok = Kameleoon.Logger.set_logger(MyKameleoonLogger)

alias Kameleoon.Client

# Initialise le client en utilisant le délai d'attente par défaut configuré
:ok = Client.initialize(client)

# Initialise le client avec un délai d'attente personnalisé de 5 secondes
:ok = Client.initialize(client, timeout: 5_000)

{:ok, ready?} = Kameleoon.Client.is_ready?(client)

if ready? do
  # Le client est prêt
end

alias Kameleoon.ClientFactory

# Supprime le client mis en cache pour le site code donné
:ok = ClientFactory.forget("a8st4f59bj")

# Supprime le client mis en cache pour le site code et l'environnement donnés
:ok = ClientFactory.forget("a8st4f59bj", environment: "production")

alias Kameleoon.Client

feature_key = "new_checkout"

# Évalue le feature flag et envoie les données de tracking (comportement par défaut)
{:ok, active?} = Client.is_feature_active?(client, visitor_code, feature_key)

# Évalue le feature flag sans envoyer de données de tracking
{:ok, active_without_tracking?} =
  Client.is_feature_active?(client, visitor_code, feature_key, track: false)

alias Kameleoon.Client

feature_key = "new_checkout"

# Récupère la variation attribuée au visiteur (avec le tracking activé par défaut)
{:ok, variation} = Client.get_variation(client, visitor_code, feature_key)

# Récupère la variation sans envoyer de données de tracking
{:ok, variation_without_tracking} =
  Client.get_variation(client, visitor_code, feature_key, track: false)

alias Kameleoon.Client

# Récupère toutes les variations attribuées au visiteur (avec les options par défaut)
{:ok, variations} = Client.get_variations(client, visitor_code)

# Récupère uniquement les variations actives pour le visiteur
{:ok, only_active_variations} = Client.get_variations(client, visitor_code, only_active: true)

# Récupère les variations sans envoyer de données de tracking
{:ok, variations_without_tracking} = Client.get_variations(client, visitor_code, track: false)

alias Kameleoon.Client

experiment_id = 202_387

# Force le visiteur dans "variation_2" pour l'expérience donnée
:ok = Client.set_forced_variation(client, visitor_code, experiment_id, "variation_2")

# Supprime toute variation précédemment forcée pour le visiteur dans cette expérience
:ok = Client.set_forced_variation(client, visitor_code, experiment_id, nil)

# Force le visiteur dans "variation_2" avec des options personnalisées.
# Dans ce cas, les règles de ciblage sont respectées (force_targeting = false).
:ok =
  Client.set_forced_variation(
    client,
    visitor_code,
    experiment_id,
    "variation_2",
    force_targeting: false
  )

:ok = Kameleoon.Client.evaluate_audiences(client, visitor_code)

{:ok, datafile} = Kameleoon.Client.get_datafile(client)

alias Kameleoon.Client
alias Kameleoon.Data.Browser
alias Kameleoon.Data.PageView
alias Kameleoon.Data.UserAgent

:ok = Client.add_data(client, visitor_code, Browser.new!(:chrome, version: 123.0))

:ok =
  Client.add_data(client, visitor_code, [
    PageView.new!("https://example.com/pricing", title: "Pricing", referrers: [3]),
    UserAgent.new!("Mozilla/5.0")
  ])

:ok =
  Client.add_data(
    client,
    visitor_code,
    PageView.new!("https://example.com/checkout", title: "Checkout"),
    track: false
  )

# Met en file d'attente une opération de flush pour le visitor_code donné.
# Les données seront envoyées selon l'intervalle de tracking configuré.
:ok = Kameleoon.Client.flush(client, visitor_code)

# Envoie immédiatement toutes les données de tracking en attente pour le visitor_code donné.
:ok = Kameleoon.Client.flush_instant(client, visitor_code)

{:ok, data} = Kameleoon.Client.get_remote_data(client, "test-key")

alias Kameleoon.Client
alias Kameleoon.Types.RemoteVisitorDataFilter

# Récupérer les données distantes du visiteur sans aucun filtre.
# Cela renverra toutes les données disponibles pour le visiteur donné.
:ok = Client.get_remote_visitor_data(client, visitor_code)

# Créer un filtre pour limiter les données renvoyées.
filter = %RemoteVisitorDataFilter{
  previous_visit_amount: 5,
  conversions: true,
  page_views: true
}

# Récupérer les données distantes du visiteur en utilisant le filtre spécifié.
# Cela ne renverra que les données correspondant aux critères du filtre.
:ok = Client.get_remote_visitor_data(client, visitor_code, filter: filter)

alias Kameleoon.Client

# Récupérer les données d'audience d'un visiteur en utilisant uniquement le visitor_code.
:ok = Client.get_visitor_warehouse_audience(client, visitor_code, 98)

# Récupérer les données d'audience d'un visiteur en utilisant à la fois visitor_code et warehouse_key.
# Utile lorsque votre warehouse utilise un identifiant différent du visitor_code.
:ok = Client.get_visitor_warehouse_audience(client, visitor_code, 98, warehouse_key: "internal-user-id")

cookies = {PlugConnCookies, conn}

# Définir le consentement et mettre à jour les cookies.
{:ok, conn} = Kameleoon.Client.set_legal_consent(client, visitor_code, true, cookies)

alias Kameleoon.Client
alias Kameleoon.Data.CustomData

# Suivre un objectif.
:ok = Client.track_conversion(client, visitor_code, goal_id)

# Suivre un objectif avec un revenu.
:ok = Client.track_conversion(client, visitor_code, goal_id, revenue: 100.0)

# Suivre un objectif avec un revenu négatif.
:ok = Client.track_conversion(client, visitor_code, goal_id, revenue: 100.0, negative: true)

# Suivre un objectif avec des métadonnées personnalisées.
:ok =
  Client.track_conversion(
    client,
    visitor_code,
    goal_id,
    metadata: [CustomData.new!(4, ["true"])]
  )

{:ok, tracking_code} = Kameleoon.Client.get_engine_tracking_code(client, visitor_code)

:ok =
  Kameleoon.Client.on_datafile_update(client, fn ->
    IO.puts("Kameleoon datafile updated")
  end)

:ok = Kameleoon.Client.on_datafile_update(client, nil)

alias Kameleoon.Client
alias Kameleoon.Data.ApplicationVersion

# major
:ok = Client.add_data(client, visitor_code, ApplicationVersion.new!("10"))
# major.minor
:ok = Client.add_data(client, visitor_code, ApplicationVersion.new!("10.20"))
# major.minor.patch
:ok = Client.add_data(client, visitor_code, ApplicationVersion.new!("10.20.30"))

alias Kameleoon.Client
alias Kameleoon.Data.Browser

# Données de navigateur avec une version
:ok = Client.add_data(client, visitor_code, Browser.new!(:safari, version: 26.4))
# Données de navigateur sans version
:ok = Client.add_data(client, visitor_code, Browser.new!(:chrome))

alias Kameleoon.Client
alias Kameleoon.Data.Conversion
alias Kameleoon.Data.CustomData

# Ajouter une conversion simple avec l'ID 32
:ok = Client.add_data(client, visitor_code, Conversion.new!(32))

# Ajouter une conversion avec l'ID 33 incluant un revenu et marquée comme négative
:ok = Client.add_data(client, visitor_code, Conversion.new!(33, revenue: 10.0, negative: true))

# Ajouter une conversion avec l'ID 34 incluant un revenu, un drapeau négatif et des métadonnées personnalisées
:ok =
  Client.add_data(
    client,
    visitor_code,
    Conversion.new!(34,
      revenue: 10.0,
      negative: true,
      metadata: [
        CustomData.new!(3, ["metadata1", "md2"]),
        CustomData.new!(5, ["md3"])
      ]
    )
  )

alias Kameleoon.Client
alias Kameleoon.Data.Cookie

:ok = Client.add_data(client, visitor_code, Cookie.new!(%{"segment" => "vip"}))

alias Kameleoon.Client
alias Kameleoon.Data.CustomData

:ok = Client.add_data(client, visitor_code, CustomData.new!(1, ["value"]))

# Avec plusieurs valeurs
:ok = Client.add_data(client, visitor_code, CustomData.new!(1, ["value1", "value2"]))

# Pour définir le drapeau `overwrite` à false
:ok = Client.add_data(client, visitor_code, CustomData.new!(1, ["value"], overwrite: false))

# Pour utiliser un nom à la place de l'index
:ok = Client.add_data(client, visitor_code, CustomData.new_with_name!("my-custom-data", ["value"]))

# Pour utiliser un nom à la place de l'index et définir le drapeau `overwrite` à false
:ok =
  Client.add_data(
    client,
    visitor_code,
    CustomData.new_with_name!("my-custom-data", ["value"], overwrite: false)
  )

alias Kameleoon.Client
alias Kameleoon.Data.Device

:ok = Client.add_data(client, visitor_code, Device.new!(:desktop))

alias Kameleoon.Client
alias Kameleoon.Data.Geolocation

geolocation =
  Geolocation.new!("France",
    region: "Ile-de-France",
    city: "Paris",
    postal_code: "75009",
    latitude: 48.8720171,
    longitude: 2.3338352
  )

:ok = Client.add_data(client, visitor_code, geolocation)

alias Kameleoon.Client
alias Kameleoon.Data.OperatingSystem

:ok = Client.add_data(client, visitor_code, OperatingSystem.new!(:windows))

alias Kameleoon.Client
alias Kameleoon.Data.PageView

# Constructeur complet avec url, titre optionnel et référents.
:ok = Client.add_data(client, visitor_code, PageView.new!("https://example.com", title: "Homepage", referrers: [3]))

# Constructeur minimal, ne nécessite qu'une URL.
:ok = Client.add_data(client, visitor_code, PageView.new!("https://example.com"))

alias Kameleoon.Client
alias Kameleoon.Data.UniqueIdentifier

:ok = Client.add_data(client, visitor_code, UniqueIdentifier.new!(true))

alias Kameleoon.Client
alias Kameleoon.Data.UserAgent

:ok = Client.add_data(client, visitor_code, UserAgent.new!("Mozilla/5.0"))

# Récupère la map des feature flags depuis le DataFile.
# La map est indexée par les identifiants de feature flag, chaque valeur étant une structure FeatureFlag.
feature_flags = datafile.feature_flags

# Récupère l'horodatage de la dernière modification du DataFile.
# La valeur est un entier représentant les millisecondes depuis l'époque Unix.
date_modified = datafile.date_modified

# Vérifie si le feature flag est activé dans l'environnement actuel.
environment_enabled = feature_flag.environment_enabled

# Récupère la clé de la variation par défaut.
default_variation_key = feature_flag.default_variation_key

# Récupère la structure de la variation par défaut.
default_variation = Kameleoon.Types.FeatureFlag.default_variation(feature_flag)

# Récupère toutes les variations du feature flag sous forme de map (clé = clé de variation, valeur = structure Variation).
variations = feature_flag.variations

# Récupère toutes les règles de ciblage associées au feature flag.
rules = feature_flag.rules

# Récupère toutes les variations de la règle sous forme de map (clé = clé de variation, valeur = structure Variation).
variations = rule.variations

# Récupération du nom de la variation.
variation_name = variation.name

# Récupération de la clé de la variation.
variation_key = variation.key

# Récupération de l'id de la variation.
variation_id = variation.id

# Récupération de l'id de l'expérience.
experiment_id = variation.experiment_id

# Récupération de la liste des variables.
variables = variation.variables

# Vérifier si la variation est active (c'est-a-dire actuellement servie aux visiteurs).
active? = Kameleoon.Types.Variation.active?(variation)

# Récupération d'une variable par sa clé, renvoyant nil si introuvable.
variable = Enum.find(variation.variables, &(&1.key == "title"))

# Récupérer la liste des variables associées à la variation.
variables = variation.variables

# Accéder au type de variable (kind) pour une gestion conditionnelle.
kind = variable.kind

# Extraire la valeur en tant que nombre.
number = variable.value

# Extraire la valeur en tant que booléen.
apply_discount? = variable.value

# Extraire la valeur en tant que chaîne.
title = variable.value