Lege rijen bij het downloaden via Invantive Bridge

Via de Invantive Bridge Online downloaden wij eens per week de gegevens die zijn opgeslagen in de volgende tabellen:

  • ExactOnlineREST.Project.ProjectWBSBulk
  • ExactOnlineREST.Project.Projects
  • ExactOnlineREST.Views.PjtTimeTransactionsIncremental
  • ExactOnlineREST.Users.Users

Nu zie ik dat de tabelnamen licht gewijzigd zijn: in plaats van punten als separator zijn er underscores ("_") gebruikt. Dat is eenvoudig op te lossen, maar ik kan de inhoud van de tabellen niet meer uitlezen.

string dataEndPointUrl = $"{bridgeOnlineEndpoint}/{selectedDatabase.Segment}/odata4/{selectedEntity.EntityType.Name}";
 
rows = GetDataForEndpoint(httpClient, dataEndPointUrl);
fields = GetFieldsForEntityType(selectedEntity.EntityType);

De waarde van dataEndPointUrl is: https://bridge-online.cloud/acme-exact-online/odata4/ExactOnlineREST_Views_PjtTimeTransactionsIncremental@eol.

De velden kloppen prima, die worden netjes gelezen, maar de rows blijven leeg: waar kan dat aan liggen?

In welke taal is dit script geschreven?

Is het mogelijk om het om te zetten in een uitgebreider stuk code dat geïsoleerd uitgevoerd kan worden (dus met alleen bibliotheken e.d. op het Internet)?

