I pass fedeltà supportano il rendering dei modelli. Se non è stato definito alcun modello, ne verrà utilizzato uno predefinito.
Definizione del modello
Un modello di pass viene definito a livello di classe e viene utilizzato per visualizzare qualsiasi oggetto associato alla classe. Il modello definisce quali campi mostrare nelle diverse sezioni del pass.
Il modello è suddiviso nelle seguenti sezioni:
Android
Web
Titolo della scheda
Android
|
|
Web
|
|
Nella sezione del titolo della carta vengono mostrati il logo, il nome dell'emittente e il titolo del programma. Non è possibile modificare né i riferimenti dei campi utilizzati per inserirli né la posizione.
Modello di scheda
Android
Web
La sezione Modello di scheda viene utilizzata per visualizzare le righe aggiuntive. Queste righe possono contenere campi di dati strutturati basati su testo o campi di moduli di testo.
Puoi specificare il numero di righe che definiscono il numero di oggetti nell'elenco class.classTemplateInfo.cardTemplateOverride.cardRowTemplateInfos[]. L'elenco richiede almeno un elemento e consigliamo di utilizzare al massimo due elementi. Ogni elemento deve essere di uno dei seguenti tipi:
-
oneItem, che accetta un elemento:item
-
twoItems, che accetta due elementi:startItemendItem
-
threeItems, che accetta tre elementi:startItemmiddleItemendItem
Ogni elemento può essere definito come un singolo selettore di campi (.firstValue), due selettori di campo (.firstValue e .secondValue) o un elemento predefinito (.predefinedItem). Vengono visualizzati sia i valori del campo selezionato sia le rispettive etichette. Quando definisci due selettori, i valori dei campi selezionati vengono visualizzati con un separatore "/". Lo stesso vale per le etichette dei campi selezionati. Gli elementi predefiniti vengono utilizzati per definire un rendering più complesso.
Il seguente esempio di codice mostra come eseguire l'override delle sezioni delle righe delle schede
dei modelli di schede per specificare due righe. Ogni riga include tre elementi che
fanno riferimento a sei campi personalizzati textModuleData a livello di classe e le relative
intestazioni come etichette:
Python
{
... //Rest of class
"textModulesData": [
{
"header": "Label 1",
"body": "Some info 1",
"id": "myfield1"
},
{
"header": "Label 2",
"body": "Some info 2",
"id": "myfield2"
},
{
"header": "Label 3",
"body": "Some info 3",
"id": "myfield3"
},
{
"header": "Label 4",
"body": "Some info 4",
"id": "myfield4"
},
{
"header": "Label 5",
"body": "Some info 5",
"id": "myfield5"
},
{
"header": "Label 6",
"body": "Some info 6",
"id": "myfield6"
}
],
"classTemplateInfo": {
"cardTemplateOverride": {
"cardRowTemplateInfos": [{
"threeItems": {
"startItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield1']"
}]
}
},
"middleItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield2']"
}]
}
},
"endItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield3']"
}]
}
},
}
},{
"threeItems": {
"startItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield4']"
}]
}
},
"middleItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield5']"
}]
}
},
"endItem": {
"firstValue": {
"fields": [{
"fieldPath": "class.textModulesData['myfield6']"
}]
}
},
}
}]
}
}
}
Java
// Rest of class
.setTextModulesData((new ArrayList<TextModuleData>() {
{
add((new TextModuleData()).setHeader("Label 1")
.setBody("Some info 1")
.setId("myfield1"));
add((new TextModuleData()).setHeader("Label 2")
.setBody("Some info 1")
.setId("myfield2"));
add((new TextModuleData()).setHeader("Label 3")
.setBody("Some info 3")
.setId("myfield3"));
add((new TextModuleData()).setHeader("Label 4")
.setBody("Some info 4")
.setId("myfield4"));
add((new TextModuleData()).setHeader("Label 5")
.setBody("Some info 5")
.setId("myfield5"));
add((new TextModuleData()).setHeader("Label 6")
.setBody("Some info 5")
.setId("myfield6"));
}
}))
.setClassTemplateInfo((new ClassTemplateInfo())
.setCardTemplateOverride((new CardTemplateOverride())
.setCardRowTemplateInfos(new ArrayList<CardRowTemplateInfo>() {
{
add((new CardRowTemplateInfo()).setThreeItems((new CardRowThreeItems())
.setStartItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield1']"));
}
})))
.setMiddleItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield2']"));
}
})))
.setEndItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield3']"));
}
})))
));
add((new CardRowTemplateInfo()).setThreeItems((new CardRowThreeItems())
.setStartItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield4']"));
}
})))
.setMiddleItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield5']"));
}
})))
.setEndItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.textModulesData['myfield6']"));
}
})))
));
}
})))
PHP
// Rest of class
$textModulesData1 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData1->setBody("Some info 1");
$textModulesData1->setHeader("Label 1");
$textModulesData1->setId("myfield1");
$textModulesData2 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData2->setBody("Some info 2");
$textModulesData2->setHeader("Label 2");
$textModulesData2->setId("myfield2");
$textModulesData3 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData3->setBody("Some info 3");
$textModulesData3->setHeader("Label 3");
$textModulesData3->setId("myfield3");
$textModulesData4 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData4->setBody("Some info 4");
$textModulesData4->setHeader("Label 4");
$textModulesData4->setId("myfield4");
$textModulesData5 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData5->setBody("Some info 5");
$textModulesData5->setHeader("Label 5");
$textModulesData5->setId("myfield5");
$textModulesData6 = new Google_Service_Walletobjects_TextModuleData();
$textModulesData6->setBody("Some info 6");
$textModulesData6->setHeader("Label 6");
$textModulesData6->setId("myfield6");
$textModulesDatas = array($textModulesData1, $textModulesData2, $textModulesData3,
$textModulesData4, $textModulesData5, $textModulesData6);
$startItemField = new Google_Service_Walletobjects_FieldReference();
$startItemField->setFieldPath("class.textModulesData['myfield1']");
$startItemFirstValue = new Google_Service_Walletobjects_FieldSelector();
$startItemFirstValue->setFields(array($startItemField));
$startItem = new Google_Service_Walletobjects_TemplateItem();
$startItem->setFirstValue($startItemFirstValue);
$middleItemField = new Google_Service_Walletobjects_FieldReference();
$middleItemField->setFieldPath("class.textModulesData['myfield2']");
$middleItemFirstValue = new Google_Service_Walletobjects_FieldSelector();
$middleItemFirstValue->setFields(array($middleItemField));
$middleItem = new Google_Service_Walletobjects_TemplateItem();
$middleItem->setFirstValue($middleItemFirstValue);
$endItemField = new Google_Service_Walletobjects_FieldReference();
$endItemField->setFieldPath("class.textModulesData['myfield3']");
$endItemFirstValue = new Google_Service_Walletobjects_FieldSelector();
$endItemFirstValue->setFields(array($endItemField));
$endItem = new Google_Service_Walletobjects_TemplateItem();
$endItem->setFirstValue($endItemFirstValue);
$cardRowTemplate = new Google_Service_Walletobjects_CardRowThreeItems();
$cardRowTemplate->setStartItem($startItem);
$cardRowTemplate->setMiddleItem($middleItem);
$cardRowTemplate->setEndItem($endItem);
$cardRowTemplateInfo1 = new Google_Service_Walletobjects_CardRowTemplateInfo();
$cardRowTemplateInfo1->setThreeItems($cardRowTemplate);
$startItemField2 = new Google_Service_Walletobjects_FieldReference();
$startItemField2->setFieldPath("class.textModulesData['myfield4']");
$startItemFirstValue2 = new Google_Service_Walletobjects_FieldSelector();
$startItemFirstValue2->setFields(array($startItemField2));
$startItem2 = new Google_Service_Walletobjects_TemplateItem();
$startItem2->setFirstValue($startItemFirstValue2);
$middleItemField2 = new Google_Service_Walletobjects_FieldReference();
$middleItemField2->setFieldPath("class.textModulesData['myfield5']");
$middleItemFirstValue2 = new Google_Service_Walletobjects_FieldSelector();
$middleItemFirstValue2->setFields(array($middleItemField2));
$middleItem2 = new Google_Service_Walletobjects_TemplateItem();
$middleItem2->setFirstValue($middleItemFirstValue2);
$endItemField2 = new Google_Service_Walletobjects_FieldReference();
$endItemField2->setFieldPath("class.textModulesData['myfield6']");
$endItemFirstValue2 = new Google_Service_Walletobjects_FieldSelector();
$endItemFirstValue2->setFields(array($endItemField2));
$endItem2 = new Google_Service_Walletobjects_TemplateItem();
$endItem2->setFirstValue($endItemFirstValue2);
$cardRowTemplate2 = new Google_Service_Walletobjects_CardRowThreeItems();
$cardRowTemplate2->setStartItem($startItem2);
$cardRowTemplate2->setMiddleItem($middleItem2);
$cardRowTemplate2->setEndItem($endItem2);
$cardRowTemplateInfo2 = new Google_Service_Walletobjects_CardRowTemplateInfo();
$cardRowTemplateInfo2->setThreeItems($cardRowTemplate2);
$cardTemplateOverride = new Google_Service_Walletobjects_CardTemplateOverride();
$cardTemplateOverride->setCardRowTemplateInfos(array($cardRowTemplateInfo1,
$cardRowTemplateInfo2));
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setCardTemplateOverride($cardTemplateOverride);
$payload->setTextModulesData($textModulesDatas);
$payload->setClassTemplateInfo($classTemplateInfo);
Il codice crea un pass con il seguente formato di sezione di modello di codice:
Se un elemento è vuoto, non viene visualizzato. Per maggiori dettagli, consulta Riferimenti del campo. Se tutti gli elementi di una riga sono vuoti, la riga non viene visualizzata. Se alcuni elementi in una riga, ma non tutti, sono vuoti, gli elementi non vuoti vengono riorganizzati e visualizzati come una riga con meno elementi.
Se non esegui l'override del modello di scheda, vengono utilizzati il numero predefinito di righe, il numero predefinito di elementi e i riferimenti ai campi predefiniti. Per maggiori dettagli, consulta la sezione Modello predefinito.
Dopo la definizione, un'immagine hero può essere visualizzata dopo la prima riga, se sono presenti più righe nell'elenco cardRowTemplateInfos oppure sopra la riga, se ce n'è una sola.
Codice a barre della carta
Android
|
|
Web
|
|
La sezione del codice a barre delle schede viene utilizzata per mostrare testo o immagini aggiuntive sopra e sotto il codice a barre. Nessuno dei campi di questa sezione è obbligatorio.
Esistono tre selettori dei campi che possono essere utilizzati per definire due campi affiancati sopra e uno sotto il codice a barre. Vengono visualizzati senza etichetta e possono essere campi di dati strutturati basati su testo, campi per moduli di testo o campi per moduli immagine. Se utilizzi le immagini, queste devono seguire le linee guida per il brand.
Il codice a barre viene definito da un tipo e un valore. Per un elenco dei tipi di codici a barre supportati, consulta la sezione Riferimento. Inoltre, un testo può essere mostrato sotto il codice a barre. Questo testo, tra gli altri utilizzi, può semplificare la scansione dei codici a barre.
Il seguente esempio di codice mostra come eseguire l'override della sezione di codice a barre di un pass per visualizzare un'immagine sopra il codice a barre:
Python
#... rest of class
"imageModulesData": [
{
"mainImage": {
"sourceUri": {
"uri": "http://farm4.staticflickr.com/3738/12440799783_3dc3c20606_b.jpg",
"description": "Coffee"
}
},
"Id": "myimage"
}
],
"classTemplateInfo": {
"cardBarcodeSectionDetails": {
"firstTopDetail": {
"fieldSelector": {
"fields": [
{
"fieldPath": "class.imageModulesData['myimage'].mainImage"
}
]
}
}
}
}
}
Java
//... rest of class
.setImageModulesData((new ArrayList<ImageModuleData>() {
{
add((new ImageModuleData())
.setId("myimage")
.setMainImage((new Image()).setSourceUri((new ImageUri()).setDescription("Coffee beans")
.setUri("http://farm4.staticflickr.com/3738/12440799783_3dc3c20606_b.jpg"))));
}
}))
.setClassTemplateInfo((new ClassTemplateInfo())
.setCardBarcodeSectionDetails((new CardBarcodeSectionDetails())
.setFirstTopDetail((new BarcodeSectionDetail())
.setFieldSelector((new FieldSelector())
.setFields((new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.imageModulesData['myimage'].mainImage"));
}
})))))
}
PHP
//... rest of class
$imageUri = new Google_Service_Walletobjects_ImageUri();
$imageUri->setUri("https://farm8.staticflickr.com/7340/11177041185_a61a7f2139_o.jpg");
$imageUri->setDescription("Baconrista flights image");
$image = new Google_Service_Walletobjects_Image();
$image->setSourceUri($imageUri);
$imageModulesData = new Google_Service_Walletobjects_ImageModuleData();
$imageModulesData->setMainImage($image);
$imageModulesData->setId("myimage");
$cardBarcodeFieldReference = new Google_Service_Walletobjects_FieldReference();
$cardBarcodeFieldReference->setFieldPath("class.imageModulesData['myimage'].mainImage");
$cardBarcodeFieldSelector = new Google_Service_Walletobjects_FieldSelector();
$cardBarcodeFieldSelector->setFields(array($cardBarcodeFieldReference));
$cardBarcodeDetail = new Google_Service_Walletobjects_BarcodeSectionDetail();
$cardBarcodeDetail->setFieldSelector($cardBarcodeFieldSelector);
$cardBarcodeSectionDetails = new Google_Service_Walletobjects_CardBarcodeSectionDetails();
$cardBarcodeSectionDetails->setFirstTopDetail($cardBarcodeDetail);
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setCardBarcodeSectionDetails($cardBarcodeSectionDetails);
$payload->setClassTemplateInfo($classTemplateInfo);
$payload->setImageModuleData($imageModulesData);
Il codice crea un pass con il seguente formato di sezione di codice a barre:
Se non esegui l'override della sezione del codice a barre, vengono utilizzati i campi del codice a barre predefiniti. Per saperne di più, vedi Modello predefinito.
Modello di dettagli
Android
|
|
Web
|
|
La sezione del modello dei dettagli è un elenco di elementi
class.classTemplateInfo.detailsTemplateOverride.detailsItemInfos[]. Gli elementi possono contenere qualsiasi tipo di campi di dati strutturati, campi di moduli di testo, campi di moduli di link, campi di modulo immagine o messaggi.
Ogni elemento può essere definito come un singolo selettore di campi (.firstValue), due selettori (.firstValue e .secondValue) o un elemento predefinito (.predefinedItem). Vengono visualizzati sia i valori del campo selezionato sia le rispettive etichette. Quando definisci due selettori, i valori dei campi selezionati vengono visualizzati con un separatore "/". Lo stesso vale per le etichette dei campi selezionati. Gli elementi predefiniti vengono utilizzati per definire un rendering più complesso. I campi del modulo immagine vengono visualizzati a larghezza intera senza un'etichetta.
Il seguente esempio di codice mostra come eseguire l'override della sezione dei dettagli del pass per visualizzare un singolo campo linksModuleData con la sua etichetta:
Python
//... rest of class
"linksModuleData": {
"uris": [
{
"uri": "http://maps.google.com/",
"description": "Nearby Locations",
"id":"mylink"
}
]
},
"classTemplateInfo": {
"detailsTemplateOverride": {
"detailsItemInfos": [
{
"item":{
"firstValue": {
"fields": [{
"fieldPath": "class.linksModuleData.uris['mylink']"
}]
}
}
}
]
}
}
//... rest of class
Java
//... rest of class
.setLinksModuleData((new ArrayList<LinksModuleData>() {
{
add((new LinksModuleData()).setDescription("Nearby Locations")
.setUri("http://maps.google.com/")
.setId("mylink"));
}))
.setClassTemplateInfo((new ClassTemplateInfo())
.setDetailsTemplateOverride((new DetailsTemplateOverride())
.setDetailsItemInfos(new ArrayList<DetailsItemInfo>(){
{
add((new DetailsItemInfo())
.setItem((new TemplateItem()).setFirstValue((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("class.linksModuleData.uris['mylink']"));
}
}))));
}
}))
//... rest of class
PHP
//... rest of class building
$locationUri = new Google_Service_Walletobjects_Uri();
$locationUri->setUri("http://maps.google.com/");
$locationUri->setDescription("Nearby Locations");
$locationUri->setId("mylink");
$linksModuleData = new Google_Service_Walletobjects_LinksModuleData();
$linksModuleData->setUris(array($locationUri));
$detailItemFieldReference = new Google_Service_Walletobjects_FieldReference();
$detailItemFieldReference->setFieldPath("class.linksModuleData.uris['mylink']");
$detailItemFieldSelector = new Google_Service_Walletobjects_FieldSelector();
$detailItemFieldSelector->setFields(array($detailItemFieldReference));
$detailItem = new Google_Service_Walletobjects_TemplateItem();
$detailItem->setFirstValue($detailItemFieldSelector);
$detailsItemInfo = new Google_Service_Walletobjects_DetailsItemInfo();
$detailsItemInfo->setItem($detailItem);
$cardDetailsTemplateOverride = new Google_Service_Walletobjects_DetailsTemplateOverride();
$cardDetailsTemplateOverride->setDetailsItemInfos(array($detailsItemInfo));
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setDetailsTemplateOverride($cardDetailsTemplateOverride);
$payload->setClassTemplateInfo($classTemplateInfo);
$payload->setLinksModuleData($linksModuleData);
//... rest of class
Il codice crea un pass con il seguente formato di sezione dei dettagli:
Se un elemento è vuoto, non viene visualizzato. Per maggiori dettagli, consulta Riferimenti del campo.
Se non esegui l'override del modello dettagli, viene visualizzato l'elenco predefinito dei campi di riferimento nell'ordine predefinito. Per maggiori informazioni, consulta la pagina Modello predefinito.
Modello di elenco
|
|
La sezione del modello dell'elenco viene utilizzata per selezionare il campo da mostrare nella visualizzazione "Pass" dell'app Google Wallet. Il pass è rappresentato nell'elenco con il logo, il colore di sfondo e tre righe.
Il seguente esempio di codice mostra come eseguire l'override del modello di elenco di un pass per visualizzare un campo data di scadenza dell'oggetto di un singolo pass nella prima riga del modello di elenco:
Python
#... rest of class definition
"classTemplateInfo": {
"listTemplateOverride":{
"firstRowOption": {
"fieldOption":{
"fields": [{
"fieldPath": "object.validTimeInterval.end"
}]
}
}
}
}
}
Java
//... rest of class
.setClassTemplateInfo((new ClassTemplateInfo())
.setListTemplateOverride((new ListTemplateOverride())
.setFirstRowOption((new FirstRowOption())
.setFieldOption((new FieldSelector()).setFields(new ArrayList<FieldReference>(){
{
add((new FieldReference()).setFieldPath("object.validTimeInterval.end"));
}
}))))
//... rest of class
PHP
//... rest of class
$fieldReference = new Google_Service_Walletobjects_FieldReference();
$fieldReference->setFieldPath("object.validTimeInterval.end");
$fieldOption = new Google_Service_Walletobjects_FieldSelector();
$fieldOption->setFields(array($fieldReference));
$firstRowOption = new Google_Service_Walletobjects_FirstRowOption();
$firstRowOption->setFieldOption($fieldOption);
$listTemplateOverride = new Google_Service_Walletobjects_ListTemplateOverride();
$listTemplateOverride->setFirstRowOption($firstRowOption);
$classTemplateInfo = new Google_Service_Walletobjects_ClassTemplateInfo();
$classTemplateInfo->setListTemplateOverride($listTemplateOverride);
$payload->setClassTemplateInfo($classTemplateInfo);
//... rest of class
Il codice crea un pass con la seguente rappresentazione del modello di elenco:
Le tre righe possono essere definite con un selettore di campi. I campi sono visualizzati senza etichetta.
Etichette
Tutti i campi dei dati strutturati hanno un'etichetta fornita da Google. Google è responsabile di fornire una traduzione per ciascuna di queste etichette in tutte le lingue supportate.
Puoi personalizzare alcune di queste etichette utilizzando uno dei
campi class.custom<name_of_the_field>Label. Quando personalizzi un'etichetta, sei responsabile della traduzione per quell'etichetta in tutte le lingue che vuoi supportare.
Riferimenti dei campi
I riferimenti ai campi vengono utilizzati in diverse parti del modello con il modulo class.classTemplateInfo.*.fields[]. Un riferimento di campo contiene un elenco di percorsi per campi di dati strutturati, campi di modulo di testo, campi di moduli di link, campi di modulo immagine o messaggi.
Non tutti i tipi di percorsi sono consentiti in ogni riferimento ai campi. Ad esempio, alcuni riferimenti a campi consentono solo i percorsi per campi di dati strutturati basati su testo o campi di moduli di testo. I campi strutturati basati su testo sono campi di dati strutturati di tipo stringa, stringa localizzata, data o denaro.
L'elenco può essere utilizzato per implementare una logica di riserva. Ciò significa che se il primo percorso dell'elenco viene risolto in un campo vuoto, viene valutato il percorso successivo. La logica di riserva è mirata principalmente a campi di dati strutturati basati su testo o campi di moduli di testo. Non combinare diversi tipi di campi nello stesso elenco. Utilizza la logica di riserva con cautela e solo in situazioni specifiche in cui prevedi un pattern coerente di campi esistenti in alcuni oggetti, ma non in altri. Nella maggior parte dei casi, è più facile creare corsi separati per casi d'uso distinti.
Se tutti i percorsi in un elenco di riferimenti ai campi si trasformano in campi vuoti, l'elemento che utilizza il riferimento del campo non viene visualizzato. Se vuoi che l'elemento che utilizza il riferimento del campo sia sempre presente, assicurati che almeno un percorso non sia vuoto. Ti consigliamo di impostare un campo su un carattere speciale, come "-", per rappresentare un valore nullo, anche se alcuni campi consentono stringhe con solo uno spazio.
Per fare riferimento a un campo contenuto in un elenco, puoi utilizzare l'indice del campo nell'elenco o, nella maggior parte dei casi, un ID di riferimento. Gli elementi di un elenco a cui è possibile fare riferimento in base all'ID hanno un campo .id. Ti consigliamo di utilizzare un ID di riferimento sull'indice del campo nell'elenco, se disponibile.
Ecco un esempio di come fare riferimento ai campi contenuti in un elenco.
object.imageModulesData[0].id = my-first-idobject.imageModulesData[1].id = my-second-idclass.detailsTemplateOverride.detailsItemInfos[0].item.firstValue.fields[0].fieldPath = object.imageModulesData[‘my-second-id’]class.detailsTemplateOverride.detailsItemInfos[1].item.firstValue.fields[0].fieldPath = object.imageModulesData[0]
In questo caso, il primo elemento nella sezione dei dettagli del pass è la seconda immagine dichiarata nell'oggetto. Il secondo elemento nella sezione Dettagli del pass è la prima immagine dichiarata nell'oggetto.
Modello predefinito
Android
|
|
Web
|
|
Per i campi del modulo immagine, mostriamo un solo campo modulo immagine della classe e un solo campo modulo immagine dell'oggetto. Se hai bisogno di più di un campo di modulo immagine per entrambi i livelli, esegui l'override del modello predefinito.
Per i campi del modulo di testo, vengono mostrati solo un massimo di 20 campi modulo di testo della classe e 20 campi del modulo di testo dell'oggetto. I campi vengono visualizzati nello stesso ordine in cui sono definiti nell'array. Se hai bisogno di più di 20 campi del modulo di testo in entrambi i livelli, esegui l'override del modello predefinito.
Per i messaggi, mostriamo solo un massimo di 20 messaggi provenienti dalla classe e 20 dall'oggetto. Non garantiamo l'ordine dei messaggi. Se ti servono più di 20 messaggi in entrambi i livelli o una garanzia per tutti gli ordini, esegui l'override del modello predefinito.
Per il campo del modulo Link, non esiste un limite al numero di uri che puoi definire. Gli Uris vengono visualizzati nel seguente ordine per ogni livello (classe o oggetto):
- Coordinate della mappa
- Numeri di telefono
- Indirizzi email
- Pagine web
Per ogni gruppo, gli URI vengono visualizzati nello stesso ordine in cui sono definiti nella matrice. Se hai bisogno di un ordine diverso, esegui l'override del modello predefinito.
|
|
|