@aryacode/dsh-engineering 0.5.0 → 0.6.0

package/vendor/optix/netlogic/pages/resource-uri.md

@@ -0,0 +1,308 @@
+# Resource URIs
+
+## Important note
+
+Although multiple solutions are shown here to set the target path for a ResourceUri variable, please remember that the WebPresentationEngine only supports accessing elements that are in the `%PROJECTDIR%` and a relative path is used (example: `%PROJECTDIR%/imgs/logo.svg`), using an absolute path for an element (example: `C:/OptixProjects/NewHMIProject1/Project Files/imgs/logo.svg`), will never work in the WebPresentationEngine for safety reasons.
+
+## Check if a file is within the project directory and use relative URIs
+
+When working with file operations, it's essential to determine whether a file is located within the project directory. If it is, you should use a project-relative URI for WebPresentationEngine compatibility. This is particularly important for components like the WebPresentationEngine that **only accept relative resource URIs**.
+
+```csharp
+/// <summary>
+/// Attempts to get the project-relative path if the file is within the project directory.
+/// </summary>
+/// <param name="filePath">The file path to check (can be URI or absolute path)</param>
+/// <returns>The relative path within the project directory, or null if the file is not within the project</returns>
+private string TryGetProjectRelativePath(string filePath)
+{
+    try
+    {
+        // Get the absolute file path from the input (could be a file URI)
+        string absoluteFilePath = GetAbsolutePathFromUri(filePath);
+        if (string.IsNullOrEmpty(absoluteFilePath))
+            return null;
+
+        // Get the project directory
+        string projectDirectory = Project.Current.ProjectDirectory;
+        if (string.IsNullOrEmpty(projectDirectory))
+            return null;
+
+        // Normalize both paths to ensure consistent comparison
+        string normalizedFilePath = Path.GetFullPath(absoluteFilePath);
+        string normalizedProjectPath = Path.GetFullPath(projectDirectory);
+
+        // Ensure project path ends with directory separator for proper containment check
+        if (!normalizedProjectPath.EndsWith(Path.DirectorySeparatorChar.ToString()) && 
+            !normalizedProjectPath.EndsWith(Path.AltDirectorySeparatorChar.ToString()))
+        {
+            normalizedProjectPath += Path.DirectorySeparatorChar;
+        }
+
+        // Check if the file is within the project directory
+        if (normalizedFilePath.StartsWith(normalizedProjectPath, StringComparison.OrdinalIgnoreCase))
+        {
+            // Calculate the relative path from project directory
+            string relativePath = normalizedFilePath.Substring(normalizedProjectPath.Length);
+            
+            // Convert path separators to forward slashes for consistency
+            relativePath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
+            
+            return relativePath;
+        }
+
+        return null;
+    }
+    catch (Exception ex)
+    {
+        Log.Error("TryGetProjectRelativePath", $"Error determining project relative path: {ex.Message}");
+        return null;
+    }
+}
+
+/// <summary>
+/// Extracts the absolute file path from a URI or returns the path if it's already absolute.
+/// </summary>
+/// <param name="uriOrPath">URI or file path</param>
+/// <returns>Absolute file path, or null if invalid</returns>
+private string GetAbsolutePathFromUri(string uriOrPath)
+{
+    if (string.IsNullOrEmpty(uriOrPath))
+        return null;
+
+    try
+    {
+        // Try to parse as URI first
+        if (Uri.TryCreate(uriOrPath, UriKind.Absolute, out Uri uri))
+        {
+            return uri.IsFile ? uri.LocalPath : uriOrPath;
+        }
+
+        // If not a URI, treat as file path
+        return Path.IsPathRooted(uriOrPath) ? uriOrPath : null;
+    }
+    catch (Exception ex)
+    {
+        Log.Error("GetAbsolutePathFromUri", $"Error parsing URI/path '{uriOrPath}': {ex.Message}");
+        return null;
+    }
+}
+```
+
+### Usage example
+
+```csharp
+[ExportMethod]
+public void HandleFileSelection(string filePath)
+{
+    try
+    {
+        // Try to determine if the file is within the project directory
+        var projectRelativePath = TryGetProjectRelativePath(filePath);
+        if (projectRelativePath != null)
+        {
+            // File is within project directory - use project relative URI for WebPresentationEngine compatibility
+            var resourceUri = ResourceUri.FromProjectRelativePath(projectRelativePath);
+            Log.Info("HandleFileSelection", $"Using project relative path: {projectRelativePath}");
+            // Use resourceUri for WebPresentationEngine-compatible components
+        }
+        else
+        {
+            // File is outside project directory - cannot be used with WebPresentationEngine
+            Log.Warning("HandleFileSelection", "The selected file will not work in the WebPresentationEngine as it is not in the ProjectDir");
+            // Fallback to absolute path if needed, but be aware of limitations
+        }
+    }
+    catch (Exception ex)
+    {
+        Log.Error("HandleFileSelection", $"Error processing file path '{filePath}': {ex.Message}");
+    }
+}
+```
+
+## Create a ResourceUri from scratch
+
+```csharp
+// Get the working folder from the current context
+var baseUri = new Uri(System.IO.Directory.GetCurrentDirectory());
+// Get the ProjectDir folder
+var chartUri = new Uri(baseUri, Project.Current.ProjectDirectory);
+// Browse to the NetSolution folder
+var nextStep = new Uri(chartUri, "NetSolution");
+// Browse to NetSolution/Charts.xlst
+var finalPath = new Uri(nextStep, "Charts.xslt");
+// Get the full path
+string filePath = finalPath.AbsolutePath;
+Log.Info("Final path: " + filePath);
+Log.Info(MethodBase.GetCurrentMethod().Name, $"File name is: {fileName}");
+```
+
+## Reading a ResourceUri
+
+This assumes the variable is set to ResourceUri
+
+```csharp
+// Get a variable with datatype set to ResourceUri
+var csvPathVariable = LogicObject.Get<IUAVariable>("CSVPath");
+// Get the full path
+string myString = new ResourceUri(csvPathVariable.Value).Uri;
+```
+
+```csharp
+/// <summary>
+/// Examples to log common ResourceUri locations: project, application and USB.
+/// This helps when debugging paths used by NetLogic or UI resources.
+/// </summary>
+// Project files
+Log.Info(ResourceUri.FromProjectRelativePath("").Uri);
+// Application files
+Log.Info(ResourceUri.FromApplicationRelativePath("").Uri);
+// USB device 1 (may throw if not present)
+try
+{
+    Log.Info(ResourceUri.FromUSBRelativePath(1, "").Uri);
+}
+catch (Exception ex)
+{
+    Log.Warning("ResourceUri", "USB1 not available: " + ex.Message);
+}
+```
+
+```csharp
+pdfPathStr = new ResourceUri(((IUAVariable)myPathNode).Value).Uri;
+```
+
+## Set the path of an Image to the ProjectFiles
+
+### Using absolute path
+
+> [!TIP]
+> This method is not recommended as it will not work if the project is moved to another folder or computer, and might have issues with the WebPresentationEngine. Use the relative path below.
+
+```csharp
+// Note: the Path.DirectorySeparatorChar is used to make the application cross-platform capable
+singlePiece.Get<Image>("PuzzleImage").Path = ResourceUri.FromProjectRelativePath("").Uri + Path.DirectorySeparatorChar + "imgs" + Path.DirectorySeparatorChar + "Puzzle" + Path.DirectorySeparatorChar + "Piece" + (i + 1).ToString() + ".png";
+```
+
+### Using relative path
+
+> [!TIP]
+> This method is recommended as it will produce a relative path that will work if the project is moved to another folder or computer, and is compatible with the WebPresentationEngine.
+
+```csharp
+[ExportMethod]
+public void Method2()
+{
+    var image = Owner.Get<AdvancedSVGImage>("AdvancedSVGImage1");
+    // Set the path to %PROJECTDIR%/logo.svg
+    image.PathVariable.Value = ResourceUri.FromProjectRelativePath("logo.svg");
+}
+```
+
+## Get a file from ProjectFiles
+
+```csharp
+string localPath = Path.DirectorySeparatorChar + "imgs" + Path.DirectorySeparatorChar + "Puzzle" + Path.DirectorySeparatorChar + "Piece" + (i + 1).ToString() + ".png";
+singlePiece.Get<Image>("PuzzleImage").Path = "ns=" + singlePiece.NodeId.NamespaceIndex.ToString() + ";%PROJECTDIR%" + localPath;
+```
+
+```csharp
+string localPath = "imgs" + Path.DirectorySeparatorChar + "Puzzle" + Path.DirectorySeparatorChar + "Piece" + (i + 1).ToString() + ".png";
+singlePiece.Get<Image>("PuzzleImage").Path = Path.Combine(ResourceUri.FromProjectRelativePath(""), localPath);
+```
+
+```csharp
+// Start from the ProjectDir and get the Template-line-smooth.html file
+var templatePath = ResourceUri.FromProjectRelativePath("Template-line-smooth.html");
+// Remove the Template- prefix
+templatePath = ResourceUri.FromProjectRelativePath(templatePath.Uri.Replace("Template-", ""));
+// Write the new content to the file
+File.WriteAllText(templatePath.Uri, text);
+```
+
+## USB Check (Windows)
+
+```csharp
+/// <summary>
+/// Periodically checks for removable USB drives (Windows) and logs their presence.
+/// Inputs: none. This is intended for a Runtime NetLogic.
+/// Notes: Uses System.IO.DriveInfo and will only run on platforms that expose drive letters (Windows).
+/// </summary>
+private PeriodicTask task;
+
+public override void Start()
+{
+    task = new PeriodicTask(CheckUSB, 1000, LogicObject);
+    task.Start();
+}
+
+private void CheckUSB()
+{
+    var usbDevices = System.IO.DriveInfo.GetDrives();
+    foreach (var device in usbDevices)
+    {
+        if (device.DriveType == System.IO.DriveType.Removable && device.IsReady)
+        {
+            Log.Info("RuntimeNetLogic1", $"USB device found: {device.Name} - {device.VolumeLabel}");
+        }
+    }
+}
+
+public override void Stop()
+{
+    task.Dispose();
+}
+```
+
+## Ensure a directory exists and write a file (Windows)
+
+```csharp
+/// <summary>
+/// Create a folder if missing and write a small test file. Useful when exporting logs or CSV files.
+/// Inputs: NetLogic variables `FolderPath` (string) and `FileName` (string).
+/// </summary>
+[ExportMethod]
+public void CreateFileTest()
+{
+    var folder = LogicObject.GetVariable("FolderPath");
+    var fileName = LogicObject.GetVariable("FileName");
+
+    bool exists = System.IO.Directory.Exists(folder.Value.ToString());
+
+    if (!exists)
+        System.IO.Directory.CreateDirectory(folder.Value.ToString());
+
+    using (var writer = new StreamWriter(System.IO.Path.Combine(folder.Value.ToString(), fileName.Value.ToString())))
+    {
+        // Write some data rows
+        writer.WriteLine("Test file created from NetLogic");
+    }
+
+}
+```
+
+## Project / Application / USB resource URIs
+
+```csharp
+/// <summary>
+/// Examples showing how to log or inspect the different ResourceUri roots available from C#.
+/// Use these to resolve files inside the project, application or on attached USB devices.
+/// </summary>
+// Project files root
+Log.Info(ResourceUri.FromProjectRelativePath("").Uri);
+
+// Application files root
+Log.Info(ResourceUri.FromApplicationRelativePath("").Uri);
+
+// Access USB slot 1 (if present)
+// [!WARNING]
+// Accessing USB paths at runtime can throw if the device is not present - always guard with try/catch.
+try
+{
+    Log.Info(ResourceUri.FromUSBRelativePath(1, "").Uri);
+}
+catch (Exception ex)
+{
+    Log.Warning("ResourceUri", "USB not available: " + ex.Message);
+}
+```

