@aryacode/dsh-engineering 0.4.3 → 0.4.5

package/vendor/optix/templates/arya-optix-panel/project/ProjectFiles/NetSolution/FTRemoteAccessWidgetSetupLogic.cs

@@ -0,0 +1,153 @@
+#region Using directives
+using UAManagedCore;
+using OpcUa = UAManagedCore.OpcUa;
+using FTOptix.HMIProject;
+using FTOptix.System;
+using FTOptix.NetLogic;
+using FTOptix.Core;
+using FTOptix.CoreBase;
+#endregion
+
+public class FTRemoteAccessWidgetSetupLogic : BaseNetLogic
+{
+    private const string LOG_CATEGORY = nameof(FTRemoteAccessWidgetSetupLogic);
+
+    [ExportMethod]
+    public void SetupFTRemoteAccessNode()
+    {
+        var ftRemoteAccessNodePointer = Owner.Get<NodePointer>("FTRemoteAccessNode");
+        if (ftRemoteAccessNodePointer == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessNode property not defined.");
+            return;
+        }
+
+        if (Owner.Context.GetNode(ftRemoteAccessNodePointer.Value) is not FTRemoteAccess ftRemoteAccessNode)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessNode is not defined.");
+            return;
+        }
+
+        var eventArguments = InformationModel.MakeObject("EventArguments", FTOptix.System.ObjectTypes.RemoteConnectionRequestEvent);
+
+        if (ftRemoteAccessNode.Get("RemoteConnectionRequestEventHandler") is not EventHandler eventHandlerNode)
+        {
+            eventHandlerNode = InformationModel.MakeObject<EventHandler>("RemoteConnectionRequestEventHandler");
+            ftRemoteAccessNode.Add(eventHandlerNode);
+            eventHandlerNode.ListenEventType = FTOptix.System.ObjectTypes.RemoteConnectionRequestEvent;
+            eventHandlerNode.Add(eventArguments);
+        }
+
+        CreateVariables(ftRemoteAccessNode, eventHandlerNode, eventArguments);
+    }
+
+    private static void CreateVariables(FTRemoteAccess ftRemoteAccessNode,
+                                        EventHandler eventHandlerNode,
+                                        IUAObject eventArguments)
+    {
+        const string usernameVariableName = "FTRemoteAccessWidgetUsername";
+        const string ipAddressVariableName = "FTRemoteAccessWidgetIPAddress";
+        const string supervisorIdVariableName = "FTRemoteAccessWidgetSupervisorId";
+        const string connectionPendingVariableName = "FTRemoteAccessWidgetConnectionPending";
+        const string getErrorMessage = "Unable to get event argument: ";
+
+        Log.Info(LOG_CATEGORY, "Creating FTRemoteAccess widget variables and Remote Connection Request event commands.");
+
+        IUAVariable usernameVariable = ftRemoteAccessNode.GetVariable(usernameVariableName);
+        if (usernameVariable == null)
+        {
+            usernameVariable = InformationModel.MakeVariable(usernameVariableName, OpcUa.DataTypes.String);
+            ftRemoteAccessNode.Add(usernameVariable);
+        }
+
+        IUAVariable eventArgumentUsernameVariable = eventArguments.GetVariable("Username");
+        if (eventArgumentUsernameVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, getErrorMessage + "Username");
+            return;
+        }
+
+        SetupEventHandler(eventHandlerNode, usernameVariable, OpcUa.DataTypes.String, eventArgumentUsernameVariable);
+
+        IUAVariable ipAddressVariable = ftRemoteAccessNode.GetVariable(ipAddressVariableName);
+        if (ipAddressVariable == null)
+        {
+            ipAddressVariable = InformationModel.MakeVariable(ipAddressVariableName, OpcUa.DataTypes.String);
+            ftRemoteAccessNode.Add(ipAddressVariable);
+        }
+
+        IUAVariable eventArgumentIpAddressVariable = eventArguments.GetVariable("IpAddress");
+        if (eventArgumentIpAddressVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, getErrorMessage + "IpAddress");
+            return;
+        }
+
+        SetupEventHandler(eventHandlerNode, ipAddressVariable, OpcUa.DataTypes.String, eventArgumentIpAddressVariable);
+
+        IUAVariable supervisorIdVariable = ftRemoteAccessNode.GetVariable(supervisorIdVariableName);
+        if (supervisorIdVariable == null)
+        {
+            supervisorIdVariable = InformationModel.MakeVariable(supervisorIdVariableName, OpcUa.DataTypes.ByteString);
+            ftRemoteAccessNode.Add(supervisorIdVariable);
+        }
+
+        IUAVariable eventArgumentSupervisorIdVariable = eventArguments.GetVariable("SupervisorId");
+        if (eventArgumentSupervisorIdVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, getErrorMessage + "SupervisorId");
+            return;
+        }
+
+        SetupEventHandler(eventHandlerNode, supervisorIdVariable, OpcUa.DataTypes.ByteString, eventArgumentSupervisorIdVariable);
+
+        IUAVariable connectionPendingVariable = ftRemoteAccessNode.GetVariable(connectionPendingVariableName);
+        if (connectionPendingVariable == null)
+        {
+            connectionPendingVariable = InformationModel.MakeVariable(connectionPendingVariableName, OpcUa.DataTypes.Boolean);
+            ftRemoteAccessNode.Add(connectionPendingVariable);
+        }
+
+        SetupEventHandler(eventHandlerNode, connectionPendingVariable, OpcUa.DataTypes.Boolean, null);
+    }
+
+    private static void SetupEventHandler(EventHandler eventHandlerNode,
+                                          IUAVariable variableNode,
+                                          NodeId valueType,
+                                          IUAVariable eventArgumentVariable)
+    {
+        string methodContainerName = "MethodContainer" + variableNode.BrowseName;
+        IUANode methodContainerNode = eventHandlerNode.Find(methodContainerName);
+        if (methodContainerNode != null)
+            return;
+
+        var methodContainer = InformationModel.MakeObject(methodContainerName);
+        eventHandlerNode.MethodsToCall.Add(methodContainer);
+
+        var objectPointerVariable = InformationModel.MakeVariable<NodePointer>("ObjectPointer", OpcUa.DataTypes.NodeId);
+        objectPointerVariable.Value = InformationModel.GetObject(FTOptix.CoreBase.Objects.VariableCommands).NodeId;
+        methodContainer.Add(objectPointerVariable);
+
+        var methodNameVariable = InformationModel.MakeVariable("Method", OpcUa.DataTypes.String);
+        methodNameVariable.Value = "Set";
+        methodContainer.Add(methodNameVariable);
+
+        var inputArguments = InformationModel.MakeObject("InputArguments");
+        methodContainer.Add(inputArguments);
+
+        var variableToModify = InformationModel.MakeVariable("VariableToModify", FTOptix.Core.DataTypes.VariablePointer);
+        variableToModify.Value = variableNode.NodeId;
+        inputArguments.Add(variableToModify);
+
+        var valueVariable = InformationModel.MakeVariable("Value", valueType);
+        if (eventArgumentVariable != null)
+            valueVariable.SetDynamicLink(eventArgumentVariable, DynamicLinkMode.ReadWrite);
+        if (valueType == OpcUa.DataTypes.Boolean)
+            valueVariable.Value = true;
+        inputArguments.Add(valueVariable);
+
+        var arrayIndexVariable = InformationModel.MakeVariable("ArrayIndex", OpcUa.DataTypes.UInt32);
+        arrayIndexVariable.ValueRank = ValueRank.ScalarOrOneDimension;
+        inputArguments.Add(arrayIndexVariable);
+    }
+}

