feat: Trigger and task validate

zhanweizhang7 · zhanweizhang7 · commit 3c51b601393e · 2026-01-15T15:38:12.000+08:00
diff --git a/apps/trigger/api/trigger.py b/apps/trigger/api/trigger.py
@@ -30,6 +30,35 @@ def get_parameters():
     def get_request():
         return TriggerCreateRequest
 
+    @staticmethod
+    def get_response():
+        return TriggerResponse
+
+
+class TriggerOperateAPI(APIMixin):
+    @staticmethod
+    def get_parameters():
+        return [
+            OpenApiParameter(
+                name="workspace_id",
+                description="工作空间id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+            OpenApiParameter(
+                name="trigger_id",
+                description="触发器id",
+                type=OpenApiTypes.STR,
+                location='path',
+                required=True,
+            ),
+        ]
+
+    @staticmethod
+    def get_request():
+        return TriggerCreateRequest
+
     @staticmethod
     def get_response():
         return TriggerResponse
diff --git a/apps/trigger/serializers/trigger.py b/apps/trigger/serializers/trigger.py
@@ -13,8 +13,10 @@
 from django.utils.translation import gettext_lazy as _
 from rest_framework import serializers
 
+from application.models import Application
 from common.db.search import page_search
 from common.exception.app_exception import AppApiException
+from tools.models import Tool
 from trigger.models import TriggerTypeChoices, Trigger, TriggerTaskTypeChoices, TriggerTask
 
 
@@ -33,6 +35,149 @@ class TriggerCreateRequest(serializers.Serializer):
     is_active = serializers.BooleanField(required=False, label=_('Is active'))
     trigger_task = TriggerTaskCreateRequest(many=True)
 
+    def is_valid(self, *, raise_exception=False):
+        super().is_valid(raise_exception=True)
+        trigger_type = self.data.get('trigger_type')
+        trigger_setting = self.data.get('trigger_setting', {})
+
+        if trigger_type == TriggerTypeChoices.SCHEDULED:
+            self._validate_scheduled_setting(trigger_setting)
+
+        elif trigger_type == TriggerTypeChoices.EVENT:
+            self._validate_event_setting(trigger_setting)
+        else:
+            raise AppApiException(500, _('Error trigger type'))
+
+        return True
+
+    @staticmethod
+    def _validate_required_field(setting, field_name, trigger_type):
+        if field_name not in setting:
+            raise serializers.ValidationError({
+                'trigger_setting': f'{trigger_type} type requires {field_name} field'
+            })
+
+    @staticmethod
+    def _validate_non_empty_array(value, field_name):
+        if not isinstance(value, list):
+            raise serializers.ValidationError({
+                'trigger_setting': f'{field_name} must be an array'
+            })
+        if len(value) == 0:
+            raise serializers.ValidationError({
+                'trigger_setting': f'{field_name} must not be empty'
+            })
+
+    @staticmethod
+    def _validate_number_range(values, field_name, min_val, max_val):
+        for val in values:
+            try:
+                num = int(str(val))
+                if num < min_val or num > max_val:
+                    raise ValueError
+            except (ValueError, TypeError):
+                raise serializers.ValidationError({
+                    'trigger_setting': f'{field_name} values must be between "{min_val}" and "{max_val}"'
+                })
+
+    def _validate_time_array(self, time_list):
+        self._validate_non_empty_array(time_list, 'time')
+
+        for time_str in time_list:
+            self._validate_time_format(time_str)
+
+    @staticmethod
+    def _validate_time_format(time_str):
+        import re
+
+        pattern = r'^([01]\d|2[0-3]):([0-5]\d)$'
+        if not re.match(pattern, str(time_str)):
+            raise serializers.ValidationError({
+                'trigger_setting': f'Invalid time format: {time_str}, must be HH:MM (e.g., 09:00)'
+            })
+
+    def _validate_scheduled_setting(self, setting):
+        schedule_type = setting.get('schedule_type')
+
+        valid_types = ['daily', 'weekly', 'monthly', 'interval']
+        if schedule_type not in valid_types:
+            raise serializers.ValidationError({'trigger_setting': f'schedule_type must be one of {valid_types}'})
+        if schedule_type == 'daily':
+            self._validate_daily(setting)
+        elif schedule_type == 'weekly':
+            self._validate_weekly(setting)
+        elif schedule_type == 'monthly':
+            self._validate_monthly(setting)
+        elif schedule_type == 'interval':
+            self._validate_interval(setting)
+
+    def _validate_daily(self, setting):
+        self._validate_required_field(setting, 'time', 'daily')
+        self._validate_time_array(setting['time'])
+
+    def _validate_weekly(self, setting):
+        self._validate_required_field(setting, 'weekdays', 'weekly')
+        self._validate_required_field(setting, 'time', 'weekly')
+        weekdays = setting['weekdays']
+        self._validate_non_empty_array(weekdays, 'weekdays')
+        self._validate_number_range(weekdays, 'weekdays', 1, 7)
+        self._validate_time_array(setting['time'])
+
+    def _validate_monthly(self, setting):
+        self._validate_required_field(setting, 'days', 'monthly')
+        self._validate_required_field(setting, 'time', 'monthly')
+        days = setting['days']
+        self._validate_non_empty_array(days, 'days')
+        self._validate_number_range(days, 'days', 1, 31)
+        self._validate_time_array(setting['time'])
+
+    def _validate_interval(self, setting):
+        self._validate_required_field(setting, 'interval_value', 'interval')
+        self._validate_required_field(setting, 'interval_unit', 'interval')
+        interval_value = setting['interval_value']
+        interval_unit = setting['interval_unit']
+        try:
+            value_int = int(interval_value)
+            if value_int < 1:
+                raise ValueError
+        except (ValueError, TypeError):
+            raise serializers.ValidationError({
+                'trigger_setting': 'interval_value must be an integer greater than or equal to 1'
+            })
+        valid_units = ['minutes', 'hours']
+        if interval_unit not in valid_units:
+            raise serializers.ValidationError({
+                'trigger_setting': f'interval_unit must be one of {valid_units}'
+            })
+
+    @staticmethod
+    def _validate_event_setting(setting):
+        body = setting.get('body')
+        if body is not None and not isinstance(body, list):
+            raise serializers.ValidationError({
+                'trigger_setting': 'body must be an array'
+            })
+
+class TriggerModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Trigger
+        fields = "__all__"
+
+class TriggerTaskModelSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = TriggerTask
+        fields = "__all__"
+
+class ApplicationTriggerTaskSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Application
+        fields = ['id', 'name', 'work_flow', 'icon', 'type']
+
+class ToolTriggerTaskSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Tool
+        fields = ['id', 'name', 'input_field_list', 'icon']
+
 
 class TriggerResponse(serializers.ModelSerializer):
     class Meta:
