Atributos personalizados anidados

Esta página trata de los atributos personalizados anidados, que te permiten definir un conjunto de atributos como propiedad de otro atributo. En otras palabras, cuando defines un objeto de atributo personalizado, puedes definir un conjunto de atributos adicionales para ese objeto.

Acerca de los atributos anidados

Los atributos anidados te permiten construir segmentos más ricos y personalizar mensajes con datos de un único objeto personalizado de atributo.

En el siguiente ejemplo, el atributo personalizado favorite_book contiene los atributos anidados title, author y publishing_date. Este objeto puede utilizarse para dirigirse a los usuarios por autor, filtrar por fecha de publicación o insertar el título del libro directamente en un mensaje:

1
2
3
4
5
"favorite_book": {
  "title": "The Hobbit",
  "author": "J.R.R. Tolkien",
  "publishing_date": "1937"
}

Tipos de datos admitidos

Se admiten los siguientes tipos de datos:

Consideraciones

• Los atributos personalizados anidados están pensados para atributos personalizados enviados a través del SDK o la API de Braze.
• Los objetos tienen un tamaño máximo de 100 KB. Si una actualización hace que el objeto supere los 100 KB, Braze descarta la actualización y el atributo permanece sin cambios.
• Los nombres de las claves y los valores de cadena tienen un límite de tamaño de 255 caracteres.
• Los nombres de las claves no pueden contener espacios.
• Los puntos (.) y los signos de dólar ($) no son caracteres compatibles en una carga útil de API si intentas enviar un atributo personalizado anidado a un perfil de usuario.
• No todos los socios de Braze admiten atributos personalizados anidados. Consulta la documentación del socio para confirmar si determinadas integraciones del socio admiten esta característica.
• Los atributos personalizados anidados no se pueden utilizar como filtro al realizar una llamada a la API de Connected Audience.

Ejemplo de API

• create
• update
• delete

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
{
  "attributes": [
    {
      "external_id": "user_id",
      "most_played_song": {
        "song_name": "Solea",
        "artist_name": "Miles Davis",
        "album_name": "Sketches of Spain",
        "genre": "Jazz",
        "play_analytics": {
            "count": 1000,
            "top_10_listeners": true
        }
      }
    }
  ]
}

1
2
3
4
5
6
7
8
9
10
11
{
  "attributes": [
    {
      "external_id": "user_id",
      "_merge_objects": true,
      "most_played_song": {
          "year_released": 1960
      }
    }
  ]
}

1
2
3
4
5
6
7
8
9
10
11
{"most_played_song": {
  "song_name": "Solea",
  "artist_name" : "Miles Davis",
  "album_name": "Sketches of Spain",
  "year_released": 1960,
  "genre": "Jazz",
  "play_analytics": {
     "count": 1000,
     "top_10_listeners": true
  }
}}

1
2
3
4
5
6
7
8
{
  "attributes": [
    {
      "external_id": "user_id",
      "most_played_song": null
    }
  ]
}

Ejemplo de SDK

• android sdk
• swift sdk
• web sdk

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
val json = JSONObject()
    .put("song_name", "Solea")
    .put("artist_name", "Miles Davis")
    .put("album_name", "Sketches of Spain")
    .put("genre", "Jazz")
    .put(
        "play_analytics",
        JSONObject()
            .put("count", 1000)
            .put("top_10_listeners", true)
    )

braze.getCurrentUser { user ->
    user.setCustomUserAttribute("most_played_song", json)
}

1
2
3
4
5
6
val json = JSONObject()
    .put("year_released", 1960)

braze.getCurrentUser { user ->
    user.setCustomUserAttribute("most_played_song", json, true)
}

1
2
3
braze.getCurrentUser { user ->
    user.unsetCustomUserAttribute("most_played_song")
}

1
2
3
4
5
6
7
8
9
10
11
12
let json: [String: Any?] = [
  "song_name": "Solea",
  "artist_name": "Miles Davis",
  "album_name": "Sketches of Spain",
  "genre": "Jazz",
  "play_analytics": [
    "count": 1000,
    "top_10_listeners": true,
  ],
]

braze.user.setCustomAttribute(key: "most_played_song", dictionary: json)

1
2
3
4
5
let json: [String: Any?] = [
  "year_released": 1960
]

braze.user.setCustomAttribute(key: "most_played_song", dictionary: json, merge: true)

1
braze.user.unsetCustomAttribute(key: "most_played_song")

1
2
3
4
5
6
7
8
9
10
11
12
import * as braze from "@braze/web-sdk";
const json = {
  "song_name": "Solea",
  "artist_name": "Miles Davis",
  "album_name": "Sketches of Spain",
  "genre": "Jazz",
  "play_analytics": {
    "count": 1000,
    "top_10_listeners": true
  }
};
braze.getUser().setCustomUserAttribute("most_played_song", json);

1
2
3
4
5
6
import * as braze from "@braze/web-sdk";
const json = {
  "year_released": 1960
};
braze.getUser().setCustomUserAttribute("most_played_song", json, true);

1
2
import * as braze from "@braze/web-sdk";
braze.getUser().setCustomUserAttribute("most_played_song", null);