package/vendor/optix/templates/arya-optix-panel/project/ProjectFiles/NetSolution/IncomingConnectionApprovalLogic.cs

@@ -0,0 +1,118 @@
+#region Using directives
+using UAManagedCore;
+using FTOptix.NetLogic;
+using FTOptix.System;
+#endregion
+
+public class IncomingConnectionApprovalLogic : BaseNetLogic
+{
+    private const string LOG_CATEGORY = nameof(IncomingConnectionApprovalLogic);
+
+    public override void Start()
+    {
+        ftRemoteAccessWidgetDataObject = LogicObject.GetAlias("FTRemoteAccessWidgetDataObject") as FTRemoteAccessWidgetDataObject;
+        if (ftRemoteAccessWidgetDataObject == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessWidgetDataObject" + notDefinedMessage);
+            return;
+        }
+
+        ftRemoteAccessNode = ftRemoteAccessWidgetDataObject.Context.GetNode(ftRemoteAccessWidgetDataObject.FTRemoteAccessNode) as FTRemoteAccess;
+        if (ftRemoteAccessNode == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessNode" + notDefinedMessage);
+            return;
+        }
+
+        connectionPendingVariable = ftRemoteAccessNode.GetVariable(connectionPendingVariableName);
+        if (connectionPendingVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, connectionPendingVariableName + notDefinedMessage);
+            return;
+        }
+    }
+
+    public override void Stop()
+    {
+        // destruct class objects
+        ftRemoteAccessNode = null;
+        ftRemoteAccessWidgetDataObject = null;
+        connectionPendingVariable = null;
+    }
+
+    [ExportMethod]
+    public void AcceptIncomingConnection()
+    {
+        if (ftRemoteAccessWidgetDataObject == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessWidgetDataObject" + notDefinedMessage);
+            return;
+        }
+
+        if (ftRemoteAccessNode == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessNode" + notDefinedMessage);
+            return;
+        }
+
+        if (connectionPendingVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, connectionPendingVariableName + notDefinedMessage);
+            return;
+        }
+
+        var result = ftRemoteAccessNode.ApproveIncomingRemoteConnection(ftRemoteAccessWidgetDataObject.SupervisorId);
+        if (result == IncomingRemoteConnectionApprovalResult.Success)
+        {
+            connectionPendingVariable.Value = false;
+        }
+        else if (result == IncomingRemoteConnectionApprovalResult.NoConnectionToApprove)
+        {
+            Log.Info(LOG_CATEGORY, "Connection request has already been handled.");
+            connectionPendingVariable.Value = false;
+        }
+        else
+            Log.Error(LOG_CATEGORY, "Failed to accept connection request. FTRemoteAccess runtime is not connected.");
+    }
+
+    [ExportMethod]
+    public void DenyIncomingConnection()
+    {
+        if (ftRemoteAccessWidgetDataObject == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessWidgetDataObject" + notDefinedMessage);
+            return;
+        }
+
+        if (ftRemoteAccessNode == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessNode" + notDefinedMessage);
+            return;
+        }
+
+        if (connectionPendingVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, connectionPendingVariableName + notDefinedMessage);
+            return;
+        }
+
+        var result = ftRemoteAccessNode.DenyIncomingRemoteConnection(ftRemoteAccessWidgetDataObject.SupervisorId);
+        if (result == IncomingRemoteConnectionApprovalResult.Success)
+        {
+            connectionPendingVariable.Value = false;
+        }
+        else if (result == IncomingRemoteConnectionApprovalResult.NoConnectionToApprove)
+        {
+            Log.Info(LOG_CATEGORY, "Connection request has already been handled.");
+            connectionPendingVariable.Value = false;
+        }
+        else
+            Log.Error(LOG_CATEGORY, "Failed to deny connection request. FTRemoteAccess runtime is not connected.");
+    }
+
+    private FTRemoteAccessWidgetDataObject ftRemoteAccessWidgetDataObject;
+    private FTRemoteAccess ftRemoteAccessNode;
+    private IUAVariable connectionPendingVariable;
+    private const string connectionPendingVariableName = "FTRemoteAccessWidgetConnectionPending";
+    private const string notDefinedMessage = " is not defined.";
+}