public async Task UitlezenExact(string Item, string path)
{
  string bridgeOnlineEndpoint = "https://bridge-online.cloud";
  string username = "ikke";
  string password = "wachtwoord";

  try
  {
    using (HttpClient httpClient = GetHttpClient(username, password))
    {
      // Get a list of databases.
      ListModel<BridgeDatabaseModel> databases = await GetDatabases(httpClient, bridgeOnlineEndpoint);
      Dictionary<int, BridgeDatabaseModel> databasesByNumber = new Dictionary<int, BridgeDatabaseModel>();

      int number = 1;

      foreach (BridgeDatabaseModel databaseModel in databases.Data)
      {
          databasesByNumber.Add(number, databaseModel);
          number++;
      }
      BridgeDatabaseModel selectedDatabase = databasesByNumber[1];

      do
      {
          string bridgeOnlineDatabaseSegmentString = @"1";

          if (!int.TryParse(bridgeOnlineDatabaseSegmentString, out int bridgeOnlineDatabaseSegment))
          {
              //Console.WriteLine($"The entered value '{bridgeOnlineDatabaseSegmentString}' is not a number.");
          }
          else if (!databasesByNumber.TryGetValue(bridgeOnlineDatabaseSegment, out selectedDatabase))
          {
              //Console.WriteLine($"There is no database on position '{bridgeOnlineDatabaseSegment}'. Enter the value in front of the database name.");
          }
      }
      while (selectedDatabase == null);

      IAsyncEnumerable<EdmEntityInformation> entities = GetOData4Metadata(httpClient, bridgeOnlineEndpoint, selectedDatabase);

      Dictionary<int, EdmEntityInformation> entitiesByNumber = new Dictionary<int, EdmEntityInformation>();

      number = 1;

      int juistenummer = 0;

      //string fileName = @"C:\Temp\tabellen.txt";
      //StreamWriter writer = new StreamWriter(fileName);

      await foreach (EdmEntityInformation entity in entities)
      {
          //writer.WriteLine(entity.Name);
          if (entity.Name.Contains(Item))
              juistenummer = number;

          entitiesByNumber.Add(number, entity);

          number++;
      }

      EdmEntityInformation selectedEntity = null;

      do
      {

          string selectedEntityString = Convert.ToString(juistenummer);

          if (!int.TryParse(selectedEntityString, out int selectedEntityNumber))
          {
              MessageBox.Show($"The entered value '{selectedEntityString}' is not a number.");
          }
          else if (!entitiesByNumber.TryGetValue(selectedEntityNumber, out selectedEntity))
          {
              MessageBox.Show($"There is no entity on position '{selectedEntityNumber}'. Enter the value in front of the entity name.");
          }
      }
      while (selectedEntity == null);

      IAsyncEnumerable<Dictionary<string, object>> rows;
      HashSet<string> fields;

      if (selectedEntity.EntityType != null)
      {
          string dataEndPointUrl = $"{bridgeOnlineEndpoint}/{selectedDatabase.Segment}/odata4/{selectedEntity.EntityType.Name}";

          rows = GetDataForEndpoint(httpClient, dataEndPointUrl);
          fields = GetFieldsForEntityType(selectedEntity.EntityType);
      }
      else if (selectedEntity.FunctionImport != null)
      {
          string dataEndPointUrl = $"{bridgeOnlineEndpoint}/{selectedDatabase.Segment}/odata4/{selectedEntity.FunctionImport.Name}";

          rows = GetDataForEndpoint(httpClient, dataEndPointUrl);
          fields = GetFieldsForFunctionImport(selectedEntity.FunctionImport);
      }
      else
      {
          throw new Exception($"Selected entity is neither an entity type, nor a function import.");
      }

      string csvFilePath = null;

      do
      {
          csvFilePath = path;

          try
          {
              FileInfo fi = new FileInfo(csvFilePath);
          }
          catch (Exception)
          {
              csvFilePath = null;
          }
      }
      while (string.IsNullOrEmpty(csvFilePath));

      //
      // Iterate the response data and write it to file immediately.
      //
      using (FileStream fs = File.Create(csvFilePath))
      {
          using (StreamWriter sw = new StreamWriter(fs))
          {
              using (CsvWriter csv = new CsvWriter(sw, CultureInfo.InvariantCulture))
              {
                  foreach (string field in fields)
                  {
                      csv.WriteField(field);
                  }

                  csv.NextRecord();

                  await foreach (Dictionary<string, object> row in rows)
                  {
                      foreach (string field in fields)
                      {
                          if (row.TryGetValue(field, out object value))
                          {
                              csv.WriteField(value);
                          }
                          else
                          {
                              csv.WriteField(null);
                          }
                      }

                      csv.NextRecord();
                  }
              }
          }
      }
    }

    if (Item == "ExactOnlineREST.Project.ProjectWBSBulk")
    {
      lblog.Items.Add(" - WBS gedownload");
      WBSGedownload = true; 
    }
    if (Item == "ExactOnlineREST.Project.Projects")
    {
       lblog.Items.Add(" - Projecten gedownload");
       ProjectenGedownload = true;    
    }
    if (Item == "ExactOnlineREST.Views.PjtTimeTransactionsIncremental")
    {
      lblog.Items.Add(" - Uren gedownload");
      UrenGedownload = true;
    }

    if (Item == "ExactOnlineREST.Users.Users")
    {
      lblog.Items.Add(" - Personeel gedownload");
      PersoneelGedownload = true;
    }

    if (WBSGedownload == true && ProjectenGedownload == true && UrenGedownload == true && PersoneelGedownload == true)
    {
      lblog.Items.Add("Start importeren....");
      lblog.Refresh();
      RunExtractExact();                   
    }
  }
  catch (Exception ex)
  {
      Application.UseWaitCursor = false;
      MessageBox.Show(ex.Message);
  }
}

Dank voor het voorbeeld in C#.

Er is kortstondig op Invantive Bridge Online per abuis een release live geweest die een andere wijze van notatie voor het datamodel (EDM) volgt, waarbij onder andere ‘.’ en ‘@’ als ongeldige tekens omgezet worden naar ‘_’.

Deze wijziging is onverwacht in productie genomen door een bug in een Microsoft-bibliotheek.

Inmiddels is de wijziging niet meer zichtbaar. Op de BETA-site van Invantive Bridge Online draait een versie waarop wel deze vervanging gebeurt, specifiek voor Tableau als rapportageproduct.

Deze vraag is automatisch gesloten na 2 weken inactiviteit. Het laatste gegeven antwoord is gemarkeerd als oplossing.

Gelieve een nieuwe vraag te stellen via een apart topic als het probleem opnieuw optreedt. Gelieve in de nieuwe vraag een link naar dit topic op te nemen door de URL er van in de tekst te plakken.

Dit topic is 7 dagen na het laatste antwoord automatisch gesloten. Nieuwe antwoorden zijn niet meer toegestaan.