Migration Guide

from azure.identity import AzureCliCredential
from azure.core.exceptions import HttpResponseError
from azure.digitaltwins.core import DigitalTwinsClient

source_uri = "https://sourceadt.api.weu.digitaltwins.azure.net/"
target_uri = "https://targetadt.api.digitaltwins.konnektr.io/"

try:
    credential = AzureCliCredential()
    source_service_client = DigitalTwinsClient(source_uri, credential)
    target_service_client = DigitalTwinsClient(target_uri, credential)

    # Copy Models
    models_query_result = source_service_client.list_models(
        include_model_definition=True
    )
    models = []
    for modeldata in models_query_result:
        models.append(modeldata.model)
    print(f"Pushing {len(models)} models")
    target_service_client.create_models(models)

    # Copy Digital Twins
    twins_query_result = source_service_client.query_twins("SELECT * FROM digitaltwins")
    for twin in twins_query_result:
        try:
            print(f"Pushing twin: {twin['$dtId']}")
            target_service_client.upsert_digital_twin(twin["$dtId"], twin)
        except HttpResponseError as e:
            print(f"Error pushing twin {twin['$dtId']}: {e.message}")

    # Copy Relationships
    relationships_query_result = source_service_client.query_twins(
        "SELECT * FROM relationships"
    )
    for rel in relationships_query_result:
        try:
            print(
                f"Pushing rel: {rel['$sourceId']} - {rel['$targetId']} - {rel['$relationshipId']}"
            )
            target_service_client.upsert_relationship(
                rel["$sourceId"], rel["$relationshipId"], rel
            )
        except HttpResponseError as e:
            print(
                f"Error pushing rel {rel['$sourceId']} - {rel['$targetId']} - {rel['$relationshipId']}: {e.message}"
            )

except HttpResponseError as e:
    print(f"\nThis script has caught an error: {e.message}")

using System;
using System.Threading.Tasks;
using Azure.DigitalTwins.Core;
using Azure.Identity;

class Program
{
    static async Task Main(string[] args)
    {
        var sourceUri = "https://sourceadt.api.weu.digitaltwins.azure.net/";
        var targetUri = "https://targetadt.api.digitaltwins.konnektr.io/";
        var credential = new AzureCliCredential();
        var sourceClient = new DigitalTwinsClient(new Uri(sourceUri), credential);
        var targetClient = new DigitalTwinsClient(new Uri(targetUri), credential);

        // Copy Models
        var models = await sourceClient.GetModelsAsync(
            new GetModelsOptions { IncludeModelDefinition = true }
        );
        var modelList = new List<string>();
        await foreach (var model in models)
        {
            modelList.Add(model.DtdlModel);
        }
        Console.WriteLine($"Pushing {modelList.Count} models");
        await targetClient.CreateModelsAsync(modelList);

        // Copy Digital Twins
        var twins = sourceClient.QueryAsync("SELECT * FROM digitaltwins");
        await foreach (var twin in twins)
        {
            var id = twin["$dtId"].ToString();
            Console.WriteLine($"Pushing twin: {id}");
            await targetClient.UpsertDigitalTwinAsync(id, twin.ToString());
        }

        // Copy Relationships
        var rels = sourceClient.QueryAsync("SELECT * FROM relationships");
        await foreach (var rel in rels)
        {
            var sourceId = rel["$sourceId"].ToString();
            var relId = rel["$relationshipId"].ToString();
            Console.WriteLine($"Pushing rel: {sourceId} - {rel["$targetId"]} - {relId}");
            await targetClient.UpsertRelationshipAsync(sourceId, relId, rel.ToString());
        }
    }
}

const { DefaultAzureCredential } = require("@azure/identity");
const { DigitalTwinsClient } = require("@azure/digital-twins-core");

const sourceUrl = "https://sourceadt.api.weu.digitaltwins.azure.net/";
const targetUrl = "https://targetadt.api.digitaltwins.konnektr.io/";

async function main() {
  const credential = new DefaultAzureCredential();
  const sourceClient = new DigitalTwinsClient(sourceUrl, credential);
  const targetClient = new DigitalTwinsClient(targetUrl, credential);

  // Copy Models
  const models = [];
  for await (const model of sourceClient.listModels({ includeModelDefinition: true })) {
    models.push(model.model);
  }
  console.log(`Pushing ${models.length} models`);
  await targetClient.createModels(models);

  // Copy Digital Twins
  for await (const twin of sourceClient.queryTwins("SELECT * FROM digitaltwins")) {
    try {
      console.log(`Pushing twin: ${twin.$dtId}`);
      await targetClient.upsertDigitalTwin(twin.$dtId, twin);
    } catch (e) {
      console.error(`Error pushing twin ${twin.$dtId}: ${e.message}`);
    }
  }

  // Copy Relationships
  for await (const rel of sourceClient.queryTwins("SELECT * FROM relationships")) {
    try {
      console.log(`Pushing rel: ${rel.$sourceId} - ${rel.$targetId} - ${rel.$relationshipId}`);
      await targetClient.upsertRelationship(rel.$sourceId, rel.$relationshipId, rel);
    } catch (e) {
      console.error(`Error pushing rel ${rel.$sourceId} - ${rel.$targetId} - ${rel.$relationshipId}: ${e.message}`);
    }
  }
}

main().catch(console.error);