PyAutomationIO 1.1.1__py3-none-any.whl

automation/pages/callbacks/opcua.py

@@ -0,0 +1,266 @@
+import dash, csv, io
+from ...utils import get_nodes_info, get_data_to_update_into_opcua_table
+from ...pages.components.opcua import OPCUAComponents
+from ...opcua.subscription import SubHandler
+
+
+subscription_handler = SubHandler()
+opcua_components = OPCUAComponents()
+
+
+def init_callback(app:dash.Dash):
+    
+    @app.callback(
+        dash.Output("data_access_view_table", "children", allow_duplicate=True),
+        dash.Input('timestamp-interval', 'n_intervals'),
+        dash.State({'type': 'file-checklist', 'index': dash.dependencies.ALL}, 'value'),
+        prevent_initial_call=False
+    )
+    def update_data_access_table( n_intervals, selected_files):
+        
+        to_get_node_values = get_nodes_info(selected_files=selected_files)
+        data = get_data_to_update_into_opcua_table(app=app, to_get_node_values=to_get_node_values)
+        
+        return opcua_components.data_access_view_table(data=data)
+
+    @app.callback(
+        dash.Output("data_access_view_table", "children"),
+        dash.Input({'type': 'file-checklist', 'index': dash.dependencies.ALL}, 'value')
+    )
+    def display_selected_file(selected_files):
+
+        subscription_handler.unsubscribe_all()
+        to_get_node_values = get_nodes_info(selected_files=selected_files)
+
+        data = list()
+        subscriptions = dict()
+        for client_name, namespaces in to_get_node_values.items():
+            
+            client = app.automation.get_opcua_client(client_name=client_name)
+            if client:
+                subscriptions[client_name] = client.create_subscription(1000, subscription_handler)
+                infos = app.automation.get_node_attributes(client_name=client_name, namespaces=namespaces)
+                if infos:
+                    for info in infos:
+                        _info = info[0]
+                        namespace = _info["Namespace"]
+                        data.append(
+                            {
+                                "server": client_name,
+                                "namespace": namespace,
+                                "data_type": _info["DataType"],
+                                "display_name": _info["DisplayName"],
+                                "value": _info["Value"],
+                                "source_timestamp": _info["DataValue"].SourceTimestamp,
+                                "status_code": _info["DataValue"].StatusCode.name
+                            }
+                        )
+                        
+                        node_id = client.get_node_id_by_namespace(namespace)
+                        subscription = subscriptions[client_name]
+                        subscription_handler.subscribe(subscription=subscription, client_name=client_name, node_id=node_id)
+
+        return opcua_components.data_access_view_table(data=data)
+
+    @app.callback(
+        dash.Output("add_server_modal", "is_open"),
+        dash.Input("add_server_button", "n_clicks"),
+        [dash.State("add_server_modal", "is_open")],
+    )
+    def add_server_button(n, is_open):
+        r"""
+        Documentation here
+        """
+        if n:
+
+            return not is_open
+        
+        return is_open
+    
+    @app.callback(
+        dash.Output("remove_server_modal", "is_open"),
+        dash.Input("remove_server_button", "n_clicks"),
+        [dash.State("remove_server_modal", "is_open")],
+    )
+    def remove_server_button(n, is_open):
+        r"""
+        Documentation here
+        """
+        if n:
+            clients = list()
+            for client_name in app.automation.get_opcua_clients().keys():
+
+                clients.append(
+                    {"label": client_name, "value": client_name}
+                )
+
+            dash.set_props("opcua_client_names_options", {"options": clients})
+            return not is_open
+        
+        return is_open
+    
+    @app.callback(
+        dash.Output("add_server_modal", "is_open", allow_duplicate=True),
+        dash.Output("server_tree", "children"),
+        dash.Input("add_server_ok_button_modal", "n_clicks"),
+        dash.State("opcua_client_name_input", "value"),
+        dash.State("opcua_client_host_input", "value"),
+        dash.State("opcua_client_port_input", "value")
+    )
+    def ok_add_server_button(n, client_name:str, host:str="127.0.0.1", port:int=4840):
+        r"""
+        Documentation here
+        """
+        resp, _ = app.automation.add_opcua_client(client_name=client_name, host=host, port=port)
+        if resp:
+
+            data = OPCUAComponents.get_opcua_tree(app)
+            subscription_handler.unsubscribe_all()        
+
+            return False, data
+        
+        message = f"Connection refused on opc.tcp://{host}:{port}"
+        dash.set_props("modal-error-opcua-connection-body", {"children": message})
+        dash.set_props("modal-error-opcua-connection", {'is_open': True})
+
+        return False, {}
+    
+    @app.callback(
+        dash.Output("add_server_modal", "is_open", allow_duplicate=True),
+        dash.Input("add_server_cancel_button_modal", "n_clicks"),
+    )
+    def cancel_add_server_button(n):
+        r"""
+        Documentation here
+        """
+        return False
+    
+    @app.callback(
+        dash.Output("remove_server_modal", "is_open", allow_duplicate=True),
+        dash.Input("remove_server_ok_button_modal", "n_clicks"),
+        dash.State("opcua_client_names_options", "value")
+    )
+    def ok_remove_server_button(n, client_name:str):
+        r"""
+        Documentation here
+        """
+        if client_name:
+
+            app.automation.remove_opcua_client(client_name=client_name)
+
+        data = OPCUAComponents.get_opcua_tree(app)
+        dash.set_props("server_tree", {"children": data})
+        return False
+    
+    @app.callback(
+        dash.Output("remove_server_modal", "is_open", allow_duplicate=True),
+        dash.Input("remove_server_cancel_button_modal", "n_clicks"),
+    )
+    def cancel_remove_server_button(n):
+        r"""
+        Documentation here
+        """
+        return False
+    
+    @app.callback(
+        dash.Output("server_tree", "children", allow_duplicate=True),
+        dash.Input('communications_page', 'pathname'),
+        prevent_initial_call=True
+        )
+    def display_page(pathname):
+        r"""
+        Documentation here
+        """
+        if pathname=="/":
+
+            data = OPCUAComponents.get_opcua_tree(app)
+            subscription_handler.unsubscribe_all()
+            
+            return data
+        
+    @app.callback(
+        dash.Output("modal-success-opcua-connection", "is_open"),
+        dash.Input("close-success-opcua-connection", "n_clicks"),
+        [dash.State("modal-success-opcua-connection", "is_open")],
+    )
+    def close_success_button(n, is_open):
+        r"""
+        Documentation here
+        """
+        if n:
+
+            return not is_open
+        
+        return is_open
+    
+    @app.callback(
+        dash.Output("modal-error-opcua-connection", "is_open"),
+        dash.Input("close-error-opcua-connection", "n_clicks"),
+        [dash.State("modal-error-opcua-connection", "is_open")],
+    )
+    def close_error_opcua_connection_button(n, is_open):
+        r"""
+        Documentation here
+        """
+        if n:
+
+            return not is_open
+        
+        return is_open
+    
+    @app.callback(
+        dash.Output("download_node_info_modal", "is_open"),
+        dash.Input("download_node_info_button", "n_clicks"),
+        [dash.State("download_node_info_modal", "is_open")],
+    )
+    def download_node_info_button(n, is_open):
+        r"""
+        Documentation here
+        """
+        if n:
+            clients = list()
+            for client_name in app.automation.get_opcua_clients().keys():
+
+                clients.append(
+                    {"label": client_name, "value": client_name}
+                )
+
+            dash.set_props("download_opcua_client_names_options", {"options": clients})
+            return not is_open
+        
+        return is_open
+    
+    @app.callback(
+        dash.Output("download_node_info_modal", "is_open", allow_duplicate=True),
+        dash.Output("download", "data"),
+        dash.Input("download_node_info_ok_button_modal", "n_clicks"),
+        dash.State("download_opcua_client_names_options", "value")
+    )
+    def ok_download_node_info_button(n, client_name:str):
+        r"""
+        Documentation here
+        """
+        if client_name:
+
+            opcua_tree = app.automation.get_opcua_tree(client_name=client_name)
+            opcua_tree = opcua_tree[0]['Objects']
+            flat = list()
+            for tree in opcua_tree:
+                
+                flat.extend(OPCUAComponents.flatten_dict(tree))
+            output = io.StringIO() 
+            writer = csv.DictWriter(output, fieldnames=["name", "namespace", "NodeClass"]) 
+            writer.writeheader() 
+            writer.writerows(flat)
+            
+        return False, dict(content=output.getvalue(), filename=f"opcua_server_node_{client_name}.csv")
+    
+    @app.callback(
+        dash.Output("download_node_info_modal", "is_open", allow_duplicate=True),
+        dash.Input("download_node_info_cancel_button_modal", "n_clicks"),
+    )
+    def cancel_remove_server_button(n):
+        r"""
+        Documentation here
+        """
+        return False