package/vendor/optix/netlogic/pages/runtime-tags-import.md

@@ -0,0 +1,280 @@
+# Run time import of PLC tags
+
+## Introduction
+
+Importing of PLC tags while the application is running is currently only supported for:
+
+- TwinCAT
+- RA Ethernet/IP
+- Siemens S7 Profinet
+
+> [!NOTE]
+> Runtime import of extended tag attributes from the RA Ethernet/IP driver is not supported yet.
+
+### Warning
+
+when importing tags at runtime, especially if filtering is used, a flat list is returned, this means that of you have a structure like:
+
+- PLC
+    - Motor1 (UDT)
+        - Speed (Int32)
+        - Torque (Int32)
+    - Motor2 (UDT)
+        - Speed (Int32)
+        - Torque (Int32)
+
+And you use the filtering mechanism to extract the `Speed` property of both structures, you will get:
+
+- PLC
+    - Speed (Int32)
+    - Speed (Int32)
+
+So, the whole structure should be imported or unique names shall be used
+
+### Code example
+
+Browse and import PLC tags
+
+```csharp
+[ExportMethod]
+public void Import()
+{
+    var station = Project.Current.Get<Station>("CommDrivers/RAEtherNet_IPDriver1/RAEtherNet_IPStation1");
+
+    Struct[] instances;
+    Struct[] types;
+    station.Browse(out instances, out types);
+    station.Import(instances, types);
+
+    var tag = Project.Current.Get<Tag>("CommDrivers/RAEtherNet_IPDriver1/RAEtherNet_IPStation1/Tags/Program:CustomUdtProgram/Increment_INT");
+    Log.Info($"Read value of {tag.BrowseName}");
+    Log.Info($"{tag.RemoteRead()}");
+}
+```
+
+The following code contains a method for each of the driver where runtime import is supported
+
+```csharp
+#region StandardUsing
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using FTOptix.CommunicationDriver;
+using FTOptix.HMIProject;
+using UAManagedCore;
+#endregion
+
+public class RuntimeTagsImport : FTOptix.NetLogic.BaseNetLogic
+{
+    /// <summary>
+    /// Import tags from TwinCAT driver
+    /// </summary>
+    [FTOptix.NetLogic.ExportMethod]
+    public static void ImportFromTwincat()
+    {
+        Log.Info(MethodBase.GetCurrentMethod().Name, "Starting runtime tags import");
+
+        var station = Project.Current.Get<FTOptix.TwinCAT.Station>("CommDrivers/TwinCATDriver1/TwinCATStation1");
+
+        // Call Browse method to retrieve data from PLC
+        // prototypes parameter for TwinCat is always empty
+        station.Browse(out var plcItems, out var prototypes);
+
+        Log.Info("RuntimeTagsImport.ImportFromTwincat", "Fetched " + plcItems.Length + " tags");
+
+        // Filter tag to import by tag name
+        var tagInstances = FilterTagsToImport(new List<string>() { "SampleTag.A", "SomeOtherTag.B" }, plcItems); //TODO
+
+        // Delete existing tags
+        Log.Info("RuntimeTagsImport.ImportFromTwincat", "Clearing existing tags");
+        station.Tags.Clear();
+
+        Log.Info("RuntimeTagsImport.ImportFromTwincat", "Importing " + tagInstances.Length + " tags");
+
+        // Filter tag to import by prototypeId
+        // var tagInstances = GetTagsOfType("MachineParameter", plcItems);
+
+        station.Import(tagInstances, prototypes);
+
+        // Remote read on imported tag
+        ReadTag("SampleTag.A", station);
+
+        // Remote write on imported structure
+        // WriteStructure("SomeOtherTag.B", station);
+
+        // Remote read on imported structure
+        // ReadStructure("SomeOtherTag.B", station);
+    }
+
+    /// <summary>
+    /// Import tags from Profinet driver
+    /// </summary>
+    [FTOptix.NetLogic.ExportMethod]
+    public static void ImportFromProfinet()
+    {
+        Log.Info(MethodBase.GetCurrentMethod().Name, "Starting runtime tags import");
+
+        var station = Project.Current.Get<FTOptix.S7TiaProfinet.Station>("CommDrivers/S7TIAPROFINETDriver1/S7TIAPROFINETStation1");
+
+        // Call Browse method to retrieve data from PLC
+        // prototypes parameter for S7TiaProfinet is always empty
+        station.Browse(out var plcItems, out var prototypes);
+
+        Log.Info("RuntimeTagsImport.ImportFromProfinet", "Fetched " + plcItems.Length + " PLC structures");
+
+        // Profinet tag are grouped by project, so we need to retrieve tags from root
+        var root = plcItems.OfType<BasePlcItem>().ToList();
+        // Root node is always the first element in the list
+        // This is called "PLC" when browsing from the TagImporter
+        var tags = root[0].Items;
+        Log.Info("RuntimeTagsImport.ImportFromProfinet", "Fetched " + tags.Length + " tags");
+        // Filter tag to import by tag name
+        var tagInstances = FilterTagsToImport(new List<string>() { "PLC/TestFix", "PLC/TestDT" }, tags);
+
+        // Delete existing tags
+        Log.Info("RuntimeTagsImport.ImportFromProfinet", "Clearing existing tags");
+        station.Tags.Clear();
+
+        Log.Info("RuntimeTagsImport.ImportFromProfinet", "Importing " + tagInstances.Length + " tags");
+
+        //Filter tag to import by prototypeId
+        //var tagInstances = GetTagsOfType("MachineParameter", tags);
+
+        station.Import(tagInstances, prototypes);
+        Log.Info("Imported " + tagInstances.Length + " tags");
+
+        // Remote read on imported tag
+        ReadTag("SampleTag.A", station);
+
+        // Remote write on imported structure
+        // WriteStructure("SomeOtherTag.B", station);
+
+        // Remote read on imported structure
+        // ReadStructure("SomeOtherTag.B", station);
+    }
+
+    /// <summary>
+    /// Import tags from RA Ethernet/IP driver
+    /// </summary>
+    [FTOptix.NetLogic.ExportMethod]
+    public static void ImportFromRAEthernetIP()
+    {
+        Log.Info("RuntimeTagsImport.ImportFromRAEthernetIP", "Starting runtime tags import");
+
+        var station = Project.Current.Get<FTOptix.RAEtherNetIP.Station>("CommDrivers/RAEtherNet_IPDriver1/RAEtherNet_IPStation1");
+
+        // Call Browse method to retrieve data from PLC
+        station.Browse(out var plcItems, out var prototypes);
+
+        Log.Info("RuntimeTagsImport.ImportFromRAEthernetIP", "Fetched " + plcItems.Length + " tags structures from the PLC");
+
+        // Filter tag to import by tag name
+        var tagInstances = FilterTagsToImport(new List<string>() { "Controller Tags/Tank1/Level", "Controller Tags/Tank2/Level" }, plcItems);
+
+        // Delete existing tags
+        Log.Info("RuntimeTagsImport.ImportFromRAEthernetIP", "Clearing existing tags");
+        station.Tags.Clear();
+
+        Log.Info("RuntimeTagsImport.ImportFromRAEthernetIP", "Importing " + tagInstances.Length + " tags");
+
+        if (tagInstances.Length == 0)
+        {
+            Log.Warning("RuntimeTagsImport.ImportFromRAEthernetIP", "No tags to import. Returning.");
+            return;
+        }
+
+        //Filter tag to import by prototypeId
+        // var tagInstances = GetTagsOfType("MachineParameter", plcItems);
+
+        station.Import(tagInstances, prototypes);
+
+        // Remote read on imported tag
+        ReadTag("Controller Tags/Tank1/Level", station);
+
+        // Remote write on imported structure
+        // WriteStructure("Controller Tags/Tank1/Level", station);
+
+        // Remote read on imported structure
+        // ReadStructure("Controller Tags/Tank1", station);
+    }
+
+    /// <summary>
+    /// Filter tags to import by tag name.
+    /// Expects a list of tag paths to import (like "Controller Tags/Motor1/Speed" and
+    /// the list of all tags that were fetch from the PLC.
+    /// If the list of tags to import is empty, all fetched tags will be returned.
+    /// Warning: a flat list is returned, so the tag paths must be unique.
+    /// </summary>
+    /// <param name="tagPathsToImport">List of tag paths to import (path with forward slashes "/")</param>
+    /// <param name="plcItems">List of all tags fetched from the PLC</param>
+    /// <returns>List of tags (Struct[]) that matches the input list</returns>
+    private static Struct[] FilterTagsToImport(List<string> tagPathsToImport, Struct[] plcItems)
+    {
+        var listOfFoundTags = new List<Struct>();
+
+        // If no list of tags to import was provided, return all tags
+        if (tagPathsToImport.Count == 0)
+        {
+            Log.Warning("RuntimeTagsImport.FilterTagsToImport", "No list of tags to import was provided. Returning all tags.");
+            return plcItems;
+        }
+
+        if (plcItems.Length == 0)
+        {
+            Log.Warning("RuntimeTagsImport.FilterTagsToImport", "No tags were fetched from the PLC. Returning empty list.");
+            return plcItems;
+        }
+
+        // Filter tags to import by tag name
+        foreach (string tagPath in tagPathsToImport)
+        {
+            string[] splitPath = tagPath.Split('/');
+            var node = plcItems;
+            for (int i = 0; i < splitPath.Length; i++)
+            {
+                for (int k = 0; k < node.Length; k++)
+                {
+                    if (((BasePlcItem)node[k]).Name == splitPath[i])
+                    {
+                        if (i == splitPath.Length - 1)
+                        {
+                            listOfFoundTags.Add(node[k]);
+                            break;
+                        }
+                        else
+                        {
+                            node = ((BasePlcItem)node[k]).Items;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        return listOfFoundTags.ToArray();
+    }
+
+    /// <summary>
+    /// Performs a remote read on a tag.
+    /// </summary>
+    /// <param name="tagName"></param>
+    /// <param name="station"></param>
+    private static void ReadTag(string tagName, FTOptix.CommunicationDriver.CommunicationStation station)
+    {
+        try
+        {
+            var tag = station.Get<FTOptix.CommunicationDriver.Tag>("Tags/" + tagName);
+            var result = tag.RemoteRead();
+            Log.Info($"RemoteRead succeed -> {tagName}: {result.Value}");
+        }
+        catch (Exception e)
+        {
+            Log.Error("RemoteRead failed: " + e.Message);
+        }
+    }
+}
+
+
+```
+