Dogukan/cnx 646 - Tekla Converter Project

Connectors/Tekla/Speckle.Connector.Tekla2024/Bindings/TeklaSendBinding.cs

@@ -1,29 +1,205 @@
+using System.Collections.Concurrent;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Cancellation;
+using Speckle.Connectors.Common.Operations;
 using Speckle.Connectors.DUI.Bindings;
 using Speckle.Connectors.DUI.Bridge;
+using Speckle.Connectors.DUI.Exceptions;
+using Speckle.Connectors.DUI.Logging;
+using Speckle.Connectors.DUI.Models;
+using Speckle.Connectors.DUI.Models.Card;
 using Speckle.Connectors.DUI.Models.Card.SendFilter;
 using Speckle.Connectors.DUI.Settings;
+using Speckle.Converter.Tekla2024;
+using Speckle.Converters.Common;
+using Speckle.Sdk;
+using Speckle.Sdk.Common;
+using Speckle.Sdk.Logging;
+using Tekla.Structures;
+using Tekla.Structures.Model;
+using Task = System.Threading.Tasks.Task;
 
 namespace Speckle.Connector.Tekla2024.Bindings;
 
-public class TeklaSendBinding : ISendBinding
+public sealed class TeklaSendBinding : ISendBinding, IDisposable
 {
   public string Name => "sendBinding";
+  public SendBindingUICommands Commands { get; }
   public IBrowserBridge Parent { get; }
+
+  private readonly DocumentModelStore _store;
+  private readonly IAppIdleManager _idleManager;
+  private readonly IServiceProvider _serviceProvider;
   private readonly List<ISendFilter> _sendFilters;
+  private readonly CancellationManager _cancellationManager;
+  private readonly ISendConversionCache _sendConversionCache;
+  private readonly IOperationProgressManager _operationProgressManager;
+  private readonly ILogger<TeklaSendBinding> _logger;
+  private readonly ITeklaConversionSettingsFactory _teklaConversionSettingsFactory;
+  private readonly ISpeckleApplication _speckleApplication;
+  private readonly ISdkActivityFactory _activityFactory;
+  private readonly Model _model;
+  private readonly Events _events;
 
-  public TeklaSendBinding(IBrowserBridge parent, IEnumerable<ISendFilter> sendFilters)
+  private ConcurrentDictionary<string, byte> ChangedObjectIds { get; set; } = new();
+
+  public TeklaSendBinding(
+    DocumentModelStore store,
+    IAppIdleManager idleManager,
+    IBrowserBridge parent,
+    IEnumerable<ISendFilter> sendFilters,
+    IServiceProvider serviceProvider,
+    CancellationManager cancellationManager,
+    ISendConversionCache sendConversionCache,
+    IOperationProgressManager operationProgressManager,
+    ILogger<TeklaSendBinding> logger,
+    ITeklaConversionSettingsFactory teklaConversionSettingsFactory,
+    ISpeckleApplication speckleApplication,
+    ISdkActivityFactory activityFactory
+  )
   {
-    Parent = parent;
+    _store = store;
+    _idleManager = idleManager;
+    _serviceProvider = serviceProvider;
     _sendFilters = sendFilters.ToList();
+    _cancellationManager = cancellationManager;
+    _sendConversionCache = sendConversionCache;
+    _operationProgressManager = operationProgressManager;
+    _logger = logger;
+    _teklaConversionSettingsFactory = teklaConversionSettingsFactory;
+    _speckleApplication = speckleApplication;
+    Parent = parent;
+    Commands = new SendBindingUICommands(parent);
+    _activityFactory = activityFactory;
+
+    _model = new Model();
+    _events = new Events();
+    SubscribeToTeklaEvents();
+  }
+
+  private void SubscribeToTeklaEvents()
+  {
+    _events.ModelObjectChanged += ModelHandler_OnChange;
+    _events.Register();
+  }
+
+  private void ModelHandler_OnChange(List<ChangeData> changes)
+  {
+    foreach (var change in changes)
+    {
+      if (change.Object is ModelObject modelObj)
+      {
+        ChangedObjectIds[modelObj.Identifier.ID.ToString()] = 1;
+      }
+    }
+
+    if (changes.Count > 0)
+    {
+      _idleManager.SubscribeToIdle(nameof(TeklaSendBinding), () => RunExpirationChecks());
+    }
   }
 
   public List<ISendFilter> GetSendFilters() => _sendFilters;
 
   public List<ICardSetting> GetSendSettings() => [];
 
-  public Task Send(string modelCardId) => Task.CompletedTask;
+  public async Task Send(string modelCardId)
+  {
+    using var activity = _activityFactory.Start();
+    using var scope = _serviceProvider.CreateScope();
+    scope
+      .ServiceProvider.GetRequiredService<IConverterSettingsStore<TeklaConversionSettings>>()
+      .Initialize(_teklaConversionSettingsFactory.Create(_model));
+
+    try
+    {
+      if (_store.GetModelById(modelCardId) is not SenderModelCard modelCard)
+      {
+        throw new InvalidOperationException("No publish model card was found.");
+      }
 
-  public void CancelSend(string modelCardId) => throw new NotImplementedException();
+      CancellationToken cancellationToken = _cancellationManager.InitCancellationTokenSource(modelCardId);
 
-  public SendBindingUICommands Commands { get; }
+      List<ModelObject> teklaObjects = modelCard
+        .SendFilter.NotNull()
+        .GetObjectIds()
+        .Select(id => _model.SelectModelObject(new Identifier(new Guid(id))))
+        .Where(obj => obj != null)
+        .ToList();
+
+      if (teklaObjects.Count == 0)
+      {
+        throw new SpeckleSendFilterException("No objects were found to convert. Please update your publish filter!");
+      }
+
+      var sendResult = await scope
+        .ServiceProvider.GetRequiredService<SendOperation<ModelObject>>()
+        .Execute(
+          teklaObjects,
+          modelCard.GetSendInfo(_speckleApplication.Slug),
+          _operationProgressManager.CreateOperationProgressEventHandler(Parent, modelCardId, cancellationToken),
+          cancellationToken
+        )
+        .ConfigureAwait(false);
+
+      await Commands
+        .SetModelSendResult(modelCardId, sendResult.RootObjId, sendResult.ConversionResults)
+        .ConfigureAwait(false);
+    }
+    catch (OperationCanceledException)
+    {
+      return;
+    }
+    catch (Exception ex) when (!ex.IsFatal())
+    {
+      _logger.LogModelCardHandledError(ex);
+      await Commands.SetModelError(modelCardId, ex).ConfigureAwait(false);
+    }
+  }
+
+  public void CancelSend(string modelCardId) => _cancellationManager.CancelOperation(modelCardId);
+
+  private async Task RunExpirationChecks()
+  {
+    if (!_model.GetConnectionStatus())
+    {
+      _logger.LogError("Tekla expiration checks were running without an active model.");
+      return;
+    }
+
+    var senders = _store.GetSenders();
+    string[] objectIdsList = ChangedObjectIds.Keys.ToArray();
+    List<string> expiredSenderIds = new();
+
+    _sendConversionCache.EvictObjects(objectIdsList);
+
+    foreach (SenderModelCard modelCard in senders)
+    {
+      var intersection = modelCard.SendFilter.NotNull().GetObjectIds().Intersect(objectIdsList).ToList();
+      var isExpired = intersection.Count != 0;
+      if (isExpired)
+      {
+        expiredSenderIds.Add(modelCard.ModelCardId.NotNull());
+      }
+    }
+
+    await Commands.SetModelsExpired(expiredSenderIds).ConfigureAwait(false);
+    ChangedObjectIds = new();
+  }
+
+  private bool _disposed;
+
+  public void Dispose()
+  {
+    if (!_disposed)
+    {
+      if (_events != null)
+      {
+        _events.UnRegister();
+      }
+      _disposed = true;
+    }
+  }
 }

