Personalizzare ThingWorx Navigate > Creare task personalizzati > Utilizzare i componenti ThingWorx Navigate in un task personalizzato > Personalizzare i componenti > Creare componenti personalizzati
  
Creare componenti personalizzati
Come descritto nell'argomento Architettura dei componenti, ciascuno dei componenti di ThingWorx Navigate è costituito da due sottocomponenti: il sottocomponente dell'interfaccia utente e il sottocomponente della logica aziendale. Il sottocomponente della logica aziendale, a sua volta, è costituito da due parti: la logica aziendale di base e l'implementazione della logica aziendale, in questo argomento indicati rispettivamente come componente di base e implementazione.
Per impostazione predefinita, ogni componente di base viene fornito con una o più implementazioni. Ogni implementazione può mostrare informazioni specifiche nell'interfaccia utente. Per visualizzare informazioni diverse, è possibile personalizzare il componente creando una implementazione personalizzata. Ad esempio, per impostazione predefinita il componente di base Identificativo elemento viene fornito con due implementazioni: Identificativo parte e Identificativo task. È anche possibile creare un'implementazione personalizzata del componente di base Identificativo elemento, ad esempio Identificativo documento.
La creazione di un'implementazione personalizzata di un componente implica l'estensione di un componente di base o di un'implementazione esistente e la sostituzione dei servizi necessari. Le sezioni riportate di seguito contengono la procedura dettagliata e un esempio.
Creare un'implementazione personalizzata estendendo un componente di base
Per creare un'implementazione personalizzata da un componente di base esistente, attenersi alla procedura descritta di seguito.
1. Scegliere un componente di base esistente da utilizzare come punto di partenza per l'implementazione personalizzata. Individuare il componente di base nella tabella riportata di seguito e prendere nota del modello di oggetto e del progetto, in base alla versione di ThingWorx Navigate in uso. Queste informazioni saranno necessarie in un secondo momento.
Componente di base
Modello di oggetto
Progetto (ThingWorx Navigate 9.0)
Progetto (ThingWorx Navigate 9.1 e versioni successive)
Attributi
PTC.Nav.AttributesBusinessLogicThingTemplate
PTC.Nav.AttributesProject
PTC.Nav.AttributesBusinessLogicProject
Identificativo elemento
PTC.Nav.ItemIdentityBusinessLogicThingTemplate
PTC.Nav.ItemIdentityProject
PTC.Nav.ItemIdentityBusinessLogicProject
Elenco elementi
PTC.Nav.ItemListBusinessLogicThingTemplate
PTC.Nav.ItemListProject
PTC.Nav.ItemListBusinessLogicProject
Avanzamento
PTC.Nav.ProgressBusinessLogicThingTemplate
PTC.Nav.ProgressProject
PTC.Nav.ProgressBusinessLogicProject
Riquadri
PTC.Nav.TilesBusinessLogicThingTemplate
PTC.Nav.TilesProject
PTC.Nav.TilesBusinessLogicProject
2. Creare un progetto per l'implementazione personalizzata. In Dipendenze progetto, immettere il progetto annotato al passo 1. Salvare il progetto.
3. Creare un modello di oggetto per l'implementazione personalizzata. In Progetto, immettere il progetto creato al passo 2. In Modello di oggetto di base, immettere il modello di oggetto annotato al passo 1.
4. Creare un oggetto per l'implementazione personalizzata. In Progetto, immettere il progetto creato al passo 2. In Modello di oggetto di base, immettere il modello di oggetto creato al passo 3.
5. Nell'oggetto creato, fare clic sulla scheda Servizi. Fare quindi clic su per sostituire il servizio GetImplementationConfigurationVersion e impostare una versione per l'implementazione. È possibile utilizzare qualsiasi valore per questa versione. Salvare l'oggetto.
6. Identificare i servizi da sostituire per l'implementazione personalizzata. Per ulteriori informazioni sui servizi per i componenti predefiniti, individuare l'argomento relativo al componente da estendere in Componenti disponibili e visualizzare la tabella Servizi di personalizzazione.
7. Nel modello di oggetto creato, fare clic su sulla scheda Servizi. Fare quindi clic su per sostituire i servizi necessari. È consigliabile sostituire il servizio GetConfigurations prima di sostituire altri servizi.
Nel codice per il servizio GetConfigurations, impostare la versione di implementationConfigurationVersion in modo che corrisponda all'insieme di versioni di GetImplementationConfigurationVersion nel passo 5. Se si ignora questo passo, possono verificarsi problemi di compatibilità nelle release future di ThingWorx Navigate.
8. Sostituire i servizi necessari rimanenti. Quando si sostituisce un servizio che riceve la configurazione come parametro, chiamare prima il servizio Migrate nel codice e passare le versioni di base e di implementazione.
Per determinare il valore da utilizzare per targetBaseVersion nel servizio Migrate, eseguire il servizio GetBaseConfigurationVersion sull'oggetto creato al passo 4. Non chiamare il codice del servizio GetBaseConfigurationVersion e restituire il valore.
Quando si imposta targetImplementationVersion nel servizio Migrate, utilizzare la versione impostata in precedenza al passo 5.
Vedere l'argomento Controllo delle versioni e migrazione per ulteriori informazioni sulla chiamata del servizio Migrate.
 