Capturar fechas como propiedades de objeto

Para capturar fechas como propiedades de objeto, debes usar la clave $time. En el siguiente ejemplo, se usa un objeto “Important Dates” para capturar el conjunto de propiedades de objeto, birthday y wedding_anniversary. Los valores de estas fechas son un objeto con una clave $time, que no puede ser un valor nulo.

1
2
3
4
5
6
7
8
9
10
11
{
  "attributes": [
    {
      "external_id": "time_with_nca_test",
      "important_dates": {
        "birthday": {"$time" : "1980-01-01"},
        "wedding_anniversary": {"$time" : "2020-05-28"}
      }
    }
  ]
}

Plantillas Liquid

El siguiente ejemplo de plantilla Liquid muestra cómo hacer referencia a las propiedades del objeto de atributo personalizado guardadas desde la solicitud de API anterior y usarlas en tu mensajería.

Usa la etiqueta de personalización custom_attribute y la notación de punto para acceder a las propiedades de un objeto. Especifica el nombre del objeto (y la posición en la matriz si haces referencia a una matriz de objetos), seguido de un punto, seguido del nombre de la propiedad.

{{custom_attribute.${most_played_song}[0].artist_name}} — “Miles Davis”
{{custom_attribute.${most_played_song}[0].song_name}} — “Solea”
{{custom_attribute.${most_played_song}[0].play_analytics.count}} — “1000”

Personalización

Usando el modal Add Personalization, también puedes insertar atributos personalizados anidados en tu mensajería. Selecciona Nested Custom Attributes como tipo de personalización. A continuación, selecciona el atributo de nivel superior y la clave del atributo.

Por ejemplo, en el modal de personalización a continuación, esto inserta el atributo personalizado anidado de una oficina de barrio local basándose en las preferencias de un usuario.

Regenerar esquemas

Después de que se haya generado un esquema, se puede regenerar una vez cada 24 horas. Esta sección describe cómo regenerar tu esquema. Para información más detallada sobre esquemas, consulta Generar un esquema usando el explorador de objetos anidados.

Para regenerar el esquema de tu atributo personalizado anidado:

1. Ve a Data Settings > Custom Attributes.
2. Busca tu atributo personalizado anidado.
3. En la columna Attribute Name de tu atributo, selecciona para administrar el esquema.
4. Aparecerá un modal. Selecciona Regenerate Schema.

La opción de regenerar esquema estará deshabilitada si han pasado menos de 24 horas desde la última regeneración del esquema. Regenerar el esquema solo detectará nuevos objetos y no eliminará objetos que actualmente existen en el esquema.

Si los datos no aparecen como se esperaba después de regenerar el esquema, es posible que el atributo no se ingiera con suficiente frecuencia. Los datos de usuario se muestrean a partir de datos anteriores enviados a Braze para el atributo anidado dado. Si el atributo no se ingiere lo suficiente, no será recogido para el esquema.

Desencadenar cambios en atributos personalizados anidados

Puedes desencadenar acciones cuando un objeto de atributo personalizado anidado cambia. Esta opción no está disponible para cambios en matrices de objetos. Si no ves una opción para ver el explorador de rutas, verifica que hayas generado un esquema.

Por ejemplo, en una Campaign basada en acciones, puedes añadir una nueva acción desencadenante para Change Custom Attribute Value para dirigirte a usuarios que hayan cambiado sus preferencias de oficina de barrio.

Comportamiento de segmentación con matrices de objetos

Cuando usas múltiples filtros de Nested Custom Attribute con lógica AND para segmentar en una matriz de objetos, cada filtro se evalúa de forma independiente en todos los elementos de la matriz. Un usuario califica para el segmento si cualquier elemento de la matriz satisface cada filtro individual; los filtros no tienen que coincidir con el mismo elemento.

Por ejemplo, supongamos que un usuario tiene la siguiente matriz:

1
2
3
4
5
6
{
  "orders": [
    {"product": "Shoes", "price": 80},
    {"product": "Hat", "price": 25}
  ]
}

Un segmento con los siguientes filtros AND:

• orders[].price es mayor que 50
• orders[].price es menor que 30

Este usuario calificaría porque el primer filtro coincide con el elemento “Shoes” (80 > 50) y el segundo filtro coincide con el elemento “Hat” (25 < 30). Aunque ningún elemento individual satisface ambas condiciones, el usuario aún entra en el segmento.

Si necesitas que todas las condiciones coincidan con el mismo elemento dentro de una matriz, usa segmentación multicriterio en la misma ruta, o reestructura tus datos para evitar la coincidencia entre elementos.

Puntos de datos

Cualquier clave que se envíe consume un punto de datos. Por ejemplo, este objeto inicializado en el perfil de usuario cuenta como siete (7) puntos de datos:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
  "attributes": [
    {
      "external_id": "user_id",
      "most_played_song": {
        "song_name": "Solea",
        "artist_name": "Miles Davis",
        "album_name": "Sketches of Spain",
        "year_released": 1960,
        "genre": "Jazz",
        "play_analytics": {
          "count": 1000,
          "top_10_listeners": true
        }
      }
    }
  ]
}