feat: all models

core/form_descriptors.py

@@ -0,0 +1,460 @@
+from typing import Dict, Any
+
+# Дескриптор формы для узла IF
+IF_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "condition_row",
+            "type": "row",
+            "label": "Условие проверки",
+            "link_port": {
+                "id": "then_output",
+                "label": "Then"
+            },
+            "elements": [
+                {
+                    "name": "condition",
+                    "type": "area",
+                    "label": "Условие",
+                    "placeholder": "Введите условие"
+                }
+            ]
+        },
+        {
+            "name": "else_row",
+            "type": "row",
+            "label": "Альтернативный путь",
+            "link_port": {
+                "id": "else_output",
+                "label": "Else"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла Listen
+LISTEN_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "event_row",
+            "type": "row",
+            "label": "Событие",
+            "elements": [
+                {
+                    "name": "event_name",
+                    "type": "line",
+                    "label": "Событие",
+                    "placeholder": "Идентификатор события"
+                }
+            ]
+        },
+        {
+            "name": "condition_row",
+            "type": "row",
+            "label": "Условие",
+            "elements": [
+                {
+                    "name": "condition",
+                    "type": "area",
+                    "label": "Условие",
+                    "placeholder": "Если P([condition(i), [AND, OR]]) == true"
+                }
+            ]
+        },
+        {
+            "name": "then_row",
+            "type": "row",
+            "label": "Then",
+            "link_port": {
+                "id": "then_output",
+                "label": "Then"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла Trigger
+TRIGGER_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "event_row",
+            "type": "row",
+            "label": "Событие",
+            "elements": [
+                {
+                    "name": "event_name",
+                    "type": "line",
+                    "label": "Событие",
+                    "placeholder": "Идентификатор события"
+                }
+            ]
+        },
+        {
+            "name": "context_row",
+            "type": "row",
+            "label": "Контекст",
+            "elements": [
+                {
+                    "name": "context",
+                    "type": "area",
+                    "label": "Данные",
+                    "placeholder": "Подготовка указанных переменных окружения в формат запроса JSON"
+                }
+            ]
+        },
+        {
+            "name": "then_row",
+            "type": "row",
+            "label": "Then",
+            "link_port": {
+                "id": "then_output",
+                "label": "Then"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла Run
+RUN_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "task_row",
+            "type": "row",
+            "label": "Задача",
+            "elements": [
+                {
+                    "name": "task",
+                    "type": "select",
+                    "label": "Задача",
+                    "data": ["send_email", "process_data", "generate_report", "validate_input", "transform_data"],
+                    "default": "send_email"
+                }
+            ]
+        },
+        {
+            "name": "context_row",
+            "type": "row",
+            "label": "Аргументы",
+            "elements": [
+                {
+                    "name": "context",
+                    "type": "area",
+                    "label": "Аргументы",
+                    "placeholder": "Подготовка указанных переменных окружения в формат запроса JSON"
+                }
+            ]
+        },
+        {
+            "name": "then_row",
+            "type": "row",
+            "label": "Then",
+            "link_port": {
+                "id": "then_output",
+                "label": "Then"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла Callback
+CALLBACK_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "uri_row",
+            "type": "row",
+            "label": "URI",
+            "elements": [
+                {
+                    "name": "uri",
+                    "type": "line",
+                    "label": "Событие",
+                    "placeholder": "URI хука"
+                }
+            ]
+        },
+        {
+            "name": "method_row",
+            "type": "row",
+            "label": "Метод",
+            "elements": [
+                {
+                    "name": "method",
+                    "type": "select",
+                    "label": "Метод",
+                    "data": ["POST", "GET", "PUT", "PATCH", "DELETE"],
+                    "default": "POST"
+                }
+            ]
+        },
+        {
+            "name": "headers_row",
+            "type": "row",
+            "label": "Заголовки",
+            "elements": [
+                {
+                    "name": "headers",
+                    "type": "area",
+                    "label": "Заголовки",
+                    "placeholder": "Приведение и валидация заголовков"
+                }
+            ]
+        },
+        {
+            "name": "body_row",
+            "type": "row",
+            "label": "Данные",
+            "elements": [
+                {
+                    "name": "body",
+                    "type": "area",
+                    "label": "Данные",
+                    "placeholder": "Приведение значений и валидация JSON"
+                }
+            ]
+        },
+        {
+            "name": "sync_row",
+            "type": "row",
+            "label": "Ожидать выполнение запроса",
+            "elements": [
+                {
+                    "name": "sync",
+                    "type": "select",
+                    "label": "Ожидать выполнение запроса",
+                    "data": ["Да", "Нет"],
+                    "default": "Да"
+                }
+            ]
+        },
+        {
+            "name": "then_row",
+            "type": "row",
+            "label": "Then",
+            "link_port": {
+                "id": "then_output",
+                "label": "Then"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла Switch
+SWITCH_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "switch_row",
+            "type": "row",
+            "label": "Условие проверки",
+            "link_port": {
+                "id": "case_1_output",
+                "label": "case_1",
+                "is_addable": True
+            },
+
+            "elements": [
+                {
+                    "name": "switch_value",
+                    "type": "area",
+                    "label": "Условие проверки",
+                    "placeholder": "Введите условие"
+                }
+            ]
+        },
+        {
+            "name": "default_row",
+            "type": "row",
+            "label": "По умолчанию",
+            "link_port": {
+                "id": "default_output",
+                "label": "default"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла Set
+SET_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "variable_row",
+            "type": "row",
+            "label": "Имя параметра",
+            "elements": [
+                {
+                    "name": "variable",
+                    "type": "line",
+                    "label": "Имя параметра",
+                    "placeholder": "Введите имя параметра"
+                }
+            ]
+        },
+        {
+            "name": "value_row",
+            "type": "row",
+            "label": "Параметр",
+            "elements": [
+                {
+                    "name": "value",
+                    "type": "area",
+                    "label": "Параметр",
+                    "placeholder": "Введите значение"
+                }
+            ]
+        },
+        {
+            "name": "link_row",
+            "type": "row",
+            "label": "Связь",
+            "link_port": {
+                "id": "then_output",
+                "label": "then"
+            },
+            "elements": []
+        }
+    ]
+}
+
+# Дескриптор формы для узла Wait
+WAIT_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "type_row",
+            "type": "row",
+            "label": "Параметр",
+            "elements": [
+                {
+                    "name": "type",
+                    "type": "select",
+                    "label": "Параметр",
+                    "data": ["seconds", "datetime"],
+                    "placeholder": "Выбранный вариант"
+                }
+            ]
+        },
+        {
+            "name": "wait_for_row",
+            "type": "row",
+            "label": "Время",
+            "elements": [
+                {
+                    "name": "wait_for",
+                    "type": "number",
+                    "label": "Время",
+                    "placeholder": "Вычислить значение ожидания в секундах"
+                }
+            ]
+        },
+        {
+            "name": "wait_datetime_row",
+            "type": "row",
+            "label": "Подождать",
+            "elements": [
+                {
+                    "name": "wait_datetime",
+                    "type": "date",
+                    "label": "Подождать",
+                    "placeholder": "Вычислить значение до определённого времени"
+                }
+            ]
+        },
+        {
+            "name": "then_row",
+            "type": "row",
+            "label": "Переход",
+            "link_port": {
+                "id": "then_output",
+                "label": "then"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла While
+WHILE_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "condition_row",
+            "type": "row",
+            "label": "Параметр",
+            "link_port": {
+                "id": "then_output",
+                "label": "Then"
+            },
+            "elements": [
+                {
+                    "name": "condition",
+                    "type": "area",
+                    "label": "Параметр",
+                    "placeholder": "P(condition) == true"
+                }
+            ]
+        },
+        {
+            "name": "else_row",
+            "type": "row",
+            "label": "Альтернативный путь",
+            "link_port": {
+                "id": "else_output",
+                "label": "Else"
+            }
+        }
+    ]
+}
+
+# Дескриптор формы для узла Each
+EACH_FORM_DESCRIPTOR = {
+    "elements": [
+        {
+            "name": "list_row",
+            "type": "row",
+            "label": "Список",
+            "link_port": {
+                "id": "then_output",
+                "label": "Then"
+            },
+            "elements": [
+                {
+                    "name": "list",
+                    "type": "line",
+                    "label": "Список",
+                    "placeholder": "Валидация списка и получение очередного value из списка"
+                }
+            ]
+        },
+        {
+            "name": "else_row",
+            "type": "row",
+            "label": "Альтернативный путь",
+            "link_port": {
+                "id": "else_output",
+                "label": "Else"
+            }
+        }
+    ]
+}
+
+# Маппинг типов узлов на дескрипторы форм
+FORM_DESCRIPTORS = {
+    "IF": IF_FORM_DESCRIPTOR,
+    "LISTEN": LISTEN_FORM_DESCRIPTOR,
+    "TRIGGER": TRIGGER_FORM_DESCRIPTOR,
+    "RUN": RUN_FORM_DESCRIPTOR,
+    "CALLBACK": CALLBACK_FORM_DESCRIPTOR,
+    "SWITCH": SWITCH_FORM_DESCRIPTOR,
+    "SET": SET_FORM_DESCRIPTOR,
+    "WAIT": WAIT_FORM_DESCRIPTOR,
+    "WHILE": WHILE_FORM_DESCRIPTOR,
+    "EACH": EACH_FORM_DESCRIPTOR,
+}
+
+def get_form_descriptor(node_type: str) -> Dict[str, Any]:
+    """
+    Получить дескриптор формы для указанного типа узла
+
+    Args:
+        node_type: Тип узла (например, "node_if")
+
+    Returns:
+        Dict с дескриптором формы или пустой dict если тип не найден
+    """
+    return FORM_DESCRIPTORS.get(node_type, {})

core/vork_node_link.py

@@ -57,9 +57,10 @@ class VorkNodeLink:
                 # Перевалидируем данные
                 validated_data = self.validate_data()
             else:
-                # Если имя уже указано, оставляем его как есть
+                old_link_name = edge_title_to_number(validated_data.last_link_name)
-                # (не пытаемся преобразовать произвольные имена в номера)
+                new_link_name = self.generate_link_name(old_link_name + 1)
-                pass
+                self.data['last_link_name'] = new_link_name
+                validated_data = self.validate_data()
 
             # Создаем схему с валидированными данными
             return VorkNodeLinkSchema(

core/vork_node_start.py

@@ -1,10 +1,8 @@
-from typing import Dict, Any, Optional
+from typing import Dict, Any
 from .vork_node import VorkNode
 from model_nodes.node_start_models import (
     StartNodeData,
-    StartNodeLinks,
     StartNodeCoreSchema,
-    StartNodeDescriptor,
     StartNodeCoreSchemaData
 )
 

model_nodes/__init__.py

@@ -1,18 +1,41 @@
 # Экспорты для моделей узла listen
-# from .node_listen_models import (
+from .node_listen_models import (
-#     ListenNodeData,
+    ListenNodeData,
-#     ListenNodeLinks,
+    ListenNodeLinks,
-#     ListenNodePSNodeCore,
+    ListenNodeCoreSchema,
-#     ListenNodeSettingsDataCore
+    ListenNodeCoreSchemaData
-# )
+)
+
+# Экспорты для моделей узла trigger
+from .node_trigger_models import (
+    TriggerNodeData,
+    TriggerNodeLinks,
+    TriggerNodeCoreSchema,
+    TriggerNodeCoreSchemaData
+)
+
+# Экспорты для моделей узла run
+from .node_run_models import (
+    RunNodeData,
+    RunNodeLinks,
+    RunNodeCoreSchema,
+    RunNodeCoreSchemaData
+)
+
+# Экспорты для моделей узла callback
+from .node_callback_models import (
+    CallbackNodeData,
+    CallbackNodeLinks,
+    CallbackNodeCoreSchema,
+    CallbackNodeCoreSchemaData
+)
 
 # Экспорты для моделей узла if
 from .node_if_models import (
     IfNodeData,
     IfNodeLinks,
     IfNodeCoreSchema,
-    IfNodeCoreSchemaData,
+    IfNodeCoreSchemaData
-    IfNodeDescriptor
 )
 
 # Экспорты для моделей узла start
@@ -20,8 +43,47 @@ from .node_start_models import (
     StartNodeData,
     StartNodeLinks,
     StartNodeCoreSchema,
-    StartNodeCoreSchemaData,
+    StartNodeCoreSchemaData
-    StartNodeDescriptor
+)
+
+# Экспорты для моделей узла switch
+from .node_switch_models import (
+    SwitchNodeData,
+    SwitchNodeLinks,
+    SwitchNodeCoreSchema,
+    SwitchNodeCoreSchemaData
+)
+
+# Экспорты для моделей узла set
+from .node_set_models import (
+    SetNodeData,
+    SetNodeLinks,
+    SetNodeCoreSchema,
+    SetNodeCoreSchemaData
+)
+
+# Экспорты для моделей узла wait
+from .node_wait_models import (
+    WaitNodeData,
+    WaitNodeLinks,
+    WaitNodeCoreSchema,
+    WaitNodeCoreSchemaData
+)
+
+# Экспорты для моделей узла while
+from .node_while_models import (
+    WhileNodeData,
+    WhileNodeLinks,
+    WhileNodeCoreSchema,
+    WhileNodeCoreSchemaData
+)
+
+# Экспорты для моделей узла each
+from .node_each_models import (
+    EachNodeData,
+    EachNodeLinks,
+    EachNodeCoreSchema,
+    EachNodeCoreSchemaData
 )
 
 # Экспорты для моделей связей между узлами
@@ -32,24 +94,70 @@ from .node_link_models import (
 
 __all__ = [
     # Listen node models
-    # "ListenNodeData",
+    "ListenNodeData",
-    # "ListenNodeLinks",
+    "ListenNodeLinks",
-    # "ListenNodePSNodeCore",
+    "ListenNodeCoreSchema",
-    # "ListenNodeSettingsDataCore",
+    "ListenNodeCoreSchemaData",
+
+    # Trigger node models
+    "TriggerNodeData",
+    "TriggerNodeLinks",
+    "TriggerNodeCoreSchema",
+    "TriggerNodeCoreSchemaData",
+
+    # Run node models
+    "RunNodeData",
+    "RunNodeLinks",
+    "RunNodeCoreSchema",
+    "RunNodeCoreSchemaData",
+
+    # Callback node models
+    "CallbackNodeData",
+    "CallbackNodeLinks",
+    "CallbackNodeCoreSchema",
+    "CallbackNodeCoreSchemaData",
 
     # If node models
     "IfNodeData",
     "IfNodeLinks",
     "IfNodeCoreSchema",
     "IfNodeCoreSchemaData",
-    "IfNodeDescriptor",
 
     # Start node models
     "StartNodeData",
     "StartNodeLinks",
     "StartNodeCoreSchema",
     "StartNodeCoreSchemaData",
-    "StartNodeDescriptor",
+
+    # Switch node models
+    "SwitchNodeData",
+    "SwitchNodeLinks",
+    "SwitchNodeCoreSchema",
+    "SwitchNodeCoreSchemaData",
+
+    # Set node models
+    "SetNodeData",
+    "SetNodeLinks",
+    "SetNodeCoreSchema",
+    "SetNodeCoreSchemaData",
+
+    # Wait node models
+    "WaitNodeData",
+    "WaitNodeLinks",
+    "WaitNodeCoreSchema",
+    "WaitNodeCoreSchemaData",
+
+    # While node models
+    "WhileNodeData",
+    "WhileNodeLinks",
+    "WhileNodeCoreSchema",
+    "WhileNodeCoreSchemaData",
+
+    # Each node models
+    "EachNodeData",
+    "EachNodeLinks",
+    "EachNodeCoreSchema",
+    "EachNodeCoreSchemaData",
 
     # Node link models
     "VorkNodeLinkData",

model_nodes/node_callback_models.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class CallbackNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла callback
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class CallbackNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла callback
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class CallbackNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла callback
+    """
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи Then (LINK)")
+
+
+class CallbackNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла callback
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[CallbackNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_each_models.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class EachNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла each
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class EachNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла each
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class EachNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла each
+    """
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи Then (LINK)")
+    else_port_number: Optional[int] = Field(default=1, description="Номер порта для перехода по Связи Else (LINK)")
+
+
+class EachNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла each
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[EachNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_if_models.py

@@ -1,4 +1,4 @@
-from typing import Optional, Dict, Any
+from typing import Optional
 from pydantic import BaseModel, Field
 
 
@@ -35,10 +35,3 @@ class IfNodeCoreSchema(BaseModel):
     parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
     parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
     data: Optional[IfNodeCoreSchemaData] = Field(default=None, description="Данные узла")
-
-
-class IfNodeDescriptor(BaseModel):
-    """
-    Pydantic модель для дескриптора узла if
-    """
-    condition: Optional[str] = Field(default=None, description="Условие для проверки (PREDICATE)")

model_nodes/node_listen_models.py

@@ -1,33 +1,38 @@
-# from multiprocessing import process
+from typing import Optional
-# from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
-# from pydantic import BaseModel, Field
-# from orm.schemas.base import Base
 
 
-# class ListenNodeData(Base):
+class ListenNodeData(BaseModel):
-#     """
+    """
-#     Поле Data для Core
+    Pydantic модель для валидации данных узла listen
-#     """
+    """
-#     process_schema_id: Optional[int] = Field(default=None, description="ID процесса")
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
-#     node_type: str = Field(description="Тип узла")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    is_start: bool = Field(default=False, description="Является ли узел стартовым")
 
 
-# class ListenNodeLinks(Base):
+class ListenNodeLinks(BaseModel):
-#     """
+    """
-#     Поле Links для Core
+    Pydantic модель для валидации связей узла listen
-#     """
+    """
-#     node_port_number: Optional[int] = Field(default=0, description="Источник данных")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
 
 
-# class ListenNodePSNodeCore(Base):
+class ListenNodeCoreSchemaData(BaseModel):
-#     """
+    """
-#     Данные для PS_Node которые уходят из Core
+    Pydantic модель для данных портов узла listen
-#     """
+    """
-#     process_schema_id: Optional[int] = Field(default=None, description="ID процесса")
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи Then (LINK)")
-#     node_type: str = Field(description="Тип узла")
+    is_start: bool = Field(default=False, description="Является ли узел стартовым")
 
-# class ListenNodeSettingsDataCore(Base):
+
-#     """
+class ListenNodeCoreSchema(BaseModel):
-#     Данные для process_schema Settings которые уходят из Core
+    """
-#     """
+    Pydantic модель для схемы узла listen
-#     node_port_number: Optional[int] = Field(default=0, description="Источник данных")
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[ListenNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_run_models.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class RunNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла run
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class RunNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла run
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class RunNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла run
+    """
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи Then (LINK)")
+
+
+class RunNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла run
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[RunNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_set_models.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class SetNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла set
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class SetNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла set
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class SetNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла set
+    """
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи then (LINK)")
+
+
+class SetNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла set
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[SetNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_start_models.py

@@ -31,10 +31,3 @@ class StartNodeCoreSchema(BaseModel):
     ps_id: Optional[int] = Field(default=None, description="ID процесса")
     node_type: Optional[str] = Field(default=None, description="Тип узла")
     data: Optional[StartNodeCoreSchemaData] = Field(default=None, description="Данные узла")
-
-
-class StartNodeDescriptor(BaseModel):
-    """
-    Pydantic модель для дескриптора узла start
-    """
-    # Start узел не имеет дополнительных параметров, это точка входа в процесс

model_nodes/node_switch_models.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class SwitchNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла switch
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class SwitchNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла switch
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class SwitchNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла switch
+    """
+    default_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи default (LINK)")
+    case_1_port_number: Optional[int] = Field(default=1, description="Номер порта для перехода по Связи case_1 (LINK)")
+
+
+class SwitchNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла switch
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[SwitchNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_trigger_models.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class TriggerNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла trigger
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class TriggerNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла trigger
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class TriggerNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла trigger
+    """
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи Then (LINK)")
+
+
+class TriggerNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла trigger
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[TriggerNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_wait_models.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class WaitNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла wait
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class WaitNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла wait
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class WaitNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла wait
+    """
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи then (LINK)")
+
+
+class WaitNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла wait
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[WaitNodeCoreSchemaData] = Field(default=None, description="Данные узла")

model_nodes/node_while_models.py

@@ -0,0 +1,37 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+
+class WhileNodeData(BaseModel):
+    """
+    Pydantic модель для валидации данных узла while
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+
+
+class WhileNodeLinks(BaseModel):
+    """
+    Pydantic модель для валидации связей узла while
+    """
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+
+
+class WhileNodeCoreSchemaData(BaseModel):
+    """
+    Pydantic модель для данных портов узла while
+    """
+    then_port_number: Optional[int] = Field(default=0, description="Номер порта для перехода по Связи Then (LINK)")
+    else_port_number: Optional[int] = Field(default=1, description="Номер порта для перехода по Связи Else (LINK)")
+
+
+class WhileNodeCoreSchema(BaseModel):
+    """
+    Pydantic модель для схемы узла while
+    """
+    ps_id: Optional[int] = Field(default=None, description="ID процесса")
+    node_type: Optional[str] = Field(default=None, description="Тип узла")
+    parent_id: Optional[int] = Field(default=None, description="ID родительского узла")
+    parent_port_number: Optional[int] = Field(default=None, description="Номер порта родительского узла")
+    data: Optional[WhileNodeCoreSchemaData] = Field(default=None, description="Данные узла")

nodes/vork_node_callback.py

@@ -1,18 +1,73 @@
+from typing import Dict, Any
+import requests
+import json
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_callback_models import (
+    CallbackNodeData,
+    CallbackNodeLinks,
+    CallbackNodeCoreSchema,
+    CallbackNodeCoreSchemaData
+)
 
 
 class VorkNodeCallback(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла callback
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_callback"
+        return "CALLBACK"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла Callback
+        """
+        return get_form_descriptor("CALLBACK")
 
-    def validate(self) -> bool:
+    def validate(self) -> CallbackNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла callback и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            node_data = CallbackNodeCoreSchemaData(
+                then_port_number=0
+            )
+
+            # Создаем схему с валидированными данными
+            return CallbackNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Callback node validation error: {e}")
+            raise
+
+    def validate_data(self) -> CallbackNodeData:
+        """
+        Валидирует данные узла callback
+        """
+        return CallbackNodeData(**self.data)
+
+    def validate_links(self) -> CallbackNodeLinks:
+        """
+        Валидирует связи узла callback
+        """
+        return CallbackNodeLinks(**self.links)
 
     def process(self, context):
         pass

nodes/vork_node_each.py

@@ -1,18 +1,73 @@
+from typing import Dict, Any
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_each_models import (
+    EachNodeData,
+    EachNodeLinks,
+    EachNodeCoreSchema,
+    EachNodeCoreSchemaData
+)
 
 
 class VorkNodeEach(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла each
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_each"
+        return "EACH"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла Each
+        """
+        return get_form_descriptor("EACH")
 
-    def validate(self) -> bool:
+    def validate(self) -> EachNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла each и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            # Создаем данные портов (аналогично if)
+            node_data = EachNodeCoreSchemaData(
+                then_port_number=0,
+                else_port_number=1,
+            )
+
+            # Создаем схему с валидированными данными
+            return EachNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Each node validation error: {e}")
+            raise
+
+    def validate_data(self) -> EachNodeData:
+        """
+        Валидирует данные узла each
+        """
+        return EachNodeData(**self.data)
+
+    def validate_links(self) -> EachNodeLinks:
+        """
+        Валидирует связи узла each
+        """
+        return EachNodeLinks(**self.links)
 
     def process(self, context):
         pass

nodes/vork_node_if.py

@@ -1,11 +1,11 @@
-from typing import Dict, Any
+from typing import Any, Dict
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
 from model_nodes.node_if_models import (
     IfNodeData,
     IfNodeLinks,
     IfNodeCoreSchema,
-    IfNodeCoreSchemaData,
+    IfNodeCoreSchemaData
-    IfNodeDescriptor
 )
 
 
@@ -16,8 +16,11 @@ class VorkNodeIf(VorkNode):
         return "IF"
 
     @classmethod
-    def form(cls) -> IfNodeDescriptor:
+    def form(cls) -> Dict[str, Any]:
-        return IfNodeDescriptor()
+        """
+        Возвращает статический дескриптор формы для узла IF
+        """
+        return get_form_descriptor("IF")
 
     def validate(self) -> IfNodeCoreSchema:
         """
@@ -58,5 +61,5 @@ class VorkNodeIf(VorkNode):
 
         return IfNodeLinks(**self.links)
 
-    def process(self, context: Any) -> bool:
+    def process(self, context):
-        return True
+        pass

nodes/vork_node_listen.py

@@ -1,25 +1,72 @@
 from typing import Dict, Any
 from core import VorkNode
-# from model_nodes.node_listen_models import (
+from core.form_descriptors import get_form_descriptor
-#     ListenNodeData,
+from model_nodes.node_listen_models import (
-#     ListenNodeLinks,
+    ListenNodeData,
-#     ListenNodePSNodeCore,
+    ListenNodeLinks,
-#     ListenNodeSettingsDataCore
+    ListenNodeCoreSchema,
-# )
+    ListenNodeCoreSchemaData
+)
 
 
 class VorkNodeListen(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла listen
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
         return "LISTEN"
 
     @classmethod
     def form(cls) -> Dict[str, Any]:
-        return cls.get_schema()
+        """
+        Возвращает статический дескриптор формы для узла Listen
+        """
+        return get_form_descriptor("LISTEN")
 
-    def validate(self) -> bool:
+    def validate(self) -> ListenNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла listen и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            node_data = ListenNodeCoreSchemaData(
+                then_port_number=0,
+                is_start=validated_data.is_start
+            )
+
+            # Создаем схему с валидированными данными
+            return ListenNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Listen node validation error: {e}")
+            raise
+
+    def validate_data(self) -> ListenNodeData:
+        """
+        Валидирует данные узла listen
+        """
+        return ListenNodeData(**self.data)
+
+    def validate_links(self) -> ListenNodeLinks:
+        """
+        Валидирует связи узла listen
+        """
+        return ListenNodeLinks(**self.links)
 
     def process(self, context):
         pass

nodes/vork_node_run.py

@@ -1,18 +1,75 @@
+from typing import Dict, Any
+import json
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_run_models import (
+    RunNodeData,
+    RunNodeLinks,
+    RunNodeCoreSchema,
+    RunNodeCoreSchemaData
+)
 
 
 class VorkNodeRun(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла run
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_run"
+        return "RUN"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла Run
+        """
+        return get_form_descriptor("RUN")
 
-    def validate(self) -> bool:
+    def validate(self) -> RunNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла run и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            node_data = RunNodeCoreSchemaData(
+                then_port_number=0
+            )
+
+            # Создаем схему с валидированными данными
+            return RunNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Run node validation error: {e}")
+            raise
+
+    def validate_data(self) -> RunNodeData:
+        """
+        Валидирует данные узла run
+        """
+        return RunNodeData(**self.data)
+
+    def validate_links(self) -> RunNodeLinks:
+        """
+        Валидирует связи узла run
+        """
+        return RunNodeLinks(**self.links)
 
     def process(self, context):
+        """
+        Обрабатывает логику узла run - выполнение встроенной задачи
+        """
         pass

nodes/vork_node_set.py

@@ -1,18 +1,72 @@
+from typing import Dict, Any
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_set_models import (
+    SetNodeData,
+    SetNodeLinks,
+    SetNodeCoreSchema,
+    SetNodeCoreSchemaData
+)
 
 
 class VorkNodeSet(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла set
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_set"
+        return "SET"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла Set
+        """
+        return get_form_descriptor("SET")
 
-    def validate(self) -> bool:
+    def validate(self) -> SetNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла set и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            # Создаем данные портов
+            node_data = SetNodeCoreSchemaData(
+                then_port_number=0,
+            )
+
+            # Создаем схему с валидированными данными
+            return SetNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Set node validation error: {e}")
+            raise
+
+    def validate_data(self) -> SetNodeData:
+        """
+        Валидирует данные узла set
+        """
+        return SetNodeData(**self.data)
+
+    def validate_links(self) -> SetNodeLinks:
+        """
+        Валидирует связи узла set
+        """
+        return SetNodeLinks(**self.links)
 
     def process(self, context):
         pass

nodes/vork_node_switch.py

@@ -1,18 +1,73 @@
+from typing import Dict, Any
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_switch_models import (
+    SwitchNodeData,
+    SwitchNodeLinks,
+    SwitchNodeCoreSchema,
+    SwitchNodeCoreSchemaData
+)
 
 
 class VorkNodeSwitch(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла switch
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_switch"
+        return "SWITCH"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла Switch
+        """
+        return get_form_descriptor("SWITCH")
 
-    def validate(self) -> bool:
+    def validate(self) -> SwitchNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла switch и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            # Создаем данные портов (default=0, case_1=1)
+            node_data = SwitchNodeCoreSchemaData(
+                default_port_number=0,
+                case_1_port_number=1,
+            )
+
+            # Создаем схему с валидированными данными
+            return SwitchNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Switch node validation error: {e}")
+            raise
+
+    def validate_data(self) -> SwitchNodeData:
+        """
+        Валидирует данные узла switch
+        """
+        return SwitchNodeData(**self.data)
+
+    def validate_links(self) -> SwitchNodeLinks:
+        """
+        Валидирует связи узла switch
+        """
+        return SwitchNodeLinks(**self.links)
 
     def process(self, context):
         pass

nodes/vork_node_trigger.py

@@ -1,18 +1,71 @@
+from typing import Dict, Any
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_trigger_models import (
+    TriggerNodeData,
+    TriggerNodeLinks,
+    TriggerNodeCoreSchema,
+    TriggerNodeCoreSchemaData
+)
 
 
 class VorkNodeTrigger(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла trigger
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_trigger"
+        return "TRIGGER"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла Trigger
+        """
+        return get_form_descriptor("TRIGGER")
 
-    def validate(self) -> bool:
+    def validate(self) -> TriggerNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла trigger и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            node_data = TriggerNodeCoreSchemaData(
+                then_port_number=0
+            )
+
+            # Создаем схему с валидированными данными
+            return TriggerNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Trigger node validation error: {e}")
+            raise
+
+    def validate_data(self) -> TriggerNodeData:
+        """
+        Валидирует данные узла trigger
+        """
+        return TriggerNodeData(**self.data)
+
+    def validate_links(self) -> TriggerNodeLinks:
+        """
+        Валидирует связи узла trigger
+        """
+        return TriggerNodeLinks(**self.links)
 
     def process(self, context):
         pass

nodes/vork_node_wait.py

@@ -1,18 +1,72 @@
+from typing import Dict, Any
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_wait_models import (
+    WaitNodeData,
+    WaitNodeLinks,
+    WaitNodeCoreSchema,
+    WaitNodeCoreSchemaData
+)
 
 
 class VorkNodeWait(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла wait
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_wait"
+        return "WAIT"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла Wait
+        """
+        return get_form_descriptor("WAIT")
 
-    def validate(self) -> bool:
+    def validate(self) -> WaitNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла wait и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            # Создаем данные портов
+            node_data = WaitNodeCoreSchemaData(
+                then_port_number=0,
+            )
+
+            # Создаем схему с валидированными данными
+            return WaitNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"Wait node validation error: {e}")
+            raise
+
+    def validate_data(self) -> WaitNodeData:
+        """
+        Валидирует данные узла wait
+        """
+        return WaitNodeData(**self.data)
+
+    def validate_links(self) -> WaitNodeLinks:
+        """
+        Валидирует связи узла wait
+        """
+        return WaitNodeLinks(**self.links)
 
     def process(self, context):
         pass

nodes/vork_node_while.py

@@ -1,18 +1,73 @@
+from typing import Dict, Any
 from core import VorkNode
+from core.form_descriptors import get_form_descriptor
+from model_nodes.node_while_models import (
+    WhileNodeData,
+    WhileNodeLinks,
+    WhileNodeCoreSchema,
+    WhileNodeCoreSchemaData
+)
 
 
 class VorkNodeWhile(VorkNode):
 
+    def __init__(self, data: Dict[str, Any], links: Dict[str, Any] = None):
+        """
+        Инициализация узла while
+        """
+        super().__init__(data, links or {})
+
     @property
     def id(self) -> str:
-        return "node_while"
+        return "WHILE"
 
     @classmethod
-    def form(cls):
+    def form(cls) -> Dict[str, Any]:
-        pass
+        """
+        Возвращает статический дескриптор формы для узла While
+        """
+        return get_form_descriptor("WHILE")
 
-    def validate(self) -> bool:
+    def validate(self) -> WhileNodeCoreSchema:
-        return True
+        """
+        Валидирует данные узла while и возвращает схему
+        """
+        try:
+            # Валидируем данные узла
+            validated_data = self.validate_data()
+
+            # Валидируем связи узла
+            validated_links = self.validate_links()
+
+            # Создаем данные портов (аналогично if)
+            node_data = WhileNodeCoreSchemaData(
+                then_port_number=0,
+                else_port_number=1,
+            )
+
+            # Создаем схему с валидированными данными
+            return WhileNodeCoreSchema(
+                ps_id=validated_data.ps_id,
+                node_type=validated_data.node_type,
+                parent_id=validated_links.parent_id,
+                parent_port_number=validated_links.parent_port_number,
+                data=node_data
+            )
+        except Exception as e:
+            print(f"While node validation error: {e}")
+            raise
+
+    def validate_data(self) -> WhileNodeData:
+        """
+        Валидирует данные узла while
+        """
+        return WhileNodeData(**self.data)
+
+    def validate_links(self) -> WhileNodeLinks:
+        """
+        Валидирует связи узла while
+        """
+        return WhileNodeLinks(**self.links)
 
     def process(self, context):
         pass

orm/tables/process.py

@@ -69,6 +69,14 @@ class NodeType(Enum):
     LISTEN = "LISTEN"
     IF = "IF"
     START = "START"
+    CALLBACK = "CALLBACK"
+    EACH = "EACH"
+    RUN = "RUN"
+    SET = "SET"
+    SWITCH = "SWITCH"
+    TRIGGER = "TRIGGER"
+    WAIT = "WAIT"
+    WHILE = "WHILE"
 
 
 ps_node_table = Table(