Quando si sostituiscono dei servizi, non sostituire i servizi con la categoria PTC.Nav.Private.
9. Salvare il modello di oggetto. L'implementazione personalizzata ora è pronta per l'uso. Per utilizzare l'implementazione, creare un mashup. Aggiungere il componente di base per l'implementazione al mashup e fare clic su . Nel menu a discesa Tipo di configurazione, selezionare la configurazione appartenente all'implementazione personalizzata.
Creare un'implementazione personalizzata estendendo un'implementazione
Per creare un'implementazione personalizzata da un'implementazione esistente, attenersi alla procedura descritta di seguito.
1. Scegliere un'implementazione esistente da utilizzare come punto di partenza per l'implementazione personalizzata.
Se si utilizza un'implementazione predefinita, individuarla nella tabella seguente e prendere nota del modello di oggetto e del progetto in base alla versione di ThingWorx Navigate in uso. Queste informazioni saranno necessarie in un secondo momento.
Se si utilizza un'implementazione personalizzata, prendere nota del modello di oggetto e del progetto. Queste informazioni saranno necessarie in un secondo momento.
Implementazione
Modello di oggetto
Progetto (ThingWorx Navigate 9.0)
Progetto (ThingWorx Navigate 9.1 e versioni successive)
Attività
PTC.Nav.ActivityBusinessLogicThingTemplate
PTC.Nav.ItemListProject
PTC.Nav.ActivityBusinessLogicProject
Elementi interessati
PTC.Nav.AffectedItemsBusinessLogicThingTemplate
PTC.Nav.ItemListProject
PTC.Nav.AttachmentsBusinessLogicProject
Allegati
PTC.Nav.AttachmentsBusinessLogicThingTemplate
PTC.Nav.ItemListProject
PTC.Nav.AffectedItemsBusinessLogicProject
Attributi generici
PTC.Nav.AttributesGenericBusinessLogicThingTemplate
PTC.Nav.AttributesProject
PTC.Nav.AttributesGenericBusinessLogicProject
Identificativo parte
PTC.Nav.PartIdentityBusinessLogicThingTemplate
PTC.Nav.ItemIdentityProject
PTC.Nav.PartIdentityBusinessLogicProject
Identificativo task
PTC.Nav.TaskIdentityBusinessLogicThingTemplate
PTC.Nav.ItemIdentityProject
PTC.Nav.TaskIdentityBusinessLogicProject
Avanzamento task
PTC.Nav.TaskProgressBusinessLogicThingTemplate
PTC.Nav.ProgressProject
PTC.Nav.TaskProgressBusinessLogicProject
Task
PTC.Nav.TaskListBusinessLogicThingTemplate
PTC.Nav.ItemListProject
PTC.Nav.TaskListBusinessLogicProject
Riquadri generici
PTC.Nav.TilesGenericBusinessLogicThingTemplate
PTC.Nav.TilesProject
PTC.Nav.TilesGenericBusinessLogicProject
2. Creare un progetto per l'implementazione personalizzata. In Dipendenze progetto, immettere il progetto annotato al passo 1. Salvare il progetto.
3. Creare un modello di oggetto per l'implementazione personalizzata. In Progetto, immettere il progetto creato al passo 2. In Modello di oggetto di base, immettere il modello di oggetto annotato al passo 1.
4. Creare un oggetto per l'implementazione personalizzata. In Progetto, immettere il progetto creato al passo 2. In Modello di oggetto di base, immettere il modello di oggetto creato al passo 3.
5. Nell'oggetto creato, fare clic sulla scheda Servizi.
Fare clic su per sostituire GetBaseMigrationVersion con la versione in uso di ThingWorx Navigate, ad esempio 9.0.0 o 9.1.0.
Fare clic su per sostituire GetImplementationConfigurationVersion con la versione in uso di ThingWorx Navigate, ad esempio 9.0.0 o 9.1.0.
6. Salvare l'oggetto.
7. Identificare i servizi da sostituire per l'implementazione personalizzata. Per ulteriori informazioni sui servizi per i componenti predefiniti, individuare l'argomento relativo al componente da estendere in Componenti disponibili e visualizzare la tabella Servizi di personalizzazione.
8. Nel modello di oggetto creato, fare clic su sulla scheda Servizi. Fare quindi clic su per sostituire i servizi necessari. È consigliabile sostituire il servizio GetConfigurations prima di sostituire altri servizi.
* 
Quando si sostituisce il servizio GetConfigurations, la modifica della struttura di configurazione dalla relativa struttura predefinita non è supportata. Modificare solo i valori delle singole proprietà JSON. Per ulteriori informazioni, vedere l'argomento Esempi di modifiche alle proprietà di configurazione.
Nella configurazione, assicurarsi di impostare il valore della proprietà implementationConfigurationVersion in modo che sia uguale al valore restituito dal servizio GetImplementationConfigurationVersion.
9. Sostituire i servizi necessari rimanenti. Quando si sostituisce un servizio che riceve la configurazione come parametro, chiamare prima il servizio Migrate nel codice e passare le versioni di base e di implementazione.
Per determinare la versione di base da passare al servizio Migrate, eseguire il servizio GetBaseConfigurationVersion sull'oggetto creato al passo 4. Non chiamare il servizio GetBaseConfigurationVersion e restituire il valore.
Per determinare la versione di implementazione da passare al servizio Migrate, eseguire il servizio GetImplementationConfigurationVersion sull'oggetto creato al passo 4. Non chiamare il servizio GetImplementationConfigurationVersion e restituire il valore.
Vedere l'argomento Controllo delle versioni e migrazione per ulteriori informazioni sulla chiamata del servizio Migrate.
 