automation/pages/callbacks/opcua_server.py

@@ -0,0 +1,244 @@
+import dash
+from ...pages.components.opcua import OPCUAComponents
+from ...opcua.subscription import SubHandler
+from ...models import StringType
+from ...state_machine import Node, ua
+from ...utils import find_differences_between_lists_opcua_server
+
+
+subscription_handler = SubHandler()
+opcua_components = OPCUAComponents()
+
+
+def init_callback(app:dash.Dash):
+
+    def create_opcua_server_table(opcua_server_machine):
+
+        attrs = list()        
+        for attr in dir(opcua_server_machine):
+            if hasattr(opcua_server_machine, attr):
+                node = getattr(opcua_server_machine, attr)
+                if isinstance(node, Node):
+
+                    node_class = node.get_node_class()
+                    if node_class == ua.NodeClass.Variable:
+                        
+                        display_name = node.get_attribute(ua.AttributeIds.DisplayName).Value.Value.Text
+                        # Obtén el nodo padre
+                        parent_node = node.get_parent()
+
+                        # Obtén el nombre de la carpeta padre (nodo padre)
+                        parent_name = parent_node.get_browse_name().Name
+                        access_level = node.get_access_level()
+                        # Verificar los niveles de acceso
+                        write_only = ua.AccessLevel.CurrentWrite in access_level and ua.AccessLevel.CurrentRead not in access_level
+                        read_write = ua.AccessLevel.CurrentRead in access_level and ua.AccessLevel.CurrentWrite in access_level
+                        access_type = "Read"
+                        if write_only:
+
+                            access_type = "Write"
+                        
+                        elif read_write:
+
+                            access_type = "ReadWrite"
+
+                        attrs.append({
+                            "name": f"{parent_name}.{display_name}",
+                            "namespace": node.nodeid.to_string(),
+                            "access_type": access_type
+                        })
+
+                        properties = node.get_properties()
+                        for prop in properties:
+                            prop_name = prop.get_display_name().Text
+                            # prop_value = prop.get_value()
+
+                            access_level = prop.get_access_level()
+                            # Verificar los niveles de acceso
+                            write_only = ua.AccessLevel.CurrentWrite in access_level and ua.AccessLevel.CurrentRead not in access_level
+                            read_write = ua.AccessLevel.CurrentRead in access_level and ua.AccessLevel.CurrentWrite in access_level
+                            access_type = "Read"
+                            if write_only:
+
+                                access_type = "Write"
+                            
+                            elif read_write:
+
+                                access_type = "ReadWrite"
+
+                            attrs.append({
+                                "name": f"{parent_name}.{display_name}.{prop_name}",
+                                "namespace": prop.nodeid.to_string(),
+                                "access_type": access_type
+                            })
+        return attrs
+
+    @app.callback(
+        dash.Output("opcua_server_datatable", "data", allow_duplicate=True),
+        dash.Input('opcua_server', 'pathname'),
+        prevent_initial_call=True
+        )
+    def display_page(pathname):
+        r"""
+        Documentation here
+        """
+        attrs = list()
+
+        if pathname=="/opcua-server":
+            opcua_server_machine = app.automation.get_machine(name=StringType("OPCUAServer"))
+            attrs = create_opcua_server_table(opcua_server_machine=opcua_server_machine)
+
+        return attrs
+    
+    @app.callback(
+        dash.Input('opcua_server_datatable', 'data_timestamp'),
+        dash.State('opcua_server_datatable', 'data_previous'),
+        dash.State('opcua_server_datatable', 'data'),
+        )
+    def update_read_only(timestamp, previous, current):
+        message = None
+        attr_not_clearable = ("name", "namespace")
+        if timestamp:
+
+            if previous and current: # UPDATE TAG DEFINITION
+                
+                to_updates = find_differences_between_lists_opcua_server(previous, current)
+                node_to_update = to_updates[0]
+                node_name = node_to_update.pop("name")
+                node_to_update.pop("namespace")
+                for attr in attr_not_clearable:
+                    if attr in node_to_update:
+                        if not node_to_update[attr]:
+                            message = f"You can not empty {attr} attribute"
+                
+                if message:
+                    dash.set_props("modal-update-opcua-server-body", {"children": message})
+                    dash.set_props("modal-update-opcua-server-centered", {'is_open': True})
+                    return
+                message = f"Do you want to update node {node_name} Access Type to {node_to_update['access_type']}?"
+                # OPEN MODAL TO CONFIRM CHANGES
+                dash.set_props("modal-update-opcua-server-body", {"children": message})
+                dash.set_props("modal-update-opcua-server-centered", {'is_open': True})
+
+    @app.callback(
+        [
+            dash.Output("modal-update-opcua-server-centered", "is_open"), 
+            dash.Output('opcua_server_datatable', 'data'), 
+            dash.Output('opcua_server_datatable', 'data_timestamp'),
+            dash.Output("update-opcua-server-yes", "n_clicks"),
+            dash.Output("update-opcua-server-no", "n_clicks")
+        ],
+        [dash.Input("update-opcua-server-yes", "n_clicks"), dash.Input("update-opcua-server-no", "n_clicks")],
+        [
+            dash.State('opcua_server_datatable', 'data_timestamp'),
+            dash.State("modal-update-opcua-server-centered", "is_open"),
+            dash.State('opcua_server_datatable', 'data_previous'),
+            dash.State('opcua_server_datatable', 'data')
+        ]
+    )
+    def toggle_modal_update_read_only(yes_n, no_n, timestamp, is_open, previous, current):
+        r"""
+        Documentation here
+        """
+        from ...opcua.subscription import SubHandlerServer
+
+        handler = SubHandlerServer()
+        opcua_server_machine = app.automation.get_machine(name=StringType("OPCUAServer"))
+        attrs = create_opcua_server_table(opcua_server_machine=opcua_server_machine)
+
+        if yes_n:
+            
+            if timestamp:
+                        
+                if previous and current: # UPDATE TAG DEFINITION
+                    to_updates = find_differences_between_lists_opcua_server(previous, current)
+                    node_to_update = to_updates[0]
+                    namespace = node_to_update.pop("namespace")
+                    access_type = node_to_update.pop("access_type")
+                    # Code for update read_only attribute
+                    opcua_server_machine = app.automation.get_machine(name=StringType("OPCUAServer"))
+                    opcua_server_attrs = dir(opcua_server_machine)
+                    node = False
+
+                    for i, item in enumerate(opcua_server_attrs):
+                    
+                        if hasattr(opcua_server_machine, item):
+                            node = getattr(opcua_server_machine, item)
+                            if isinstance(node, Node):
+
+                                node_class = node.get_node_class()
+
+                                if node_class == ua.NodeClass.Variable:
+
+                                    if node.nodeid.to_string()==namespace:
+                                        
+                                        break 
+
+                                    else:
+                                        props = node.get_properties()
+                                        flag = False
+                                        for node in props:
+                                            
+                                            if node.nodeid.to_string()==namespace:
+                                                
+                                                flag = True
+                                                break
+
+                                        if flag:
+
+                                            break
+
+                    if node:
+
+                        opcua_server_obj = app.automation.get_opcua_server_record_by_namespace(namespace=namespace)
+                        if opcua_server_obj:
+                            app.automation.update_opcua_server_access_type(namespace=namespace, access_type=access_type)
+                        else:
+                            app.automation.create_opcua_server_record(name=node_to_update["name"], namespace=namespace, access_type=access_type)
+                        access_type = access_type.lower()
+                        # Limpiar todos los bits de acceso primero
+                        node.unset_attr_bit(ua.AttributeIds.AccessLevel, ua.AccessLevel.CurrentRead)
+                        node.unset_attr_bit(ua.AttributeIds.AccessLevel, ua.AccessLevel.CurrentWrite)
+                        node.unset_attr_bit(ua.AttributeIds.UserAccessLevel, ua.AccessLevel.CurrentRead)
+                        node.unset_attr_bit(ua.AttributeIds.UserAccessLevel, ua.AccessLevel.CurrentWrite)
+
+                        subscriptions = handler.subscriptions
+                        # Unsubscribe
+
+                        if namespace in subscriptions:
+
+                            _sub = subscriptions.pop(namespace)
+                            _sub.delete()
+                        
+                        if access_type == "write":
+                            # Solo escritura: deshabilitamos la lectura y habilitamos la escritura
+                            node.set_attr_bit(ua.AttributeIds.AccessLevel, ua.AccessLevel.CurrentWrite)
+                            node.set_attr_bit(ua.AttributeIds.UserAccessLevel, ua.AccessLevel.CurrentWrite)
+                            sub = opcua_server_machine.server.create_subscription(100, handler)
+                            sub.subscribe_data_change(node)
+                            handler.subscriptions[namespace] = sub
+                        elif access_type == "read":
+                            # Solo lectura: habilitamos la lectura y deshabilitamos la escritura
+                            node.set_attr_bit(ua.AttributeIds.AccessLevel, ua.AccessLevel.CurrentRead)
+                            node.set_attr_bit(ua.AttributeIds.UserAccessLevel, ua.AccessLevel.CurrentRead)
+                        elif access_type == "readwrite":
+                            # Lectura y escritura: habilitamos ambos
+                            node.set_attr_bit(ua.AttributeIds.AccessLevel, ua.AccessLevel.CurrentRead)
+                            node.set_attr_bit(ua.AttributeIds.AccessLevel, ua.AccessLevel.CurrentWrite)
+                            node.set_attr_bit(ua.AttributeIds.UserAccessLevel, ua.AccessLevel.CurrentRead)
+                            node.set_attr_bit(ua.AttributeIds.UserAccessLevel, ua.AccessLevel.CurrentWrite)
+                            sub = opcua_server_machine.server.create_subscription(100, handler)
+                            sub.subscribe_data_change(node)
+                            handler.subscriptions[namespace] = sub
+
+                    attrs = create_opcua_server_table(opcua_server_machine=opcua_server_machine)
+
+                return not is_open, attrs, None, 0, 0
+
+        elif no_n:
+            
+            return not is_open, attrs, None, 0, 0
+
+        else:
+
+            return is_open, attrs, None, 0, 0