Connectors/Tekla/Speckle.Connector.Tekla2024/Operations/Send/TeklaRootObjectBuilder.cs

@@ -0,0 +1,111 @@
+using Microsoft.Extensions.Logging;
+using Speckle.Connectors.Common.Builders;
+using Speckle.Connectors.Common.Caching;
+using Speckle.Connectors.Common.Conversion;
+using Speckle.Connectors.Common.Operations;
+using Speckle.Converter.Tekla2024;
+using Speckle.Converters.Common;
+using Speckle.Sdk;
+using Speckle.Sdk.Logging;
+using Speckle.Sdk.Models;
+using Speckle.Sdk.Models.Collections;
+using Tekla.Structures.Model;
+using Task = System.Threading.Tasks.Task;
+
+namespace Speckle.Connector.Tekla2024.Operations.Send;
+
+public class TeklaRootObjectBuilder : IRootObjectBuilder<ModelObject>
+{
+  private readonly IRootToSpeckleConverter _rootToSpeckleConverter;
+  private readonly ISendConversionCache _sendConversionCache;
+  private readonly IConverterSettingsStore<TeklaConversionSettings> _converterSettings;
+  private readonly ILogger<TeklaRootObjectBuilder> _logger;
+  private readonly ISdkActivityFactory _activityFactory;
+
+  public TeklaRootObjectBuilder(
+    IRootToSpeckleConverter rootToSpeckleConverter,
+    ISendConversionCache sendConversionCache,
+    IConverterSettingsStore<TeklaConversionSettings> converterSettings,
+    ILogger<TeklaRootObjectBuilder> logger,
+    ISdkActivityFactory activityFactory
+  )
+  {
+    _sendConversionCache = sendConversionCache;
+    _converterSettings = converterSettings;
+    _rootToSpeckleConverter = rootToSpeckleConverter;
+    _logger = logger;
+    _activityFactory = activityFactory;
+  }
+
+  public async Task<RootObjectBuilderResult> Build(
+    IReadOnlyList<ModelObject> teklaObjects,
+    SendInfo sendInfo,
+    IProgress<CardProgress> onOperationProgressed,
+    CancellationToken cancellationToken = default
+  )
+  {
+    using var activity = _activityFactory.Start("Build");
+
+    var model = new Model();
+    string modelName = model.GetInfo().ModelName ?? "Unnamed model";
+
+    Collection rootObjectCollection = new() { name = modelName };
+    rootObjectCollection["units"] = _converterSettings.Current.SpeckleUnits;
+
+    List<SendConversionResult> results = new(teklaObjects.Count);
+    int count = 0;
+
+    using (var _ = _activityFactory.Start("Convert all"))
+    {
+      foreach (ModelObject teklaObject in teklaObjects)
+      {
+        using var _2 = _activityFactory.Start("Convert");
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var result = ConvertTeklaObject(teklaObject, rootObjectCollection, sendInfo.ProjectId);
+        results.Add(result);
+
+        ++count;
+        onOperationProgressed.Report(new("Converting", (double)count / teklaObjects.Count));
+      }
+    }
+
+    if (results.All(x => x.Status == Status.ERROR))
+    {
+      throw new SpeckleException("Failed to convert all objects.");
+    }
+
+    await Task.Yield();
+    return new RootObjectBuilderResult(rootObjectCollection, results);
+  }
+
+  private SendConversionResult ConvertTeklaObject(ModelObject teklaObject, Collection collectionHost, string projectId)
+  {
+    string applicationId = teklaObject.Identifier.ToString();
+    string sourceType = teklaObject.GetType().Name;
+
+    try
+    {
+      Base converted;
+      if (_sendConversionCache.TryGetValue(projectId, applicationId, out ObjectReference? value))
+      {
+        converted = value;
+      }
+      else
+      {
+        converted = _rootToSpeckleConverter.Convert(teklaObject);
+        converted.applicationId = applicationId;
+      }
+
+      // Add to host collection
+      collectionHost.elements.Add(converted);
+
+      return new(Status.SUCCESS, applicationId, sourceType, converted);
+    }
+    catch (Exception ex) when (!ex.IsFatal())
+    {
+      _logger.LogError(ex, sourceType);
+      return new(Status.ERROR, applicationId, sourceType, null, ex);
+    }
+  }
+}