Quando si sostituiscono dei servizi, non sostituire i servizi con la categoria PTC.Nav.Private.
10. Salvare il modello di oggetto. L'implementazione personalizzata ora è pronta per l'uso. Per utilizzare l'implementazione, creare un mashup. Aggiungere il componente di base per l'implementazione al mashup e fare clic su . Nel menu a discesa Tipo di configurazione, selezionare la configurazione appartenente all'implementazione personalizzata.
Esempio: creare un'implementazione Elenco parti
Nell'esempio riportato di seguito viene illustrato come creare un'implementazione personalizzata denominata Elenco parti, che è un'implementazione del componente di base Elenco elementi. Elenco parti riceve una parte come input e restituisce il primo livello delle parti che contiene.
* 
L'esempio riportato di seguito è progettato per funzionare in ThingWorx Navigate 9.0 e i valori di versione utilizzati negli snippet di codice sono corretti per tale versione di ThingWorx Navigate. Per seguire questo esempio in una versione successiva di ThingWorx Navigate, assicurarsi di utilizzare i valori di versione corretti nel codice.
1. In ThingWorx Composer, creare un nuovo progetto denominato Demo.PartsListProject.
In ThingWorx Navigate 9.0, immettere PTC.Nav.ItemListProject in Dipendenze progetto.
In ThingWorx Navigate 9.1 e versioni successive, immettere PTC.Nav.ItemListBusinessLogicProject in Dipendenze progetto.
2. Creare un nuovo modello di oggetto Demo.PartsListBusinessLogicThingTemplate. Impostare Progetto su Demo.PartsListProject e impostare Modello di oggetto di base su PTC.Nav.ItemListBusinessLogicThingTemplate.
3. Creare un oggetto Demo.PartsListBusinessLogicThing. Impostare Progetto su Demo.PartsListProject e impostare Modello di oggetto di base su Demo.PartsListBusinessLogicThingTemplate.
4. Fare clic su sulla scheda Servizi e trovare il servizio GetImplementationConfigurationVersion. Fare clic su per sostituire il servizio e impostare la versione su 1.0.0 utilizzando il codice riportato di seguito.
result = "1.0.0";
Fare clic su Fine. A questo punto fare clic su Salva per salvare l'oggetto.
5. Trovare Elenco elementi nella tabella dei servizi di personalizzazione e identificare i servizi che devono essere sostituiti nel modello di oggetto. Per questa implementazione personalizzata, è necessario sostituire tre servizi:
GetConfigurations - Questo servizio restituisce le configurazioni disponibili per l'implementazione. Lo si modificherà per definire la configurazione dell'elenco parti.
GetImplementationLabel - Questo servizio restituisce il nome dell'implementazione visualizzato in Mashup Builder. Lo si imposterà per visualizzare il nome Parts List Demo.
GetItems - Questo servizio riceve l'input e la configurazione come parametri e restituisce un JSON in formato CCO con i dati da visualizzare nell'interfaccia utente del componente Elenco elementi. Lo si imposterà per restituire le parti di primo livello di una determinata parte, nonché gli attributi delle parti di primo livello.
6. Aprire il modello di oggetto Demo.ItemListBusinessLogicThingTemplate. Fare clic sulla scheda Servizi.
7. Fare clic su per sostituire il servizio GetConfigurations. Incollare il codice seguente nel servizio. Questo codice include una configurazione per l'elenco parti etichettata come Parts List sia in Mashup Builder che nell'interfaccia utente di ThingWorx Navigate.
result = {
"partsList": {
"label": "Parts List",
"configuration": {
"selectionType": {
"selectedKey": "single"
},
"waitForInput": {
"value": true
},
"actionBarConfiguration": {
"value": {
"actionBarConfigurationJSON": {
"value": ""
}
}
},
"baseConfigurationVersion": {
"value": "9.0.0"
},
"implementationConfigurationVersion": {
"value": "1.0.0"
},
"defaultSortFields": {
"selectedValues": {
"data": [{
"itemListsData": [{
"items": [{
"additionalData": {
"itemListDefaultSortFieldDefinition": {
"defaultSortDirection": {
"selectedKey": "asc"
}
}
},
"id": "Name"
}
],
"objectType": "PTC.ProdMgmt.Part"
}
],
"adapter": {
"instanceName": "windchill",
"thingName": "PTC.WCAdapter"
}
}
]
}
},
"attributes": {
"selectedValues": {
"data": [{
"itemListsData": [{
"items": [{
"id": "Name",
"ordinal": 1
}, {
"id": "State#Display",
"ordinal": 2
}, {
"id": "Version",
"ordinal": 3
}, {
"id": "Number",
"ordinal": 0
}, {
"id": "ID",
"ordinal": 4
}
],
"objectType": "PTC.ProdMgmt.Part"
}
],
"adapter": {
"instanceName": "windchill",
"thingName": "PTC.WCAdapter"
}
}
]
},
"inTailoring": false
},
"label": {
"value": "Parts List"
},
"showExportAction": {
"value": true
},
"enableSearch": {
"additionalData": {
"itemListSearchDefinition": {
"searchHintText": {
"value": "Find"
}
}
},
"value": true
},
"maxNumberOfRowsInGrid": {
"inTailoring": false,
"value": 50
}
}
}
};
Di seguito è riportato un altro codice di esempio per GetConfigurations che contiene due configurazioni anziché una. La prima configurazione corrisponde a quella del codice precedente. La seconda configurazione si applica a una versione ridotta di Elenco parti. Vengono visualizzati solo tre attributi e massimo cinque righe. È etichettata come Parts List mini in Mashup Builder e come Parts List nell'interfaccia utente di ThingWorx Navigate.
result = {
"partsList": {
"label": "Parts List",
"configuration": {
"selectionType": {
"selectedKey": "single"
},
"waitForInput": {
"value": true
},
"actionBarConfiguration": {
"value": {
"actionBarConfigurationJSON": {
"value": ""
}
}
},
"baseConfigurationVersion": {
"value": "9.0.0"
},
"implementationConfigurationVersion": {
"value": "1.0.0"
},
"defaultSortFields": {
"selectedValues": {
"data": [{
"itemListsData": [{
"items": [{
"additionalData": {
"itemListDefaultSortFieldDefinition": {
"defaultSortDirection": {
"selectedKey": "asc"
}
}
},
"id": "Name"
}
],
"objectType": "PTC.ProdMgmt.Part"
}
],
"adapter": {
"instanceName": "windchill",
"thingName": "PTC.WCAdapter"
}
}
]
}
},
"attributes": {
"selectedValues": {
"data": [{
"itemListsData": [{
"items": [{
"id": "Name",
"ordinal": 1
}, {
"id": "State#Display",
"ordinal": 2
}, {
"id": "Version",
"ordinal": 3
}, {
"id": "Number",
"ordinal": 0
}, {
"id": "ID",
"ordinal": 4
}
],
"objectType": "PTC.ProdMgmt.Part"
}
],
"adapter": {
"instanceName": "windchill",
"thingName": "PTC.WCAdapter"
}
}
]
},
"inTailoring": false
},
"label": {
"value": "Parts List"
},
"showExportAction": {
"value": true
},
"enableSearch": {
"additionalData": {
"itemListSearchDefinition": {
"searchHintText": {
"value": "Find"
}
}
},
"value": true
},
"maxNumberOfRowsInGrid": {
"inTailoring": false,
"value": 50
}
}
},
"partsListMini": {
"label": "Parts List mini",
"configuration": {
"selectionType": {
"selectedKey": "single"
},
"waitForInput": {
"value": true
},
"actionBarConfiguration": {
"value": {
"actionBarConfigurationJSON": {
"value": ""
}
}
},
"baseConfigurationVersion": {
"value": "9.0.0"
},
"implementationConfigurationVersion": {
"value": "1.0.0"
},
"defaultSortFields": {
"selectedValues": {
"data": [{
"itemListsData": [{
"items": [{
"additionalData": {
"itemListDefaultSortFieldDefinition": {
"defaultSortDirection": {
"selectedKey": "asc"
}
}
},
"id": "Name"
}
],
"objectType": "PTC.ProdMgmt.Part"
}
],
"adapter": {
"instanceName": "windchill",
"thingName": "PTC.WCAdapter"
}
}
]
}
},
"attributes": {
"selectedValues": {
"data": [{
"itemListsData": [{
"items": [{
"id": "Name",
"ordinal": 1
}, {
"id": "Version",
"ordinal": 2
}, {
"id": "Number",
"ordinal": 0
}
],
"objectType": "PTC.ProdMgmt.Part"
}
],
"adapter": {
"instanceName": "windchill",
"thingName": "PTC.WCAdapter"
}
}
]
},
"inTailoring": false
},
"label": {
"value": "Parts List"
},
"showExportAction": {
"value": true
},
"enableSearch": {
"additionalData": {
"itemListSearchDefinition": {
"searchHintText": {
"value": "Find"
}
}
},
"value": true
},
"maxNumberOfRowsInGrid": {
"inTailoring": false,
"value": 5
}
}
}
};
Dopo aver aggiunto il codice, fare clic su Fine.
8. Sostituire il servizio GetImplementationLabel. Impostare l'etichetta di implementazione utilizzando il codice seguente:
result = "Parts List Demo";
Fare clic su Fine.
9. Il servizio GetItems recupererà le parti di primo livello da Windchill utilizzando il processo riportato di seguito.
a. Convertire la parte degli attributi della configurazione in una struttura CCO utilizzando il servizio ConvertAttributesToCCO, che verrà creato.
b. Passare il JSON risultante in formato CCO al servizio GetRelatedItems in PTC.WCAdapter. Questo servizio recupera i dati come oggetti UsageLink.
c. Convertire gli oggetti UsageLink in oggetti Part, utilizzando il servizio ConvertUsageLinkToPart, che verrà creato.
Prima di sostituire il servizio GetItems è necessario creare i servizi ConvertAttributesToCCO e ConvertUsageLinkToPart.
10. Creare un nuovo servizio a cui assegnare il nome ConvertAttributesToCCO. In Input, aggiungere gli input seguenti:
configuration, con JSON come Tipo di base
attributesPrefix, con STRING come Tipo di base
replaceObjectType, con STRING come Tipo di base
In Output, selezionare JSON dal menu a discesa.
11. Incollare il codice seguente nel servizio ConvertAttributesToCCO:
let attributesData = configuration.attributes.selectedValues;
attributesPrefix = attributesPrefix || "";
let objectType = replaceObjectType || attributesData.data[0].itemListsData[0].objectType;
attributesData.data[0].itemListsData[0].objectType = objectType;
let items = attributesData.data[0].itemListsData[0].items;
let newItems = [];
let newObj = {};
let hasID = false;
//convert to CCO
for(var i = 0; i < items.length; i++) {
let item = items[i];
if (item.id === 'ID') {
hasID = true;
}
newObj[attributesPrefix + item.id] = {"value":""};
}
//add ID if needed
if (!hasID) {
newObj[attributesPrefix + 'ID'] = {"value":""};
}
newItems.push (newObj);
attributesData.data[0].itemListsData[0].items = newItems;
//create date
var dateValue = new Date();
var y = dateValue.getFullYear();
var mo = dateValue.getMonth()+1;
if(mo<10) {mo='0'+mo;}
var d = dateValue.getDate();
if(d<10) {d='0'+d;}
//create time
var h = dateValue.getHours();
if(h<10) {h='0'+h;}
var mi = dateValue.getMinutes();
if(mi<10) {mi='0'+mi;}
var s = dateValue.getSeconds();
if(s<10) {s='0'+s;}
var ms = dateValue.getMilliseconds();
if(ms<10) {ms='00'+ms;} else {if(ms>=10 && ms<100) {ms='0'+ms;}}
attributesData.timeStamp = y + "-" + mo + "-" + d + " " + h + ":" + mi + ":" + s + "." + ms;
attributesData.version = "";
attributesData.statusMessage = "OK";
attributesData.status = "200";
result = attributesData;
Fare clic su Fine.
12. Creare un nuovo servizio a cui assegnare il nome ConvertUsageLinkToPart. In Input, aggiungere gli input seguenti:
usageLinkCCO, con JSON come Tipo di base
In Output, selezionare JSON dal menu a discesa.
13. Incollare il codice seguente nel servizio ConvertUsageLinkToPart:
let itemListsData = usageLinkCCO.data[0].itemListsData[0];
let tempMetadata = itemListsData.metadata;
let items = itemListsData.items;
//convert metadata
delete tempMetadata.ID;
let newMetadata = {};
for (var key in tempMetadata) {
let newKey = key.replace(/^(Uses\|)/,"");
newMetadata[newKey] = tempMetadata[key];
}
newMetadata['id'] = newMetadata.ID;
itemListsData['metadata'] = newMetadata;
//convert Items
let newItems = [];
for (var i=0 ; i<items.length ; i++) {
let item = items[i];
let newItem = {};
for (key in item) {
let newKey = key.replace(/^(Uses\|)/,"");
newItem[newKey] = item[key];
}
newItem['id'] = newItem.ID;
newItems.push(newItem);
}
itemListsData['items'] = newItems;
itemListsData['objectType'] = 'PTC.ProdMgmt.Part';
//update CCO
let partsListCCO = usageLinkCCO;
partsListCCO.data[0].itemListsData = [itemListsData];
result = partsListCCO;
Fare clic su Fine.
14. Fare clic su per sostituire il servizio GetItems. Incollare il codice seguente nel servizio GetItems:
var migratedConfig = me.Migrate({
targetImplementationVersion: "1.0.0" /* STRING */,
data: configuration /* JSON */,
migrationType: "Configuration" /* STRING */,
targetBaseVersion: "9.0.0" /* STRING */
});
var attributesConfigurationCCO = me.ConvertAttributesToCCO({
configuration:migratedConfig /* JSON */,
attributesPrefix: "Uses|" /* STRING */,
replaceObjectType: "PTC.ProdMgmt.PartUse" /* STRING */
});
// result: JSON
var tempResult = Things["PTC.WCAdapter"].GetRelatedItems({
item: input /* JSON */,
relation: {path:"Uses"} /* JSON */,
attributes: attributesConfigurationCCO /* JSON */
});