package/vendor/optix/templates/arya-optix-panel/project/ProjectFiles/NetSolution/IncomingConnectionReceiverLogic.cs

@@ -0,0 +1,166 @@
+#region Using directives
+using UAManagedCore;
+using FTOptix.System;
+using FTOptix.NetLogic;
+#endregion
+
+public class IncomingConnectionReceiverLogic : BaseNetLogic
+{
+    private const string LOG_CATEGORY = nameof(IncomingConnectionReceiverLogic);
+
+    public override void Start()
+    {
+        bool cancelStart = false;
+
+        ftRemoteAccessWidgetDataObject = Owner.Get<FTRemoteAccessWidgetDataObject>("FTRemoteAccessWidgetDataObject");
+        if (ftRemoteAccessWidgetDataObject == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessWidgetDataObject" + notDefinedMessage);
+            return;
+        }
+
+        ftRemoteAccessNode = ftRemoteAccessWidgetDataObject.Context.GetNode(ftRemoteAccessWidgetDataObject.FTRemoteAccessNode) as FTRemoteAccess;
+        if (ftRemoteAccessNode == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessNode" + notDefinedMessage);
+            return;
+        }
+
+        connectionPendingVariable = ftRemoteAccessNode.GetVariable(connectionPendingVariableName);
+        if (connectionPendingVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, connectionPendingVariableName + notDefinedMessage);
+            cancelStart = true;
+        }
+
+        usernameVariable = ftRemoteAccessNode.GetVariable(usernameVariableName);
+        if (usernameVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, usernameVariableName + notDefinedMessage);
+            cancelStart = true;
+        }
+
+        ipAddressVariable = ftRemoteAccessNode.GetVariable(ipAddressVariableName);
+        if (ipAddressVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, ipAddressVariableName + notDefinedMessage);
+            cancelStart = true;
+        }
+
+        supervisorIdVariable = ftRemoteAccessNode.GetVariable(supervisorIdVariableName);
+        if (supervisorIdVariable == null)
+        {
+            Log.Error(LOG_CATEGORY, supervisorIdVariableName + notDefinedMessage);
+            cancelStart = true;
+        }
+
+        if (cancelStart)
+        {
+            DestroyClassFields();
+            return;
+        }
+
+        //handle the case where an incoming connection request may already be pending at startup of the widget
+        SetFTRemoteAccessWidgetDataObjectValues(connectionPendingVariable.Value);
+
+        connectionPendingVariable.VariableChange += HandleConnectionPendingVariableChangedEvent;
+    }
+
+    public override void Stop()
+    {
+        if (connectionPendingVariable != null)
+            connectionPendingVariable.VariableChange -= HandleConnectionPendingVariableChangedEvent;
+
+        DestroyClassFields();
+    }
+
+    private void DestroyClassFields()
+    {
+        ftRemoteAccessNode = null;
+        ftRemoteAccessWidgetDataObject = null;
+        connectionPendingVariable = null;
+        usernameVariable = null;
+        ipAddressVariable = null;
+        supervisorIdVariable = null;
+    }
+
+    private void HandleConnectionPendingVariableChangedEvent(object sender, VariableChangeEventArgs args)
+    {
+        if (ftRemoteAccessWidgetDataObject == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessWidgetDataObject" + notDefinedMessage);
+            return;
+        }
+
+        if (ftRemoteAccessNode == null)
+        {
+            Log.Error(LOG_CATEGORY, "FTRemoteAccessNode" + notDefinedMessage);
+        }
+
+        SetFTRemoteAccessWidgetDataObjectValues(args.NewValue);
+    }
+
+    private void SetFTRemoteAccessWidgetDataObjectValues(bool requestPending)
+    {
+        bool undefinedVars = false;
+
+        if (requestPending)
+        {
+            string userNameValue = usernameVariable.Value;
+            if (!string.IsNullOrEmpty(userNameValue))
+                ftRemoteAccessWidgetDataObject.Username = userNameValue;
+            else
+            {
+                Log.Error(LOG_CATEGORY, usernameVariableName + noValueMessage);
+                undefinedVars = true;
+            }
+
+            string ipAddressValue = ipAddressVariable.Value;
+            if (!string.IsNullOrEmpty(ipAddressValue))
+                ftRemoteAccessWidgetDataObject.IpAddress = ipAddressVariable.Value;
+            else
+            {
+                Log.Error(LOG_CATEGORY, ipAddressVariableName + noValueMessage);
+                undefinedVars = true;
+            }
+
+            ByteString supervisorIdValue = supervisorIdVariable.Value;
+            if (!supervisorIdValue.IsEmpty)
+                ftRemoteAccessWidgetDataObject.SupervisorId = supervisorIdValue;
+            else
+            {
+                Log.Error(LOG_CATEGORY, supervisorIdVariableName + noValueMessage);
+                undefinedVars = true;
+            }
+        }
+        else
+        {
+            usernameVariable.Value = ftRemoteAccessWidgetDataObject.Username = string.Empty;
+            ipAddressVariable.Value = ftRemoteAccessWidgetDataObject.IpAddress = string.Empty;
+            supervisorIdVariable.Value = ftRemoteAccessWidgetDataObject.SupervisorId = ByteString.Empty;
+        }
+
+        if (requestPending && !undefinedVars)
+        {
+            ftRemoteAccessWidgetDataObject.IncomingConnectionRequest = true;
+        }
+        else
+        {
+            connectionPendingVariable.Value = false;
+            ftRemoteAccessWidgetDataObject.IncomingConnectionRequest = false;
+        }
+    }
+
+    private FTRemoteAccessWidgetDataObject ftRemoteAccessWidgetDataObject;
+    private FTRemoteAccess ftRemoteAccessNode;
+    private IUAVariable connectionPendingVariable;
+    private IUAVariable usernameVariable;
+    private IUAVariable ipAddressVariable;
+    private IUAVariable supervisorIdVariable;
+    private const string usernameVariableName = "FTRemoteAccessWidgetUsername";
+    private const string ipAddressVariableName = "FTRemoteAccessWidgetIPAddress";
+    private const string supervisorIdVariableName = "FTRemoteAccessWidgetSupervisorId";
+    private const string connectionPendingVariableName = "FTRemoteAccessWidgetConnectionPending";
+    private const string noValueMessage = " has no value.";
+    private const string notDefinedMessage = " is not defined.";
+}