@@ -75,7 +220,6 @@ def insert(self, instance, with_valid=True):
         else:
             raise AppApiException(500, _('Trigger task can not be empty'))
 
-
         return TriggerResponse(trigger_model).data
 
     @staticmethod
@@ -89,7 +233,6 @@ def to_trigger_task_model(trigger_id: str, source_type: str, source_id: str):
         )
 
 
-
 class TriggerOperateSerializer(serializers.Serializer):
     trigger_id = serializers.UUIDField(required=True, label=_('trigger id'))
     user_id = serializers.UUIDField(required=True, label=_("User ID"))
@@ -104,6 +247,30 @@ def is_valid(self, *, raise_exception=False):
         if not query_set.exists():
             raise AppApiException(500, _('Trigger id does not exist'))
 
+    def edit(self):
+        pass
+
+    def one(self, with_valid=True):
+        if with_valid:
+            self.is_valid()
+        trigger_id = self.data.get('trigger_id')
+        trigger = QuerySet(Trigger).filter(id=trigger_id).first()
+
+        trigger_tasks = QuerySet(TriggerTask).filter(trigger_id=trigger_id)
+        application_ids = [str(task.source_id) for task in trigger_tasks if task.source_type == TriggerTaskTypeChoices.APPLICATION]
+        tool_ids = [str(task.source_id) for task in trigger_tasks if task.source_type == TriggerTaskTypeChoices.TOOL]
+
+
+        application_task_list = [ApplicationTriggerTaskSerializer(application).data for application in
+                            QuerySet(Application).filter(id__in=application_ids)]
+
+        tool_task_list = [ToolTriggerTaskSerializer(tool).data for tool in QuerySet(Tool).filter(id__in=tool_ids)]
+
+        return {
+            **TriggerModelSerializer(trigger).data,
+            'application_task_list':application_task_list,
+            'tool_task_list':tool_task_list,
+        }
 
 class TriggerQuerySerializer(serializers.Serializer):
     name = serializers.CharField(required=False, allow_null=True, allow_blank=True, label=_('Trigger name'))
diff --git a/apps/trigger/urls.py b/apps/trigger/urls.py
@@ -14,6 +14,7 @@
 
 urlpatterns = [
     path('workspace/<str:workspace_id>/trigger', views.TriggerView.as_view(), name='trigger'),
+    path('workspace/<str:workspace_id>/trigger/<str:trigger_id>', views.TriggerView.Operate.as_view(), name='trigger'),
     path('workspace/<str:workspace_id>/trigger/<int:current_page>/<int:page_size>', views.TriggerView.Page.as_view(),
          name='trigger_page'),
     path('workspace/<str:workspace_id>/task', views.TriggerTaskView.as_view(), name='task'),
diff --git a/apps/trigger/views/trigger.py b/apps/trigger/views/trigger.py
@@ -14,12 +14,12 @@
 from application.api.application_api import ApplicationCreateAPI
 from common import result
 from common.auth import TokenAuth
-from trigger.serializers.trigger import TriggerSerializer, TriggerQuerySerializer
+from trigger.serializers.trigger import TriggerSerializer, TriggerQuerySerializer, TriggerOperateSerializer
 from common.auth.authentication import has_permissions, get_is_permissions
 from common.constants.permission_constants import PermissionConstants, RoleConstants, ViewPermission, CompareConstants
 from common.log.log import log
 from tools.api.tool import GetInternalToolAPI
-from trigger.api.trigger import TriggerCreateAPI
+from trigger.api.trigger import TriggerCreateAPI, TriggerOperateAPI
 from trigger.serializers.trigger import TriggerSerializer
 
 
@@ -55,6 +55,24 @@ def get(self, request: Request, workspace_id: str):
                                                            'name': request.query_params.get('name'),
                                                            'type': request.query_params.get('type')}).list())
 
+    class Operate(APIView):
+        authentication_classes = [TokenAuth]
+
+        @extend_schema(
+            methods=['GET'],
+            description=_('Get trigger details'),
+            summary=_('Get trigger details'),
+            operation_id=_('Get trigger details'),  # type: ignore
+            parameters=TriggerOperateAPI.get_parameters(),
+            responses=result.DefaultResultSerializer,
+            tags=[_('Trigger')]  # type: ignore
+        )
+        def get(self, request: Request, workspace_id: str, trigger_id: str):
+            return result.success(TriggerOperateSerializer(
+                data={'trigger_id': trigger_id, 'workspace_id': workspace_id,'user_id': request.user.id}
+            ).one())
+
+
     class Page(APIView):
         authentication_classes = [TokenAuth]
 