var convertedResults = me.ConvertUsageLinkToPart({
usageLinkCCO:tempResult /* JSON */
});
var result = convertedResults;
Fare clic su Fine. A questo punto fare clic su Salva per salvare il modello di oggetto.
L'implementazione personalizzata Elenco parti e la relativa configurazione sono create e pronte all'uso in Mashup Builder. Per utilizzare l'implementazione, aggiungere il componente di base Elenco elementi a un mashup e fare clic su . Nel menu a discesa Tipo di configurazione, selezionare la configurazione Elenco parti etichettata Parts Lists Demo - Parts List.
Se si utilizza Elenco parti per creare il mashup mostrato nel video seguente, di seguito viene fornito codice aggiuntivo.
Codice utilizzato per configurare il componente Attributi:
{
"layout": {
"selectedKey": "horizontal",
"additionalData": {
"dimensionDefinition": {
"maxHeight": {
"value": 200,
"version": "1.0.0"
},
"maxWidth": {
"value": 200,
"version": "1.0.0"
}
}
},
"version": "1.0.0"
},
"attributes": {
"sets": [{
"data": {
"selectedValues": {
"data": [{
"itemListsData": [{
"items": [{
"id": "ModifiedBy",
"ordinal": 0
}, {
"id": "GatheringPart",
"ordinal": 1
}, {
"id": "Latest",
"ordinal": 2
}, {
"id": "FolderName",
"ordinal": 3
}
],
"objectType": "PTC.ProdMgmt.Part"
}
],
"adapter": {
"instanceName": "windchill",
"thingName": "PTC.WCAdapter"
}
}
]
}
},
"name": ""
}
],
"inTailoring": true,
"filteredValues": {
"data": [{
"itemListsData": [{
"objectType": ""
}
],
"adapter": {
"instanceName": "",
"thingName": ""
}
}
]
},
"version": "1.0.0"
}
}
Codice utilizzato per il parametro di input del mashup. Assicurarsi di aggiungere un ID parte valido:
{
"version": "1.0.0",
"data": [{
"adapter": {
"thingName": "PTC.WCAdapter",
"instanceName": "windchill"
},
"itemListsData": [{
"objectType": "PTC.ProdMgmt.Part",
"items": [{
"id": {
"value": ""
}
}
]
}
]
}
]
}
Esercitazione video: creare un'implementazione Elenco parti
Nelle due esercitazioni video seguenti viene illustrato come creare e utilizzare l'implementazione personalizzata Elenco parti. Il primo video mostra come creare Elenco parti seguendo la procedura descritta nell'esempio precedente. Il secondo video mostra come utilizzare Elenco parti in un mashup. È possibile trovare tutto il codice utilizzato nei video nell'esempio precedente.
Per visualizzare un video in una finestra di dimensioni maggiori, fare clic sul titolo nel lettore. Il video viene aperto in YouTube in una nuova scheda.