package/vendor/optix/templates/arya-optix-panel/project/ProjectFiles/NetSolution/NetworkConfiguratorEditModelsLogic.cs

@@ -0,0 +1,56 @@
+#region Using directives
+using UAManagedCore;
+using FTOptix.HMIProject;
+using FTOptix.NetLogic;
+using System.Linq;
+using FTOptix.UI;
+using FTOptix.SerialPort;
+#endregion
+
+public class NetworkConfiguratorEditModelsLogic : BaseNetLogic
+{
+    public static void CreateEditModels(FTOptix.System.System systemNode, IUAObject parentNode)
+    {
+        NetworkInterfacesEditModel.CreateEditModel(systemNode, parentNode);
+    }
+
+    public static IUAObject GetNetworkInterfacesEditModel(IUAObject parentNode)
+    {
+        var networkInterfacesEditModel = parentNode.GetObject(editModelNetworkInterfacesBrowseName);
+        if (networkInterfacesEditModel == null)
+            throw new CoreConfigurationException("Edit model for network interfaces not found");
+
+        return networkInterfacesEditModel;
+    }
+
+    public static void DeleteEditModels(IUAObject parentNode)
+    {
+        NetworkInterfacesEditModel.DeleteEditModel(parentNode);
+    }
+
+    private static class NetworkInterfacesEditModel
+    {
+        public static IUAObject CreateEditModel(FTOptix.System.System systemNode, IUAObject parentNode)
+        {
+            var editModelNetworkInterfaces = parentNode.FindObject(editModelNetworkInterfacesBrowseName);
+            if (editModelNetworkInterfaces == null)
+            {
+                editModelNetworkInterfaces = InformationModel.MakeObject(editModelNetworkInterfacesBrowseName);
+                var systemToNetworkInterfacesEditModelWriter = new SystemToNetworkInterfacesEditModelWriterLogic(editModelNetworkInterfaces);
+                systemToNetworkInterfacesEditModelWriter.InitializeEditModel(systemNode.NetworkInterfaces.ToList());
+                parentNode.Add(editModelNetworkInterfaces);
+            }
+
+            return editModelNetworkInterfaces;
+        }
+
+        public static void DeleteEditModel(IUAObject parentNode)
+        {
+            var editModelNetworkInterfaces = parentNode.FindObject(editModelNetworkInterfacesBrowseName);
+            if (editModelNetworkInterfaces != null)
+                parentNode.Remove(editModelNetworkInterfaces);
+        }
+    }
+
+    private static readonly string editModelNetworkInterfacesBrowseName = "NetworkInterfacesEditModel";
+}

package/vendor/optix/templates/arya-optix-panel/project/ProjectFiles/NetSolution/NetworkInterfaceLogic.cs

@@ -0,0 +1,138 @@
+#region Using directives
+using FTOptix.CoreBase;
+using FTOptix.UI;
+using UAManagedCore;
+using FTOptix.NetLogic;
+using FTOptix.SerialPort;
+#endregion
+
+public class NetworkInterfaceLogic : BaseNetLogic
+{
+    public override void Stop()
+    {
+        if (doesThisNetworkInterfaceExist && dhcpCheckbox != null)
+            dhcpCheckbox.CheckedVariable.VariableChange -= DhcpChecked_VariableChange;
+
+        editModelNetworkInterfacesReader = null;
+        dhcpCheckbox = null;
+        ipAddressTextBox = null;
+        maskTextBox= null;
+        defaultGatewayTextBox= null;
+        dns1TextBox= null;
+        dns2TextBox= null;
+    }
+
+    public void SetMembers(FTOptix.System.System systemNode, string interfaceName, IUAObject networkConfiguratorEditModelsObject, IUANode panelObject)
+    {
+        this.interfaceName = interfaceName;
+
+        dhcpCheckbox = panelObject.Find<CheckBox>("DHCPClientEnabledCheckbox");
+        if (dhcpCheckbox == null)
+            throw new CoreConfigurationException("LAN DHCPClientEnabledCheckbox not found");
+
+        ipAddressTextBox = panelObject.Find<TextBox>("IPAddressTextBox");
+        if (ipAddressTextBox == null)
+            throw new CoreConfigurationException("LAN IPAddressTextBox not found");
+
+        maskTextBox = panelObject.Find<TextBox>("MaskTextBox");
+        if (maskTextBox == null)
+            throw new CoreConfigurationException("LAN MaskTextBox not found");
+
+        defaultGatewayTextBox = panelObject.Find<TextBox>("DefaultGatewayTextBox");
+        if (defaultGatewayTextBox == null)
+            throw new CoreConfigurationException("LAN DefaultGatewayTextBox not found");
+
+        dns1TextBox = panelObject.Find<TextBox>("DNS1TextBox");
+        if (dns1TextBox == null)
+            throw new CoreConfigurationException("LAN DNS1TextBox not found");
+
+        dns2TextBox = panelObject.Find<TextBox>("DNS2TextBox");
+        if (dns2TextBox == null)
+            throw new CoreConfigurationException("LAN DNS2TextBox not found");
+
+        NetworkConfiguratorEditModelsLogic.CreateEditModels(systemNode, networkConfiguratorEditModelsObject);
+        var editModelNetworkInterfaces = NetworkConfiguratorEditModelsLogic.GetNetworkInterfacesEditModel(networkConfiguratorEditModelsObject);
+
+        editModelNetworkInterfacesReader = new NetworkInterfacesEditModelReaderLogic(editModelNetworkInterfaces);
+
+        var networkInterfaceObject = editModelNetworkInterfaces.GetObject(interfaceName);
+        if (networkInterfaceObject == null)
+        {
+            if (panelObject is Panel panel)
+                panel.Enabled = false;
+
+            doesThisNetworkInterfaceExist = false;
+        }
+        else
+        {
+            SetDynamicLinksToEditModel(this.interfaceName);
+            SetControlsEnabled();
+            dhcpCheckbox.CheckedVariable.VariableChange += DhcpChecked_VariableChange;
+        }
+    }
+
+    private void DhcpChecked_VariableChange(object sender, VariableChangeEventArgs e)
+    {
+        SetControlsEnabled();
+    }
+
+    private void SetDynamicLinksToEditModel(string interfaceName)
+    {
+        var checkedVariable = dhcpCheckbox.CheckedVariable;
+        checkedVariable.ResetDynamicLink();
+        checkedVariable.SetDynamicLink(editModelNetworkInterfacesReader.GetDhcpVariable(interfaceName), DynamicLinkMode.ReadWrite);
+
+        var ipAddressTextBoxTextVariable = ipAddressTextBox.TextVariable;
+        ipAddressTextBoxTextVariable.ResetDynamicLink();
+        ipAddressTextBoxTextVariable.SetDynamicLink(editModelNetworkInterfacesReader.GetIPAddressVariable(interfaceName), DynamicLinkMode.ReadWrite);
+
+        var maskTextBoxTextVariable = maskTextBox.TextVariable;
+        maskTextBoxTextVariable.ResetDynamicLink();
+        maskTextBoxTextVariable.SetDynamicLink(editModelNetworkInterfacesReader.GetMaskVariable(interfaceName), DynamicLinkMode.ReadWrite);
+
+        var dns1TextBoxTextVariable = dns1TextBox.TextVariable;
+        dns1TextBoxTextVariable.ResetDynamicLink();
+        dns1TextBoxTextVariable.SetDynamicLink(editModelNetworkInterfacesReader.GetDNS1Variable(interfaceName), DynamicLinkMode.ReadWrite);
+
+        var dns2TextBoxTextVariable = dns2TextBox.TextVariable;
+        dns2TextBoxTextVariable.ResetDynamicLink();
+        dns2TextBoxTextVariable.SetDynamicLink(editModelNetworkInterfacesReader.GetDNS2Variable(interfaceName), DynamicLinkMode.ReadWrite);
+
+        var defaultGatewayTextBoxTextVariable = defaultGatewayTextBox.TextVariable;
+        defaultGatewayTextBoxTextVariable.ResetDynamicLink();
+        defaultGatewayTextBoxTextVariable.SetDynamicLink(editModelNetworkInterfacesReader.GetDefaultGatewayVariable(interfaceName), DynamicLinkMode.ReadWrite);
+    }
+
+    private void SetControlsEnabled()
+    {
+        if (dhcpCheckbox.Checked)
+        {
+            ipAddressTextBox.Enabled = false;
+            maskTextBox.Enabled = false;
+            defaultGatewayTextBox.Enabled = false;
+            dns1TextBox.Enabled = false;
+            dns2TextBox.Enabled = false;
+        }
+        else
+        {
+            ipAddressTextBox.Enabled = true;
+            maskTextBox.Enabled = true;
+            defaultGatewayTextBox.Enabled = true;
+            dns1TextBox.Enabled = true;
+            dns2TextBox.Enabled = true;
+        }
+    }
+
+    private string interfaceName;
+
+    private NetworkInterfacesEditModelReaderLogic editModelNetworkInterfacesReader;
+
+    private CheckBox dhcpCheckbox;
+    private TextBox ipAddressTextBox;
+    private TextBox maskTextBox;
+    private TextBox defaultGatewayTextBox;
+    private TextBox dns1TextBox;
+    private TextBox dns2TextBox;
+
+    private bool doesThisNetworkInterfaceExist = true;
+}