{templeList.map(item => (
Date: Fri, 21 Nov 2025 10:33:52 +0800
Subject: [PATCH 020/191] feat: support redis 7.0 shared pub and sub (#28333)
---
api/libs/broadcast_channel/redis/__init__.py | 3 +-
.../broadcast_channel/redis/_subscription.py | 205 ++++
api/libs/broadcast_channel/redis/channel.py | 171 +---
.../redis/sharded_channel.py | 65 ++
.../broadcast_channel/redis/test_channel.py | 32 +-
.../redis/test_sharded_channel.py | 317 ++++++
.../redis/test_channel_unit_tests.py | 903 +++++++++++++++++-
7 files changed, 1532 insertions(+), 164 deletions(-)
create mode 100644 api/libs/broadcast_channel/redis/_subscription.py
create mode 100644 api/libs/broadcast_channel/redis/sharded_channel.py
create mode 100644 api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_sharded_channel.py
diff --git a/api/libs/broadcast_channel/redis/__init__.py b/api/libs/broadcast_channel/redis/__init__.py
index 138fef5c5f..f92c94f736 100644
--- a/api/libs/broadcast_channel/redis/__init__.py
+++ b/api/libs/broadcast_channel/redis/__init__.py
@@ -1,3 +1,4 @@
from .channel import BroadcastChannel
+from .sharded_channel import ShardedRedisBroadcastChannel
-__all__ = ["BroadcastChannel"]
+__all__ = ["BroadcastChannel", "ShardedRedisBroadcastChannel"]
diff --git a/api/libs/broadcast_channel/redis/_subscription.py b/api/libs/broadcast_channel/redis/_subscription.py
new file mode 100644
index 0000000000..571ad87468
--- /dev/null
+++ b/api/libs/broadcast_channel/redis/_subscription.py
@@ -0,0 +1,205 @@
+import logging
+import queue
+import threading
+import types
+from collections.abc import Generator, Iterator
+from typing import Self
+
+from libs.broadcast_channel.channel import Subscription
+from libs.broadcast_channel.exc import SubscriptionClosedError
+from redis.client import PubSub
+
+_logger = logging.getLogger(__name__)
+
+
+class RedisSubscriptionBase(Subscription):
+ """Base class for Redis pub/sub subscriptions with common functionality.
+
+ This class provides shared functionality for both regular and sharded
+ Redis pub/sub subscriptions, reducing code duplication and improving
+ maintainability.
+ """
+
+ def __init__(
+ self,
+ pubsub: PubSub,
+ topic: str,
+ ):
+ # The _pubsub is None only if the subscription is closed.
+ self._pubsub: PubSub | None = pubsub
+ self._topic = topic
+ self._closed = threading.Event()
+ self._queue: queue.Queue[bytes] = queue.Queue(maxsize=1024)
+ self._dropped_count = 0
+ self._listener_thread: threading.Thread | None = None
+ self._start_lock = threading.Lock()
+ self._started = False
+
+ def _start_if_needed(self) -> None:
+ """Start the subscription if not already started."""
+ with self._start_lock:
+ if self._started:
+ return
+ if self._closed.is_set():
+ raise SubscriptionClosedError(f"The Redis {self._get_subscription_type()} subscription is closed")
+ if self._pubsub is None:
+ raise SubscriptionClosedError(
+ f"The Redis {self._get_subscription_type()} subscription has been cleaned up"
+ )
+
+ self._subscribe()
+ _logger.debug("Subscribed to %s channel %s", self._get_subscription_type(), self._topic)
+
+ self._listener_thread = threading.Thread(
+ target=self._listen,
+ name=f"redis-{self._get_subscription_type().replace(' ', '-')}-broadcast-{self._topic}",
+ daemon=True,
+ )
+ self._listener_thread.start()
+ self._started = True
+
+ def _listen(self) -> None:
+ """Main listener loop for processing messages."""
+ pubsub = self._pubsub
+ assert pubsub is not None, "PubSub should not be None while starting listening."
+ while not self._closed.is_set():
+ raw_message = self._get_message()
+
+ if raw_message is None:
+ continue
+
+ if raw_message.get("type") != self._get_message_type():
+ continue
+
+ channel_field = raw_message.get("channel")
+ if isinstance(channel_field, bytes):
+ channel_name = channel_field.decode("utf-8")
+ elif isinstance(channel_field, str):
+ channel_name = channel_field
+ else:
+ channel_name = str(channel_field)
+
+ if channel_name != self._topic:
+ _logger.warning(
+ "Ignoring %s message from unexpected channel %s", self._get_subscription_type(), channel_name
+ )
+ continue
+
+ payload_bytes: bytes | None = raw_message.get("data")
+ if not isinstance(payload_bytes, bytes):
+ _logger.error(
+ "Received invalid data from %s channel %s, type=%s",
+ self._get_subscription_type(),
+ self._topic,
+ type(payload_bytes),
+ )
+ continue
+
+ self._enqueue_message(payload_bytes)
+
+ _logger.debug("%s listener thread stopped for channel %s", self._get_subscription_type().title(), self._topic)
+ self._unsubscribe()
+ pubsub.close()
+ _logger.debug("%s PubSub closed for topic %s", self._get_subscription_type().title(), self._topic)
+ self._pubsub = None
+
+ def _enqueue_message(self, payload: bytes) -> None:
+ """Enqueue a message to the internal queue with dropping behavior."""
+ while not self._closed.is_set():
+ try:
+ self._queue.put_nowait(payload)
+ return
+ except queue.Full:
+ try:
+ self._queue.get_nowait()
+ self._dropped_count += 1
+ _logger.debug(
+ "Dropped message from Redis %s subscription, topic=%s, total_dropped=%d",
+ self._get_subscription_type(),
+ self._topic,
+ self._dropped_count,
+ )
+ except queue.Empty:
+ continue
+ return
+
+ def _message_iterator(self) -> Generator[bytes, None, None]:
+ """Iterator for consuming messages from the subscription."""
+ while not self._closed.is_set():
+ try:
+ item = self._queue.get(timeout=0.1)
+ except queue.Empty:
+ continue
+
+ yield item
+
+ def __iter__(self) -> Iterator[bytes]:
+ """Return an iterator over messages from the subscription."""
+ if self._closed.is_set():
+ raise SubscriptionClosedError(f"The Redis {self._get_subscription_type()} subscription is closed")
+ self._start_if_needed()
+ return iter(self._message_iterator())
+
+ def receive(self, timeout: float | None = None) -> bytes | None:
+ """Receive the next message from the subscription."""
+ if self._closed.is_set():
+ raise SubscriptionClosedError(f"The Redis {self._get_subscription_type()} subscription is closed")
+ self._start_if_needed()
+
+ try:
+ item = self._queue.get(timeout=timeout)
+ except queue.Empty:
+ return None
+
+ return item
+
+ def __enter__(self) -> Self:
+ """Context manager entry point."""
+ self._start_if_needed()
+ return self
+
+ def __exit__(
+ self,
+ exc_type: type[BaseException] | None,
+ exc_value: BaseException | None,
+ traceback: types.TracebackType | None,
+ ) -> bool | None:
+ """Context manager exit point."""
+ self.close()
+ return None
+
+ def close(self) -> None:
+ """Close the subscription and clean up resources."""
+ if self._closed.is_set():
+ return
+
+ self._closed.set()
+ # NOTE: PubSub is not thread-safe. More specifically, the `PubSub.close` method and the
+ # message retrieval method should NOT be called concurrently.
+ #
+ # Due to the restriction above, the PubSub cleanup logic happens inside the consumer thread.
+ listener = self._listener_thread
+ if listener is not None:
+ listener.join(timeout=1.0)
+ self._listener_thread = None
+
+ # Abstract methods to be implemented by subclasses
+ def _get_subscription_type(self) -> str:
+ """Return the subscription type (e.g., 'regular' or 'sharded')."""
+ raise NotImplementedError
+
+ def _subscribe(self) -> None:
+ """Subscribe to the Redis topic using the appropriate command."""
+ raise NotImplementedError
+
+ def _unsubscribe(self) -> None:
+ """Unsubscribe from the Redis topic using the appropriate command."""
+ raise NotImplementedError
+
+ def _get_message(self) -> dict | None:
+ """Get a message from Redis using the appropriate method."""
+ raise NotImplementedError
+
+ def _get_message_type(self) -> str:
+ """Return the expected message type (e.g., 'message' or 'smessage')."""
+ raise NotImplementedError
diff --git a/api/libs/broadcast_channel/redis/channel.py b/api/libs/broadcast_channel/redis/channel.py
index e6b32345be..1fc3db8156 100644
--- a/api/libs/broadcast_channel/redis/channel.py
+++ b/api/libs/broadcast_channel/redis/channel.py
@@ -1,24 +1,15 @@
-import logging
-import queue
-import threading
-import types
-from collections.abc import Generator, Iterator
-from typing import Self
-
from libs.broadcast_channel.channel import Producer, Subscriber, Subscription
-from libs.broadcast_channel.exc import SubscriptionClosedError
from redis import Redis
-from redis.client import PubSub
-_logger = logging.getLogger(__name__)
+from ._subscription import RedisSubscriptionBase
class BroadcastChannel:
"""
- Redis Pub/Sub based broadcast channel implementation.
+ Redis Pub/Sub based broadcast channel implementation (regular, non-sharded).
- Provides "at most once" delivery semantics for messages published to channels.
- Uses Redis PUBLISH/SUBSCRIBE commands for real-time message delivery.
+ Provides "at most once" delivery semantics for messages published to channels
+ using Redis PUBLISH/SUBSCRIBE commands for real-time message delivery.
The `redis_client` used to construct BroadcastChannel should have `decode_responses` set to `False`.
"""
@@ -54,147 +45,23 @@ class Topic:
)
-class _RedisSubscription(Subscription):
- def __init__(
- self,
- pubsub: PubSub,
- topic: str,
- ):
- # The _pubsub is None only if the subscription is closed.
- self._pubsub: PubSub | None = pubsub
- self._topic = topic
- self._closed = threading.Event()
- self._queue: queue.Queue[bytes] = queue.Queue(maxsize=1024)
- self._dropped_count = 0
- self._listener_thread: threading.Thread | None = None
- self._start_lock = threading.Lock()
- self._started = False
+class _RedisSubscription(RedisSubscriptionBase):
+ """Regular Redis pub/sub subscription implementation."""
- def _start_if_needed(self) -> None:
- with self._start_lock:
- if self._started:
- return
- if self._closed.is_set():
- raise SubscriptionClosedError("The Redis subscription is closed")
- if self._pubsub is None:
- raise SubscriptionClosedError("The Redis subscription has been cleaned up")
+ def _get_subscription_type(self) -> str:
+ return "regular"
- self._pubsub.subscribe(self._topic)
- _logger.debug("Subscribed to channel %s", self._topic)
+ def _subscribe(self) -> None:
+ assert self._pubsub is not None
+ self._pubsub.subscribe(self._topic)
- self._listener_thread = threading.Thread(
- target=self._listen,
- name=f"redis-broadcast-{self._topic}",
- daemon=True,
- )
- self._listener_thread.start()
- self._started = True
+ def _unsubscribe(self) -> None:
+ assert self._pubsub is not None
+ self._pubsub.unsubscribe(self._topic)
- def _listen(self) -> None:
- pubsub = self._pubsub
- assert pubsub is not None, "PubSub should not be None while starting listening."
- while not self._closed.is_set():
- raw_message = pubsub.get_message(ignore_subscribe_messages=True, timeout=0.1)
+ def _get_message(self) -> dict | None:
+ assert self._pubsub is not None
+ return self._pubsub.get_message(ignore_subscribe_messages=True, timeout=0.1)
- if raw_message is None:
- continue
-
- if raw_message.get("type") != "message":
- continue
-
- channel_field = raw_message.get("channel")
- if isinstance(channel_field, bytes):
- channel_name = channel_field.decode("utf-8")
- elif isinstance(channel_field, str):
- channel_name = channel_field
- else:
- channel_name = str(channel_field)
-
- if channel_name != self._topic:
- _logger.warning("Ignoring message from unexpected channel %s", channel_name)
- continue
-
- payload_bytes: bytes | None = raw_message.get("data")
- if not isinstance(payload_bytes, bytes):
- _logger.error("Received invalid data from channel %s, type=%s", self._topic, type(payload_bytes))
- continue
-
- self._enqueue_message(payload_bytes)
-
- _logger.debug("Listener thread stopped for channel %s", self._topic)
- pubsub.unsubscribe(self._topic)
- pubsub.close()
- _logger.debug("PubSub closed for topic %s", self._topic)
- self._pubsub = None
-
- def _enqueue_message(self, payload: bytes) -> None:
- while not self._closed.is_set():
- try:
- self._queue.put_nowait(payload)
- return
- except queue.Full:
- try:
- self._queue.get_nowait()
- self._dropped_count += 1
- _logger.debug(
- "Dropped message from Redis subscription, topic=%s, total_dropped=%d",
- self._topic,
- self._dropped_count,
- )
- except queue.Empty:
- continue
- return
-
- def _message_iterator(self) -> Generator[bytes, None, None]:
- while not self._closed.is_set():
- try:
- item = self._queue.get(timeout=0.1)
- except queue.Empty:
- continue
-
- yield item
-
- def __iter__(self) -> Iterator[bytes]:
- if self._closed.is_set():
- raise SubscriptionClosedError("The Redis subscription is closed")
- self._start_if_needed()
- return iter(self._message_iterator())
-
- def receive(self, timeout: float | None = None) -> bytes | None:
- if self._closed.is_set():
- raise SubscriptionClosedError("The Redis subscription is closed")
- self._start_if_needed()
-
- try:
- item = self._queue.get(timeout=timeout)
- except queue.Empty:
- return None
-
- return item
-
- def __enter__(self) -> Self:
- self._start_if_needed()
- return self
-
- def __exit__(
- self,
- exc_type: type[BaseException] | None,
- exc_value: BaseException | None,
- traceback: types.TracebackType | None,
- ) -> bool | None:
- self.close()
- return None
-
- def close(self) -> None:
- if self._closed.is_set():
- return
-
- self._closed.set()
- # NOTE: PubSub is not thread-safe. More specifically, the `PubSub.close` method and the `PubSub.get_message`
- # method should NOT be called concurrently.
- #
- # Due to the restriction above, the PubSub cleanup logic happens inside the consumer thread.
- listener = self._listener_thread
- if listener is not None:
- listener.join(timeout=1.0)
- self._listener_thread = None
+ def _get_message_type(self) -> str:
+ return "message"
diff --git a/api/libs/broadcast_channel/redis/sharded_channel.py b/api/libs/broadcast_channel/redis/sharded_channel.py
new file mode 100644
index 0000000000..16e3a80ee1
--- /dev/null
+++ b/api/libs/broadcast_channel/redis/sharded_channel.py
@@ -0,0 +1,65 @@
+from libs.broadcast_channel.channel import Producer, Subscriber, Subscription
+from redis import Redis
+
+from ._subscription import RedisSubscriptionBase
+
+
+class ShardedRedisBroadcastChannel:
+ """
+ Redis 7.0+ Sharded Pub/Sub based broadcast channel implementation.
+
+ Provides "at most once" delivery semantics using SPUBLISH/SSUBSCRIBE commands,
+ distributing channels across Redis cluster nodes for better scalability.
+ """
+
+ def __init__(
+ self,
+ redis_client: Redis,
+ ):
+ self._client = redis_client
+
+ def topic(self, topic: str) -> "ShardedTopic":
+ return ShardedTopic(self._client, topic)
+
+
+class ShardedTopic:
+ def __init__(self, redis_client: Redis, topic: str):
+ self._client = redis_client
+ self._topic = topic
+
+ def as_producer(self) -> Producer:
+ return self
+
+ def publish(self, payload: bytes) -> None:
+ self._client.spublish(self._topic, payload) # type: ignore[attr-defined]
+
+ def as_subscriber(self) -> Subscriber:
+ return self
+
+ def subscribe(self) -> Subscription:
+ return _RedisShardedSubscription(
+ pubsub=self._client.pubsub(),
+ topic=self._topic,
+ )
+
+
+class _RedisShardedSubscription(RedisSubscriptionBase):
+ """Redis 7.0+ sharded pub/sub subscription implementation."""
+
+ def _get_subscription_type(self) -> str:
+ return "sharded"
+
+ def _subscribe(self) -> None:
+ assert self._pubsub is not None
+ self._pubsub.ssubscribe(self._topic) # type: ignore[attr-defined]
+
+ def _unsubscribe(self) -> None:
+ assert self._pubsub is not None
+ self._pubsub.sunsubscribe(self._topic) # type: ignore[attr-defined]
+
+ def _get_message(self) -> dict | None:
+ assert self._pubsub is not None
+ return self._pubsub.get_sharded_message(ignore_subscribe_messages=True, timeout=0.1) # type: ignore[attr-defined]
+
+ def _get_message_type(self) -> str:
+ return "smessage"
diff --git a/api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_channel.py b/api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_channel.py
index c2e17328d6..b7cb472713 100644
--- a/api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_channel.py
+++ b/api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_channel.py
@@ -107,7 +107,11 @@ class TestRedisBroadcastChannelIntegration:
assert received_messages[0] == message
def test_multiple_subscribers_same_topic(self, broadcast_channel: BroadcastChannel):
- """Test message broadcasting to multiple subscribers."""
+ """Test message broadcasting to multiple subscribers.
+
+ This test ensures the publisher only sends after all subscribers have actually started
+ their Redis Pub/Sub subscriptions to avoid race conditions/flakiness.
+ """
topic_name = "broadcast-topic"
message = b"broadcast message"
subscriber_count = 5
@@ -116,16 +120,33 @@ class TestRedisBroadcastChannelIntegration:
topic = broadcast_channel.topic(topic_name)
producer = topic.as_producer()
subscriptions = [topic.subscribe() for _ in range(subscriber_count)]
+ ready_events = [threading.Event() for _ in range(subscriber_count)]
def producer_thread():
- time.sleep(0.2) # Allow all subscribers to connect
+ # Wait for all subscribers to start (with a reasonable timeout)
+ deadline = time.time() + 5.0
+ for ev in ready_events:
+ remaining = deadline - time.time()
+ if remaining <= 0:
+ break
+ ev.wait(timeout=max(0.0, remaining))
+ # Now publish the message
producer.publish(message)
time.sleep(0.2)
for sub in subscriptions:
sub.close()
- def consumer_thread(subscription: Subscription) -> list[bytes]:
+ def consumer_thread(subscription: Subscription, ready_event: threading.Event) -> list[bytes]:
received_msgs = []
+ # Prime the subscription to ensure the underlying Pub/Sub is started
+ try:
+ _ = subscription.receive(0.01)
+ except SubscriptionClosedError:
+ ready_event.set()
+ return received_msgs
+ # Signal readiness after first receive returns (subscription started)
+ ready_event.set()
+
while True:
try:
msg = subscription.receive(0.1)
@@ -141,7 +162,10 @@ class TestRedisBroadcastChannelIntegration:
# Run producer and consumers
with ThreadPoolExecutor(max_workers=subscriber_count + 1) as executor:
producer_future = executor.submit(producer_thread)
- consumer_futures = [executor.submit(consumer_thread, subscription) for subscription in subscriptions]
+ consumer_futures = [
+ executor.submit(consumer_thread, subscription, ready_events[idx])
+ for idx, subscription in enumerate(subscriptions)
+ ]
# Wait for completion
producer_future.result(timeout=10.0)
diff --git a/api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_sharded_channel.py b/api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_sharded_channel.py
new file mode 100644
index 0000000000..ea61747ba2
--- /dev/null
+++ b/api/tests/test_containers_integration_tests/libs/broadcast_channel/redis/test_sharded_channel.py
@@ -0,0 +1,317 @@
+"""
+Integration tests for Redis sharded broadcast channel implementation using TestContainers.
+
+Covers real Redis 7+ sharded pub/sub interactions including:
+- Multiple producer/consumer scenarios
+- Topic isolation
+- Concurrency under load
+- Resource cleanup accounting via PUBSUB SHARDNUMSUB
+"""
+
+import threading
+import time
+import uuid
+from collections.abc import Iterator
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import pytest
+import redis
+from testcontainers.redis import RedisContainer
+
+from libs.broadcast_channel.channel import BroadcastChannel, Subscription, Topic
+from libs.broadcast_channel.exc import SubscriptionClosedError
+from libs.broadcast_channel.redis.sharded_channel import (
+ ShardedRedisBroadcastChannel,
+)
+
+
+class TestShardedRedisBroadcastChannelIntegration:
+ """Integration tests for Redis sharded broadcast channel with real Redis 7 instance."""
+
+ @pytest.fixture(scope="class")
+ def redis_container(self) -> Iterator[RedisContainer]:
+ """Create a Redis 7 container for integration testing (required for sharded pub/sub)."""
+ # Redis 7+ is required for SPUBLISH/SSUBSCRIBE
+ with RedisContainer(image="redis:7-alpine") as container:
+ yield container
+
+ @pytest.fixture(scope="class")
+ def redis_client(self, redis_container: RedisContainer) -> redis.Redis:
+ """Create a Redis client connected to the test container."""
+ host = redis_container.get_container_host_ip()
+ port = redis_container.get_exposed_port(6379)
+ return redis.Redis(host=host, port=port, decode_responses=False)
+
+ @pytest.fixture
+ def broadcast_channel(self, redis_client: redis.Redis) -> BroadcastChannel:
+ """Create a ShardedRedisBroadcastChannel instance with real Redis client."""
+ return ShardedRedisBroadcastChannel(redis_client)
+
+ @classmethod
+ def _get_test_topic_name(cls) -> str:
+ return f"test_sharded_topic_{uuid.uuid4()}"
+
+ # ==================== Basic Functionality Tests ====================
+
+ def test_close_an_active_subscription_should_stop_iteration(self, broadcast_channel: BroadcastChannel):
+ topic_name = self._get_test_topic_name()
+ topic = broadcast_channel.topic(topic_name)
+ subscription = topic.subscribe()
+ consuming_event = threading.Event()
+
+ def consume():
+ msgs = []
+ consuming_event.set()
+ for msg in subscription:
+ msgs.append(msg)
+ return msgs
+
+ with ThreadPoolExecutor(max_workers=1) as executor:
+ consumer_future = executor.submit(consume)
+ consuming_event.wait()
+ subscription.close()
+ msgs = consumer_future.result(timeout=2)
+ assert msgs == []
+
+ def test_end_to_end_messaging(self, broadcast_channel: BroadcastChannel):
+ """Test complete end-to-end messaging flow (sharded)."""
+ topic_name = self._get_test_topic_name()
+ message = b"hello sharded world"
+
+ topic = broadcast_channel.topic(topic_name)
+ producer = topic.as_producer()
+ subscription = topic.subscribe()
+
+ def producer_thread():
+ time.sleep(0.1) # Small delay to ensure subscriber is ready
+ producer.publish(message)
+ time.sleep(0.1)
+ subscription.close()
+
+ def consumer_thread() -> list[bytes]:
+ received_messages = []
+ for msg in subscription:
+ received_messages.append(msg)
+ return received_messages
+
+ with ThreadPoolExecutor(max_workers=2) as executor:
+ producer_future = executor.submit(producer_thread)
+ consumer_future = executor.submit(consumer_thread)
+
+ producer_future.result(timeout=5.0)
+ received_messages = consumer_future.result(timeout=5.0)
+
+ assert len(received_messages) == 1
+ assert received_messages[0] == message
+
+ def test_multiple_subscribers_same_topic(self, broadcast_channel: BroadcastChannel):
+ """Test message broadcasting to multiple sharded subscribers."""
+ topic_name = self._get_test_topic_name()
+ message = b"broadcast sharded message"
+ subscriber_count = 5
+
+ topic = broadcast_channel.topic(topic_name)
+ producer = topic.as_producer()
+ subscriptions = [topic.subscribe() for _ in range(subscriber_count)]
+
+ def producer_thread():
+ time.sleep(0.2) # Allow all subscribers to connect
+ producer.publish(message)
+ time.sleep(0.2)
+ for sub in subscriptions:
+ sub.close()
+
+ def consumer_thread(subscription: Subscription) -> list[bytes]:
+ received_msgs = []
+ while True:
+ try:
+ msg = subscription.receive(0.1)
+ except SubscriptionClosedError:
+ break
+ if msg is None:
+ continue
+ received_msgs.append(msg)
+ if len(received_msgs) >= 1:
+ break
+ return received_msgs
+
+ with ThreadPoolExecutor(max_workers=subscriber_count + 1) as executor:
+ producer_future = executor.submit(producer_thread)
+ consumer_futures = [executor.submit(consumer_thread, subscription) for subscription in subscriptions]
+
+ producer_future.result(timeout=10.0)
+ msgs_by_consumers = []
+ for future in as_completed(consumer_futures, timeout=10.0):
+ msgs_by_consumers.append(future.result())
+
+ for subscription in subscriptions:
+ subscription.close()
+
+ for msgs in msgs_by_consumers:
+ assert len(msgs) == 1
+ assert msgs[0] == message
+
+ def test_topic_isolation(self, broadcast_channel: BroadcastChannel):
+ """Test that different sharded topics are isolated from each other."""
+ topic1_name = self._get_test_topic_name()
+ topic2_name = self._get_test_topic_name()
+ message1 = b"message for sharded topic1"
+ message2 = b"message for sharded topic2"
+
+ topic1 = broadcast_channel.topic(topic1_name)
+ topic2 = broadcast_channel.topic(topic2_name)
+
+ def producer_thread():
+ time.sleep(0.1)
+ topic1.publish(message1)
+ topic2.publish(message2)
+
+ def consumer_by_thread(topic: Topic) -> list[bytes]:
+ subscription = topic.subscribe()
+ received = []
+ with subscription:
+ for msg in subscription:
+ received.append(msg)
+ if len(received) >= 1:
+ break
+ return received
+
+ with ThreadPoolExecutor(max_workers=3) as executor:
+ producer_future = executor.submit(producer_thread)
+ consumer1_future = executor.submit(consumer_by_thread, topic1)
+ consumer2_future = executor.submit(consumer_by_thread, topic2)
+
+ producer_future.result(timeout=5.0)
+ received_by_topic1 = consumer1_future.result(timeout=5.0)
+ received_by_topic2 = consumer2_future.result(timeout=5.0)
+
+ assert len(received_by_topic1) == 1
+ assert len(received_by_topic2) == 1
+ assert received_by_topic1[0] == message1
+ assert received_by_topic2[0] == message2
+
+ # ==================== Performance / Concurrency ====================
+
+ def test_concurrent_producers(self, broadcast_channel: BroadcastChannel):
+ """Test multiple producers publishing to the same sharded topic."""
+ topic_name = self._get_test_topic_name()
+ producer_count = 5
+ messages_per_producer = 5
+
+ topic = broadcast_channel.topic(topic_name)
+ subscription = topic.subscribe()
+
+ expected_total = producer_count * messages_per_producer
+ consumer_ready = threading.Event()
+
+ def producer_thread(producer_idx: int) -> set[bytes]:
+ producer = topic.as_producer()
+ produced = set()
+ for i in range(messages_per_producer):
+ message = f"producer_{producer_idx}_msg_{i}".encode()
+ produced.add(message)
+ producer.publish(message)
+ time.sleep(0.001)
+ return produced
+
+ def consumer_thread() -> set[bytes]:
+ received_msgs: set[bytes] = set()
+ with subscription:
+ consumer_ready.set()
+ while True:
+ try:
+ msg = subscription.receive(timeout=0.1)
+ except SubscriptionClosedError:
+ break
+ if msg is None:
+ if len(received_msgs) >= expected_total:
+ break
+ else:
+ continue
+ received_msgs.add(msg)
+ return received_msgs
+
+ with ThreadPoolExecutor(max_workers=producer_count + 1) as executor:
+ consumer_future = executor.submit(consumer_thread)
+ consumer_ready.wait()
+ producer_futures = [executor.submit(producer_thread, i) for i in range(producer_count)]
+
+ sent_msgs: set[bytes] = set()
+ for future in as_completed(producer_futures, timeout=30.0):
+ sent_msgs.update(future.result())
+
+ subscription.close()
+ consumer_received_msgs = consumer_future.result(timeout=30.0)
+
+ assert sent_msgs == consumer_received_msgs
+
+ # ==================== Resource Management ====================
+
+ def _get_sharded_numsub(self, redis_client: redis.Redis, topic_name: str) -> int:
+ """Return number of sharded subscribers for a given topic using PUBSUB SHARDNUMSUB.
+
+ Redis returns a flat list like [channel1, count1, channel2, count2, ...].
+ We request a single channel, so parse accordingly.
+ """
+ try:
+ res = redis_client.execute_command("PUBSUB", "SHARDNUMSUB", topic_name)
+ except Exception:
+ return 0
+ # Normalize different possible return shapes from drivers
+ if isinstance(res, (list, tuple)):
+ # Expect [channel, count] (bytes/str, int)
+ if len(res) >= 2:
+ key = res[0]
+ cnt = res[1]
+ if key == topic_name or (isinstance(key, (bytes, bytearray)) and key == topic_name.encode()):
+ try:
+ return int(cnt)
+ except Exception:
+ return 0
+ # Fallback parse pairs
+ count = 0
+ for i in range(0, len(res) - 1, 2):
+ key = res[i]
+ cnt = res[i + 1]
+ if key == topic_name or (isinstance(key, (bytes, bytearray)) and key == topic_name.encode()):
+ try:
+ count = int(cnt)
+ except Exception:
+ count = 0
+ break
+ return count
+ return 0
+
+ def test_subscription_cleanup(self, broadcast_channel: BroadcastChannel, redis_client: redis.Redis):
+ """Test proper cleanup of sharded subscription resources via SHARDNUMSUB."""
+ topic_name = self._get_test_topic_name()
+
+ topic = broadcast_channel.topic(topic_name)
+
+ def _consume(sub: Subscription):
+ for _ in sub:
+ pass
+
+ subscriptions = []
+ for _ in range(5):
+ subscription = topic.subscribe()
+ subscriptions.append(subscription)
+
+ thread = threading.Thread(target=_consume, args=(subscription,))
+ thread.start()
+ time.sleep(0.01)
+
+ # Verify subscriptions are active using SHARDNUMSUB
+ topic_subscribers = self._get_sharded_numsub(redis_client, topic_name)
+ assert topic_subscribers >= 5
+
+ # Close all subscriptions
+ for subscription in subscriptions:
+ subscription.close()
+
+ # Wait a bit for cleanup
+ time.sleep(1)
+
+ # Verify subscriptions are cleaned up
+ topic_subscribers_after = self._get_sharded_numsub(redis_client, topic_name)
+ assert topic_subscribers_after == 0
diff --git a/api/tests/unit_tests/libs/broadcast_channel/redis/test_channel_unit_tests.py b/api/tests/unit_tests/libs/broadcast_channel/redis/test_channel_unit_tests.py
index dffad4142c..ccba075fdf 100644
--- a/api/tests/unit_tests/libs/broadcast_channel/redis/test_channel_unit_tests.py
+++ b/api/tests/unit_tests/libs/broadcast_channel/redis/test_channel_unit_tests.py
@@ -25,6 +25,11 @@ from libs.broadcast_channel.redis.channel import (
Topic,
_RedisSubscription,
)
+from libs.broadcast_channel.redis.sharded_channel import (
+ ShardedRedisBroadcastChannel,
+ ShardedTopic,
+ _RedisShardedSubscription,
+)
class TestBroadcastChannel:
@@ -39,9 +44,14 @@ class TestBroadcastChannel:
@pytest.fixture
def broadcast_channel(self, mock_redis_client: MagicMock) -> RedisBroadcastChannel:
- """Create a BroadcastChannel instance with mock Redis client."""
+ """Create a BroadcastChannel instance with mock Redis client (regular)."""
return RedisBroadcastChannel(mock_redis_client)
+ @pytest.fixture
+ def sharded_broadcast_channel(self, mock_redis_client: MagicMock) -> ShardedRedisBroadcastChannel:
+ """Create a ShardedRedisBroadcastChannel instance with mock Redis client."""
+ return ShardedRedisBroadcastChannel(mock_redis_client)
+
def test_topic_creation(self, broadcast_channel: RedisBroadcastChannel, mock_redis_client: MagicMock):
"""Test that topic() method returns a Topic instance with correct parameters."""
topic_name = "test-topic"
@@ -60,6 +70,38 @@ class TestBroadcastChannel:
assert topic1._topic == "topic1"
assert topic2._topic == "topic2"
+ def test_sharded_topic_creation(
+ self, sharded_broadcast_channel: ShardedRedisBroadcastChannel, mock_redis_client: MagicMock
+ ):
+ """Test that topic() on ShardedRedisBroadcastChannel returns a ShardedTopic instance with correct parameters."""
+ topic_name = "test-sharded-topic"
+ sharded_topic = sharded_broadcast_channel.topic(topic_name)
+
+ assert isinstance(sharded_topic, ShardedTopic)
+ assert sharded_topic._client == mock_redis_client
+ assert sharded_topic._topic == topic_name
+
+ def test_sharded_topic_isolation(self, sharded_broadcast_channel: ShardedRedisBroadcastChannel):
+ """Test that different sharded topic names create isolated ShardedTopic instances."""
+ topic1 = sharded_broadcast_channel.topic("sharded-topic1")
+ topic2 = sharded_broadcast_channel.topic("sharded-topic2")
+
+ assert topic1 is not topic2
+ assert topic1._topic == "sharded-topic1"
+ assert topic2._topic == "sharded-topic2"
+
+ def test_regular_and_sharded_topic_isolation(
+ self, broadcast_channel: RedisBroadcastChannel, sharded_broadcast_channel: ShardedRedisBroadcastChannel
+ ):
+ """Test that regular topics and sharded topics from different channels are separate instances."""
+ regular_topic = broadcast_channel.topic("test-topic")
+ sharded_topic = sharded_broadcast_channel.topic("test-topic")
+
+ assert isinstance(regular_topic, Topic)
+ assert isinstance(sharded_topic, ShardedTopic)
+ assert regular_topic is not sharded_topic
+ assert regular_topic._topic == sharded_topic._topic
+
class TestTopic:
"""Test cases for the Topic class."""
@@ -98,6 +140,51 @@ class TestTopic:
mock_redis_client.publish.assert_called_once_with("test-topic", payload)
+class TestShardedTopic:
+ """Test cases for the ShardedTopic class."""
+
+ @pytest.fixture
+ def mock_redis_client(self) -> MagicMock:
+ """Create a mock Redis client for testing."""
+ client = MagicMock()
+ client.pubsub.return_value = MagicMock()
+ return client
+
+ @pytest.fixture
+ def sharded_topic(self, mock_redis_client: MagicMock) -> ShardedTopic:
+ """Create a ShardedTopic instance for testing."""
+ return ShardedTopic(mock_redis_client, "test-sharded-topic")
+
+ def test_as_producer_returns_self(self, sharded_topic: ShardedTopic):
+ """Test that as_producer() returns self as Producer interface."""
+ producer = sharded_topic.as_producer()
+ assert producer is sharded_topic
+ # Producer is a Protocol, check duck typing instead
+ assert hasattr(producer, "publish")
+
+ def test_as_subscriber_returns_self(self, sharded_topic: ShardedTopic):
+ """Test that as_subscriber() returns self as Subscriber interface."""
+ subscriber = sharded_topic.as_subscriber()
+ assert subscriber is sharded_topic
+ # Subscriber is a Protocol, check duck typing instead
+ assert hasattr(subscriber, "subscribe")
+
+ def test_publish_calls_redis_spublish(self, sharded_topic: ShardedTopic, mock_redis_client: MagicMock):
+ """Test that publish() calls Redis SPUBLISH with correct parameters."""
+ payload = b"test sharded message"
+ sharded_topic.publish(payload)
+
+ mock_redis_client.spublish.assert_called_once_with("test-sharded-topic", payload)
+
+ def test_subscribe_returns_sharded_subscription(self, sharded_topic: ShardedTopic, mock_redis_client: MagicMock):
+ """Test that subscribe() returns a _RedisShardedSubscription instance."""
+ subscription = sharded_topic.subscribe()
+
+ assert isinstance(subscription, _RedisShardedSubscription)
+ assert subscription._pubsub is mock_redis_client.pubsub.return_value
+ assert subscription._topic == "test-sharded-topic"
+
+
@dataclasses.dataclass(frozen=True)
class SubscriptionTestCase:
"""Test case data for subscription tests."""
@@ -175,14 +262,14 @@ class TestRedisSubscription:
"""Test that _start_if_needed() raises error when subscription is closed."""
subscription.close()
- with pytest.raises(SubscriptionClosedError, match="The Redis subscription is closed"):
+ with pytest.raises(SubscriptionClosedError, match="The Redis regular subscription is closed"):
subscription._start_if_needed()
def test_start_if_needed_when_cleaned_up(self, subscription: _RedisSubscription):
"""Test that _start_if_needed() raises error when pubsub is None."""
subscription._pubsub = None
- with pytest.raises(SubscriptionClosedError, match="The Redis subscription has been cleaned up"):
+ with pytest.raises(SubscriptionClosedError, match="The Redis regular subscription has been cleaned up"):
subscription._start_if_needed()
def test_context_manager_usage(self, subscription: _RedisSubscription, mock_pubsub: MagicMock):
@@ -250,7 +337,7 @@ class TestRedisSubscription:
"""Test that iterator raises error when subscription is closed."""
subscription.close()
- with pytest.raises(BroadcastChannelError, match="The Redis subscription is closed"):
+ with pytest.raises(BroadcastChannelError, match="The Redis regular subscription is closed"):
iter(subscription)
# ==================== Message Enqueue Tests ====================
@@ -465,21 +552,21 @@ class TestRedisSubscription:
"""Test iterator behavior after close."""
subscription.close()
- with pytest.raises(SubscriptionClosedError, match="The Redis subscription is closed"):
+ with pytest.raises(SubscriptionClosedError, match="The Redis regular subscription is closed"):
iter(subscription)
def test_start_after_close(self, subscription: _RedisSubscription):
"""Test start attempts after close."""
subscription.close()
- with pytest.raises(SubscriptionClosedError, match="The Redis subscription is closed"):
+ with pytest.raises(SubscriptionClosedError, match="The Redis regular subscription is closed"):
subscription._start_if_needed()
def test_pubsub_none_operations(self, subscription: _RedisSubscription):
"""Test operations when pubsub is None."""
subscription._pubsub = None
- with pytest.raises(SubscriptionClosedError, match="The Redis subscription has been cleaned up"):
+ with pytest.raises(SubscriptionClosedError, match="The Redis regular subscription has been cleaned up"):
subscription._start_if_needed()
# Close should still work
@@ -512,3 +599,805 @@ class TestRedisSubscription:
with pytest.raises(SubscriptionClosedError):
subscription.receive()
+
+
+class TestRedisShardedSubscription:
+ """Test cases for the _RedisShardedSubscription class."""
+
+ @pytest.fixture
+ def mock_pubsub(self) -> MagicMock:
+ """Create a mock PubSub instance for testing."""
+ pubsub = MagicMock()
+ pubsub.ssubscribe = MagicMock()
+ pubsub.sunsubscribe = MagicMock()
+ pubsub.close = MagicMock()
+ pubsub.get_sharded_message = MagicMock()
+ return pubsub
+
+ @pytest.fixture
+ def sharded_subscription(self, mock_pubsub: MagicMock) -> Generator[_RedisShardedSubscription, None, None]:
+ """Create a _RedisShardedSubscription instance for testing."""
+ subscription = _RedisShardedSubscription(
+ pubsub=mock_pubsub,
+ topic="test-sharded-topic",
+ )
+ yield subscription
+ subscription.close()
+
+ @pytest.fixture
+ def started_sharded_subscription(
+ self, sharded_subscription: _RedisShardedSubscription
+ ) -> _RedisShardedSubscription:
+ """Create a sharded subscription that has been started."""
+ sharded_subscription._start_if_needed()
+ return sharded_subscription
+
+ # ==================== Lifecycle Tests ====================
+
+ def test_sharded_subscription_initialization(self, mock_pubsub: MagicMock):
+ """Test that sharded subscription is properly initialized."""
+ subscription = _RedisShardedSubscription(
+ pubsub=mock_pubsub,
+ topic="test-sharded-topic",
+ )
+
+ assert subscription._pubsub is mock_pubsub
+ assert subscription._topic == "test-sharded-topic"
+ assert not subscription._closed.is_set()
+ assert subscription._dropped_count == 0
+ assert subscription._listener_thread is None
+ assert not subscription._started
+
+ def test_start_if_needed_first_call(self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock):
+ """Test that _start_if_needed() properly starts sharded subscription on first call."""
+ sharded_subscription._start_if_needed()
+
+ mock_pubsub.ssubscribe.assert_called_once_with("test-sharded-topic")
+ assert sharded_subscription._started is True
+ assert sharded_subscription._listener_thread is not None
+
+ def test_start_if_needed_subsequent_calls(self, started_sharded_subscription: _RedisShardedSubscription):
+ """Test that _start_if_needed() doesn't start sharded subscription on subsequent calls."""
+ original_thread = started_sharded_subscription._listener_thread
+ started_sharded_subscription._start_if_needed()
+
+ # Should not create new thread or generator
+ assert started_sharded_subscription._listener_thread is original_thread
+
+ def test_start_if_needed_when_closed(self, sharded_subscription: _RedisShardedSubscription):
+ """Test that _start_if_needed() raises error when sharded subscription is closed."""
+ sharded_subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match="The Redis sharded subscription is closed"):
+ sharded_subscription._start_if_needed()
+
+ def test_start_if_needed_when_cleaned_up(self, sharded_subscription: _RedisShardedSubscription):
+ """Test that _start_if_needed() raises error when pubsub is None."""
+ sharded_subscription._pubsub = None
+
+ with pytest.raises(SubscriptionClosedError, match="The Redis sharded subscription has been cleaned up"):
+ sharded_subscription._start_if_needed()
+
+ def test_context_manager_usage(self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock):
+ """Test that sharded subscription works as context manager."""
+ with sharded_subscription as sub:
+ assert sub is sharded_subscription
+ assert sharded_subscription._started is True
+ mock_pubsub.ssubscribe.assert_called_once_with("test-sharded-topic")
+
+ def test_close_idempotent(self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock):
+ """Test that close() is idempotent and can be called multiple times."""
+ sharded_subscription._start_if_needed()
+
+ # Close multiple times
+ sharded_subscription.close()
+ sharded_subscription.close()
+ sharded_subscription.close()
+
+ # Should only cleanup once
+ mock_pubsub.sunsubscribe.assert_called_once_with("test-sharded-topic")
+ mock_pubsub.close.assert_called_once()
+ assert sharded_subscription._pubsub is None
+ assert sharded_subscription._closed.is_set()
+
+ def test_close_cleanup(self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock):
+ """Test that close() properly cleans up all resources."""
+ sharded_subscription._start_if_needed()
+ thread = sharded_subscription._listener_thread
+
+ sharded_subscription.close()
+
+ # Verify cleanup
+ mock_pubsub.sunsubscribe.assert_called_once_with("test-sharded-topic")
+ mock_pubsub.close.assert_called_once()
+ assert sharded_subscription._pubsub is None
+ assert sharded_subscription._listener_thread is None
+
+ # Wait for thread to finish (with timeout)
+ if thread and thread.is_alive():
+ thread.join(timeout=1.0)
+ assert not thread.is_alive()
+
+ # ==================== Message Processing Tests ====================
+
+ def test_message_iterator_with_messages(self, started_sharded_subscription: _RedisShardedSubscription):
+ """Test message iterator behavior with messages in queue."""
+ test_messages = [b"sharded_msg1", b"sharded_msg2", b"sharded_msg3"]
+
+ # Add messages to queue
+ for msg in test_messages:
+ started_sharded_subscription._queue.put_nowait(msg)
+
+ # Iterate through messages
+ iterator = iter(started_sharded_subscription)
+ received_messages = []
+
+ for msg in iterator:
+ received_messages.append(msg)
+ if len(received_messages) >= len(test_messages):
+ break
+
+ assert received_messages == test_messages
+
+ def test_message_iterator_when_closed(self, sharded_subscription: _RedisShardedSubscription):
+ """Test that iterator raises error when sharded subscription is closed."""
+ sharded_subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match="The Redis sharded subscription is closed"):
+ iter(sharded_subscription)
+
+ # ==================== Message Enqueue Tests ====================
+
+ def test_enqueue_message_success(self, started_sharded_subscription: _RedisShardedSubscription):
+ """Test successful message enqueue."""
+ payload = b"test sharded message"
+
+ started_sharded_subscription._enqueue_message(payload)
+
+ assert started_sharded_subscription._queue.qsize() == 1
+ assert started_sharded_subscription._queue.get_nowait() == payload
+
+ def test_enqueue_message_when_closed(self, sharded_subscription: _RedisShardedSubscription):
+ """Test message enqueue when sharded subscription is closed."""
+ sharded_subscription.close()
+ payload = b"test sharded message"
+
+ # Should not raise exception, but should not enqueue
+ sharded_subscription._enqueue_message(payload)
+
+ assert sharded_subscription._queue.empty()
+
+ def test_enqueue_message_with_full_queue(self, started_sharded_subscription: _RedisShardedSubscription):
+ """Test message enqueue with full queue (dropping behavior)."""
+ # Fill the queue
+ for i in range(started_sharded_subscription._queue.maxsize):
+ started_sharded_subscription._queue.put_nowait(f"old_msg_{i}".encode())
+
+ # Try to enqueue new message (should drop oldest)
+ new_message = b"new_sharded_message"
+ started_sharded_subscription._enqueue_message(new_message)
+
+ # Should have dropped one message and added new one
+ assert started_sharded_subscription._dropped_count == 1
+
+ # New message should be in queue
+ messages = []
+ while not started_sharded_subscription._queue.empty():
+ messages.append(started_sharded_subscription._queue.get_nowait())
+
+ assert new_message in messages
+
+ # ==================== Listener Thread Tests ====================
+
+ @patch("time.sleep", side_effect=lambda x: None) # Speed up test
+ def test_listener_thread_normal_operation(
+ self, mock_sleep, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock
+ ):
+ """Test sharded listener thread normal operation."""
+ # Mock sharded message from Redis
+ mock_message = {"type": "smessage", "channel": "test-sharded-topic", "data": b"test sharded payload"}
+ mock_pubsub.get_sharded_message.return_value = mock_message
+
+ # Start listener
+ sharded_subscription._start_if_needed()
+
+ # Wait a bit for processing
+ time.sleep(0.1)
+
+ # Verify message was processed
+ assert not sharded_subscription._queue.empty()
+ assert sharded_subscription._queue.get_nowait() == b"test sharded payload"
+
+ def test_listener_thread_ignores_subscribe_messages(
+ self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock
+ ):
+ """Test that listener thread ignores ssubscribe/sunsubscribe messages."""
+ mock_message = {"type": "ssubscribe", "channel": "test-sharded-topic", "data": 1}
+ mock_pubsub.get_sharded_message.return_value = mock_message
+
+ sharded_subscription._start_if_needed()
+ time.sleep(0.1)
+
+ # Should not enqueue ssubscribe messages
+ assert sharded_subscription._queue.empty()
+
+ def test_listener_thread_ignores_wrong_channel(
+ self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock
+ ):
+ """Test that listener thread ignores messages from wrong channels."""
+ mock_message = {"type": "smessage", "channel": "wrong-sharded-topic", "data": b"test payload"}
+ mock_pubsub.get_sharded_message.return_value = mock_message
+
+ sharded_subscription._start_if_needed()
+ time.sleep(0.1)
+
+ # Should not enqueue messages from wrong channels
+ assert sharded_subscription._queue.empty()
+
+ def test_listener_thread_ignores_regular_messages(
+ self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock
+ ):
+ """Test that listener thread ignores regular (non-sharded) messages."""
+ mock_message = {"type": "message", "channel": "test-sharded-topic", "data": b"test payload"}
+ mock_pubsub.get_sharded_message.return_value = mock_message
+
+ sharded_subscription._start_if_needed()
+ time.sleep(0.1)
+
+ # Should not enqueue regular messages in sharded subscription
+ assert sharded_subscription._queue.empty()
+
+ def test_listener_thread_handles_redis_exceptions(
+ self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock
+ ):
+ """Test that listener thread handles Redis exceptions gracefully."""
+ mock_pubsub.get_sharded_message.side_effect = Exception("Redis error")
+
+ sharded_subscription._start_if_needed()
+
+ # Wait for thread to handle exception
+ time.sleep(0.2)
+
+ # Thread should still be alive but not processing
+ assert sharded_subscription._listener_thread is not None
+ assert not sharded_subscription._listener_thread.is_alive()
+
+ def test_listener_thread_stops_when_closed(
+ self, sharded_subscription: _RedisShardedSubscription, mock_pubsub: MagicMock
+ ):
+ """Test that listener thread stops when sharded subscription is closed."""
+ sharded_subscription._start_if_needed()
+ thread = sharded_subscription._listener_thread
+
+ # Close subscription
+ sharded_subscription.close()
+
+ # Wait for thread to finish
+ if thread is not None and thread.is_alive():
+ thread.join(timeout=1.0)
+
+ assert thread is None or not thread.is_alive()
+
+ # ==================== Table-driven Tests ====================
+
+ @pytest.mark.parametrize(
+ "test_case",
+ [
+ SubscriptionTestCase(
+ name="basic_sharded_message",
+ buffer_size=5,
+ payload=b"hello sharded world",
+ expected_messages=[b"hello sharded world"],
+ description="Basic sharded message publishing and receiving",
+ ),
+ SubscriptionTestCase(
+ name="empty_sharded_message",
+ buffer_size=5,
+ payload=b"",
+ expected_messages=[b""],
+ description="Empty sharded message handling",
+ ),
+ SubscriptionTestCase(
+ name="large_sharded_message",
+ buffer_size=5,
+ payload=b"x" * 10000,
+ expected_messages=[b"x" * 10000],
+ description="Large sharded message handling",
+ ),
+ SubscriptionTestCase(
+ name="unicode_sharded_message",
+ buffer_size=5,
+ payload="你好世界".encode(),
+ expected_messages=["你好世界".encode()],
+ description="Unicode sharded message handling",
+ ),
+ ],
+ )
+ def test_sharded_subscription_scenarios(self, test_case: SubscriptionTestCase, mock_pubsub: MagicMock):
+ """Test various sharded subscription scenarios using table-driven approach."""
+ subscription = _RedisShardedSubscription(
+ pubsub=mock_pubsub,
+ topic="test-sharded-topic",
+ )
+
+ # Simulate receiving sharded message
+ mock_message = {"type": "smessage", "channel": "test-sharded-topic", "data": test_case.payload}
+ mock_pubsub.get_sharded_message.return_value = mock_message
+
+ try:
+ with subscription:
+ # Wait for message processing
+ time.sleep(0.1)
+
+ # Collect received messages
+ received = []
+ for msg in subscription:
+ received.append(msg)
+ if len(received) >= len(test_case.expected_messages):
+ break
+
+ assert received == test_case.expected_messages, f"Failed: {test_case.description}"
+ finally:
+ subscription.close()
+
+ def test_concurrent_close_and_enqueue(self, started_sharded_subscription: _RedisShardedSubscription):
+ """Test concurrent close and enqueue operations for sharded subscription."""
+ errors = []
+
+ def close_subscription():
+ try:
+ time.sleep(0.05) # Small delay
+ started_sharded_subscription.close()
+ except Exception as e:
+ errors.append(e)
+
+ def enqueue_messages():
+ try:
+ for i in range(50):
+ started_sharded_subscription._enqueue_message(f"sharded_msg_{i}".encode())
+ time.sleep(0.001)
+ except Exception as e:
+ errors.append(e)
+
+ # Start threads
+ close_thread = threading.Thread(target=close_subscription)
+ enqueue_thread = threading.Thread(target=enqueue_messages)
+
+ close_thread.start()
+ enqueue_thread.start()
+
+ # Wait for completion
+ close_thread.join(timeout=2.0)
+ enqueue_thread.join(timeout=2.0)
+
+ # Should not have any errors (operations should be safe)
+ assert len(errors) == 0
+
+ # ==================== Error Handling Tests ====================
+
+ def test_iterator_after_close(self, sharded_subscription: _RedisShardedSubscription):
+ """Test iterator behavior after close for sharded subscription."""
+ sharded_subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match="The Redis sharded subscription is closed"):
+ iter(sharded_subscription)
+
+ def test_start_after_close(self, sharded_subscription: _RedisShardedSubscription):
+ """Test start attempts after close for sharded subscription."""
+ sharded_subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match="The Redis sharded subscription is closed"):
+ sharded_subscription._start_if_needed()
+
+ def test_pubsub_none_operations(self, sharded_subscription: _RedisShardedSubscription):
+ """Test operations when pubsub is None for sharded subscription."""
+ sharded_subscription._pubsub = None
+
+ with pytest.raises(SubscriptionClosedError, match="The Redis sharded subscription has been cleaned up"):
+ sharded_subscription._start_if_needed()
+
+ # Close should still work
+ sharded_subscription.close() # Should not raise
+
+ def test_channel_name_variations(self, mock_pubsub: MagicMock):
+ """Test various sharded channel name formats."""
+ channel_names = [
+ "simple",
+ "with-dashes",
+ "with_underscores",
+ "with.numbers",
+ "WITH.UPPERCASE",
+ "mixed-CASE_name",
+ "very.long.sharded.channel.name.with.multiple.parts",
+ ]
+
+ for channel_name in channel_names:
+ subscription = _RedisShardedSubscription(
+ pubsub=mock_pubsub,
+ topic=channel_name,
+ )
+
+ subscription._start_if_needed()
+ mock_pubsub.ssubscribe.assert_called_with(channel_name)
+ subscription.close()
+
+ def test_receive_on_closed_sharded_subscription(self, sharded_subscription: _RedisShardedSubscription):
+ """Test receive method on closed sharded subscription."""
+ sharded_subscription.close()
+
+ with pytest.raises(SubscriptionClosedError):
+ sharded_subscription.receive()
+
+ def test_receive_with_timeout(self, started_sharded_subscription: _RedisShardedSubscription):
+ """Test receive method with timeout for sharded subscription."""
+ # Should return None when no message available and timeout expires
+ result = started_sharded_subscription.receive(timeout=0.01)
+ assert result is None
+
+ def test_receive_with_message(self, started_sharded_subscription: _RedisShardedSubscription):
+ """Test receive method when message is available for sharded subscription."""
+ test_message = b"test sharded receive"
+ started_sharded_subscription._queue.put_nowait(test_message)
+
+ result = started_sharded_subscription.receive(timeout=1.0)
+ assert result == test_message
+
+
+class TestRedisSubscriptionCommon:
+ """Parameterized tests for common Redis subscription functionality.
+
+ This test suite eliminates duplication by running the same tests against
+ both regular and sharded subscriptions using pytest.mark.parametrize.
+ """
+
+ @pytest.fixture(
+ params=[
+ ("regular", _RedisSubscription),
+ ("sharded", _RedisShardedSubscription),
+ ]
+ )
+ def subscription_params(self, request):
+ """Parameterized fixture providing subscription type and class."""
+ return request.param
+
+ @pytest.fixture
+ def mock_pubsub(self) -> MagicMock:
+ """Create a mock PubSub instance for testing."""
+ pubsub = MagicMock()
+ # Set up mock methods for both regular and sharded subscriptions
+ pubsub.subscribe = MagicMock()
+ pubsub.unsubscribe = MagicMock()
+ pubsub.ssubscribe = MagicMock() # type: ignore[attr-defined]
+ pubsub.sunsubscribe = MagicMock() # type: ignore[attr-defined]
+ pubsub.get_message = MagicMock()
+ pubsub.get_sharded_message = MagicMock() # type: ignore[attr-defined]
+ pubsub.close = MagicMock()
+ return pubsub
+
+ @pytest.fixture
+ def subscription(self, subscription_params, mock_pubsub: MagicMock):
+ """Create a subscription instance based on parameterized type."""
+ subscription_type, subscription_class = subscription_params
+ topic_name = f"test-{subscription_type}-topic"
+ subscription = subscription_class(
+ pubsub=mock_pubsub,
+ topic=topic_name,
+ )
+ yield subscription
+ subscription.close()
+
+ @pytest.fixture
+ def started_subscription(self, subscription):
+ """Create a subscription that has been started."""
+ subscription._start_if_needed()
+ return subscription
+
+ # ==================== Initialization Tests ====================
+
+ def test_subscription_initialization(self, subscription, subscription_params):
+ """Test that subscription is properly initialized."""
+ subscription_type, _ = subscription_params
+ expected_topic = f"test-{subscription_type}-topic"
+
+ assert subscription._pubsub is not None
+ assert subscription._topic == expected_topic
+ assert not subscription._closed.is_set()
+ assert subscription._dropped_count == 0
+ assert subscription._listener_thread is None
+ assert not subscription._started
+
+ def test_subscription_type(self, subscription, subscription_params):
+ """Test that subscription returns correct type."""
+ subscription_type, _ = subscription_params
+ assert subscription._get_subscription_type() == subscription_type
+
+ # ==================== Lifecycle Tests ====================
+
+ def test_start_if_needed_first_call(self, subscription, subscription_params, mock_pubsub: MagicMock):
+ """Test that _start_if_needed() properly starts subscription on first call."""
+ subscription_type, _ = subscription_params
+ subscription._start_if_needed()
+
+ if subscription_type == "regular":
+ mock_pubsub.subscribe.assert_called_once()
+ else:
+ mock_pubsub.ssubscribe.assert_called_once()
+
+ assert subscription._started is True
+ assert subscription._listener_thread is not None
+
+ def test_start_if_needed_subsequent_calls(self, started_subscription):
+ """Test that _start_if_needed() doesn't start subscription on subsequent calls."""
+ original_thread = started_subscription._listener_thread
+ started_subscription._start_if_needed()
+
+ # Should not create new thread
+ assert started_subscription._listener_thread is original_thread
+
+ def test_context_manager_usage(self, subscription, subscription_params, mock_pubsub: MagicMock):
+ """Test that subscription works as context manager."""
+ subscription_type, _ = subscription_params
+ expected_topic = f"test-{subscription_type}-topic"
+
+ with subscription as sub:
+ assert sub is subscription
+ assert subscription._started is True
+ if subscription_type == "regular":
+ mock_pubsub.subscribe.assert_called_with(expected_topic)
+ else:
+ mock_pubsub.ssubscribe.assert_called_with(expected_topic)
+
+ def test_close_idempotent(self, subscription, subscription_params, mock_pubsub: MagicMock):
+ """Test that close() is idempotent and can be called multiple times."""
+ subscription_type, _ = subscription_params
+ subscription._start_if_needed()
+
+ # Close multiple times
+ subscription.close()
+ subscription.close()
+ subscription.close()
+
+ # Should only cleanup once
+ if subscription_type == "regular":
+ mock_pubsub.unsubscribe.assert_called_once()
+ else:
+ mock_pubsub.sunsubscribe.assert_called_once()
+ mock_pubsub.close.assert_called_once()
+ assert subscription._pubsub is None
+ assert subscription._closed.is_set()
+
+ # ==================== Message Processing Tests ====================
+
+ def test_message_iterator_with_messages(self, started_subscription):
+ """Test message iterator behavior with messages in queue."""
+ test_messages = [b"msg1", b"msg2", b"msg3"]
+
+ # Add messages to queue
+ for msg in test_messages:
+ started_subscription._queue.put_nowait(msg)
+
+ # Iterate through messages
+ iterator = iter(started_subscription)
+ received_messages = []
+
+ for msg in iterator:
+ received_messages.append(msg)
+ if len(received_messages) >= len(test_messages):
+ break
+
+ assert received_messages == test_messages
+
+ def test_message_iterator_when_closed(self, subscription, subscription_params):
+ """Test that iterator raises error when subscription is closed."""
+ subscription_type, _ = subscription_params
+ subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match=f"The Redis {subscription_type} subscription is closed"):
+ iter(subscription)
+
+ # ==================== Message Enqueue Tests ====================
+
+ def test_enqueue_message_success(self, started_subscription):
+ """Test successful message enqueue."""
+ payload = b"test message"
+
+ started_subscription._enqueue_message(payload)
+
+ assert started_subscription._queue.qsize() == 1
+ assert started_subscription._queue.get_nowait() == payload
+
+ def test_enqueue_message_when_closed(self, subscription):
+ """Test message enqueue when subscription is closed."""
+ subscription.close()
+ payload = b"test message"
+
+ # Should not raise exception, but should not enqueue
+ subscription._enqueue_message(payload)
+
+ assert subscription._queue.empty()
+
+ def test_enqueue_message_with_full_queue(self, started_subscription):
+ """Test message enqueue with full queue (dropping behavior)."""
+ # Fill the queue
+ for i in range(started_subscription._queue.maxsize):
+ started_subscription._queue.put_nowait(f"old_msg_{i}".encode())
+
+ # Try to enqueue new message (should drop oldest)
+ new_message = b"new_message"
+ started_subscription._enqueue_message(new_message)
+
+ # Should have dropped one message and added new one
+ assert started_subscription._dropped_count == 1
+
+ # New message should be in queue
+ messages = []
+ while not started_subscription._queue.empty():
+ messages.append(started_subscription._queue.get_nowait())
+
+ assert new_message in messages
+
+ # ==================== Message Type Tests ====================
+
+ def test_get_message_type(self, subscription, subscription_params):
+ """Test that subscription returns correct message type."""
+ subscription_type, _ = subscription_params
+ expected_type = "message" if subscription_type == "regular" else "smessage"
+ assert subscription._get_message_type() == expected_type
+
+ # ==================== Error Handling Tests ====================
+
+ def test_start_if_needed_when_closed(self, subscription, subscription_params):
+ """Test that _start_if_needed() raises error when subscription is closed."""
+ subscription_type, _ = subscription_params
+ subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match=f"The Redis {subscription_type} subscription is closed"):
+ subscription._start_if_needed()
+
+ def test_start_if_needed_when_cleaned_up(self, subscription, subscription_params):
+ """Test that _start_if_needed() raises error when pubsub is None."""
+ subscription_type, _ = subscription_params
+ subscription._pubsub = None
+
+ with pytest.raises(
+ SubscriptionClosedError, match=f"The Redis {subscription_type} subscription has been cleaned up"
+ ):
+ subscription._start_if_needed()
+
+ def test_iterator_after_close(self, subscription, subscription_params):
+ """Test iterator behavior after close."""
+ subscription_type, _ = subscription_params
+ subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match=f"The Redis {subscription_type} subscription is closed"):
+ iter(subscription)
+
+ def test_start_after_close(self, subscription, subscription_params):
+ """Test start attempts after close."""
+ subscription_type, _ = subscription_params
+ subscription.close()
+
+ with pytest.raises(SubscriptionClosedError, match=f"The Redis {subscription_type} subscription is closed"):
+ subscription._start_if_needed()
+
+ def test_pubsub_none_operations(self, subscription, subscription_params):
+ """Test operations when pubsub is None."""
+ subscription_type, _ = subscription_params
+ subscription._pubsub = None
+
+ with pytest.raises(
+ SubscriptionClosedError, match=f"The Redis {subscription_type} subscription has been cleaned up"
+ ):
+ subscription._start_if_needed()
+
+ # Close should still work
+ subscription.close() # Should not raise
+
+ def test_receive_on_closed_subscription(self, subscription, subscription_params):
+ """Test receive method on closed subscription."""
+ subscription.close()
+
+ with pytest.raises(SubscriptionClosedError):
+ subscription.receive()
+
+ # ==================== Table-driven Tests ====================
+
+ @pytest.mark.parametrize(
+ "test_case",
+ [
+ SubscriptionTestCase(
+ name="basic_message",
+ buffer_size=5,
+ payload=b"hello world",
+ expected_messages=[b"hello world"],
+ description="Basic message publishing and receiving",
+ ),
+ SubscriptionTestCase(
+ name="empty_message",
+ buffer_size=5,
+ payload=b"",
+ expected_messages=[b""],
+ description="Empty message handling",
+ ),
+ SubscriptionTestCase(
+ name="large_message",
+ buffer_size=5,
+ payload=b"x" * 10000,
+ expected_messages=[b"x" * 10000],
+ description="Large message handling",
+ ),
+ SubscriptionTestCase(
+ name="unicode_message",
+ buffer_size=5,
+ payload="你好世界".encode(),
+ expected_messages=["你好世界".encode()],
+ description="Unicode message handling",
+ ),
+ ],
+ )
+ def test_subscription_scenarios(
+ self, test_case: SubscriptionTestCase, subscription, subscription_params, mock_pubsub: MagicMock
+ ):
+ """Test various subscription scenarios using table-driven approach."""
+ subscription_type, _ = subscription_params
+ expected_topic = f"test-{subscription_type}-topic"
+ expected_message_type = "message" if subscription_type == "regular" else "smessage"
+
+ # Simulate receiving message
+ mock_message = {"type": expected_message_type, "channel": expected_topic, "data": test_case.payload}
+
+ if subscription_type == "regular":
+ mock_pubsub.get_message.return_value = mock_message
+ else:
+ mock_pubsub.get_sharded_message.return_value = mock_message
+
+ try:
+ with subscription:
+ # Wait for message processing
+ time.sleep(0.1)
+
+ # Collect received messages
+ received = []
+ for msg in subscription:
+ received.append(msg)
+ if len(received) >= len(test_case.expected_messages):
+ break
+
+ assert received == test_case.expected_messages, f"Failed: {test_case.description}"
+ finally:
+ subscription.close()
+
+ # ==================== Concurrency Tests ====================
+
+ def test_concurrent_close_and_enqueue(self, started_subscription):
+ """Test concurrent close and enqueue operations."""
+ errors = []
+
+ def close_subscription():
+ try:
+ time.sleep(0.05) # Small delay
+ started_subscription.close()
+ except Exception as e:
+ errors.append(e)
+
+ def enqueue_messages():
+ try:
+ for i in range(50):
+ started_subscription._enqueue_message(f"msg_{i}".encode())
+ time.sleep(0.001)
+ except Exception as e:
+ errors.append(e)
+
+ # Start threads
+ close_thread = threading.Thread(target=close_subscription)
+ enqueue_thread = threading.Thread(target=enqueue_messages)
+
+ close_thread.start()
+ enqueue_thread.start()
+
+ # Wait for completion
+ close_thread.join(timeout=2.0)
+ enqueue_thread.join(timeout=2.0)
+
+ # Should not have any errors (operations should be safe)
+ assert len(errors) == 0
From c2043d0f6de977036c0322a72f0995bafac326c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=BC=A0=E5=93=B2=E8=8A=B3?=
<34058239+zhangzhefang-github@users.noreply.github.com>
Date: Fri, 21 Nov 2025 10:34:55 +0800
Subject: [PATCH 021/191] fix: allow API to access conversations created before
upgrade to 1.10.0 (#28462)
Co-authored-by: crazywoola <100913391+crazywoola@users.noreply.github.com>
---
api/services/end_user_service.py | 26 ++++++++++++++++++++++++--
1 file changed, 24 insertions(+), 2 deletions(-)
diff --git a/api/services/end_user_service.py b/api/services/end_user_service.py
index aa4a2e46ec..81098e95bb 100644
--- a/api/services/end_user_service.py
+++ b/api/services/end_user_service.py
@@ -1,11 +1,15 @@
+import logging
from collections.abc import Mapping
+from sqlalchemy import case
from sqlalchemy.orm import Session
from core.app.entities.app_invoke_entities import InvokeFrom
from extensions.ext_database import db
from models.model import App, DefaultEndUserSessionID, EndUser
+logger = logging.getLogger(__name__)
+
class EndUserService:
"""
@@ -32,18 +36,36 @@ class EndUserService:
user_id = DefaultEndUserSessionID.DEFAULT_SESSION_ID
with Session(db.engine, expire_on_commit=False) as session:
+ # Query with ORDER BY to prioritize exact type matches while maintaining backward compatibility
+ # This single query approach is more efficient than separate queries
end_user = (
session.query(EndUser)
.where(
EndUser.tenant_id == tenant_id,
EndUser.app_id == app_id,
EndUser.session_id == user_id,
- EndUser.type == type,
+ )
+ .order_by(
+ # Prioritize records with matching type (0 = match, 1 = no match)
+ case((EndUser.type == type, 0), else_=1)
)
.first()
)
- if end_user is None:
+ if end_user:
+ # If found a legacy end user with different type, update it for future consistency
+ if end_user.type != type:
+ logger.info(
+ "Upgrading legacy EndUser %s from type=%s to %s for session_id=%s",
+ end_user.id,
+ end_user.type,
+ type,
+ user_id,
+ )
+ end_user.type = type
+ session.commit()
+ else:
+ # Create new end user if none exists
end_user = EndUser(
tenant_id=tenant_id,
app_id=app_id,
From 73c58e4cbb52409071cb823f381a6cf7875ed2a0 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
<41898282+github-actions[bot]@users.noreply.github.com>
Date: Fri, 21 Nov 2025 10:35:04 +0800
Subject: [PATCH 022/191] chore: translate i18n files and update type
definitions (#28478)
Co-authored-by: asukaminato0721 <30024051+asukaminato0721@users.noreply.github.com>
---
web/i18n/de-DE/billing.ts | 22 ++++++++++++++++++++++
web/i18n/es-ES/billing.ts | 22 ++++++++++++++++++++++
web/i18n/fa-IR/billing.ts | 22 ++++++++++++++++++++++
web/i18n/fr-FR/billing.ts | 22 ++++++++++++++++++++++
web/i18n/hi-IN/billing.ts | 22 ++++++++++++++++++++++
web/i18n/id-ID/billing.ts | 22 ++++++++++++++++++++++
web/i18n/it-IT/billing.ts | 22 ++++++++++++++++++++++
web/i18n/ko-KR/billing.ts | 22 ++++++++++++++++++++++
web/i18n/pl-PL/billing.ts | 22 ++++++++++++++++++++++
web/i18n/pt-BR/billing.ts | 22 ++++++++++++++++++++++
web/i18n/ro-RO/billing.ts | 22 ++++++++++++++++++++++
web/i18n/ru-RU/billing.ts | 22 ++++++++++++++++++++++
web/i18n/sl-SI/billing.ts | 22 ++++++++++++++++++++++
web/i18n/th-TH/billing.ts | 22 ++++++++++++++++++++++
web/i18n/tr-TR/billing.ts | 22 ++++++++++++++++++++++
web/i18n/uk-UA/billing.ts | 22 ++++++++++++++++++++++
web/i18n/vi-VN/billing.ts | 22 ++++++++++++++++++++++
web/i18n/zh-Hant/billing.ts | 22 ++++++++++++++++++++++
18 files changed, 396 insertions(+)
diff --git a/web/i18n/de-DE/billing.ts b/web/i18n/de-DE/billing.ts
index b921e5e341..6a57b75f5f 100644
--- a/web/i18n/de-DE/billing.ts
+++ b/web/i18n/de-DE/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Beginnen Sie mit der Entwicklung',
taxTipSecond: 'Wenn in Ihrer Region keine relevanten Steuervorschriften gelten, wird an der Kasse keine Steuer angezeigt und Ihnen werden während der gesamten Abonnementlaufzeit keine zusätzlichen Gebühren berechnet.',
taxTip: 'Alle Abonnementspreise (monatlich/jährlich) verstehen sich zuzüglich der geltenden Steuern (z. B. MwSt., Umsatzsteuer).',
+ triggerEvents: {
+ tooltip: 'Die Anzahl der Ereignisse, die Workflows automatisch über Plugin-, Zeitplan- oder Webhook-Auslöser starten.',
+ unlimited: 'Unbegrenzte Auslöser-Ereignisse',
+ },
+ workflowExecution: {
+ faster: 'Schnellere Arbeitsablauf-Ausführung',
+ tooltip: 'Priorität und Geschwindigkeit der Arbeitsablauf-Ausführungswarteschlange.',
+ priority: 'Prioritäts-Workflow-Ausführung',
+ standard: 'Standard-Workflow-Ausführung',
+ },
+ startNodes: {
+ unlimited: 'Unbegrenzte Auslöser/Workflows',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
documentsUploadQuota: 'Dokumenten-Upload-Quota',
vectorSpace: 'Wissensdatenbank',
vectorSpaceTooltip: 'Dokumente mit dem Hochqualitäts-Indexierungsmodus verbrauchen Ressourcen des Knowledge Data Storage. Wenn der Knowledge Data Storage die Grenze erreicht, werden keine neuen Dokumente hochgeladen.',
+ perMonth: 'pro Monat',
+ triggerEvents: 'Auslöser-Ereignisse',
},
teamMembers: 'Teammitglieder',
+ triggerLimitModal: {
+ dismiss: 'Schließen',
+ upgrade: 'Aktualisieren',
+ title: 'Upgrade, um mehr Auslöser-Ereignisse freizuschalten',
+ usageTitle: 'AUSLÖSEEREIGNISSE',
+ description: 'Sie haben das Limit der Workflow-Ereignisauslöser für diesen Plan erreicht.',
+ },
}
export default translation
diff --git a/web/i18n/es-ES/billing.ts b/web/i18n/es-ES/billing.ts
index 48377bbaa3..10c6b15b1e 100644
--- a/web/i18n/es-ES/billing.ts
+++ b/web/i18n/es-ES/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Empezar a construir',
taxTip: 'Todos los precios de suscripción (mensuales/anuales) excluyen los impuestos aplicables (por ejemplo, IVA, impuesto sobre ventas).',
taxTipSecond: 'Si su región no tiene requisitos fiscales aplicables, no se mostrará ningún impuesto en su pago y no se le cobrará ninguna tarifa adicional durante todo el período de suscripción.',
+ triggerEvents: {
+ unlimited: 'Eventos de Disparo Ilimitados',
+ tooltip: 'El número de eventos que inician automáticamente flujos de trabajo mediante desencadenadores de Plugin, Programación o Webhook.',
+ },
+ workflowExecution: {
+ tooltip: 'Prioridad y velocidad de la cola de ejecución de flujos de trabajo.',
+ standard: 'Ejecución estándar del flujo de trabajo',
+ priority: 'Ejecución de flujo de trabajo prioritaria',
+ faster: 'Ejecución de flujo de trabajo más rápida',
+ },
+ startNodes: {
+ unlimited: 'Disparadores/flujo de trabajo ilimitados',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
teamMembers: 'Miembros del equipo',
annotationQuota: 'Cuota de anotación',
vectorSpaceTooltip: 'Los documentos con el modo de indexación de alta calidad consumirán recursos de Almacenamiento de Datos de Conocimiento. Cuando el Almacenamiento de Datos de Conocimiento alcanza el límite, no se subirán nuevos documentos.',
+ triggerEvents: 'Eventos desencadenantes',
+ perMonth: 'por mes',
},
teamMembers: 'Miembros del equipo',
+ triggerLimitModal: {
+ dismiss: 'Descartar',
+ upgrade: 'Actualizar',
+ usageTitle: 'EVENTOS DESENCADENANTES',
+ title: 'Actualiza para desbloquear más eventos desencadenantes',
+ description: 'Has alcanzado el límite de activadores de eventos de flujo de trabajo para este plan.',
+ },
}
export default translation
diff --git a/web/i18n/fa-IR/billing.ts b/web/i18n/fa-IR/billing.ts
index 24c7f749f9..ae5aaa67ab 100644
--- a/web/i18n/fa-IR/billing.ts
+++ b/web/i18n/fa-IR/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'شروع به ساخت کنید',
taxTip: 'تمام قیمتهای اشتراک (ماهانه/سالانه) شامل مالیاتهای مربوطه (مثلاً مالیات بر ارزش افزوده، مالیات فروش) نمیشوند.',
taxTipSecond: 'اگر منطقه شما هیچ الزامات مالیاتی قابل اجرا نداشته باشد، هیچ مالیاتی در هنگام پرداخت نشان داده نمیشود و برای کل مدت اشتراک هیچ هزینه اضافی از شما دریافت نخواهد شد.',
+ triggerEvents: {
+ unlimited: 'رویدادهای ماشهای نامحدود',
+ tooltip: 'تعداد رویدادهایی که بهطور خودکار گردشهای کاری را از طریق افزونه، برنامهزمانبندی یا ماشههای وبهوک آغاز میکنند.',
+ },
+ workflowExecution: {
+ faster: 'اجرای سریعتر جریان کاری',
+ priority: 'اجرای جریان کاری اولویتدار',
+ standard: 'اجرای جریان کاری استاندارد',
+ tooltip: 'اولویت و سرعت صف اجرای گردش کار.',
+ },
+ startNodes: {
+ unlimited: 'راهاندازی/فرآیندهای نامحدود',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
annotationQuota: 'سهام حاشیه',
buildApps: 'ساخت برنامه ها',
vectorSpaceTooltip: 'سندهایی که با حالت نمایهسازی با کیفیت بالا تهیه میشوند، منابع ذخیرهسازی دادههای دانش را مصرف خواهند کرد. زمانی که ذخیرهسازی دادههای دانش به حد خود برسد، اسناد جدید بارگزاری نخواهند شد.',
+ perMonth: 'در ماه',
+ triggerEvents: 'رویدادهای محرک',
},
teamMembers: 'اعضای تیم',
+ triggerLimitModal: {
+ upgrade: 'ارتقا',
+ description: 'شما به حد مجاز تریگرهای رویداد گردش کار برای این طرح رسیدهاید.',
+ dismiss: 'رد کردن',
+ title: 'ارتقا دهید تا رویدادهای محرک بیشتری باز شود',
+ usageTitle: 'رویدادهای محرک',
+ },
}
export default translation
diff --git a/web/i18n/fr-FR/billing.ts b/web/i18n/fr-FR/billing.ts
index 383b6bdca1..b2a8b04364 100644
--- a/web/i18n/fr-FR/billing.ts
+++ b/web/i18n/fr-FR/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Commencez à construire',
taxTip: 'Tous les prix des abonnements (mensuels/annuels) s\'entendent hors taxes applicables (par exemple, TVA, taxe de vente).',
taxTipSecond: 'Si votre région n\'a pas de exigences fiscales applicables, aucune taxe n\'apparaîtra lors de votre paiement et vous ne serez pas facturé de frais supplémentaires pendant toute la durée de l\'abonnement.',
+ triggerEvents: {
+ unlimited: 'Événements Déclencheurs Illimités',
+ tooltip: 'Le nombre d\'événements qui déclenchent automatiquement des flux de travail via des déclencheurs Plugin, Planification ou Webhook.',
+ },
+ workflowExecution: {
+ priority: 'Exécution du flux de travail prioritaire',
+ standard: 'Exécution du flux de travail standard',
+ tooltip: 'Priorité et vitesse de la file d\'exécution des flux de travail.',
+ faster: 'Exécution de flux de travail plus rapide',
+ },
+ startNodes: {
+ unlimited: 'Déclencheurs/workflows illimités',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
teamMembers: 'Membres de l\'équipe',
annotationQuota: 'Quota d\'annotation',
documentsUploadQuota: 'Quota de téléchargement de documents',
+ perMonth: 'par mois',
+ triggerEvents: 'Événements déclencheurs',
},
teamMembers: 'Membres de l\'équipe',
+ triggerLimitModal: {
+ upgrade: 'Mettre à niveau',
+ usageTitle: 'ÉVÉNEMENTS DÉCLENCHEURS',
+ description: 'Vous avez atteint la limite des déclencheurs d\'événements de flux de travail pour ce plan.',
+ dismiss: 'Fermer',
+ title: 'Mettez à niveau pour débloquer plus d\'événements déclencheurs',
+ },
}
export default translation
diff --git a/web/i18n/hi-IN/billing.ts b/web/i18n/hi-IN/billing.ts
index eb970f38ab..1176504931 100644
--- a/web/i18n/hi-IN/billing.ts
+++ b/web/i18n/hi-IN/billing.ts
@@ -104,6 +104,19 @@ const translation = {
startBuilding: 'बनाना शुरू करें',
taxTip: 'सभी सदस्यता मूल्य (मासिक/वार्षिक) लागू करों (जैसे, VAT, बिक्री कर) को शामिल नहीं करते हैं।',
taxTipSecond: 'यदि आपके क्षेत्र में कोई लागू कर आवश्यकताएँ नहीं हैं, तो आपकी चेकआउट में कोई कर नहीं दिखाई देगा, और पूरे सदस्यता अवधि के लिए आपसे कोई अतिरिक्त शुल्क नहीं लिया जाएगा।',
+ triggerEvents: {
+ unlimited: 'असीमित ट्रिगर इवेंट्स',
+ tooltip: 'घटनाओं की संख्या जो प्लगइन, शेड्यूल या वेबहुक ट्रिगर के माध्यम से स्वतः वर्कफ़्लो शुरू करती हैं।',
+ },
+ workflowExecution: {
+ standard: 'मानक कार्यप्रवाह निष्पादन',
+ faster: 'तेज़ कार्यप्रवाह निष्पादन',
+ priority: 'प्राथमिकता कार्यप्रवाह निष्पादन',
+ tooltip: 'वर्कफ़्लो निष्पादन कतार की प्राथमिकता और गति।',
+ },
+ startNodes: {
+ unlimited: 'असीमित ट्रिगर्स/कार्यप्रवाह',
+ },
},
plans: {
sandbox: {
@@ -197,8 +210,17 @@ const translation = {
vectorSpace: 'ज्ञान डेटा भंडारण',
teamMembers: 'टीम के सदस्य',
vectorSpaceTooltip: 'उच्च गुणवत्ता वाले अनुक्रमण मोड के साथ दस्तावेज़ों के लिए ज्ञान डेटा स्टोरेज संसाधनों का उपभोग होगा। जब ज्ञान डेटा स्टोरेज सीमा तक पहुँच जाएगा, तो नए दस्तावेज़ नहीं अपलोड किए जाएंगे।',
+ perMonth: 'प्रति माह',
+ triggerEvents: 'उत्तेजक घटनाएँ',
},
teamMembers: 'टीम के सदस्य',
+ triggerLimitModal: {
+ upgrade: 'अपग्रेड',
+ usageTitle: 'ट्रिगर घटनाएँ',
+ dismiss: 'खारिज करें',
+ title: 'अधिक ट्रिगर इवेंट्स अनलॉक करने के लिए अपग्रेड करें',
+ description: 'आप इस योजना के लिए वर्कफ़्लो इवेंट ट्रिगर्स की सीमा तक पहुँच चुके हैं।',
+ },
}
export default translation
diff --git a/web/i18n/id-ID/billing.ts b/web/i18n/id-ID/billing.ts
index c6c718d15b..2f6b89598b 100644
--- a/web/i18n/id-ID/billing.ts
+++ b/web/i18n/id-ID/billing.ts
@@ -6,6 +6,8 @@ const translation = {
documentsUploadQuota: 'Kuota Unggah Dokumen',
teamMembers: 'Anggota Tim',
annotationQuota: 'Kuota Anotasi',
+ perMonth: 'per bulan',
+ triggerEvents: 'Pemicu Acara',
},
upgradeBtn: {
encourage: 'Tingkatkan Sekarang',
@@ -89,6 +91,19 @@ const translation = {
startBuilding: 'Mulai Membangun',
taxTip: 'Semua harga langganan (bulanan/tahunan) belum termasuk pajak yang berlaku (misalnya, PPN, pajak penjualan).',
taxTipSecond: 'Jika wilayah Anda tidak memiliki persyaratan pajak yang berlaku, tidak akan ada pajak yang muncul saat checkout, dan Anda tidak akan dikenakan biaya tambahan apa pun selama masa langganan.',
+ triggerEvents: {
+ unlimited: 'Peristiwa Pemicu Tak Terbatas',
+ tooltip: 'Jumlah peristiwa yang secara otomatis memulai alur kerja melalui pemicu Plugin, Jadwal, atau Webhook.',
+ },
+ workflowExecution: {
+ priority: 'Eksekusi Alur Kerja Prioritas',
+ standard: 'Eksekusi Alur Kerja Standar',
+ faster: 'Eksekusi Alur Kerja yang Lebih Cepat',
+ tooltip: 'Prioritas dan kecepatan antrian eksekusi alur kerja.',
+ },
+ startNodes: {
+ unlimited: 'Pemicu/alur kerja tanpa batas',
+ },
},
plans: {
sandbox: {
@@ -176,6 +191,13 @@ const translation = {
buyPermissionDeniedTip: 'Hubungi administrator perusahaan Anda untuk berlangganan',
viewBilling: 'Mengelola penagihan dan langganan',
teamMembers: 'Anggota Tim',
+ triggerLimitModal: {
+ upgrade: 'Tingkatkan',
+ dismiss: 'Tutup',
+ usageTitle: 'PERISTIWA PEMICU',
+ title: 'Tingkatkan untuk membuka lebih banyak peristiwa pemicu',
+ description: 'Anda telah mencapai batas pemicu acara alur kerja untuk paket ini.',
+ },
}
export default translation
diff --git a/web/i18n/it-IT/billing.ts b/web/i18n/it-IT/billing.ts
index 175bfad10c..60fe22bf6d 100644
--- a/web/i18n/it-IT/billing.ts
+++ b/web/i18n/it-IT/billing.ts
@@ -104,6 +104,19 @@ const translation = {
startBuilding: 'Inizia a costruire',
taxTip: 'Tutti i prezzi degli abbonamenti (mensili/annuali) non includono le tasse applicabili (ad esempio, IVA, imposta sulle vendite).',
taxTipSecond: 'Se nella tua regione non ci sono requisiti fiscali applicabili, nessuna tassa apparirà al momento del pagamento e non ti verranno addebitate spese aggiuntive per l\'intera durata dell\'abbonamento.',
+ triggerEvents: {
+ unlimited: 'Eventi di attivazione illimitati',
+ tooltip: 'Il numero di eventi che avviano automaticamente i flussi di lavoro tramite trigger Plugin, Pianificazione o Webhook.',
+ },
+ workflowExecution: {
+ priority: 'Esecuzione del flusso di lavoro prioritario',
+ faster: 'Esecuzione del flusso di lavoro più rapida',
+ standard: 'Esecuzione del flusso di lavoro standard',
+ tooltip: 'Priorità e velocità della coda di esecuzione del flusso di lavoro.',
+ },
+ startNodes: {
+ unlimited: 'Trigger/workflow illimitati',
+ },
},
plans: {
sandbox: {
@@ -197,8 +210,17 @@ const translation = {
teamMembers: 'Membri del team',
documentsUploadQuota: 'Quota di Caricamento Documenti',
vectorSpaceTooltip: 'I documenti con la modalità di indicizzazione ad alta qualità consumeranno risorse di Knowledge Data Storage. Quando il Knowledge Data Storage raggiunge il limite, nuovi documenti non verranno caricati.',
+ perMonth: 'al mese',
+ triggerEvents: 'Eventi scatenanti',
},
teamMembers: 'Membri del team',
+ triggerLimitModal: {
+ upgrade: 'Aggiornamento',
+ dismiss: 'Ignora',
+ usageTitle: 'EVENTI SCATENANTI',
+ title: 'Aggiorna per sbloccare più eventi trigger',
+ description: 'Hai raggiunto il limite dei trigger degli eventi del flusso di lavoro per questo piano.',
+ },
}
export default translation
diff --git a/web/i18n/ko-KR/billing.ts b/web/i18n/ko-KR/billing.ts
index 632b629792..881a8053c2 100644
--- a/web/i18n/ko-KR/billing.ts
+++ b/web/i18n/ko-KR/billing.ts
@@ -105,6 +105,19 @@ const translation = {
startBuilding: '구축 시작',
taxTip: '모든 구독 요금(월간/연간)에는 해당 세금(예: 부가가치세, 판매세)이 포함되어 있지 않습니다.',
taxTipSecond: '귀하의 지역에 적용 가능한 세금 요구 사항이 없는 경우, 결제 시 세금이 표시되지 않으며 전체 구독 기간 동안 추가 요금이 부과되지 않습니다.',
+ triggerEvents: {
+ unlimited: '무제한 트리거 이벤트',
+ tooltip: '플러그인, 스케줄 또는 웹훅 트리거를 통해 워크플로를 자동으로 시작하는 이벤트 수입니다.',
+ },
+ workflowExecution: {
+ faster: '더 빠른 작업 흐름 실행',
+ standard: '표준 워크플로 실행',
+ priority: '우선 순위 작업 흐름 실행',
+ tooltip: '워크플로 실행 대기열 우선순위 및 속도.',
+ },
+ startNodes: {
+ unlimited: '무제한 트리거/워크플로',
+ },
},
plans: {
sandbox: {
@@ -199,8 +212,17 @@ const translation = {
documentsUploadQuota: '문서 업로드 한도',
vectorSpaceTooltip:
'고품질 색인 모드를 사용하는 문서는 지식 데이터 저장소 자원을 소모합니다. 지식 데이터 저장소가 한도에 도달하면 새 문서를 업로드할 수 없습니다.',
+ triggerEvents: '트리거 이벤트',
+ perMonth: '월별',
},
teamMembers: '팀원들',
+ triggerLimitModal: {
+ usageTitle: '트리거 이벤트',
+ dismiss: '닫기',
+ title: '업그레이드하여 더 많은 트리거 이벤트 잠금 해제',
+ description: '이 요금제의 워크플로 이벤트 트리거 한도에 도달했습니다.',
+ upgrade: '업그레이드',
+ },
}
export default translation
diff --git a/web/i18n/pl-PL/billing.ts b/web/i18n/pl-PL/billing.ts
index 0aa230e4d3..0ed2bcdcf4 100644
--- a/web/i18n/pl-PL/billing.ts
+++ b/web/i18n/pl-PL/billing.ts
@@ -103,6 +103,19 @@ const translation = {
startBuilding: 'Zacznij budować',
taxTip: 'Wszystkie ceny subskrypcji (miesięczne/roczne) nie obejmują obowiązujących podatków (np. VAT, podatek od sprzedaży).',
taxTipSecond: 'Jeśli w Twoim regionie nie ma obowiązujących przepisów podatkowych, podatek nie pojawi się podczas realizacji zamówienia i nie zostaną naliczone żadne dodatkowe opłaty przez cały okres subskrypcji.',
+ triggerEvents: {
+ unlimited: 'Nieograniczone zdarzenia wyzwalające',
+ tooltip: 'Liczba zdarzeń, które automatycznie uruchamiają przepływy pracy za pomocą wtyczki, harmonogramu lub wyzwalaczy Webhook.',
+ },
+ workflowExecution: {
+ standard: 'Standardowe wykonywanie przepływu pracy',
+ tooltip: 'Priorytet i szybkość wykonywania kolejki przepływu pracy.',
+ priority: 'Wykonywanie przepływu pracy według priorytetu',
+ faster: 'Szybsze wykonywanie przepływu pracy',
+ },
+ startNodes: {
+ unlimited: 'Nieograniczone wyzwalacze/przepływ pracy',
+ },
},
plans: {
sandbox: {
@@ -196,8 +209,17 @@ const translation = {
buildApps: 'Twórz aplikacje',
annotationQuota: 'Kwota aneksji',
vectorSpaceTooltip: 'Dokumenty z trybem indeksowania o wysokiej jakości będą zużywać zasoby magazynu danych wiedzy. Gdy magazyn danych wiedzy osiągnie limit, nowe dokumenty nie będą przesyłane.',
+ perMonth: 'miesięcznie',
+ triggerEvents: 'Wydarzenia wyzwalające',
},
teamMembers: 'Członkowie zespołu',
+ triggerLimitModal: {
+ upgrade: 'Uaktualnij',
+ usageTitle: 'WYDARZENIA WYZWALAJĄCE',
+ description: 'Osiągnąłeś limit wyzwalaczy zdarzeń przepływu pracy dla tego planu.',
+ title: 'Uaktualnij, aby odblokować więcej zdarzeń wyzwalających',
+ dismiss: 'Odrzuć',
+ },
}
export default translation
diff --git a/web/i18n/pt-BR/billing.ts b/web/i18n/pt-BR/billing.ts
index 94c7c967f9..baec9813f4 100644
--- a/web/i18n/pt-BR/billing.ts
+++ b/web/i18n/pt-BR/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Comece a construir',
taxTip: 'Todos os preços de assinatura (mensal/anual) não incluem os impostos aplicáveis (por exemplo, IVA, imposto sobre vendas).',
taxTipSecond: 'Se a sua região não tiver requisitos fiscais aplicáveis, nenhum imposto aparecerá no seu checkout e você não será cobrado por taxas adicionais durante todo o período da assinatura.',
+ triggerEvents: {
+ unlimited: 'Eventos de Gatilho Ilimitados',
+ tooltip: 'O número de eventos que iniciam automaticamente fluxos de trabalho através de disparadores de Plugin, Agendamento ou Webhook.',
+ },
+ workflowExecution: {
+ tooltip: 'Prioridade e velocidade da fila de execução de fluxo de trabalho.',
+ priority: 'Execução de Fluxo de Trabalho Prioritário',
+ faster: 'Execução de Fluxo de Trabalho Mais Rápida',
+ standard: 'Execução Padrão de Fluxo de Trabalho',
+ },
+ startNodes: {
+ unlimited: 'Gatilhos/workflow ilimitados',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
vectorSpace: 'Armazenamento de Dados do Conhecimento',
vectorSpaceTooltip: 'Documentos com o modo de indexação de Alta Qualidade consumirã recursos de Armazenamento de Dados de Conhecimento. Quando o Armazenamento de Dados de Conhecimento atingir o limite, novos documentos não serão carregados.',
buildApps: 'Desenvolver Apps',
+ perMonth: 'por mês',
+ triggerEvents: 'Eventos Desencadeadores',
},
teamMembers: 'Membros da equipe',
+ triggerLimitModal: {
+ dismiss: 'Dispensar',
+ usageTitle: 'EVENTOS DESENCADEADORES',
+ title: 'Atualize para desbloquear mais eventos de gatilho',
+ upgrade: 'Atualizar',
+ description: 'Você atingiu o limite de gatilhos de eventos de fluxo de trabalho para este plano.',
+ },
}
export default translation
diff --git a/web/i18n/ro-RO/billing.ts b/web/i18n/ro-RO/billing.ts
index 7e0118fa31..8b25b6e23d 100644
--- a/web/i18n/ro-RO/billing.ts
+++ b/web/i18n/ro-RO/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Începeți să construiți',
taxTip: 'Toate prețurile abonamentelor (lunare/anuale) nu includ taxele aplicabile (de exemplu, TVA, taxa pe vânzări).',
taxTipSecond: 'Dacă regiunea dumneavoastră nu are cerințe fiscale aplicabile, niciun impozit nu va apărea la finalizarea comenzii și nu vi se vor percepe taxe suplimentare pe întreaga durată a abonamentului.',
+ triggerEvents: {
+ unlimited: 'Evenimente de declanșare nelimitate',
+ tooltip: 'Numărul de evenimente care pornesc automat fluxuri de lucru prin declanșatoare Plugin, Programare sau Webhook.',
+ },
+ workflowExecution: {
+ faster: 'Executarea mai rapidă a fluxului de lucru',
+ standard: 'Executarea fluxului de lucru standard',
+ tooltip: 'Prioritatea și viteza cozii de execuție a fluxului de lucru.',
+ priority: 'Executarea fluxului de lucru prioritar',
+ },
+ startNodes: {
+ unlimited: 'Declanșatori/workflow nelimitați',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
teamMembers: 'Membrii echipei',
annotationQuota: 'Cota de Anotare',
documentsUploadQuota: 'Cota de încărcare a documentelor',
+ triggerEvents: 'Evenimente declanșatoare',
+ perMonth: 'pe lună',
},
teamMembers: 'Membrii echipei',
+ triggerLimitModal: {
+ dismiss: 'Respinge',
+ upgrade: 'Actualizare',
+ usageTitle: 'EVENIMENTE TRIGER',
+ description: 'Ai atins limita de declanșatoare de evenimente de flux de lucru pentru acest plan.',
+ title: 'Actualizează pentru a debloca mai multe evenimente declanșatoare',
+ },
}
export default translation
diff --git a/web/i18n/ru-RU/billing.ts b/web/i18n/ru-RU/billing.ts
index 68466e0df8..cfebc8a914 100644
--- a/web/i18n/ru-RU/billing.ts
+++ b/web/i18n/ru-RU/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Начать строительство',
taxTip: 'Все цены на подписку (ежемесячную/годовую) не включают применимые налоги (например, НДС, налог с продаж).',
taxTipSecond: 'Если в вашем регионе нет применимых налоговых требований, налоги не будут отображаться при оформлении заказа, и с вас не будут взиматься дополнительные сборы за весь срок подписки.',
+ triggerEvents: {
+ unlimited: 'Неограниченные триггерные события',
+ tooltip: 'Количество событий, которые автоматически запускают рабочие процессы с помощью плагина, расписания или вебхука.',
+ },
+ workflowExecution: {
+ faster: 'Более быстрое выполнение рабочих процессов',
+ standard: 'Стандартное выполнение рабочего процесса',
+ tooltip: 'Приоритет и скорость выполнения очереди рабочих процессов.',
+ priority: 'Выполнение рабочего процесса по приоритету',
+ },
+ startNodes: {
+ unlimited: 'Неограниченные триггеры/рабочий процесс',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
annotationQuota: 'Квота аннотации',
vectorSpace: 'Хранилище данных знаний',
documentsUploadQuota: 'Квота на загрузку документов',
+ perMonth: 'в месяц',
+ triggerEvents: 'Триггерные события',
},
teamMembers: 'Члены команды',
+ triggerLimitModal: {
+ upgrade: 'Обновить',
+ dismiss: 'Отклонить',
+ usageTitle: 'СОБЫТИЯ-ИНИЦИАТОРЫ',
+ description: 'Вы достигли предела триггеров событий рабочего процесса для этого плана.',
+ title: 'Обновите, чтобы открыть больше событий срабатывания',
+ },
}
export default translation
diff --git a/web/i18n/sl-SI/billing.ts b/web/i18n/sl-SI/billing.ts
index 33dde5dec3..ac5c3ebb03 100644
--- a/web/i18n/sl-SI/billing.ts
+++ b/web/i18n/sl-SI/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Začnite graditi',
taxTip: 'Vse cene naročnin (mesečne/letne) ne vključujejo veljavnih davkov (npr. DDV, davek na promet).',
taxTipSecond: 'Če vaša regija nima veljavnih davčnih zahtev, se v vaši košarici ne bo prikazal noben davek in za celotno obdobje naročnine vam ne bodo zaračunani nobeni dodatni stroški.',
+ triggerEvents: {
+ unlimited: 'Neomejeni sprožilni dogodki',
+ tooltip: 'Število dogodkov, ki samodejno sprožijo delovne tokove prek vtičnika, urnika ali sprožilcev spletnih klicev.',
+ },
+ workflowExecution: {
+ standard: 'Izvajanje standardnega delovnega procesa',
+ priority: 'Izvajanje prednostnega poteka dela',
+ tooltip: 'Prednostna vrstni red in hitrost izvajanja delovnega toka.',
+ faster: 'Hitrejše izvajanje delovnega procesa',
+ },
+ startNodes: {
+ unlimited: 'Neomejeni sprožilci/poteki dela',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
annotationQuota: 'Quota za anotacijo',
teamMembers: 'Člani ekipe',
buildApps: 'Gradite aplikacije',
+ perMonth: 'na mesec',
+ triggerEvents: 'Sprožilni dogodki',
},
teamMembers: 'Člani ekipe',
+ triggerLimitModal: {
+ dismiss: 'Zavrni',
+ usageTitle: 'SPROŽITVENI DOGODKI',
+ description: 'Dosegli ste omejitev sprožilcev dogodkov delovnega toka za ta načrt.',
+ title: 'Nadgradite za odklep več sprožilnih dogodkov',
+ upgrade: 'Nadgradnja',
+ },
}
export default translation
diff --git a/web/i18n/th-TH/billing.ts b/web/i18n/th-TH/billing.ts
index e486de61d4..2119a412f8 100644
--- a/web/i18n/th-TH/billing.ts
+++ b/web/i18n/th-TH/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'เริ่มสร้าง',
taxTip: 'ราคาการสมัครสมาชิกทั้งหมด (รายเดือน/รายปี) ไม่รวมภาษีที่ใช้บังคับ (เช่น ภาษีมูลค่าเพิ่ม, ภาษีการขาย)',
taxTipSecond: 'หากภูมิภาคของคุณไม่มีข้อกำหนดเกี่ยวกับภาษีที่ใช้ได้ จะไม่มีการคิดภาษีในขั้นตอนการชำระเงินของคุณ และคุณจะไม่ถูกเรียกเก็บค่าธรรมเนียมเพิ่มเติมใด ๆ ตลอดระยะเวลาสมาชิกทั้งหมด',
+ triggerEvents: {
+ unlimited: 'เหตุการณ์ทริกเกอร์ไม่จำกัด',
+ tooltip: 'จำนวนเหตุการณ์ที่เริ่มเวิร์กโฟลว์โดยอัตโนมัติผ่านปลั๊กอิน ตารางเวลา หรือทริกเกอร์เว็บฮุก',
+ },
+ workflowExecution: {
+ standard: 'การดำเนินงานเวิร์กโฟลว์มาตรฐาน',
+ priority: 'การดำเนินงานลำดับความสำคัญ',
+ tooltip: 'ลำดับความสำคัญและความเร็วของคิวการดำเนินงานของเวิร์กโฟลว์',
+ faster: 'การดำเนินงานเวิร์กโฟลว์ที่รวดเร็วขึ้น',
+ },
+ startNodes: {
+ unlimited: 'ทริกเกอร์/เวิร์กโฟลว์ไม่จำกัด',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
teamMembers: 'สมาชิกในทีม',
vectorSpace: 'การจัดเก็บข้อมูลความรู้',
vectorSpaceTooltip: 'เอกสารที่ใช้โหมดการจัดทำดัชนีคุณภาพสูงจะใช้ทรัพยากรเก็บข้อมูลความรู้ เมื่อการเก็บข้อมูลความรู้ถึงขีดจำกัด เอกสารใหม่จะไม่สามารถอัปโหลดได้.',
+ triggerEvents: 'เหตุการณ์กระตุ้น',
+ perMonth: 'ต่อเดือน',
},
teamMembers: 'สมาชิกในทีม',
+ triggerLimitModal: {
+ upgrade: 'อัปเกรด',
+ dismiss: 'ปฏิเสธ',
+ usageTitle: 'เหตุการณ์ทริกเกอร์',
+ title: 'อัปเกรดเพื่อปลดล็อกเหตุการณ์ทริกเกอร์เพิ่มเติม',
+ description: 'คุณได้ถึงขีดจำกัดของทริกเกอร์เหตุการณ์เวิร์กโฟลว์สำหรับแผนนี้แล้ว',
+ },
}
export default translation
diff --git a/web/i18n/tr-TR/billing.ts b/web/i18n/tr-TR/billing.ts
index 36fcadb404..f94bbfe009 100644
--- a/web/i18n/tr-TR/billing.ts
+++ b/web/i18n/tr-TR/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'İnşa Etmeye Başlayın',
taxTip: 'Tüm abonelik fiyatları (aylık/yıllık) geçerli vergiler (ör. KDV, satış vergisi) hariçtir.',
taxTipSecond: 'Bölgenizde geçerli vergi gereksinimleri yoksa, ödeme sayfanızda herhangi bir vergi görünmeyecek ve tüm abonelik süresi boyunca ek bir ücret tahsil edilmeyecektir.',
+ triggerEvents: {
+ unlimited: 'Sınırsız Tetikleme Olayları',
+ tooltip: 'Eklenti, Zamanlama veya Webhook tetikleyicileri aracılığıyla iş akışlarını otomatik olarak başlatan etkinliklerin sayısı.',
+ },
+ workflowExecution: {
+ faster: 'Daha Hızlı İş Akışı Yürütme',
+ tooltip: 'İş akışı yürütme kuyruğu önceliği ve hızı.',
+ priority: 'Öncelikli İş Akışı Yürütme',
+ standard: 'Standart İş Akışı Yürütme',
+ },
+ startNodes: {
+ unlimited: 'Sınırsız Tetikleyiciler/iş akışı',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
buildApps: 'Uygulama Geliştir',
annotationQuota: 'Notlandırma Kotası',
documentsUploadQuota: 'Belgeler Yükleme Kotası',
+ triggerEvents: 'Tetikleyici Olaylar',
+ perMonth: 'ayda',
},
teamMembers: 'Ekip Üyeleri',
+ triggerLimitModal: {
+ upgrade: 'Güncelle',
+ title: 'Daha fazla tetikleyici olayı açmak için yükseltin',
+ dismiss: 'Kapat',
+ description: 'Bu plan için iş akışı etkinliği tetikleyici sınırına ulaştınız.',
+ usageTitle: 'TETİKLEYİCİ OLAYLAR',
+ },
}
export default translation
diff --git a/web/i18n/uk-UA/billing.ts b/web/i18n/uk-UA/billing.ts
index d5967d0ff0..3b326b18fb 100644
--- a/web/i18n/uk-UA/billing.ts
+++ b/web/i18n/uk-UA/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Почніть будувати',
taxTip: 'Всі ціни на підписку (щомісячна/щорічна) не включають відповідні податки (наприклад, ПДВ, податок з продажу).',
taxTipSecond: 'Якщо для вашого регіону немає відповідних податкових вимог, податок не відображатиметься на вашому чек-ауті, і з вас не стягуватимуть додаткові збори протягом усього терміну підписки.',
+ triggerEvents: {
+ unlimited: 'Необмежена кількість тригерних подій',
+ tooltip: 'Кількість подій, які автоматично запускають робочі процеси через тригери Плагіна, Розкладу або Вебхука.',
+ },
+ workflowExecution: {
+ faster: 'Швидше виконання робочого процесу',
+ standard: 'Виконання стандартного робочого процесу',
+ priority: 'Виконання пріоритетного робочого процесу',
+ tooltip: 'Пріоритет і швидкість виконання черги робочого процесу.',
+ },
+ startNodes: {
+ unlimited: 'Необмежені тригери/робочі процеси',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
vectorSpaceTooltip: 'Документи з режимом індексування високої якості споживатимуть ресурси Сховища Знань. Коли Сховище Знань досягне межі, нові документи не будуть завантажені.',
documentsUploadQuota: 'Квота на завантаження документів',
vectorSpace: 'Сховище даних знань',
+ perMonth: 'на місяць',
+ triggerEvents: 'Тригерні події',
},
teamMembers: 'Члени команди',
+ triggerLimitModal: {
+ upgrade: 'Оновити',
+ dismiss: 'Закрити',
+ usageTitle: 'ПОДІЇ-ТРИГЕРИ',
+ title: 'Оновіть, щоб розблокувати більше подій-тригерів',
+ description: 'Ви досягли ліміту тригерів подій робочого процесу для цього плану.',
+ },
}
export default translation
diff --git a/web/i18n/vi-VN/billing.ts b/web/i18n/vi-VN/billing.ts
index 837dde499b..92421b700e 100644
--- a/web/i18n/vi-VN/billing.ts
+++ b/web/i18n/vi-VN/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: 'Bắt đầu xây dựng',
taxTipSecond: 'Nếu khu vực của bạn không có yêu cầu thuế áp dụng, sẽ không có thuế xuất hiện trong quá trình thanh toán của bạn và bạn sẽ không bị tính bất kỳ khoản phí bổ sung nào trong suốt thời gian đăng ký.',
taxTip: 'Tất cả giá đăng ký (hàng tháng/hàng năm) chưa bao gồm các loại thuế áp dụng (ví dụ: VAT, thuế bán hàng).',
+ triggerEvents: {
+ unlimited: 'Sự kiện Kích hoạt Không giới hạn',
+ tooltip: 'Số lượng sự kiện tự động kích hoạt quy trình làm việc thông qua Plugin, Lịch trình hoặc Webhook.',
+ },
+ workflowExecution: {
+ faster: 'Thực hiện quy trình làm việc nhanh hơn',
+ priority: 'Thực thi Quy trình Làm việc Ưu tiên',
+ tooltip: 'Ưu tiên và tốc độ hàng đợi thực thi quy trình làm việc.',
+ standard: 'Thực thi Quy trình Làm việc Chuẩn',
+ },
+ startNodes: {
+ unlimited: 'Kích hoạt/quy trình làm việc không giới hạn',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
teamMembers: 'Các thành viên trong nhóm',
vectorSpace: 'Lưu trữ dữ liệu kiến thức',
buildApps: 'Xây dựng ứng dụng',
+ triggerEvents: 'Các sự kiện kích hoạt',
+ perMonth: 'mỗi tháng',
},
teamMembers: 'Các thành viên trong nhóm',
+ triggerLimitModal: {
+ upgrade: 'Nâng cấp',
+ dismiss: 'Đóng',
+ usageTitle: 'SỰ KIỆN KÍCH HOẠT',
+ description: 'Bạn đã đạt đến giới hạn kích hoạt sự kiện quy trình cho gói này.',
+ title: 'Nâng cấp để mở khóa thêm nhiều sự kiện kích hoạt',
+ },
}
export default translation
diff --git a/web/i18n/zh-Hant/billing.ts b/web/i18n/zh-Hant/billing.ts
index 7f1be09008..b83cf5eb15 100644
--- a/web/i18n/zh-Hant/billing.ts
+++ b/web/i18n/zh-Hant/billing.ts
@@ -96,6 +96,19 @@ const translation = {
startBuilding: '開始建造',
taxTip: '所有訂閱價格（月費/年費）不包含適用的稅費（例如增值稅、銷售稅）。',
taxTipSecond: '如果您的地區沒有適用的稅務要求，結帳時將不會顯示任何稅款，且在整個訂閱期間您也不會被收取任何額外費用。',
+ triggerEvents: {
+ unlimited: '無限觸發事件',
+ tooltip: '透過插件、排程或 Webhook 觸發器自動啟動工作流程的事件數量。',
+ },
+ workflowExecution: {
+ standard: '標準工作流程執行',
+ priority: '優先工作流程執行',
+ faster: '更快速的工作流程執行',
+ tooltip: '工作流程執行隊列的優先順序與速度。',
+ },
+ startNodes: {
+ unlimited: '無限觸發器/工作流程',
+ },
},
plans: {
sandbox: {
@@ -186,8 +199,17 @@ const translation = {
vectorSpace: '知識數據儲存',
buildApps: '建構應用程式',
teamMembers: '團隊成員',
+ perMonth: '每月',
+ triggerEvents: '觸發事件',
},
teamMembers: '團隊成員',
+ triggerLimitModal: {
+ dismiss: '關閉',
+ description: '您已達到此方案的工作流程事件觸發上限。',
+ usageTitle: '觸發事件',
+ title: '升級以解鎖更多觸發事件',
+ upgrade: '升級',
+ },
}
export default translation
From 3cf19dc07f254b3cd7658b92324b6cb911382908 Mon Sep 17 00:00:00 2001
From: Asuka Minato
Date: Fri, 21 Nov 2025 11:36:41 +0900
Subject: [PATCH 023/191] add two test examples (#28236)
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
api/app_factory.py | 1 +
.../datasource_content_preview.py | 33 +++++++------
.../service_api/dataset/document.py | 48 +++++++++++--------
3 files changed, 46 insertions(+), 36 deletions(-)
diff --git a/api/app_factory.py b/api/app_factory.py
index 17c376de77..933cf294d1 100644
--- a/api/app_factory.py
+++ b/api/app_factory.py
@@ -18,6 +18,7 @@ def create_flask_app_with_configs() -> DifyApp:
"""
dify_app = DifyApp(__name__)
dify_app.config.from_mapping(dify_config.model_dump())
+ dify_app.config["RESTX_INCLUDE_ALL_MODELS"] = True
# add before request hook
@dify_app.before_request
diff --git a/api/controllers/console/datasets/rag_pipeline/datasource_content_preview.py b/api/controllers/console/datasets/rag_pipeline/datasource_content_preview.py
index d413def27f..5e3b3428eb 100644
--- a/api/controllers/console/datasets/rag_pipeline/datasource_content_preview.py
+++ b/api/controllers/console/datasets/rag_pipeline/datasource_content_preview.py
@@ -1,7 +1,7 @@
from flask_restx import ( # type: ignore
Resource, # type: ignore
- reqparse,
)
+from pydantic import BaseModel
from werkzeug.exceptions import Forbidden
from controllers.console import api, console_ns
@@ -12,17 +12,21 @@ from models import Account
from models.dataset import Pipeline
from services.rag_pipeline.rag_pipeline import RagPipelineService
-parser = (
- reqparse.RequestParser()
- .add_argument("inputs", type=dict, required=True, nullable=False, location="json")
- .add_argument("datasource_type", type=str, required=True, location="json")
- .add_argument("credential_id", type=str, required=False, location="json")
-)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class Parser(BaseModel):
+ inputs: dict
+ datasource_type: str
+ credential_id: str | None = None
+
+
+console_ns.schema_model(Parser.__name__, Parser.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0))
@console_ns.route("/rag/pipelines//workflows/published/datasource/nodes//preview")
class DataSourceContentPreviewApi(Resource):
- @api.expect(parser)
+ @api.expect(console_ns.models[Parser.__name__], validate=True)
@setup_required
@login_required
@account_initialization_required
@@ -34,15 +38,10 @@ class DataSourceContentPreviewApi(Resource):
if not isinstance(current_user, Account):
raise Forbidden()
- args = parser.parse_args()
-
- inputs = args.get("inputs")
- if inputs is None:
- raise ValueError("missing inputs")
- datasource_type = args.get("datasource_type")
- if datasource_type is None:
- raise ValueError("missing datasource_type")
+ args = Parser.model_validate(api.payload)
+ inputs = args.inputs
+ datasource_type = args.datasource_type
rag_pipeline_service = RagPipelineService()
preview_content = rag_pipeline_service.run_datasource_node_preview(
pipeline=pipeline,
@@ -51,6 +50,6 @@ class DataSourceContentPreviewApi(Resource):
account=current_user,
datasource_type=datasource_type,
is_published=True,
- credential_id=args.get("credential_id"),
+ credential_id=args.credential_id,
)
return preview_content, 200
diff --git a/api/controllers/service_api/dataset/document.py b/api/controllers/service_api/dataset/document.py
index 7c525845a7..ed47e706b6 100644
--- a/api/controllers/service_api/dataset/document.py
+++ b/api/controllers/service_api/dataset/document.py
@@ -1,7 +1,10 @@
import json
+from typing import Self
+from uuid import UUID
from flask import request
from flask_restx import marshal, reqparse
+from pydantic import BaseModel, model_validator
from sqlalchemy import desc, select
from werkzeug.exceptions import Forbidden, NotFound
@@ -31,7 +34,7 @@ from fields.document_fields import document_fields, document_status_fields
from libs.login import current_user
from models.dataset import Dataset, Document, DocumentSegment
from services.dataset_service import DatasetService, DocumentService
-from services.entities.knowledge_entities.knowledge_entities import KnowledgeConfig
+from services.entities.knowledge_entities.knowledge_entities import KnowledgeConfig, ProcessRule, RetrievalModel
from services.file_service import FileService
# Define parsers for document operations
@@ -51,15 +54,26 @@ document_text_create_parser = (
.add_argument("embedding_model_provider", type=str, required=False, nullable=True, location="json")
)
-document_text_update_parser = (
- reqparse.RequestParser()
- .add_argument("name", type=str, required=False, nullable=True, location="json")
- .add_argument("text", type=str, required=False, nullable=True, location="json")
- .add_argument("process_rule", type=dict, required=False, nullable=True, location="json")
- .add_argument("doc_form", type=str, default="text_model", required=False, nullable=False, location="json")
- .add_argument("doc_language", type=str, default="English", required=False, nullable=False, location="json")
- .add_argument("retrieval_model", type=dict, required=False, nullable=False, location="json")
-)
+DEFAULT_REF_TEMPLATE_SWAGGER_2_0 = "#/definitions/{model}"
+
+
+class DocumentTextUpdate(BaseModel):
+ name: str | None = None
+ text: str | None = None
+ process_rule: ProcessRule | None = None
+ doc_form: str = "text_model"
+ doc_language: str = "English"
+ retrieval_model: RetrievalModel | None = None
+
+ @model_validator(mode="after")
+ def check_text_and_name(self) -> Self:
+ if self.text is not None and self.name is None:
+ raise ValueError("name is required when text is provided")
+ return self
+
+
+for m in [ProcessRule, RetrievalModel, DocumentTextUpdate]:
+ service_api_ns.schema_model(m.__name__, m.model_json_schema(ref_template=DEFAULT_REF_TEMPLATE_SWAGGER_2_0)) # type: ignore
@service_api_ns.route(
@@ -160,7 +174,7 @@ class DocumentAddByTextApi(DatasetApiResource):
class DocumentUpdateByTextApi(DatasetApiResource):
"""Resource for update documents."""
- @service_api_ns.expect(document_text_update_parser)
+ @service_api_ns.expect(service_api_ns.models[DocumentTextUpdate.__name__], validate=True)
@service_api_ns.doc("update_document_by_text")
@service_api_ns.doc(description="Update an existing document by providing text content")
@service_api_ns.doc(params={"dataset_id": "Dataset ID", "document_id": "Document ID"})
@@ -173,12 +187,10 @@ class DocumentUpdateByTextApi(DatasetApiResource):
)
@cloud_edition_billing_resource_check("vector_space", "dataset")
@cloud_edition_billing_rate_limit_check("knowledge", "dataset")
- def post(self, tenant_id, dataset_id, document_id):
+ def post(self, tenant_id: str, dataset_id: UUID, document_id: UUID):
"""Update document by text."""
- args = document_text_update_parser.parse_args()
- dataset_id = str(dataset_id)
- tenant_id = str(tenant_id)
- dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == dataset_id).first()
+ args = DocumentTextUpdate.model_validate(service_api_ns.payload).model_dump(exclude_unset=True)
+ dataset = db.session.query(Dataset).where(Dataset.tenant_id == tenant_id, Dataset.id == str(dataset_id)).first()
if not dataset:
raise ValueError("Dataset does not exist.")
@@ -198,11 +210,9 @@ class DocumentUpdateByTextApi(DatasetApiResource):
# indexing_technique is already set in dataset since this is an update
args["indexing_technique"] = dataset.indexing_technique
- if args["text"]:
+ if args.get("text"):
text = args.get("text")
name = args.get("name")
- if text is None or name is None:
- raise ValueError("Both text and name must be strings.")
if not current_user:
raise ValueError("current_user is required")
upload_file = FileService(db.engine).upload_text(
From a4c4d18f427b0cce408602484c23fead304a5828 Mon Sep 17 00:00:00 2001
From: yangzheli <43645580+yangzheli@users.noreply.github.com>
Date: Fri, 21 Nov 2025 11:23:52 +0800
Subject: [PATCH 024/191] fix(api): add session_id validation for webapp JWT
authentication (#28297)
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
api/controllers/web/login.py | 3 ++-
api/controllers/web/wraps.py | 6 +++++-
web/app/(shareLayout)/components/splash.tsx | 2 +-
web/service/webapp-auth.ts | 7 +++++--
4 files changed, 13 insertions(+), 5 deletions(-)
diff --git a/api/controllers/web/login.py b/api/controllers/web/login.py
index 244ef47982..538d0c44be 100644
--- a/api/controllers/web/login.py
+++ b/api/controllers/web/login.py
@@ -81,6 +81,7 @@ class LoginStatusApi(Resource):
)
def get(self):
app_code = request.args.get("app_code")
+ user_id = request.args.get("user_id")
token = extract_webapp_access_token(request)
if not app_code:
return {
@@ -103,7 +104,7 @@ class LoginStatusApi(Resource):
user_logged_in = False
try:
- _ = decode_jwt_token(app_code=app_code)
+ _ = decode_jwt_token(app_code=app_code, user_id=user_id)
app_logged_in = True
except Exception:
app_logged_in = False
diff --git a/api/controllers/web/wraps.py b/api/controllers/web/wraps.py
index 9efd9f25d1..152137f39c 100644
--- a/api/controllers/web/wraps.py
+++ b/api/controllers/web/wraps.py
@@ -38,7 +38,7 @@ def validate_jwt_token(view: Callable[Concatenate[App, EndUser, P], R] | None =
return decorator
-def decode_jwt_token(app_code: str | None = None):
+def decode_jwt_token(app_code: str | None = None, user_id: str | None = None):
system_features = FeatureService.get_system_features()
if not app_code:
app_code = str(request.headers.get(HEADER_NAME_APP_CODE))
@@ -63,6 +63,10 @@ def decode_jwt_token(app_code: str | None = None):
if not end_user:
raise NotFound()
+ # Validate user_id against end_user's session_id if provided
+ if user_id is not None and end_user.session_id != user_id:
+ raise Unauthorized("Authentication has expired.")
+
# for enterprise webapp auth
app_web_auth_enabled = False
webapp_settings = None
diff --git a/web/app/(shareLayout)/components/splash.tsx b/web/app/(shareLayout)/components/splash.tsx
index eb9538e49b..9315e79d20 100644
--- a/web/app/(shareLayout)/components/splash.tsx
+++ b/web/app/(shareLayout)/components/splash.tsx
@@ -58,7 +58,7 @@ const Splash: FC = ({ children }) => {
(async () => {
// if access mode is public, user login is always true, but the app login(passport) may be expired
- const { userLoggedIn, appLoggedIn } = await webAppLoginStatus(shareCode!)
+ const { userLoggedIn, appLoggedIn } = await webAppLoginStatus(shareCode!, embeddedUserId || undefined)
if (userLoggedIn && appLoggedIn) {
redirectOrFinish()
}
diff --git a/web/service/webapp-auth.ts b/web/service/webapp-auth.ts
index e7e3f86406..7a9abd9599 100644
--- a/web/service/webapp-auth.ts
+++ b/web/service/webapp-auth.ts
@@ -30,10 +30,13 @@ type isWebAppLogin = {
app_logged_in: boolean
}
-export async function webAppLoginStatus(shareCode: string) {
+export async function webAppLoginStatus(shareCode: string, userId?: string) {
// always need to check login to prevent passport from being outdated
// check remotely, the access token could be in cookie (enterprise SSO redirected with https)
- const { logged_in, app_logged_in } = await getPublic(`/login/status?app_code=${shareCode}`)
+ const params = new URLSearchParams({ app_code: shareCode })
+ if (userId)
+ params.append('user_id', userId)
+ const { logged_in, app_logged_in } = await getPublic(`/login/status?${params.toString()}`)
return {
userLoggedIn: logged_in,
appLoggedIn: app_logged_in,
From ae5b5a6aa9b570d54944cc7ffbe227f5972c4c76 Mon Sep 17 00:00:00 2001
From: znn
Date: Fri, 21 Nov 2025 10:24:26 +0700
Subject: [PATCH 025/191] disable sticky scroll (#28248)
---
.../workflow/nodes/_base/components/editor/code-editor/index.tsx | 1 +
1 file changed, 1 insertion(+)
diff --git a/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx b/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx
index 691e079b4e..2a69161bef 100644
--- a/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx
+++ b/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx
@@ -161,6 +161,7 @@ const CodeEditor: FC = ({
unicodeHighlight: {
ambiguousCharacters: false,
},
+ stickyScroll: { enabled: false },
}}
onMount={handleEditorDidMount}
/>
From c5b6219006bb549aed1148a350d3d763a82d4b0a Mon Sep 17 00:00:00 2001
From: Gritty_dev <101377478+codomposer@users.noreply.github.com>
Date: Thu, 20 Nov 2025 23:54:50 -0500
Subject: [PATCH 026/191] Feat/add test script for account models (#28479)
---
.../unit_tests/models/test_account_models.py | 886 ++++++++++++++++++
1 file changed, 886 insertions(+)
create mode 100644 api/tests/unit_tests/models/test_account_models.py
diff --git a/api/tests/unit_tests/models/test_account_models.py b/api/tests/unit_tests/models/test_account_models.py
new file mode 100644
index 0000000000..cc311d447f
--- /dev/null
+++ b/api/tests/unit_tests/models/test_account_models.py
@@ -0,0 +1,886 @@
+"""
+Comprehensive unit tests for Account model.
+
+This test suite covers:
+- Account model validation
+- Password hashing/verification
+- Account status transitions
+- Tenant relationship integrity
+- Email uniqueness constraints
+"""
+
+import base64
+import secrets
+from datetime import UTC, datetime
+from unittest.mock import MagicMock, patch
+from uuid import uuid4
+
+import pytest
+
+from libs.password import compare_password, hash_password, valid_password
+from models.account import Account, AccountStatus, Tenant, TenantAccountJoin, TenantAccountRole
+
+
+class TestAccountModelValidation:
+ """Test suite for Account model validation and basic operations."""
+
+ def test_account_creation_with_required_fields(self):
+ """Test creating an account with all required fields."""
+ # Arrange & Act
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ password="hashed_password",
+ password_salt="salt_value",
+ )
+
+ # Assert
+ assert account.name == "Test User"
+ assert account.email == "test@example.com"
+ assert account.password == "hashed_password"
+ assert account.password_salt == "salt_value"
+ assert account.status == "active" # Default value
+
+ def test_account_creation_with_optional_fields(self):
+ """Test creating an account with optional fields."""
+ # Arrange & Act
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ avatar="https://example.com/avatar.png",
+ interface_language="en-US",
+ interface_theme="dark",
+ timezone="America/New_York",
+ )
+
+ # Assert
+ assert account.avatar == "https://example.com/avatar.png"
+ assert account.interface_language == "en-US"
+ assert account.interface_theme == "dark"
+ assert account.timezone == "America/New_York"
+
+ def test_account_creation_without_password(self):
+ """Test creating an account without password (for invite-based registration)."""
+ # Arrange & Act
+ account = Account(
+ name="Invited User",
+ email="invited@example.com",
+ )
+
+ # Assert
+ assert account.password is None
+ assert account.password_salt is None
+ assert not account.is_password_set
+
+ def test_account_is_password_set_property(self):
+ """Test the is_password_set property."""
+ # Arrange
+ account_with_password = Account(
+ name="User With Password",
+ email="withpass@example.com",
+ password="hashed_password",
+ )
+ account_without_password = Account(
+ name="User Without Password",
+ email="nopass@example.com",
+ )
+
+ # Assert
+ assert account_with_password.is_password_set
+ assert not account_without_password.is_password_set
+
+ def test_account_default_status(self):
+ """Test that account has default status of 'active'."""
+ # Arrange & Act
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+
+ # Assert
+ assert account.status == "active"
+
+ def test_account_get_status_method(self):
+ """Test the get_status method returns AccountStatus enum."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ status="pending",
+ )
+
+ # Act
+ status = account.get_status()
+
+ # Assert
+ assert status == AccountStatus.PENDING
+ assert isinstance(status, AccountStatus)
+
+
+class TestPasswordHashingAndVerification:
+ """Test suite for password hashing and verification functionality."""
+
+ def test_password_hashing_produces_consistent_result(self):
+ """Test that hashing the same password with the same salt produces the same result."""
+ # Arrange
+ password = "TestPassword123"
+ salt = secrets.token_bytes(16)
+
+ # Act
+ hash1 = hash_password(password, salt)
+ hash2 = hash_password(password, salt)
+
+ # Assert
+ assert hash1 == hash2
+
+ def test_password_hashing_different_salts_produce_different_hashes(self):
+ """Test that different salts produce different hashes for the same password."""
+ # Arrange
+ password = "TestPassword123"
+ salt1 = secrets.token_bytes(16)
+ salt2 = secrets.token_bytes(16)
+
+ # Act
+ hash1 = hash_password(password, salt1)
+ hash2 = hash_password(password, salt2)
+
+ # Assert
+ assert hash1 != hash2
+
+ def test_password_comparison_success(self):
+ """Test successful password comparison."""
+ # Arrange
+ password = "TestPassword123"
+ salt = secrets.token_bytes(16)
+ password_hashed = hash_password(password, salt)
+
+ # Encode to base64 as done in the application
+ base64_salt = base64.b64encode(salt).decode()
+ base64_password_hashed = base64.b64encode(password_hashed).decode()
+
+ # Act
+ result = compare_password(password, base64_password_hashed, base64_salt)
+
+ # Assert
+ assert result is True
+
+ def test_password_comparison_failure(self):
+ """Test password comparison with wrong password."""
+ # Arrange
+ correct_password = "TestPassword123"
+ wrong_password = "WrongPassword456"
+ salt = secrets.token_bytes(16)
+ password_hashed = hash_password(correct_password, salt)
+
+ # Encode to base64
+ base64_salt = base64.b64encode(salt).decode()
+ base64_password_hashed = base64.b64encode(password_hashed).decode()
+
+ # Act
+ result = compare_password(wrong_password, base64_password_hashed, base64_salt)
+
+ # Assert
+ assert result is False
+
+ def test_valid_password_with_correct_format(self):
+ """Test password validation with correct format."""
+ # Arrange
+ valid_passwords = [
+ "Password123",
+ "Test1234",
+ "MySecure1Pass",
+ "abcdefgh1",
+ ]
+
+ # Act & Assert
+ for password in valid_passwords:
+ result = valid_password(password)
+ assert result == password
+
+ def test_valid_password_with_incorrect_format(self):
+ """Test password validation with incorrect format."""
+ # Arrange
+ invalid_passwords = [
+ "short1", # Too short
+ "NoNumbers", # No numbers
+ "12345678", # No letters
+ "Pass1", # Too short
+ ]
+
+ # Act & Assert
+ for password in invalid_passwords:
+ with pytest.raises(ValueError, match="Password must contain letters and numbers"):
+ valid_password(password)
+
+ def test_password_hashing_integration_with_account(self):
+ """Test password hashing integration with Account model."""
+ # Arrange
+ password = "SecurePass123"
+ salt = secrets.token_bytes(16)
+ base64_salt = base64.b64encode(salt).decode()
+ password_hashed = hash_password(password, salt)
+ base64_password_hashed = base64.b64encode(password_hashed).decode()
+
+ # Act
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ password=base64_password_hashed,
+ password_salt=base64_salt,
+ )
+
+ # Assert
+ assert account.is_password_set
+ assert compare_password(password, account.password, account.password_salt)
+
+
+class TestAccountStatusTransitions:
+ """Test suite for account status transitions."""
+
+ def test_account_status_enum_values(self):
+ """Test that AccountStatus enum has all expected values."""
+ # Assert
+ assert AccountStatus.PENDING == "pending"
+ assert AccountStatus.UNINITIALIZED == "uninitialized"
+ assert AccountStatus.ACTIVE == "active"
+ assert AccountStatus.BANNED == "banned"
+ assert AccountStatus.CLOSED == "closed"
+
+ def test_account_status_transition_pending_to_active(self):
+ """Test transitioning account status from pending to active."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ status=AccountStatus.PENDING,
+ )
+
+ # Act
+ account.status = AccountStatus.ACTIVE
+ account.initialized_at = datetime.now(UTC)
+
+ # Assert
+ assert account.get_status() == AccountStatus.ACTIVE
+ assert account.initialized_at is not None
+
+ def test_account_status_transition_active_to_banned(self):
+ """Test transitioning account status from active to banned."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ status=AccountStatus.ACTIVE,
+ )
+
+ # Act
+ account.status = AccountStatus.BANNED
+
+ # Assert
+ assert account.get_status() == AccountStatus.BANNED
+
+ def test_account_status_transition_active_to_closed(self):
+ """Test transitioning account status from active to closed."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ status=AccountStatus.ACTIVE,
+ )
+
+ # Act
+ account.status = AccountStatus.CLOSED
+
+ # Assert
+ assert account.get_status() == AccountStatus.CLOSED
+
+ def test_account_status_uninitialized(self):
+ """Test account with uninitialized status."""
+ # Arrange & Act
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ status=AccountStatus.UNINITIALIZED,
+ )
+
+ # Assert
+ assert account.get_status() == AccountStatus.UNINITIALIZED
+ assert account.initialized_at is None
+
+
+class TestTenantRelationshipIntegrity:
+ """Test suite for tenant relationship integrity."""
+
+ @patch("models.account.db")
+ def test_account_current_tenant_property(self, mock_db):
+ """Test the current_tenant property getter."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.id = str(uuid4())
+
+ tenant = Tenant(name="Test Tenant")
+ tenant.id = str(uuid4())
+
+ account._current_tenant = tenant
+
+ # Act
+ result = account.current_tenant
+
+ # Assert
+ assert result == tenant
+
+ @patch("models.account.Session")
+ @patch("models.account.db")
+ def test_account_current_tenant_setter_with_valid_tenant(self, mock_db, mock_session_class):
+ """Test setting current_tenant with a valid tenant relationship."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.id = str(uuid4())
+
+ tenant = Tenant(name="Test Tenant")
+ tenant.id = str(uuid4())
+
+ # Mock the session and queries
+ mock_session = MagicMock()
+ mock_session_class.return_value.__enter__.return_value = mock_session
+
+ # Mock TenantAccountJoin query result
+ tenant_join = TenantAccountJoin(
+ tenant_id=tenant.id,
+ account_id=account.id,
+ role=TenantAccountRole.OWNER,
+ )
+ mock_session.scalar.return_value = tenant_join
+
+ # Mock Tenant query result
+ mock_session.scalars.return_value.one.return_value = tenant
+
+ # Act
+ account.current_tenant = tenant
+
+ # Assert
+ assert account._current_tenant == tenant
+ assert account.role == TenantAccountRole.OWNER
+
+ @patch("models.account.Session")
+ @patch("models.account.db")
+ def test_account_current_tenant_setter_without_relationship(self, mock_db, mock_session_class):
+ """Test setting current_tenant when no relationship exists."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.id = str(uuid4())
+
+ tenant = Tenant(name="Test Tenant")
+ tenant.id = str(uuid4())
+
+ # Mock the session and queries
+ mock_session = MagicMock()
+ mock_session_class.return_value.__enter__.return_value = mock_session
+
+ # Mock no TenantAccountJoin found
+ mock_session.scalar.return_value = None
+
+ # Act
+ account.current_tenant = tenant
+
+ # Assert
+ assert account._current_tenant is None
+
+ def test_account_current_tenant_id_property(self):
+ """Test the current_tenant_id property."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ tenant = Tenant(name="Test Tenant")
+ tenant.id = str(uuid4())
+
+ # Act - with tenant
+ account._current_tenant = tenant
+ tenant_id = account.current_tenant_id
+
+ # Assert
+ assert tenant_id == tenant.id
+
+ # Act - without tenant
+ account._current_tenant = None
+ tenant_id_none = account.current_tenant_id
+
+ # Assert
+ assert tenant_id_none is None
+
+ @patch("models.account.Session")
+ @patch("models.account.db")
+ def test_account_set_tenant_id_method(self, mock_db, mock_session_class):
+ """Test the set_tenant_id method."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.id = str(uuid4())
+
+ tenant = Tenant(name="Test Tenant")
+ tenant.id = str(uuid4())
+
+ tenant_join = TenantAccountJoin(
+ tenant_id=tenant.id,
+ account_id=account.id,
+ role=TenantAccountRole.ADMIN,
+ )
+
+ # Mock the session and queries
+ mock_session = MagicMock()
+ mock_session_class.return_value.__enter__.return_value = mock_session
+ mock_session.execute.return_value.first.return_value = (tenant, tenant_join)
+
+ # Act
+ account.set_tenant_id(tenant.id)
+
+ # Assert
+ assert account._current_tenant == tenant
+ assert account.role == TenantAccountRole.ADMIN
+
+ @patch("models.account.Session")
+ @patch("models.account.db")
+ def test_account_set_tenant_id_with_no_relationship(self, mock_db, mock_session_class):
+ """Test set_tenant_id when no relationship exists."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.id = str(uuid4())
+ tenant_id = str(uuid4())
+
+ # Mock the session and queries
+ mock_session = MagicMock()
+ mock_session_class.return_value.__enter__.return_value = mock_session
+ mock_session.execute.return_value.first.return_value = None
+
+ # Act
+ account.set_tenant_id(tenant_id)
+
+ # Assert - should not set tenant when no relationship exists
+ # The method returns early without setting _current_tenant
+
+
+class TestAccountRolePermissions:
+ """Test suite for account role permissions."""
+
+ def test_is_admin_or_owner_with_admin_role(self):
+ """Test is_admin_or_owner property with admin role."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.role = TenantAccountRole.ADMIN
+
+ # Act & Assert
+ assert account.is_admin_or_owner
+
+ def test_is_admin_or_owner_with_owner_role(self):
+ """Test is_admin_or_owner property with owner role."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.role = TenantAccountRole.OWNER
+
+ # Act & Assert
+ assert account.is_admin_or_owner
+
+ def test_is_admin_or_owner_with_normal_role(self):
+ """Test is_admin_or_owner property with normal role."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ )
+ account.role = TenantAccountRole.NORMAL
+
+ # Act & Assert
+ assert not account.is_admin_or_owner
+
+ def test_is_admin_property(self):
+ """Test is_admin property."""
+ # Arrange
+ admin_account = Account(name="Admin", email="admin@example.com")
+ admin_account.role = TenantAccountRole.ADMIN
+
+ owner_account = Account(name="Owner", email="owner@example.com")
+ owner_account.role = TenantAccountRole.OWNER
+
+ # Act & Assert
+ assert admin_account.is_admin
+ assert not owner_account.is_admin
+
+ def test_has_edit_permission_with_editing_roles(self):
+ """Test has_edit_permission property with roles that have edit permission."""
+ # Arrange
+ roles_with_edit = [
+ TenantAccountRole.OWNER,
+ TenantAccountRole.ADMIN,
+ TenantAccountRole.EDITOR,
+ ]
+
+ for role in roles_with_edit:
+ account = Account(name="Test User", email=f"test_{role}@example.com")
+ account.role = role
+
+ # Act & Assert
+ assert account.has_edit_permission, f"Role {role} should have edit permission"
+
+ def test_has_edit_permission_without_editing_roles(self):
+ """Test has_edit_permission property with roles that don't have edit permission."""
+ # Arrange
+ roles_without_edit = [
+ TenantAccountRole.NORMAL,
+ TenantAccountRole.DATASET_OPERATOR,
+ ]
+
+ for role in roles_without_edit:
+ account = Account(name="Test User", email=f"test_{role}@example.com")
+ account.role = role
+
+ # Act & Assert
+ assert not account.has_edit_permission, f"Role {role} should not have edit permission"
+
+ def test_is_dataset_editor_property(self):
+ """Test is_dataset_editor property."""
+ # Arrange
+ dataset_roles = [
+ TenantAccountRole.OWNER,
+ TenantAccountRole.ADMIN,
+ TenantAccountRole.EDITOR,
+ TenantAccountRole.DATASET_OPERATOR,
+ ]
+
+ for role in dataset_roles:
+ account = Account(name="Test User", email=f"test_{role}@example.com")
+ account.role = role
+
+ # Act & Assert
+ assert account.is_dataset_editor, f"Role {role} should have dataset edit permission"
+
+ # Test normal role doesn't have dataset edit permission
+ normal_account = Account(name="Normal User", email="normal@example.com")
+ normal_account.role = TenantAccountRole.NORMAL
+ assert not normal_account.is_dataset_editor
+
+ def test_is_dataset_operator_property(self):
+ """Test is_dataset_operator property."""
+ # Arrange
+ dataset_operator = Account(name="Dataset Operator", email="operator@example.com")
+ dataset_operator.role = TenantAccountRole.DATASET_OPERATOR
+
+ normal_account = Account(name="Normal User", email="normal@example.com")
+ normal_account.role = TenantAccountRole.NORMAL
+
+ # Act & Assert
+ assert dataset_operator.is_dataset_operator
+ assert not normal_account.is_dataset_operator
+
+ def test_current_role_property(self):
+ """Test current_role property."""
+ # Arrange
+ account = Account(name="Test User", email="test@example.com")
+ account.role = TenantAccountRole.EDITOR
+
+ # Act
+ current_role = account.current_role
+
+ # Assert
+ assert current_role == TenantAccountRole.EDITOR
+
+
+class TestAccountGetByOpenId:
+ """Test suite for get_by_openid class method."""
+
+ @patch("models.account.db")
+ def test_get_by_openid_success(self, mock_db):
+ """Test successful retrieval of account by OpenID."""
+ # Arrange
+ provider = "google"
+ open_id = "google_user_123"
+ account_id = str(uuid4())
+
+ mock_account_integrate = MagicMock()
+ mock_account_integrate.account_id = account_id
+
+ mock_account = Account(name="Test User", email="test@example.com")
+ mock_account.id = account_id
+
+ # Mock the query chain
+ mock_query = MagicMock()
+ mock_where = MagicMock()
+ mock_where.one_or_none.return_value = mock_account_integrate
+ mock_query.where.return_value = mock_where
+ mock_db.session.query.return_value = mock_query
+
+ # Mock the second query for account
+ mock_account_query = MagicMock()
+ mock_account_where = MagicMock()
+ mock_account_where.one_or_none.return_value = mock_account
+ mock_account_query.where.return_value = mock_account_where
+
+ # Setup query to return different results based on model
+ def query_side_effect(model):
+ if model.__name__ == "AccountIntegrate":
+ return mock_query
+ elif model.__name__ == "Account":
+ return mock_account_query
+ return MagicMock()
+
+ mock_db.session.query.side_effect = query_side_effect
+
+ # Act
+ result = Account.get_by_openid(provider, open_id)
+
+ # Assert
+ assert result == mock_account
+
+ @patch("models.account.db")
+ def test_get_by_openid_not_found(self, mock_db):
+ """Test get_by_openid when account integrate doesn't exist."""
+ # Arrange
+ provider = "github"
+ open_id = "github_user_456"
+
+ # Mock the query chain to return None
+ mock_query = MagicMock()
+ mock_where = MagicMock()
+ mock_where.one_or_none.return_value = None
+ mock_query.where.return_value = mock_where
+ mock_db.session.query.return_value = mock_query
+
+ # Act
+ result = Account.get_by_openid(provider, open_id)
+
+ # Assert
+ assert result is None
+
+
+class TestTenantAccountJoinModel:
+ """Test suite for TenantAccountJoin model."""
+
+ def test_tenant_account_join_creation(self):
+ """Test creating a TenantAccountJoin record."""
+ # Arrange
+ tenant_id = str(uuid4())
+ account_id = str(uuid4())
+
+ # Act
+ join = TenantAccountJoin(
+ tenant_id=tenant_id,
+ account_id=account_id,
+ role=TenantAccountRole.NORMAL,
+ current=True,
+ )
+
+ # Assert
+ assert join.tenant_id == tenant_id
+ assert join.account_id == account_id
+ assert join.role == TenantAccountRole.NORMAL
+ assert join.current is True
+
+ def test_tenant_account_join_default_values(self):
+ """Test default values for TenantAccountJoin."""
+ # Arrange
+ tenant_id = str(uuid4())
+ account_id = str(uuid4())
+
+ # Act
+ join = TenantAccountJoin(
+ tenant_id=tenant_id,
+ account_id=account_id,
+ )
+
+ # Assert
+ assert join.current is False # Default value
+ assert join.role == "normal" # Default value
+ assert join.invited_by is None # Default value
+
+ def test_tenant_account_join_with_invited_by(self):
+ """Test TenantAccountJoin with invited_by field."""
+ # Arrange
+ tenant_id = str(uuid4())
+ account_id = str(uuid4())
+ inviter_id = str(uuid4())
+
+ # Act
+ join = TenantAccountJoin(
+ tenant_id=tenant_id,
+ account_id=account_id,
+ role=TenantAccountRole.EDITOR,
+ invited_by=inviter_id,
+ )
+
+ # Assert
+ assert join.invited_by == inviter_id
+
+
+class TestTenantModel:
+ """Test suite for Tenant model."""
+
+ def test_tenant_creation(self):
+ """Test creating a Tenant."""
+ # Arrange & Act
+ tenant = Tenant(name="Test Workspace")
+
+ # Assert
+ assert tenant.name == "Test Workspace"
+ assert tenant.status == "normal" # Default value
+ assert tenant.plan == "basic" # Default value
+
+ def test_tenant_custom_config_dict_property(self):
+ """Test custom_config_dict property getter."""
+ # Arrange
+ tenant = Tenant(name="Test Workspace")
+ config = {"feature1": True, "feature2": "value"}
+ tenant.custom_config = '{"feature1": true, "feature2": "value"}'
+
+ # Act
+ result = tenant.custom_config_dict
+
+ # Assert
+ assert result["feature1"] is True
+ assert result["feature2"] == "value"
+
+ def test_tenant_custom_config_dict_property_empty(self):
+ """Test custom_config_dict property with empty config."""
+ # Arrange
+ tenant = Tenant(name="Test Workspace")
+ tenant.custom_config = None
+
+ # Act
+ result = tenant.custom_config_dict
+
+ # Assert
+ assert result == {}
+
+ def test_tenant_custom_config_dict_setter(self):
+ """Test custom_config_dict property setter."""
+ # Arrange
+ tenant = Tenant(name="Test Workspace")
+ config = {"feature1": True, "feature2": "value"}
+
+ # Act
+ tenant.custom_config_dict = config
+
+ # Assert
+ assert tenant.custom_config == '{"feature1": true, "feature2": "value"}'
+
+ @patch("models.account.db")
+ def test_tenant_get_accounts(self, mock_db):
+ """Test getting accounts associated with a tenant."""
+ # Arrange
+ tenant = Tenant(name="Test Workspace")
+ tenant.id = str(uuid4())
+
+ account1 = Account(name="User 1", email="user1@example.com")
+ account1.id = str(uuid4())
+ account2 = Account(name="User 2", email="user2@example.com")
+ account2.id = str(uuid4())
+
+ # Mock the query chain
+ mock_scalars = MagicMock()
+ mock_scalars.all.return_value = [account1, account2]
+ mock_db.session.scalars.return_value = mock_scalars
+
+ # Act
+ accounts = tenant.get_accounts()
+
+ # Assert
+ assert len(accounts) == 2
+ assert account1 in accounts
+ assert account2 in accounts
+
+
+class TestTenantStatusEnum:
+ """Test suite for TenantStatus enum."""
+
+ def test_tenant_status_enum_values(self):
+ """Test TenantStatus enum values."""
+ # Arrange & Act
+ from models.account import TenantStatus
+
+ # Assert
+ assert TenantStatus.NORMAL == "normal"
+ assert TenantStatus.ARCHIVE == "archive"
+
+
+class TestAccountIntegration:
+ """Integration tests for Account model with related models."""
+
+ def test_account_with_multiple_tenants(self):
+ """Test account associated with multiple tenants."""
+ # Arrange
+ account = Account(name="Multi-Tenant User", email="multi@example.com")
+ account.id = str(uuid4())
+
+ tenant1_id = str(uuid4())
+ tenant2_id = str(uuid4())
+
+ join1 = TenantAccountJoin(
+ tenant_id=tenant1_id,
+ account_id=account.id,
+ role=TenantAccountRole.OWNER,
+ current=True,
+ )
+
+ join2 = TenantAccountJoin(
+ tenant_id=tenant2_id,
+ account_id=account.id,
+ role=TenantAccountRole.NORMAL,
+ current=False,
+ )
+
+ # Assert - verify the joins are created correctly
+ assert join1.account_id == account.id
+ assert join2.account_id == account.id
+ assert join1.current is True
+ assert join2.current is False
+
+ def test_account_last_login_tracking(self):
+ """Test account last login tracking."""
+ # Arrange
+ account = Account(name="Test User", email="test@example.com")
+ login_time = datetime.now(UTC)
+ login_ip = "192.168.1.1"
+
+ # Act
+ account.last_login_at = login_time
+ account.last_login_ip = login_ip
+
+ # Assert
+ assert account.last_login_at == login_time
+ assert account.last_login_ip == login_ip
+
+ def test_account_initialization_tracking(self):
+ """Test account initialization tracking."""
+ # Arrange
+ account = Account(
+ name="Test User",
+ email="test@example.com",
+ status=AccountStatus.PENDING,
+ )
+
+ # Act - simulate initialization
+ account.status = AccountStatus.ACTIVE
+ account.initialized_at = datetime.now(UTC)
+
+ # Assert
+ assert account.get_status() == AccountStatus.ACTIVE
+ assert account.initialized_at is not None
From 06466cb73a14e792fd8404d5009b970307acd5f2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=90=E5=B0=8F=E5=BF=83?=
Date: Fri, 21 Nov 2025 12:58:08 +0800
Subject: [PATCH 027/191] fix: fix numeric type conversion issue in if-else
condition comparison (#28155)
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
.../workflow/utils/condition/processor.py | 95 +++++++++----------
.../core/workflow/utils/test_condition.py | 52 ++++++++++
2 files changed, 99 insertions(+), 48 deletions(-)
create mode 100644 api/tests/unit_tests/core/workflow/utils/test_condition.py
diff --git a/api/core/workflow/utils/condition/processor.py b/api/core/workflow/utils/condition/processor.py
index 650a44c681..c6070b83b8 100644
--- a/api/core/workflow/utils/condition/processor.py
+++ b/api/core/workflow/utils/condition/processor.py
@@ -265,6 +265,45 @@ def _assert_not_empty(*, value: object) -> bool:
return False
+def _normalize_numeric_values(value: int | float, expected: object) -> tuple[int | float, int | float]:
+ """
+ Normalize value and expected to compatible numeric types for comparison.
+
+ Args:
+ value: The actual numeric value (int or float)
+ expected: The expected value (int, float, or str)
+
+ Returns:
+ A tuple of (normalized_value, normalized_expected) with compatible types
+
+ Raises:
+ ValueError: If expected cannot be converted to a number
+ """
+ if not isinstance(expected, (int, float, str)):
+ raise ValueError(f"Cannot convert {type(expected)} to number")
+
+ # Convert expected to appropriate numeric type
+ if isinstance(expected, str):
+ # Try to convert to float first to handle decimal strings
+ try:
+ expected_float = float(expected)
+ except ValueError as e:
+ raise ValueError(f"Cannot convert '{expected}' to number") from e
+
+ # If value is int and expected is a whole number, keep as int comparison
+ if isinstance(value, int) and expected_float.is_integer():
+ return value, int(expected_float)
+ else:
+ # Otherwise convert value to float for comparison
+ return float(value) if isinstance(value, int) else value, expected_float
+ elif isinstance(expected, float):
+ # If expected is already float, convert int value to float
+ return float(value) if isinstance(value, int) else value, expected
+ else:
+ # expected is int
+ return value, expected
+
+
def _assert_equal(*, value: object, expected: object) -> bool:
if value is None:
return False
@@ -324,18 +363,8 @@ def _assert_greater_than(*, value: object, expected: object) -> bool:
if not isinstance(value, (int, float)):
raise ValueError("Invalid actual value type: number")
- if isinstance(value, int):
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to int")
- expected = int(expected)
- else:
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to float")
- expected = float(expected)
-
- if value <= expected:
- return False
- return True
+ value, expected = _normalize_numeric_values(value, expected)
+ return value > expected
def _assert_less_than(*, value: object, expected: object) -> bool:
@@ -345,18 +374,8 @@ def _assert_less_than(*, value: object, expected: object) -> bool:
if not isinstance(value, (int, float)):
raise ValueError("Invalid actual value type: number")
- if isinstance(value, int):
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to int")
- expected = int(expected)
- else:
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to float")
- expected = float(expected)
-
- if value >= expected:
- return False
- return True
+ value, expected = _normalize_numeric_values(value, expected)
+ return value < expected
def _assert_greater_than_or_equal(*, value: object, expected: object) -> bool:
@@ -366,18 +385,8 @@ def _assert_greater_than_or_equal(*, value: object, expected: object) -> bool:
if not isinstance(value, (int, float)):
raise ValueError("Invalid actual value type: number")
- if isinstance(value, int):
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to int")
- expected = int(expected)
- else:
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to float")
- expected = float(expected)
-
- if value < expected:
- return False
- return True
+ value, expected = _normalize_numeric_values(value, expected)
+ return value >= expected
def _assert_less_than_or_equal(*, value: object, expected: object) -> bool:
@@ -387,18 +396,8 @@ def _assert_less_than_or_equal(*, value: object, expected: object) -> bool:
if not isinstance(value, (int, float)):
raise ValueError("Invalid actual value type: number")
- if isinstance(value, int):
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to int")
- expected = int(expected)
- else:
- if not isinstance(expected, (int, float, str)):
- raise ValueError(f"Cannot convert {type(expected)} to float")
- expected = float(expected)
-
- if value > expected:
- return False
- return True
+ value, expected = _normalize_numeric_values(value, expected)
+ return value <= expected
def _assert_null(*, value: object) -> bool:
diff --git a/api/tests/unit_tests/core/workflow/utils/test_condition.py b/api/tests/unit_tests/core/workflow/utils/test_condition.py
new file mode 100644
index 0000000000..efedf88726
--- /dev/null
+++ b/api/tests/unit_tests/core/workflow/utils/test_condition.py
@@ -0,0 +1,52 @@
+from core.workflow.runtime import VariablePool
+from core.workflow.utils.condition.entities import Condition
+from core.workflow.utils.condition.processor import ConditionProcessor
+
+
+def test_number_formatting():
+ condition_processor = ConditionProcessor()
+ variable_pool = VariablePool()
+ variable_pool.add(["test_node_id", "zone"], 0)
+ variable_pool.add(["test_node_id", "one"], 1)
+ variable_pool.add(["test_node_id", "one_one"], 1.1)
+ # 0 <= 0.95
+ assert (
+ condition_processor.process_conditions(
+ variable_pool=variable_pool,
+ conditions=[Condition(variable_selector=["test_node_id", "zone"], comparison_operator="≤", value="0.95")],
+ operator="or",
+ ).final_result
+ == True
+ )
+
+ # 1 >= 0.95
+ assert (
+ condition_processor.process_conditions(
+ variable_pool=variable_pool,
+ conditions=[Condition(variable_selector=["test_node_id", "one"], comparison_operator="≥", value="0.95")],
+ operator="or",
+ ).final_result
+ == True
+ )
+
+ # 1.1 >= 0.95
+ assert (
+ condition_processor.process_conditions(
+ variable_pool=variable_pool,
+ conditions=[
+ Condition(variable_selector=["test_node_id", "one_one"], comparison_operator="≥", value="0.95")
+ ],
+ operator="or",
+ ).final_result
+ == True
+ )
+
+ # 1.1 > 0
+ assert (
+ condition_processor.process_conditions(
+ variable_pool=variable_pool,
+ conditions=[Condition(variable_selector=["test_node_id", "one_one"], comparison_operator=">", value="0")],
+ operator="or",
+ ).final_result
+ == True
+ )
From 5f61ca5e6f5c93cd3e231f11bcf3d7b20ad4589a Mon Sep 17 00:00:00 2001
From: GuanMu
Date: Fri, 21 Nov 2025 12:58:20 +0800
Subject: [PATCH 028/191] feat: Implement partial update for document metadata,
allowing merging of new values with existing ones. (#28390)
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
.../vdb/matrixone/matrixone_vector.py | 25 ++-
.../knowledge_entities/knowledge_entities.py | 1 +
api/services/metadata_service.py | 19 ++-
.../services/test_metadata_partial_update.py | 153 ++++++++++++++++++
.../hooks/use-batch-edit-document-metadata.ts | 1 +
web/app/components/datasets/metadata/types.ts | 2 +-
6 files changed, 185 insertions(+), 16 deletions(-)
create mode 100644 api/tests/unit_tests/services/test_metadata_partial_update.py
diff --git a/api/core/rag/datasource/vdb/matrixone/matrixone_vector.py b/api/core/rag/datasource/vdb/matrixone/matrixone_vector.py
index 6fe396dc1e..14955c8d7c 100644
--- a/api/core/rag/datasource/vdb/matrixone/matrixone_vector.py
+++ b/api/core/rag/datasource/vdb/matrixone/matrixone_vector.py
@@ -22,6 +22,18 @@ logger = logging.getLogger(__name__)
P = ParamSpec("P")
R = TypeVar("R")
+T = TypeVar("T", bound="MatrixoneVector")
+
+
+def ensure_client(func: Callable[Concatenate[T, P], R]):
+ @wraps(func)
+ def wrapper(self: T, *args: P.args, **kwargs: P.kwargs):
+ if self.client is None:
+ self.client = self._get_client(None, False)
+ return func(self, *args, **kwargs)
+
+ return wrapper
+
class MatrixoneConfig(BaseModel):
host: str = "localhost"
@@ -206,19 +218,6 @@ class MatrixoneVector(BaseVector):
self.client.delete()
-T = TypeVar("T", bound=MatrixoneVector)
-
-
-def ensure_client(func: Callable[Concatenate[T, P], R]):
- @wraps(func)
- def wrapper(self: T, *args: P.args, **kwargs: P.kwargs):
- if self.client is None:
- self.client = self._get_client(None, False)
- return func(self, *args, **kwargs)
-
- return wrapper
-
-
class MatrixoneVectorFactory(AbstractVectorFactory):
def init_vector(self, dataset: Dataset, attributes: list, embeddings: Embeddings) -> MatrixoneVector:
if dataset.index_struct_dict:
diff --git a/api/services/entities/knowledge_entities/knowledge_entities.py b/api/services/entities/knowledge_entities/knowledge_entities.py
index b9a210740d..131e90e195 100644
--- a/api/services/entities/knowledge_entities/knowledge_entities.py
+++ b/api/services/entities/knowledge_entities/knowledge_entities.py
@@ -158,6 +158,7 @@ class MetadataDetail(BaseModel):
class DocumentMetadataOperation(BaseModel):
document_id: str
metadata_list: list[MetadataDetail]
+ partial_update: bool = False
class MetadataOperationData(BaseModel):
diff --git a/api/services/metadata_service.py b/api/services/metadata_service.py
index b369994d2d..3329ac349c 100644
--- a/api/services/metadata_service.py
+++ b/api/services/metadata_service.py
@@ -206,7 +206,10 @@ class MetadataService:
document = DocumentService.get_document(dataset.id, operation.document_id)
if document is None:
raise ValueError("Document not found.")
- doc_metadata = {}
+ if operation.partial_update:
+ doc_metadata = copy.deepcopy(document.doc_metadata) if document.doc_metadata else {}
+ else:
+ doc_metadata = {}
for metadata_value in operation.metadata_list:
doc_metadata[metadata_value.name] = metadata_value.value
if dataset.built_in_field_enabled:
@@ -219,9 +222,21 @@ class MetadataService:
db.session.add(document)
db.session.commit()
# deal metadata binding
- db.session.query(DatasetMetadataBinding).filter_by(document_id=operation.document_id).delete()
+ if not operation.partial_update:
+ db.session.query(DatasetMetadataBinding).filter_by(document_id=operation.document_id).delete()
+
current_user, current_tenant_id = current_account_with_tenant()
for metadata_value in operation.metadata_list:
+ # check if binding already exists
+ if operation.partial_update:
+ existing_binding = (
+ db.session.query(DatasetMetadataBinding)
+ .filter_by(document_id=operation.document_id, metadata_id=metadata_value.id)
+ .first()
+ )
+ if existing_binding:
+ continue
+
dataset_metadata_binding = DatasetMetadataBinding(
tenant_id=current_tenant_id,
dataset_id=dataset.id,
diff --git a/api/tests/unit_tests/services/test_metadata_partial_update.py b/api/tests/unit_tests/services/test_metadata_partial_update.py
new file mode 100644
index 0000000000..00162c10e4
--- /dev/null
+++ b/api/tests/unit_tests/services/test_metadata_partial_update.py
@@ -0,0 +1,153 @@
+import unittest
+from unittest.mock import MagicMock, patch
+
+from models.dataset import Dataset, Document
+from services.entities.knowledge_entities.knowledge_entities import (
+ DocumentMetadataOperation,
+ MetadataDetail,
+ MetadataOperationData,
+)
+from services.metadata_service import MetadataService
+
+
+class TestMetadataPartialUpdate(unittest.TestCase):
+ def setUp(self):
+ self.dataset = MagicMock(spec=Dataset)
+ self.dataset.id = "dataset_id"
+ self.dataset.built_in_field_enabled = False
+
+ self.document = MagicMock(spec=Document)
+ self.document.id = "doc_id"
+ self.document.doc_metadata = {"existing_key": "existing_value"}
+ self.document.data_source_type = "upload_file"
+
+ @patch("services.metadata_service.db")
+ @patch("services.metadata_service.DocumentService")
+ @patch("services.metadata_service.current_account_with_tenant")
+ @patch("services.metadata_service.redis_client")
+ def test_partial_update_merges_metadata(self, mock_redis, mock_current_account, mock_document_service, mock_db):
+ # Setup mocks
+ mock_redis.get.return_value = None
+ mock_document_service.get_document.return_value = self.document
+ mock_current_account.return_value = (MagicMock(id="user_id"), "tenant_id")
+
+ # Mock DB query for existing bindings
+
+ # No existing binding for new key
+ mock_db.session.query.return_value.filter_by.return_value.first.return_value = None
+
+ # Input data
+ operation = DocumentMetadataOperation(
+ document_id="doc_id",
+ metadata_list=[MetadataDetail(id="new_meta_id", name="new_key", value="new_value")],
+ partial_update=True,
+ )
+ metadata_args = MetadataOperationData(operation_data=[operation])
+
+ # Execute
+ MetadataService.update_documents_metadata(self.dataset, metadata_args)
+
+ # Verify
+ # 1. Check that doc_metadata contains BOTH existing and new keys
+ expected_metadata = {"existing_key": "existing_value", "new_key": "new_value"}
+ assert self.document.doc_metadata == expected_metadata
+
+ # 2. Check that existing bindings were NOT deleted
+ # The delete call in the original code: db.session.query(...).filter_by(...).delete()
+ # In partial update, this should NOT be called.
+ mock_db.session.query.return_value.filter_by.return_value.delete.assert_not_called()
+
+ @patch("services.metadata_service.db")
+ @patch("services.metadata_service.DocumentService")
+ @patch("services.metadata_service.current_account_with_tenant")
+ @patch("services.metadata_service.redis_client")
+ def test_full_update_replaces_metadata(self, mock_redis, mock_current_account, mock_document_service, mock_db):
+ # Setup mocks
+ mock_redis.get.return_value = None
+ mock_document_service.get_document.return_value = self.document
+ mock_current_account.return_value = (MagicMock(id="user_id"), "tenant_id")
+
+ # Input data (partial_update=False by default)
+ operation = DocumentMetadataOperation(
+ document_id="doc_id",
+ metadata_list=[MetadataDetail(id="new_meta_id", name="new_key", value="new_value")],
+ partial_update=False,
+ )
+ metadata_args = MetadataOperationData(operation_data=[operation])
+
+ # Execute
+ MetadataService.update_documents_metadata(self.dataset, metadata_args)
+
+ # Verify
+ # 1. Check that doc_metadata contains ONLY the new key
+ expected_metadata = {"new_key": "new_value"}
+ assert self.document.doc_metadata == expected_metadata
+
+ # 2. Check that existing bindings WERE deleted
+ # In full update (default), we expect the existing bindings to be cleared.
+ mock_db.session.query.return_value.filter_by.return_value.delete.assert_called()
+
+ @patch("services.metadata_service.db")
+ @patch("services.metadata_service.DocumentService")
+ @patch("services.metadata_service.current_account_with_tenant")
+ @patch("services.metadata_service.redis_client")
+ def test_partial_update_skips_existing_binding(
+ self, mock_redis, mock_current_account, mock_document_service, mock_db
+ ):
+ # Setup mocks
+ mock_redis.get.return_value = None
+ mock_document_service.get_document.return_value = self.document
+ mock_current_account.return_value = (MagicMock(id="user_id"), "tenant_id")
+
+ # Mock DB query to return an existing binding
+ # This simulates that the document ALREADY has the metadata we are trying to add
+ mock_existing_binding = MagicMock()
+ mock_db.session.query.return_value.filter_by.return_value.first.return_value = mock_existing_binding
+
+ # Input data
+ operation = DocumentMetadataOperation(
+ document_id="doc_id",
+ metadata_list=[MetadataDetail(id="existing_meta_id", name="existing_key", value="existing_value")],
+ partial_update=True,
+ )
+ metadata_args = MetadataOperationData(operation_data=[operation])
+
+ # Execute
+ MetadataService.update_documents_metadata(self.dataset, metadata_args)
+
+ # Verify
+ # We verify that db.session.add was NOT called for DatasetMetadataBinding
+ # Since we can't easily check "not called with specific type" on the generic add method without complex logic,
+ # we can check if the number of add calls is 1 (only for the document update) instead of 2 (document + binding)
+
+ # Expected calls:
+ # 1. db.session.add(document)
+ # 2. NO db.session.add(binding) because it exists
+
+ # Note: In the code, db.session.add is called for document.
+ # Then loop over metadata_list.
+ # If existing_binding found, continue.
+ # So binding add should be skipped.
+
+ # Let's filter the calls to add to see what was added
+ add_calls = mock_db.session.add.call_args_list
+ added_objects = [call.args[0] for call in add_calls]
+
+ # Check that no DatasetMetadataBinding was added
+ from models.dataset import DatasetMetadataBinding
+
+ has_binding_add = any(
+ isinstance(obj, DatasetMetadataBinding)
+ or (isinstance(obj, MagicMock) and getattr(obj, "__class__", None) == DatasetMetadataBinding)
+ for obj in added_objects
+ )
+
+ # Since we mock everything, checking isinstance might be tricky if DatasetMetadataBinding
+ # is not the exact class used in the service (imports match).
+ # But we can check the count.
+ # If it were added, there would be 2 calls. If skipped, 1 call.
+ assert mock_db.session.add.call_count == 1
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/web/app/components/datasets/metadata/hooks/use-batch-edit-document-metadata.ts b/web/app/components/datasets/metadata/hooks/use-batch-edit-document-metadata.ts
index f350fd7b8b..0f07b3de60 100644
--- a/web/app/components/datasets/metadata/hooks/use-batch-edit-document-metadata.ts
+++ b/web/app/components/datasets/metadata/hooks/use-batch-edit-document-metadata.ts
@@ -115,6 +115,7 @@ const useBatchEditDocumentMetadata = ({
return {
document_id: documentId,
metadata_list: newMetadataList,
+ partial_update: docIndex < 0,
}
})
return res
diff --git a/web/app/components/datasets/metadata/types.ts b/web/app/components/datasets/metadata/types.ts
index 00688e29cc..fb1728232a 100644
--- a/web/app/components/datasets/metadata/types.ts
+++ b/web/app/components/datasets/metadata/types.ts
@@ -25,7 +25,7 @@ export type MetadataItemInBatchEdit = MetadataItemWithValue & {
isMultipleValue?: boolean
}
-export type MetadataBatchEditToServer = { document_id: string, metadata_list: MetadataItemWithValue[] }[]
+export type MetadataBatchEditToServer = { document_id: string, metadata_list: MetadataItemWithValue[], partial_update?: boolean }[]
export enum UpdateType {
changeValue = 'changeValue',
From 3c30d0f41b3f729f01d42f0cb982f8d40580074a Mon Sep 17 00:00:00 2001
From: Asuka Minato
Date: Fri, 21 Nov 2025 14:23:32 +0900
Subject: [PATCH 029/191] more typed orm (#28331)
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
Co-authored-by: crazywoola <100913391+crazywoola@users.noreply.github.com>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
api/models/api_based_extension.py | 14 +-
api/models/oauth.py | 46 +++--
api/models/trigger.py | 31 +--
.../trigger/trigger_provider_service.py | 10 +-
.../test_api_based_extension_service.py | 180 ++++++++++--------
.../workflow/test_workflow_converter.py | 10 +-
6 files changed, 167 insertions(+), 124 deletions(-)
diff --git a/api/models/api_based_extension.py b/api/models/api_based_extension.py
index fcb819a9c7..99d33908f8 100644
--- a/api/models/api_based_extension.py
+++ b/api/models/api_based_extension.py
@@ -6,7 +6,7 @@ import sqlalchemy as sa
from sqlalchemy import DateTime, String, func
from sqlalchemy.orm import Mapped, mapped_column
-from .base import Base
+from .base import TypeBase
from .types import LongText, StringUUID
@@ -17,16 +17,18 @@ class APIBasedExtensionPoint(enum.StrEnum):
APP_MODERATION_OUTPUT = "app.moderation.output"
-class APIBasedExtension(Base):
+class APIBasedExtension(TypeBase):
__tablename__ = "api_based_extensions"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="api_based_extension_pkey"),
sa.Index("api_based_extension_tenant_idx", "tenant_id"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuid4()))
- tenant_id = mapped_column(StringUUID, nullable=False)
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
name: Mapped[str] = mapped_column(String(255), nullable=False)
api_endpoint: Mapped[str] = mapped_column(String(255), nullable=False)
- api_key = mapped_column(LongText, nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ api_key: Mapped[str] = mapped_column(LongText, nullable=False)
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
diff --git a/api/models/oauth.py b/api/models/oauth.py
index f2bb4eff2b..2fce67c998 100644
--- a/api/models/oauth.py
+++ b/api/models/oauth.py
@@ -6,62 +6,74 @@ from sqlalchemy.orm import Mapped, mapped_column
from libs.uuid_utils import uuidv7
-from .base import Base
+from .base import TypeBase
from .types import AdjustedJSON, LongText, StringUUID
-class DatasourceOauthParamConfig(Base): # type: ignore[name-defined]
+class DatasourceOauthParamConfig(TypeBase):
__tablename__ = "datasource_oauth_params"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="datasource_oauth_config_pkey"),
sa.UniqueConstraint("plugin_id", "provider", name="datasource_oauth_config_datasource_id_provider_idx"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuidv7()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
plugin_id: Mapped[str] = mapped_column(sa.String(255), nullable=False)
provider: Mapped[str] = mapped_column(sa.String(255), nullable=False)
system_credentials: Mapped[dict] = mapped_column(AdjustedJSON, nullable=False)
-class DatasourceProvider(Base):
+class DatasourceProvider(TypeBase):
__tablename__ = "datasource_providers"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="datasource_provider_pkey"),
sa.UniqueConstraint("tenant_id", "plugin_id", "provider", "name", name="datasource_provider_unique_name"),
sa.Index("datasource_provider_auth_type_provider_idx", "tenant_id", "plugin_id", "provider"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuidv7()))
- tenant_id = mapped_column(StringUUID, nullable=False)
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
name: Mapped[str] = mapped_column(sa.String(255), nullable=False)
provider: Mapped[str] = mapped_column(sa.String(128), nullable=False)
plugin_id: Mapped[str] = mapped_column(sa.String(255), nullable=False)
auth_type: Mapped[str] = mapped_column(sa.String(255), nullable=False)
encrypted_credentials: Mapped[dict] = mapped_column(AdjustedJSON, nullable=False)
avatar_url: Mapped[str] = mapped_column(LongText, nullable=True, default="default")
- is_default: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"))
- expires_at: Mapped[int] = mapped_column(sa.Integer, nullable=False, server_default="-1")
+ is_default: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"), default=False)
+ expires_at: Mapped[int] = mapped_column(sa.Integer, nullable=False, server_default="-1", default=-1)
- created_at: Mapped[datetime] = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
- sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ sa.DateTime,
+ nullable=False,
+ server_default=func.current_timestamp(),
+ onupdate=func.current_timestamp(),
+ init=False,
)
-class DatasourceOauthTenantParamConfig(Base):
+class DatasourceOauthTenantParamConfig(TypeBase):
__tablename__ = "datasource_oauth_tenant_params"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="datasource_oauth_tenant_config_pkey"),
sa.UniqueConstraint("tenant_id", "plugin_id", "provider", name="datasource_oauth_tenant_config_unique"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuidv7()))
- tenant_id = mapped_column(StringUUID, nullable=False)
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
provider: Mapped[str] = mapped_column(sa.String(255), nullable=False)
plugin_id: Mapped[str] = mapped_column(sa.String(255), nullable=False)
- client_params: Mapped[dict] = mapped_column(AdjustedJSON, nullable=False, default={})
+ client_params: Mapped[dict] = mapped_column(AdjustedJSON, nullable=False, default_factory=dict)
enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, default=False)
- created_at: Mapped[datetime] = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
- updated_at: Mapped[datetime] = mapped_column(
- sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
+ updated_at: Mapped[datetime] = mapped_column(
+ sa.DateTime,
+ nullable=False,
+ server_default=func.current_timestamp(),
+ onupdate=func.current_timestamp(),
+ init=False,
)
diff --git a/api/models/trigger.py b/api/models/trigger.py
index 6fc8683459..932803670a 100644
--- a/api/models/trigger.py
+++ b/api/models/trigger.py
@@ -16,14 +16,15 @@ from core.trigger.entities.entities import Subscription
from core.trigger.utils.endpoint import generate_plugin_trigger_endpoint_url, generate_webhook_trigger_endpoint
from libs.datetime_utils import naive_utc_now
from libs.uuid_utils import uuidv7
-from models.base import Base, TypeBase
-from models.engine import db
-from models.enums import AppTriggerStatus, AppTriggerType, CreatorUserRole, WorkflowTriggerStatus
-from models.model import Account
-from models.types import EnumText, LongText, StringUUID
+
+from .base import Base, TypeBase
+from .engine import db
+from .enums import AppTriggerStatus, AppTriggerType, CreatorUserRole, WorkflowTriggerStatus
+from .model import Account
+from .types import EnumText, LongText, StringUUID
-class TriggerSubscription(Base):
+class TriggerSubscription(TypeBase):
"""
Trigger provider model for managing credentials
Supports multiple credential instances per provider
@@ -40,7 +41,7 @@ class TriggerSubscription(Base):
UniqueConstraint("tenant_id", "provider_id", "name", name="unique_trigger_provider"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
name: Mapped[str] = mapped_column(String(255), nullable=False, comment="Subscription instance name")
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
user_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
@@ -62,12 +63,15 @@ class TriggerSubscription(Base):
Integer, default=-1, comment="Subscription instance expiration timestamp, -1 for never"
)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.current_timestamp(),
server_onupdate=func.current_timestamp(),
+ init=False,
)
def is_credential_expired(self) -> bool:
@@ -100,24 +104,27 @@ class TriggerSubscription(Base):
# system level trigger oauth client params
-class TriggerOAuthSystemClient(Base):
+class TriggerOAuthSystemClient(TypeBase):
__tablename__ = "trigger_oauth_system_clients"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="trigger_oauth_system_client_pkey"),
sa.UniqueConstraint("plugin_id", "provider", name="trigger_oauth_system_client_plugin_id_provider_idx"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
plugin_id: Mapped[str] = mapped_column(String(255), nullable=False)
provider: Mapped[str] = mapped_column(String(255), nullable=False)
# oauth params of the trigger provider
encrypted_oauth_params: Mapped[str] = mapped_column(LongText, nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.current_timestamp(),
server_onupdate=func.current_timestamp(),
+ init=False,
)
@@ -134,7 +141,7 @@ class TriggerOAuthTenantClient(Base):
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
plugin_id: Mapped[str] = mapped_column(String(255), nullable=False)
provider: Mapped[str] = mapped_column(String(255), nullable=False)
- enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true"))
+ enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true"), default=True)
# oauth params of the trigger provider
encrypted_oauth_params: Mapped[str] = mapped_column(LongText, nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
diff --git a/api/services/trigger/trigger_provider_service.py b/api/services/trigger/trigger_provider_service.py
index 076cc7e776..6079d47bbf 100644
--- a/api/services/trigger/trigger_provider_service.py
+++ b/api/services/trigger/trigger_provider_service.py
@@ -181,19 +181,21 @@ class TriggerProviderService:
# Create provider record
subscription = TriggerSubscription(
- id=subscription_id or str(uuid.uuid4()),
tenant_id=tenant_id,
user_id=user_id,
name=name,
endpoint_id=endpoint_id,
provider_id=str(provider_id),
- parameters=parameters,
- properties=properties_encrypter.encrypt(dict(properties)),
- credentials=credential_encrypter.encrypt(dict(credentials)) if credential_encrypter else {},
+ parameters=dict(parameters),
+ properties=dict(properties_encrypter.encrypt(dict(properties))),
+ credentials=dict(credential_encrypter.encrypt(dict(credentials)))
+ if credential_encrypter
+ else {},
credential_type=credential_type.value,
credential_expires_at=credential_expires_at,
expires_at=expires_at,
)
+ subscription.id = subscription_id or str(uuid.uuid4())
session.add(subscription)
session.commit()
diff --git a/api/tests/test_containers_integration_tests/services/test_api_based_extension_service.py b/api/tests/test_containers_integration_tests/services/test_api_based_extension_service.py
index 6cd8337ff9..2cea24d085 100644
--- a/api/tests/test_containers_integration_tests/services/test_api_based_extension_service.py
+++ b/api/tests/test_containers_integration_tests/services/test_api_based_extension_service.py
@@ -69,13 +69,14 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Setup extension data
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
# Save extension
saved_extension = APIBasedExtensionService.save(extension_data)
@@ -105,13 +106,14 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Test empty name
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = ""
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name="",
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
with pytest.raises(ValueError, match="name must not be empty"):
APIBasedExtensionService.save(extension_data)
@@ -141,12 +143,14 @@ class TestAPIBasedExtensionService:
# Create multiple extensions
extensions = []
+ assert tenant is not None
for i in range(3):
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = f"Extension {i}: {fake.company()}"
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=f"Extension {i}: {fake.company()}",
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
saved_extension = APIBasedExtensionService.save(extension_data)
extensions.append(saved_extension)
@@ -173,13 +177,14 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Create an extension
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
created_extension = APIBasedExtensionService.save(extension_data)
@@ -217,13 +222,14 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Create an extension first
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
created_extension = APIBasedExtensionService.save(extension_data)
extension_id = created_extension.id
@@ -245,22 +251,23 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Create first extension
- extension_data1 = APIBasedExtension()
- extension_data1.tenant_id = tenant.id
- extension_data1.name = "Test Extension"
- extension_data1.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data1.api_key = fake.password(length=20)
+ extension_data1 = APIBasedExtension(
+ tenant_id=tenant.id,
+ name="Test Extension",
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
APIBasedExtensionService.save(extension_data1)
-
# Try to create second extension with same name
- extension_data2 = APIBasedExtension()
- extension_data2.tenant_id = tenant.id
- extension_data2.name = "Test Extension" # Same name
- extension_data2.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data2.api_key = fake.password(length=20)
+ extension_data2 = APIBasedExtension(
+ tenant_id=tenant.id,
+ name="Test Extension", # Same name
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
with pytest.raises(ValueError, match="name must be unique, it is already existed"):
APIBasedExtensionService.save(extension_data2)
@@ -273,13 +280,14 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Create initial extension
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
created_extension = APIBasedExtensionService.save(extension_data)
@@ -330,13 +338,14 @@ class TestAPIBasedExtensionService:
mock_external_service_dependencies["requestor_instance"].request.side_effect = ValueError(
"connection error: request timeout"
)
-
+ assert tenant is not None
# Setup extension data
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = "https://invalid-endpoint.com/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint="https://invalid-endpoint.com/api",
+ api_key=fake.password(length=20),
+ )
# Try to save extension with connection error
with pytest.raises(ValueError, match="connection error: request timeout"):
@@ -352,13 +361,14 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Setup extension data with short API key
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = "1234" # Less than 5 characters
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key="1234", # Less than 5 characters
+ )
# Try to save extension with short API key
with pytest.raises(ValueError, match="api_key must be at least 5 characters"):
@@ -372,13 +382,14 @@ class TestAPIBasedExtensionService:
account, tenant = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant is not None
# Test with None values
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = None
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=None, # type: ignore # why str become None here???
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
with pytest.raises(ValueError, match="name must not be empty"):
APIBasedExtensionService.save(extension_data)
@@ -424,13 +435,14 @@ class TestAPIBasedExtensionService:
# Mock invalid ping response
mock_external_service_dependencies["requestor_instance"].request.return_value = {"result": "invalid"}
-
+ assert tenant is not None
# Setup extension data
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
# Try to save extension with invalid ping response
with pytest.raises(ValueError, match="{'result': 'invalid'}"):
@@ -447,13 +459,14 @@ class TestAPIBasedExtensionService:
# Mock ping response without result field
mock_external_service_dependencies["requestor_instance"].request.return_value = {"status": "ok"}
-
+ assert tenant is not None
# Setup extension data
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
# Try to save extension with missing ping result
with pytest.raises(ValueError, match="{'status': 'ok'}"):
@@ -472,13 +485,14 @@ class TestAPIBasedExtensionService:
account2, tenant2 = self._create_test_account_and_tenant(
db_session_with_containers, mock_external_service_dependencies
)
-
+ assert tenant1 is not None
# Create extension in first tenant
- extension_data = APIBasedExtension()
- extension_data.tenant_id = tenant1.id
- extension_data.name = fake.company()
- extension_data.api_endpoint = f"https://{fake.domain_name()}/api"
- extension_data.api_key = fake.password(length=20)
+ extension_data = APIBasedExtension(
+ tenant_id=tenant1.id,
+ name=fake.company(),
+ api_endpoint=f"https://{fake.domain_name()}/api",
+ api_key=fake.password(length=20),
+ )
created_extension = APIBasedExtensionService.save(extension_data)
diff --git a/api/tests/unit_tests/services/workflow/test_workflow_converter.py b/api/tests/unit_tests/services/workflow/test_workflow_converter.py
index 8ea5754363..267c0a85a7 100644
--- a/api/tests/unit_tests/services/workflow/test_workflow_converter.py
+++ b/api/tests/unit_tests/services/workflow/test_workflow_converter.py
@@ -70,12 +70,13 @@ def test__convert_to_http_request_node_for_chatbot(default_variables):
api_based_extension_id = "api_based_extension_id"
mock_api_based_extension = APIBasedExtension(
- id=api_based_extension_id,
+ tenant_id="tenant_id",
name="api-1",
api_key="encrypted_api_key",
api_endpoint="https://dify.ai",
)
+ mock_api_based_extension.id = api_based_extension_id
workflow_converter = WorkflowConverter()
workflow_converter._get_api_based_extension = MagicMock(return_value=mock_api_based_extension)
@@ -131,11 +132,12 @@ def test__convert_to_http_request_node_for_workflow_app(default_variables):
api_based_extension_id = "api_based_extension_id"
mock_api_based_extension = APIBasedExtension(
- id=api_based_extension_id,
+ tenant_id="tenant_id",
name="api-1",
api_key="encrypted_api_key",
api_endpoint="https://dify.ai",
)
+ mock_api_based_extension.id = api_based_extension_id
workflow_converter = WorkflowConverter()
workflow_converter._get_api_based_extension = MagicMock(return_value=mock_api_based_extension)
@@ -281,6 +283,7 @@ def test__convert_to_llm_node_for_chatbot_simple_chat_model(default_variables):
assert llm_node["data"]["model"]["name"] == model
assert llm_node["data"]["model"]["mode"] == model_mode.value
template = prompt_template.simple_prompt_template
+ assert template is not None
for v in default_variables:
template = template.replace("{{" + v.variable + "}}", "{{#start." + v.variable + "#}}")
assert llm_node["data"]["prompt_template"][0]["text"] == template + "\n"
@@ -323,6 +326,7 @@ def test__convert_to_llm_node_for_chatbot_simple_completion_model(default_variab
assert llm_node["data"]["model"]["name"] == model
assert llm_node["data"]["model"]["mode"] == model_mode.value
template = prompt_template.simple_prompt_template
+ assert template is not None
for v in default_variables:
template = template.replace("{{" + v.variable + "}}", "{{#start." + v.variable + "#}}")
assert llm_node["data"]["prompt_template"]["text"] == template + "\n"
@@ -374,6 +378,7 @@ def test__convert_to_llm_node_for_chatbot_advanced_chat_model(default_variables)
assert llm_node["data"]["model"]["name"] == model
assert llm_node["data"]["model"]["mode"] == model_mode.value
assert isinstance(llm_node["data"]["prompt_template"], list)
+ assert prompt_template.advanced_chat_prompt_template is not None
assert len(llm_node["data"]["prompt_template"]) == len(prompt_template.advanced_chat_prompt_template.messages)
template = prompt_template.advanced_chat_prompt_template.messages[0].text
for v in default_variables:
@@ -420,6 +425,7 @@ def test__convert_to_llm_node_for_workflow_advanced_completion_model(default_var
assert llm_node["data"]["model"]["name"] == model
assert llm_node["data"]["model"]["mode"] == model_mode.value
assert isinstance(llm_node["data"]["prompt_template"], dict)
+ assert prompt_template.advanced_completion_prompt_template is not None
template = prompt_template.advanced_completion_prompt_template.prompt
for v in default_variables:
template = template.replace("{{" + v.variable + "}}", "{{#start." + v.variable + "#}}")
From 1a2f8dfcb41c4aa21d023094c31eb258a91075bf Mon Sep 17 00:00:00 2001
From: Asuka Minato
Date: Fri, 21 Nov 2025 15:25:53 +0900
Subject: [PATCH 030/191] use deco (#28153)
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
api/controllers/console/apikey.py | 5 +-
api/controllers/console/app/app.py | 9 +-
api/controllers/console/app/model_config.py | 8 +-
api/controllers/console/app/site.py | 21 ++--
api/controllers/console/app/workflow.py | 10 +-
.../console/app/workflow_draft_variable.py | 24 +++--
.../console/app/workflow_trigger.py | 19 ++--
.../console/auth/data_source_bearer_auth.py | 14 +--
.../console/auth/data_source_oauth.py | 8 +-
api/controllers/console/datasets/datasets.py | 15 +--
api/controllers/console/datasets/external.py | 6 +-
.../rag_pipeline/rag_pipeline_import.py | 21 ++--
.../rag_pipeline/rag_pipeline_workflow.py | 47 +++------
api/controllers/console/tag/tags.py | 7 +-
api/controllers/console/workspace/endpoint.py | 22 ++---
.../console/workspace/model_providers.py | 30 +++---
api/controllers/console/workspace/models.py | 45 +++------
api/controllers/console/workspace/plugin.py | 23 ++---
.../console/workspace/tool_providers.py | 49 +++-------
.../console/workspace/trigger_providers.py | 97 +++++++++----------
api/controllers/console/wraps.py | 16 +++
api/controllers/service_api/app/annotation.py | 21 +---
.../service_api/dataset/dataset.py | 5 +-
23 files changed, 205 insertions(+), 317 deletions(-)
diff --git a/api/controllers/console/apikey.py b/api/controllers/console/apikey.py
index 4f04af7932..bd5862cbd0 100644
--- a/api/controllers/console/apikey.py
+++ b/api/controllers/console/apikey.py
@@ -104,14 +104,11 @@ class BaseApiKeyResource(Resource):
resource_model: type | None = None
resource_id_field: str | None = None
- def delete(self, resource_id, api_key_id):
+ def delete(self, resource_id: str, api_key_id: str):
assert self.resource_id_field is not None, "resource_id_field must be set"
- resource_id = str(resource_id)
- api_key_id = str(api_key_id)
current_user, current_tenant_id = current_account_with_tenant()
_get_resource(resource_id, current_tenant_id, self.resource_model)
- # The role of the current user in the ta table must be admin or owner
if not current_user.is_admin_or_owner:
raise Forbidden()
diff --git a/api/controllers/console/app/app.py b/api/controllers/console/app/app.py
index defe82b8ae..a487512961 100644
--- a/api/controllers/console/app/app.py
+++ b/api/controllers/console/app/app.py
@@ -3,7 +3,7 @@ import uuid
from flask_restx import Resource, fields, inputs, marshal, marshal_with, reqparse
from sqlalchemy import select
from sqlalchemy.orm import Session
-from werkzeug.exceptions import BadRequest, Forbidden, abort
+from werkzeug.exceptions import BadRequest, abort
from controllers.console import api, console_ns
from controllers.console.app.wraps import get_app_model
@@ -12,6 +12,7 @@ from controllers.console.wraps import (
cloud_edition_billing_resource_check,
edit_permission_required,
enterprise_license_required,
+ is_admin_or_owner_required,
setup_required,
)
from core.ops.ops_trace_manager import OpsTraceManager
@@ -485,15 +486,11 @@ class AppApiStatus(Resource):
@api.response(403, "Insufficient permissions")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
@get_app_model
@marshal_with(app_detail_fields)
def post(self, app_model):
- # The role of the current user in the ta table must be admin or owner
- current_user, _ = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
-
parser = reqparse.RequestParser().add_argument("enable_api", type=bool, required=True, location="json")
args = parser.parse_args()
diff --git a/api/controllers/console/app/model_config.py b/api/controllers/console/app/model_config.py
index 72ce8a7ddf..91e2cfd60e 100644
--- a/api/controllers/console/app/model_config.py
+++ b/api/controllers/console/app/model_config.py
@@ -3,11 +3,10 @@ from typing import cast
from flask import request
from flask_restx import Resource, fields
-from werkzeug.exceptions import Forbidden
from controllers.console import api, console_ns
from controllers.console.app.wraps import get_app_model
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
from core.agent.entities import AgentToolEntity
from core.tools.tool_manager import ToolManager
from core.tools.utils.configuration import ToolParameterConfigurationManager
@@ -48,15 +47,12 @@ class ModelConfigResource(Resource):
@api.response(404, "App not found")
@setup_required
@login_required
+ @edit_permission_required
@account_initialization_required
@get_app_model(mode=[AppMode.AGENT_CHAT, AppMode.CHAT, AppMode.COMPLETION])
def post(self, app_model):
"""Modify app model config"""
current_user, current_tenant_id = current_account_with_tenant()
-
- if not current_user.has_edit_permission:
- raise Forbidden()
-
# validate config
model_configuration = AppModelConfigService.validate_configuration(
tenant_id=current_tenant_id,
diff --git a/api/controllers/console/app/site.py b/api/controllers/console/app/site.py
index c4d640bf0e..b8edbf77c7 100644
--- a/api/controllers/console/app/site.py
+++ b/api/controllers/console/app/site.py
@@ -1,10 +1,15 @@
from flask_restx import Resource, fields, marshal_with, reqparse
-from werkzeug.exceptions import Forbidden, NotFound
+from werkzeug.exceptions import NotFound
from constants.languages import supported_language
from controllers.console import api, console_ns
from controllers.console.app.wraps import get_app_model
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import (
+ account_initialization_required,
+ edit_permission_required,
+ is_admin_or_owner_required,
+ setup_required,
+)
from extensions.ext_database import db
from fields.app_fields import app_site_fields
from libs.datetime_utils import naive_utc_now
@@ -76,17 +81,13 @@ class AppSite(Resource):
@api.response(404, "App not found")
@setup_required
@login_required
+ @edit_permission_required
@account_initialization_required
@get_app_model
@marshal_with(app_site_fields)
def post(self, app_model):
args = parse_app_site_args()
current_user, _ = current_account_with_tenant()
-
- # The role of the current user in the ta table must be editor, admin, or owner
- if not current_user.has_edit_permission:
- raise Forbidden()
-
site = db.session.query(Site).where(Site.app_id == app_model.id).first()
if not site:
raise NotFound
@@ -130,16 +131,12 @@ class AppSiteAccessTokenReset(Resource):
@api.response(404, "App or site not found")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
@get_app_model
@marshal_with(app_site_fields)
def post(self, app_model):
- # The role of the current user in the ta table must be admin or owner
current_user, _ = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
-
site = db.session.query(Site).where(Site.app_id == app_model.id).first()
if not site:
diff --git a/api/controllers/console/app/workflow.py b/api/controllers/console/app/workflow.py
index 31077e371b..2f6808f11d 100644
--- a/api/controllers/console/app/workflow.py
+++ b/api/controllers/console/app/workflow.py
@@ -983,8 +983,9 @@ class DraftWorkflowTriggerRunApi(Resource):
Poll for trigger events and execute full workflow when event arrives
"""
current_user, _ = current_account_with_tenant()
- parser = reqparse.RequestParser()
- parser.add_argument("node_id", type=str, required=True, location="json", nullable=False)
+ parser = reqparse.RequestParser().add_argument(
+ "node_id", type=str, required=True, location="json", nullable=False
+ )
args = parser.parse_args()
node_id = args["node_id"]
workflow_service = WorkflowService()
@@ -1136,8 +1137,9 @@ class DraftWorkflowTriggerRunAllApi(Resource):
"""
current_user, _ = current_account_with_tenant()
- parser = reqparse.RequestParser()
- parser.add_argument("node_ids", type=list, required=True, location="json", nullable=False)
+ parser = reqparse.RequestParser().add_argument(
+ "node_ids", type=list, required=True, location="json", nullable=False
+ )
args = parser.parse_args()
node_ids = args["node_ids"]
workflow_service = WorkflowService()
diff --git a/api/controllers/console/app/workflow_draft_variable.py b/api/controllers/console/app/workflow_draft_variable.py
index 0722eb40d2..ca97d8520c 100644
--- a/api/controllers/console/app/workflow_draft_variable.py
+++ b/api/controllers/console/app/workflow_draft_variable.py
@@ -1,17 +1,18 @@
import logging
-from typing import NoReturn
+from collections.abc import Callable
+from functools import wraps
+from typing import NoReturn, ParamSpec, TypeVar
from flask import Response
from flask_restx import Resource, fields, inputs, marshal, marshal_with, reqparse
from sqlalchemy.orm import Session
-from werkzeug.exceptions import Forbidden
from controllers.console import api, console_ns
from controllers.console.app.error import (
DraftWorkflowNotExist,
)
from controllers.console.app.wraps import get_app_model
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
from controllers.web.error import InvalidArgumentError, NotFoundError
from core.file import helpers as file_helpers
from core.variables.segment_group import SegmentGroup
@@ -21,8 +22,8 @@ from core.workflow.constants import CONVERSATION_VARIABLE_NODE_ID, SYSTEM_VARIAB
from extensions.ext_database import db
from factories.file_factory import build_from_mapping, build_from_mappings
from factories.variable_factory import build_segment_with_type
-from libs.login import current_user, login_required
-from models import Account, App, AppMode
+from libs.login import login_required
+from models import App, AppMode
from models.workflow import WorkflowDraftVariable
from services.workflow_draft_variable_service import WorkflowDraftVariableList, WorkflowDraftVariableService
from services.workflow_service import WorkflowService
@@ -140,8 +141,11 @@ _WORKFLOW_DRAFT_VARIABLE_LIST_FIELDS = {
"items": fields.List(fields.Nested(_WORKFLOW_DRAFT_VARIABLE_FIELDS), attribute=_get_items),
}
+P = ParamSpec("P")
+R = TypeVar("R")
-def _api_prerequisite(f):
+
+def _api_prerequisite(f: Callable[P, R]):
"""Common prerequisites for all draft workflow variable APIs.
It ensures the following conditions are satisfied:
@@ -155,11 +159,10 @@ def _api_prerequisite(f):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_app_model(mode=[AppMode.ADVANCED_CHAT, AppMode.WORKFLOW])
- def wrapper(*args, **kwargs):
- assert isinstance(current_user, Account)
- if not current_user.has_edit_permission:
- raise Forbidden()
+ @wraps(f)
+ def wrapper(*args: P.args, **kwargs: P.kwargs):
return f(*args, **kwargs)
return wrapper
@@ -167,6 +170,7 @@ def _api_prerequisite(f):
@console_ns.route("/apps//workflows/draft/variables")
class WorkflowVariableCollectionApi(Resource):
+ @api.expect(_create_pagination_parser())
@api.doc("get_workflow_variables")
@api.doc(description="Get draft workflow variables")
@api.doc(params={"app_id": "Application ID"})
diff --git a/api/controllers/console/app/workflow_trigger.py b/api/controllers/console/app/workflow_trigger.py
index fd64261525..785813c5f0 100644
--- a/api/controllers/console/app/workflow_trigger.py
+++ b/api/controllers/console/app/workflow_trigger.py
@@ -3,12 +3,12 @@ import logging
from flask_restx import Resource, marshal_with, reqparse
from sqlalchemy import select
from sqlalchemy.orm import Session
-from werkzeug.exceptions import Forbidden, NotFound
+from werkzeug.exceptions import NotFound
from configs import dify_config
from controllers.console import api
from controllers.console.app.wraps import get_app_model
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
from extensions.ext_database import db
from fields.workflow_trigger_fields import trigger_fields, triggers_list_fields, webhook_trigger_fields
from libs.login import current_user, login_required
@@ -29,8 +29,7 @@ class WebhookTriggerApi(Resource):
@marshal_with(webhook_trigger_fields)
def get(self, app_model: App):
"""Get webhook trigger for a node"""
- parser = reqparse.RequestParser()
- parser.add_argument("node_id", type=str, required=True, help="Node ID is required")
+ parser = reqparse.RequestParser().add_argument("node_id", type=str, required=True, help="Node ID is required")
args = parser.parse_args()
node_id = str(args["node_id"])
@@ -95,19 +94,19 @@ class AppTriggerEnableApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_app_model(mode=AppMode.WORKFLOW)
@marshal_with(trigger_fields)
def post(self, app_model: App):
"""Update app trigger (enable/disable)"""
- parser = reqparse.RequestParser()
- parser.add_argument("trigger_id", type=str, required=True, nullable=False, location="json")
- parser.add_argument("enable_trigger", type=bool, required=True, nullable=False, location="json")
+ parser = (
+ reqparse.RequestParser()
+ .add_argument("trigger_id", type=str, required=True, nullable=False, location="json")
+ .add_argument("enable_trigger", type=bool, required=True, nullable=False, location="json")
+ )
args = parser.parse_args()
- assert isinstance(current_user, Account)
assert current_user.current_tenant_id is not None
- if not current_user.has_edit_permission:
- raise Forbidden()
trigger_id = args["trigger_id"]
diff --git a/api/controllers/console/auth/data_source_bearer_auth.py b/api/controllers/console/auth/data_source_bearer_auth.py
index a06435267b..9d7fcef183 100644
--- a/api/controllers/console/auth/data_source_bearer_auth.py
+++ b/api/controllers/console/auth/data_source_bearer_auth.py
@@ -1,8 +1,8 @@
from flask_restx import Resource, reqparse
-from werkzeug.exceptions import Forbidden
from controllers.console import console_ns
from controllers.console.auth.error import ApiKeyAuthFailedError
+from controllers.console.wraps import is_admin_or_owner_required
from libs.login import current_account_with_tenant, login_required
from services.auth.api_key_auth_service import ApiKeyAuthService
@@ -39,12 +39,10 @@ class ApiKeyAuthDataSourceBinding(Resource):
@setup_required
@login_required
@account_initialization_required
+ @is_admin_or_owner_required
def post(self):
# The role of the current user in the table must be admin or owner
- current_user, current_tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, current_tenant_id = current_account_with_tenant()
parser = (
reqparse.RequestParser()
.add_argument("category", type=str, required=True, nullable=False, location="json")
@@ -65,12 +63,10 @@ class ApiKeyAuthDataSourceBindingDelete(Resource):
@setup_required
@login_required
@account_initialization_required
+ @is_admin_or_owner_required
def delete(self, binding_id):
# The role of the current user in the table must be admin or owner
- current_user, current_tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, current_tenant_id = current_account_with_tenant()
ApiKeyAuthService.delete_provider_auth(current_tenant_id, binding_id)
diff --git a/api/controllers/console/auth/data_source_oauth.py b/api/controllers/console/auth/data_source_oauth.py
index 0fd433d718..a27932ccd8 100644
--- a/api/controllers/console/auth/data_source_oauth.py
+++ b/api/controllers/console/auth/data_source_oauth.py
@@ -3,11 +3,11 @@ import logging
import httpx
from flask import current_app, redirect, request
from flask_restx import Resource, fields
-from werkzeug.exceptions import Forbidden
from configs import dify_config
from controllers.console import api, console_ns
-from libs.login import current_account_with_tenant, login_required
+from controllers.console.wraps import is_admin_or_owner_required
+from libs.login import login_required
from libs.oauth_data_source import NotionOAuth
from ..wraps import account_initialization_required, setup_required
@@ -42,11 +42,9 @@ class OAuthDataSource(Resource):
)
@api.response(400, "Invalid provider")
@api.response(403, "Admin privileges required")
+ @is_admin_or_owner_required
def get(self, provider: str):
# The role of the current user in the table must be admin or owner
- current_user, _ = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
OAUTH_DATASOURCE_PROVIDERS = get_oauth_providers()
with current_app.app_context():
oauth_provider = OAUTH_DATASOURCE_PROVIDERS.get(provider)
diff --git a/api/controllers/console/datasets/datasets.py b/api/controllers/console/datasets/datasets.py
index 50bf48450c..3aac571300 100644
--- a/api/controllers/console/datasets/datasets.py
+++ b/api/controllers/console/datasets/datasets.py
@@ -15,6 +15,7 @@ from controllers.console.wraps import (
account_initialization_required,
cloud_edition_billing_rate_limit_check,
enterprise_license_required,
+ is_admin_or_owner_required,
setup_required,
)
from core.errors.error import LLMBadRequestError, ProviderTokenNotInitError
@@ -753,13 +754,11 @@ class DatasetApiKeyApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
@marshal_with(api_key_fields)
def post(self):
- # The role of the current user in the ta table must be admin or owner
- current_user, current_tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, current_tenant_id = current_account_with_tenant()
current_key_count = (
db.session.query(ApiToken)
@@ -794,15 +793,11 @@ class DatasetApiDeleteApi(Resource):
@api.response(204, "API key deleted successfully")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def delete(self, api_key_id):
- current_user, current_tenant_id = current_account_with_tenant()
+ _, current_tenant_id = current_account_with_tenant()
api_key_id = str(api_key_id)
-
- # The role of the current user in the ta table must be admin or owner
- if not current_user.is_admin_or_owner:
- raise Forbidden()
-
key = (
db.session.query(ApiToken)
.where(
diff --git a/api/controllers/console/datasets/external.py b/api/controllers/console/datasets/external.py
index 4f738db0e5..fe96a8199a 100644
--- a/api/controllers/console/datasets/external.py
+++ b/api/controllers/console/datasets/external.py
@@ -5,7 +5,7 @@ from werkzeug.exceptions import Forbidden, InternalServerError, NotFound
import services
from controllers.console import api, console_ns
from controllers.console.datasets.error import DatasetNameDuplicateError
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
from fields.dataset_fields import dataset_detail_fields
from libs.login import current_account_with_tenant, login_required
from services.dataset_service import DatasetService
@@ -200,12 +200,10 @@ class ExternalDatasetCreateApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
def post(self):
# The role of the current user in the ta table must be admin, owner, or editor
current_user, current_tenant_id = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
-
parser = (
reqparse.RequestParser()
.add_argument("external_knowledge_api_id", type=str, required=True, nullable=False, location="json")
diff --git a/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py b/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py
index 2c28120e65..d658d65b71 100644
--- a/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py
+++ b/api/controllers/console/datasets/rag_pipeline/rag_pipeline_import.py
@@ -1,11 +1,11 @@
from flask_restx import Resource, marshal_with, reqparse # type: ignore
from sqlalchemy.orm import Session
-from werkzeug.exceptions import Forbidden
from controllers.console import console_ns
from controllers.console.datasets.wraps import get_rag_pipeline
from controllers.console.wraps import (
account_initialization_required,
+ edit_permission_required,
setup_required,
)
from extensions.ext_database import db
@@ -21,12 +21,11 @@ class RagPipelineImportApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@marshal_with(pipeline_import_fields)
def post(self):
# Check user role first
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
parser = (
reqparse.RequestParser()
@@ -71,12 +70,10 @@ class RagPipelineImportConfirmApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@marshal_with(pipeline_import_fields)
def post(self, import_id):
current_user, _ = current_account_with_tenant()
- # Check user role first
- if not current_user.has_edit_permission:
- raise Forbidden()
# Create service with session
with Session(db.engine) as session:
@@ -98,12 +95,9 @@ class RagPipelineImportCheckDependenciesApi(Resource):
@login_required
@get_rag_pipeline
@account_initialization_required
+ @edit_permission_required
@marshal_with(pipeline_import_check_dependencies_fields)
def get(self, pipeline: Pipeline):
- current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
-
with Session(db.engine) as session:
import_service = RagPipelineDslService(session)
result = import_service.check_dependencies(pipeline=pipeline)
@@ -117,12 +111,9 @@ class RagPipelineExportApi(Resource):
@login_required
@get_rag_pipeline
@account_initialization_required
+ @edit_permission_required
def get(self, pipeline: Pipeline):
- current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
-
- # Add include_secret params
+ # Add include_secret params
parser = reqparse.RequestParser().add_argument("include_secret", type=str, default="false", location="args")
args = parser.parse_args()
diff --git a/api/controllers/console/datasets/rag_pipeline/rag_pipeline_workflow.py b/api/controllers/console/datasets/rag_pipeline/rag_pipeline_workflow.py
index 1e77a988bd..bc8d4fbf81 100644
--- a/api/controllers/console/datasets/rag_pipeline/rag_pipeline_workflow.py
+++ b/api/controllers/console/datasets/rag_pipeline/rag_pipeline_workflow.py
@@ -191,6 +191,7 @@ class RagPipelineDraftRunLoopNodeApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
def post(self, pipeline: Pipeline, node_id: str):
"""
@@ -198,8 +199,6 @@ class RagPipelineDraftRunLoopNodeApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_run.parse_args()
@@ -235,6 +234,7 @@ class DraftRagPipelineRunApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
def post(self, pipeline: Pipeline):
"""
@@ -242,8 +242,6 @@ class DraftRagPipelineRunApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_draft_run.parse_args()
@@ -279,6 +277,7 @@ class PublishedRagPipelineRunApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
def post(self, pipeline: Pipeline):
"""
@@ -286,8 +285,6 @@ class PublishedRagPipelineRunApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_published_run.parse_args()
@@ -404,6 +401,7 @@ class RagPipelinePublishedDatasourceNodeRunApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
def post(self, pipeline: Pipeline, node_id: str):
"""
@@ -411,8 +409,6 @@ class RagPipelinePublishedDatasourceNodeRunApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_rag_run.parse_args()
@@ -444,6 +440,7 @@ class RagPipelineDraftDatasourceNodeRunApi(Resource):
@api.expect(parser_rag_run)
@setup_required
@login_required
+ @edit_permission_required
@account_initialization_required
@get_rag_pipeline
def post(self, pipeline: Pipeline, node_id: str):
@@ -452,8 +449,6 @@ class RagPipelineDraftDatasourceNodeRunApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_rag_run.parse_args()
@@ -490,6 +485,7 @@ class RagPipelineDraftNodeRunApi(Resource):
@api.expect(parser_run_api)
@setup_required
@login_required
+ @edit_permission_required
@account_initialization_required
@get_rag_pipeline
@marshal_with(workflow_run_node_execution_fields)
@@ -499,8 +495,6 @@ class RagPipelineDraftNodeRunApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_run_api.parse_args()
@@ -523,6 +517,7 @@ class RagPipelineDraftNodeRunApi(Resource):
class RagPipelineTaskStopApi(Resource):
@setup_required
@login_required
+ @edit_permission_required
@account_initialization_required
@get_rag_pipeline
def post(self, pipeline: Pipeline, task_id: str):
@@ -531,8 +526,6 @@ class RagPipelineTaskStopApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
AppQueueManager.set_stop_flag(task_id, InvokeFrom.DEBUGGER, current_user.id)
@@ -544,6 +537,7 @@ class PublishedRagPipelineApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
@marshal_with(workflow_fields)
def get(self, pipeline: Pipeline):
@@ -551,9 +545,6 @@ class PublishedRagPipelineApi(Resource):
Get published pipeline
"""
# The role of the current user in the ta table must be admin, owner, or editor
- current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
if not pipeline.is_published:
return None
# fetch published workflow by pipeline
@@ -566,6 +557,7 @@ class PublishedRagPipelineApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
def post(self, pipeline: Pipeline):
"""
@@ -573,9 +565,6 @@ class PublishedRagPipelineApi(Resource):
"""
# The role of the current user in the ta table must be admin, owner, or editor
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
-
rag_pipeline_service = RagPipelineService()
with Session(db.engine) as session:
pipeline = session.merge(pipeline)
@@ -602,16 +591,12 @@ class DefaultRagPipelineBlockConfigsApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
def get(self, pipeline: Pipeline):
"""
Get default block config
"""
- # The role of the current user in the ta table must be admin, owner, or editor
- current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
-
# Get default block configs
rag_pipeline_service = RagPipelineService()
return rag_pipeline_service.get_default_block_configs()
@@ -626,16 +611,12 @@ class DefaultRagPipelineBlockConfigApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
def get(self, pipeline: Pipeline, block_type: str):
"""
Get default block config
"""
- # The role of the current user in the ta table must be admin, owner, or editor
- current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
-
args = parser_default.parse_args()
q = args.get("q")
@@ -667,6 +648,7 @@ class PublishedAllRagPipelineApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
@marshal_with(workflow_pagination_fields)
def get(self, pipeline: Pipeline):
@@ -674,8 +656,6 @@ class PublishedAllRagPipelineApi(Resource):
Get published workflows
"""
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_wf.parse_args()
page = args["page"]
@@ -720,6 +700,7 @@ class RagPipelineByIdApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
@get_rag_pipeline
@marshal_with(workflow_fields)
def patch(self, pipeline: Pipeline, workflow_id: str):
@@ -728,8 +709,6 @@ class RagPipelineByIdApi(Resource):
"""
# Check permission
current_user, _ = current_account_with_tenant()
- if not current_user.has_edit_permission:
- raise Forbidden()
args = parser_wf_id.parse_args()
diff --git a/api/controllers/console/tag/tags.py b/api/controllers/console/tag/tags.py
index ca8259238b..ee032756eb 100644
--- a/api/controllers/console/tag/tags.py
+++ b/api/controllers/console/tag/tags.py
@@ -3,7 +3,7 @@ from flask_restx import Resource, marshal_with, reqparse
from werkzeug.exceptions import Forbidden
from controllers.console import api, console_ns
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, edit_permission_required, setup_required
from fields.tag_fields import dataset_tag_fields
from libs.login import current_account_with_tenant, login_required
from models.model import Tag
@@ -91,12 +91,9 @@ class TagUpdateDeleteApi(Resource):
@setup_required
@login_required
@account_initialization_required
+ @edit_permission_required
def delete(self, tag_id):
- current_user, _ = current_account_with_tenant()
tag_id = str(tag_id)
- # The role of the current user in the ta table must be admin, owner, or editor
- if not current_user.has_edit_permission:
- raise Forbidden()
TagService.delete_tag(tag_id)
diff --git a/api/controllers/console/workspace/endpoint.py b/api/controllers/console/workspace/endpoint.py
index d115f62d73..ae870a630e 100644
--- a/api/controllers/console/workspace/endpoint.py
+++ b/api/controllers/console/workspace/endpoint.py
@@ -1,8 +1,7 @@
from flask_restx import Resource, fields, reqparse
-from werkzeug.exceptions import Forbidden
from controllers.console import api, console_ns
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
from core.model_runtime.utils.encoders import jsonable_encoder
from core.plugin.impl.exc import PluginPermissionDeniedError
from libs.login import current_account_with_tenant, login_required
@@ -31,11 +30,10 @@ class EndpointCreateApi(Resource):
@api.response(403, "Admin privileges required")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
parser = (
reqparse.RequestParser()
@@ -168,6 +166,7 @@ class EndpointDeleteApi(Resource):
@api.response(403, "Admin privileges required")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
@@ -175,9 +174,6 @@ class EndpointDeleteApi(Resource):
parser = reqparse.RequestParser().add_argument("endpoint_id", type=str, required=True)
args = parser.parse_args()
- if not user.is_admin_or_owner:
- raise Forbidden()
-
endpoint_id = args["endpoint_id"]
return {
@@ -207,6 +203,7 @@ class EndpointUpdateApi(Resource):
@api.response(403, "Admin privileges required")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
@@ -223,9 +220,6 @@ class EndpointUpdateApi(Resource):
settings = args["settings"]
name = args["name"]
- if not user.is_admin_or_owner:
- raise Forbidden()
-
return {
"success": EndpointService.update_endpoint(
tenant_id=tenant_id,
@@ -252,6 +246,7 @@ class EndpointEnableApi(Resource):
@api.response(403, "Admin privileges required")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
@@ -261,9 +256,6 @@ class EndpointEnableApi(Resource):
endpoint_id = args["endpoint_id"]
- if not user.is_admin_or_owner:
- raise Forbidden()
-
return {
"success": EndpointService.enable_endpoint(tenant_id=tenant_id, user_id=user.id, endpoint_id=endpoint_id)
}
@@ -284,6 +276,7 @@ class EndpointDisableApi(Resource):
@api.response(403, "Admin privileges required")
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
@@ -293,9 +286,6 @@ class EndpointDisableApi(Resource):
endpoint_id = args["endpoint_id"]
- if not user.is_admin_or_owner:
- raise Forbidden()
-
return {
"success": EndpointService.disable_endpoint(tenant_id=tenant_id, user_id=user.id, endpoint_id=endpoint_id)
}
diff --git a/api/controllers/console/workspace/model_providers.py b/api/controllers/console/workspace/model_providers.py
index 832ec8af0f..05731b3832 100644
--- a/api/controllers/console/workspace/model_providers.py
+++ b/api/controllers/console/workspace/model_providers.py
@@ -2,10 +2,9 @@ import io
from flask import send_file
from flask_restx import Resource, reqparse
-from werkzeug.exceptions import Forbidden
from controllers.console import api, console_ns
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
from core.model_runtime.entities.model_entities import ModelType
from core.model_runtime.errors.validate import CredentialsValidateFailedError
from core.model_runtime.utils.encoders import jsonable_encoder
@@ -85,12 +84,10 @@ class ModelProviderCredentialApi(Resource):
@api.expect(parser_post_cred)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
-
+ _, current_tenant_id = current_account_with_tenant()
args = parser_post_cred.parse_args()
model_provider_service = ModelProviderService()
@@ -110,11 +107,10 @@ class ModelProviderCredentialApi(Resource):
@api.expect(parser_put_cred)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def put(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, current_tenant_id = current_account_with_tenant()
args = parser_put_cred.parse_args()
@@ -136,12 +132,10 @@ class ModelProviderCredentialApi(Resource):
@api.expect(parser_delete_cred)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def delete(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
-
+ _, current_tenant_id = current_account_with_tenant()
args = parser_delete_cred.parse_args()
model_provider_service = ModelProviderService()
@@ -162,11 +156,10 @@ class ModelProviderCredentialSwitchApi(Resource):
@api.expect(parser_switch)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, current_tenant_id = current_account_with_tenant()
args = parser_switch.parse_args()
service = ModelProviderService()
@@ -250,11 +243,10 @@ class PreferredProviderTypeUpdateApi(Resource):
@api.expect(parser_preferred)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, current_tenant_id = current_account_with_tenant()
tenant_id = current_tenant_id
diff --git a/api/controllers/console/workspace/models.py b/api/controllers/console/workspace/models.py
index d6aad129a6..79079f692e 100644
--- a/api/controllers/console/workspace/models.py
+++ b/api/controllers/console/workspace/models.py
@@ -1,10 +1,9 @@
import logging
from flask_restx import Resource, reqparse
-from werkzeug.exceptions import Forbidden
from controllers.console import api, console_ns
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
from core.model_runtime.entities.model_entities import ModelType
from core.model_runtime.errors.validate import CredentialsValidateFailedError
from core.model_runtime.utils.encoders import jsonable_encoder
@@ -50,12 +49,10 @@ class DefaultModelApi(Resource):
@api.expect(parser_post_default)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
- current_user, tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, tenant_id = current_account_with_tenant()
args = parser_post_default.parse_args()
model_provider_service = ModelProviderService()
@@ -133,13 +130,11 @@ class ModelProviderModelApi(Resource):
@api.expect(parser_post_models)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider: str):
# To save the model's load balance configs
- current_user, tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, tenant_id = current_account_with_tenant()
args = parser_post_models.parse_args()
if args.get("config_from", "") == "custom-model":
@@ -181,12 +176,10 @@ class ModelProviderModelApi(Resource):
@api.expect(parser_delete_models)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def delete(self, provider: str):
- current_user, tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, tenant_id = current_account_with_tenant()
args = parser_delete_models.parse_args()
@@ -314,12 +307,10 @@ class ModelProviderModelCredentialApi(Resource):
@api.expect(parser_post_cred)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider: str):
- current_user, tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, tenant_id = current_account_with_tenant()
args = parser_post_cred.parse_args()
@@ -348,13 +339,10 @@ class ModelProviderModelCredentialApi(Resource):
@api.expect(parser_put_cred)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def put(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
-
+ _, current_tenant_id = current_account_with_tenant()
args = parser_put_cred.parse_args()
model_provider_service = ModelProviderService()
@@ -377,12 +365,10 @@ class ModelProviderModelCredentialApi(Resource):
@api.expect(parser_delete_cred)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def delete(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
-
- if not current_user.is_admin_or_owner:
- raise Forbidden()
+ _, current_tenant_id = current_account_with_tenant()
args = parser_delete_cred.parse_args()
model_provider_service = ModelProviderService()
@@ -417,12 +403,11 @@ class ModelProviderModelCredentialSwitchApi(Resource):
@api.expect(parser_switch)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider: str):
- current_user, current_tenant_id = current_account_with_tenant()
+ _, current_tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
args = parser_switch.parse_args()
service = ModelProviderService()
diff --git a/api/controllers/console/workspace/plugin.py b/api/controllers/console/workspace/plugin.py
index bb8c02b99a..deae418e96 100644
--- a/api/controllers/console/workspace/plugin.py
+++ b/api/controllers/console/workspace/plugin.py
@@ -7,7 +7,7 @@ from werkzeug.exceptions import Forbidden
from configs import dify_config
from controllers.console import api, console_ns
from controllers.console.workspace import plugin_permission_required
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
from core.model_runtime.utils.encoders import jsonable_encoder
from core.plugin.impl.exc import PluginDaemonClientSideError
from libs.login import current_account_with_tenant, login_required
@@ -132,9 +132,11 @@ class PluginAssetApi(Resource):
@login_required
@account_initialization_required
def get(self):
- req = reqparse.RequestParser()
- req.add_argument("plugin_unique_identifier", type=str, required=True, location="args")
- req.add_argument("file_name", type=str, required=True, location="args")
+ req = (
+ reqparse.RequestParser()
+ .add_argument("plugin_unique_identifier", type=str, required=True, location="args")
+ .add_argument("file_name", type=str, required=True, location="args")
+ )
args = req.parse_args()
_, tenant_id = current_account_with_tenant()
@@ -619,13 +621,10 @@ class PluginFetchDynamicSelectOptionsApi(Resource):
@api.expect(parser_dynamic)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def get(self):
- # check if the user is admin or owner
current_user, tenant_id = current_account_with_tenant()
- if not current_user.is_admin_or_owner:
- raise Forbidden()
-
user_id = current_user.id
args = parser_dynamic.parse_args()
@@ -770,9 +769,11 @@ class PluginReadmeApi(Resource):
@account_initialization_required
def get(self):
_, tenant_id = current_account_with_tenant()
- parser = reqparse.RequestParser()
- parser.add_argument("plugin_unique_identifier", type=str, required=True, location="args")
- parser.add_argument("language", type=str, required=False, location="args")
+ parser = (
+ reqparse.RequestParser()
+ .add_argument("plugin_unique_identifier", type=str, required=True, location="args")
+ .add_argument("language", type=str, required=False, location="args")
+ )
args = parser.parse_args()
return jsonable_encoder(
{
diff --git a/api/controllers/console/workspace/tool_providers.py b/api/controllers/console/workspace/tool_providers.py
index cc7fa0fc3d..917059bb4c 100644
--- a/api/controllers/console/workspace/tool_providers.py
+++ b/api/controllers/console/workspace/tool_providers.py
@@ -14,6 +14,7 @@ from controllers.console import api, console_ns
from controllers.console.wraps import (
account_initialization_required,
enterprise_license_required,
+ is_admin_or_owner_required,
setup_required,
)
from core.entities.mcp_provider import MCPAuthentication, MCPConfiguration
@@ -115,11 +116,10 @@ class ToolBuiltinProviderDeleteApi(Resource):
@api.expect(parser_delete)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider):
- user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
+ _, tenant_id = current_account_with_tenant()
args = parser_delete.parse_args()
@@ -177,13 +177,10 @@ class ToolBuiltinProviderUpdateApi(Resource):
@api.expect(parser_update)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider):
user, tenant_id = current_account_with_tenant()
-
- if not user.is_admin_or_owner:
- raise Forbidden()
-
user_id = user.id
args = parser_update.parse_args()
@@ -242,13 +239,11 @@ class ToolApiProviderAddApi(Resource):
@api.expect(parser_api_add)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
-
user_id = user.id
args = parser_api_add.parse_args()
@@ -336,13 +331,11 @@ class ToolApiProviderUpdateApi(Resource):
@api.expect(parser_api_update)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
-
user_id = user.id
args = parser_api_update.parse_args()
@@ -372,13 +365,11 @@ class ToolApiProviderDeleteApi(Resource):
@api.expect(parser_api_delete)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
-
user_id = user.id
args = parser_api_delete.parse_args()
@@ -496,13 +487,11 @@ class ToolWorkflowProviderCreateApi(Resource):
@api.expect(parser_create)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
-
user_id = user.id
args = parser_create.parse_args()
@@ -539,13 +528,10 @@ class ToolWorkflowProviderUpdateApi(Resource):
@api.expect(parser_workflow_update)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
-
- if not user.is_admin_or_owner:
- raise Forbidden()
-
user_id = user.id
args = parser_workflow_update.parse_args()
@@ -577,13 +563,11 @@ class ToolWorkflowProviderDeleteApi(Resource):
@api.expect(parser_workflow_delete)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self):
user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
-
user_id = user.id
args = parser_workflow_delete.parse_args()
@@ -734,18 +718,15 @@ class ToolLabelsApi(Resource):
class ToolPluginOAuthApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def get(self, provider):
tool_provider = ToolProviderID(provider)
plugin_id = tool_provider.plugin_id
provider_name = tool_provider.provider_name
- # todo check permission
user, tenant_id = current_account_with_tenant()
- if not user.is_admin_or_owner:
- raise Forbidden()
-
oauth_client_params = BuiltinToolManageService.get_oauth_client(tenant_id=tenant_id, provider=provider)
if oauth_client_params is None:
raise Forbidden("no oauth available client config found for this tool provider")
@@ -856,14 +837,12 @@ class ToolOAuthCustomClient(Resource):
@api.expect(parser_custom)
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
- def post(self, provider):
+ def post(self, provider: str):
args = parser_custom.parse_args()
- user, tenant_id = current_account_with_tenant()
-
- if not user.is_admin_or_owner:
- raise Forbidden()
+ _, tenant_id = current_account_with_tenant()
return BuiltinToolManageService.save_custom_oauth_client_params(
tenant_id=tenant_id,
diff --git a/api/controllers/console/workspace/trigger_providers.py b/api/controllers/console/workspace/trigger_providers.py
index bbbbe12fb0..b2abae0b3d 100644
--- a/api/controllers/console/workspace/trigger_providers.py
+++ b/api/controllers/console/workspace/trigger_providers.py
@@ -7,7 +7,7 @@ from werkzeug.exceptions import BadRequest, Forbidden
from configs import dify_config
from controllers.console import api
-from controllers.console.wraps import account_initialization_required, setup_required
+from controllers.console.wraps import account_initialization_required, is_admin_or_owner_required, setup_required
from controllers.web.error import NotFoundError
from core.model_runtime.utils.encoders import jsonable_encoder
from core.plugin.entities.plugin_daemon import CredentialType
@@ -67,14 +67,12 @@ class TriggerProviderInfoApi(Resource):
class TriggerSubscriptionListApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def get(self, provider):
"""List all trigger subscriptions for the current tenant's provider"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
try:
return jsonable_encoder(
@@ -92,17 +90,16 @@ class TriggerSubscriptionListApi(Resource):
class TriggerSubscriptionBuilderCreateApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider):
"""Add a new subscription instance for a trigger provider"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
- parser = reqparse.RequestParser()
- parser.add_argument("credential_type", type=str, required=False, nullable=True, location="json")
+ parser = reqparse.RequestParser().add_argument(
+ "credential_type", type=str, required=False, nullable=True, location="json"
+ )
args = parser.parse_args()
try:
@@ -133,18 +130,17 @@ class TriggerSubscriptionBuilderGetApi(Resource):
class TriggerSubscriptionBuilderVerifyApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider, subscription_builder_id):
"""Verify a subscription instance for a trigger provider"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
-
- parser = reqparse.RequestParser()
- # The credentials of the subscription builder
- parser.add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+ parser = (
+ reqparse.RequestParser()
+ # The credentials of the subscription builder
+ .add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+ )
args = parser.parse_args()
try:
@@ -173,15 +169,17 @@ class TriggerSubscriptionBuilderUpdateApi(Resource):
assert isinstance(user, Account)
assert user.current_tenant_id is not None
- parser = reqparse.RequestParser()
- # The name of the subscription builder
- parser.add_argument("name", type=str, required=False, nullable=True, location="json")
- # The parameters of the subscription builder
- parser.add_argument("parameters", type=dict, required=False, nullable=True, location="json")
- # The properties of the subscription builder
- parser.add_argument("properties", type=dict, required=False, nullable=True, location="json")
- # The credentials of the subscription builder
- parser.add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+ parser = (
+ reqparse.RequestParser()
+ # The name of the subscription builder
+ .add_argument("name", type=str, required=False, nullable=True, location="json")
+ # The parameters of the subscription builder
+ .add_argument("parameters", type=dict, required=False, nullable=True, location="json")
+ # The properties of the subscription builder
+ .add_argument("properties", type=dict, required=False, nullable=True, location="json")
+ # The credentials of the subscription builder
+ .add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+ )
args = parser.parse_args()
try:
return jsonable_encoder(
@@ -223,24 +221,23 @@ class TriggerSubscriptionBuilderLogsApi(Resource):
class TriggerSubscriptionBuilderBuildApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider, subscription_builder_id):
"""Build a subscription instance for a trigger provider"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
-
- parser = reqparse.RequestParser()
- # The name of the subscription builder
- parser.add_argument("name", type=str, required=False, nullable=True, location="json")
- # The parameters of the subscription builder
- parser.add_argument("parameters", type=dict, required=False, nullable=True, location="json")
- # The properties of the subscription builder
- parser.add_argument("properties", type=dict, required=False, nullable=True, location="json")
- # The credentials of the subscription builder
- parser.add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+ parser = (
+ reqparse.RequestParser()
+ # The name of the subscription builder
+ .add_argument("name", type=str, required=False, nullable=True, location="json")
+ # The parameters of the subscription builder
+ .add_argument("parameters", type=dict, required=False, nullable=True, location="json")
+ # The properties of the subscription builder
+ .add_argument("properties", type=dict, required=False, nullable=True, location="json")
+ # The credentials of the subscription builder
+ .add_argument("credentials", type=dict, required=False, nullable=True, location="json")
+ )
args = parser.parse_args()
try:
# Use atomic update_and_build to prevent race conditions
@@ -264,14 +261,12 @@ class TriggerSubscriptionBuilderBuildApi(Resource):
class TriggerSubscriptionDeleteApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, subscription_id: str):
"""Delete a subscription instance"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
try:
with Session(db.engine) as session:
@@ -446,14 +441,12 @@ class TriggerOAuthCallbackApi(Resource):
class TriggerOAuthClientManageApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def get(self, provider):
"""Get OAuth client configuration for a provider"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
try:
provider_id = TriggerProviderID(provider)
@@ -493,18 +486,18 @@ class TriggerOAuthClientManageApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def post(self, provider):
"""Configure custom OAuth client for a provider"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
- parser = reqparse.RequestParser()
- parser.add_argument("client_params", type=dict, required=False, nullable=True, location="json")
- parser.add_argument("enabled", type=bool, required=False, nullable=True, location="json")
+ parser = (
+ reqparse.RequestParser()
+ .add_argument("client_params", type=dict, required=False, nullable=True, location="json")
+ .add_argument("enabled", type=bool, required=False, nullable=True, location="json")
+ )
args = parser.parse_args()
try:
@@ -524,14 +517,12 @@ class TriggerOAuthClientManageApi(Resource):
@setup_required
@login_required
+ @is_admin_or_owner_required
@account_initialization_required
def delete(self, provider):
"""Remove custom OAuth client configuration"""
user = current_user
- assert isinstance(user, Account)
assert user.current_tenant_id is not None
- if not user.is_admin_or_owner:
- raise Forbidden()
try:
provider_id = TriggerProviderID(provider)
diff --git a/api/controllers/console/wraps.py b/api/controllers/console/wraps.py
index 9b485544db..f40f566a36 100644
--- a/api/controllers/console/wraps.py
+++ b/api/controllers/console/wraps.py
@@ -315,3 +315,19 @@ def edit_permission_required(f: Callable[P, R]):
return f(*args, **kwargs)
return decorated_function
+
+
+def is_admin_or_owner_required(f: Callable[P, R]):
+ @wraps(f)
+ def decorated_function(*args: P.args, **kwargs: P.kwargs):
+ from werkzeug.exceptions import Forbidden
+
+ from libs.login import current_user
+ from models import Account
+
+ user = current_user._get_current_object()
+ if not isinstance(user, Account) or not user.is_admin_or_owner:
+ raise Forbidden()
+ return f(*args, **kwargs)
+
+ return decorated_function
diff --git a/api/controllers/service_api/app/annotation.py b/api/controllers/service_api/app/annotation.py
index ed013b1674..f26718555a 100644
--- a/api/controllers/service_api/app/annotation.py
+++ b/api/controllers/service_api/app/annotation.py
@@ -3,14 +3,12 @@ from typing import Literal
from flask import request
from flask_restx import Api, Namespace, Resource, fields, reqparse
from flask_restx.api import HTTPStatus
-from werkzeug.exceptions import Forbidden
+from controllers.console.wraps import edit_permission_required
from controllers.service_api import service_api_ns
from controllers.service_api.wraps import validate_app_token
from extensions.ext_redis import redis_client
from fields.annotation_fields import annotation_fields, build_annotation_model
-from libs.login import current_user
-from models import Account
from models.model import App
from services.annotation_service import AppAnnotationService
@@ -161,14 +159,10 @@ class AnnotationUpdateDeleteApi(Resource):
}
)
@validate_app_token
+ @edit_permission_required
@service_api_ns.marshal_with(build_annotation_model(service_api_ns))
- def put(self, app_model: App, annotation_id):
+ def put(self, app_model: App, annotation_id: str):
"""Update an existing annotation."""
- assert isinstance(current_user, Account)
- if not current_user.has_edit_permission:
- raise Forbidden()
-
- annotation_id = str(annotation_id)
args = annotation_create_parser.parse_args()
annotation = AppAnnotationService.update_app_annotation_directly(args, app_model.id, annotation_id)
return annotation
@@ -185,13 +179,8 @@ class AnnotationUpdateDeleteApi(Resource):
}
)
@validate_app_token
- def delete(self, app_model: App, annotation_id):
+ @edit_permission_required
+ def delete(self, app_model: App, annotation_id: str):
"""Delete an annotation."""
- assert isinstance(current_user, Account)
-
- if not current_user.has_edit_permission:
- raise Forbidden()
-
- annotation_id = str(annotation_id)
AppAnnotationService.delete_app_annotation(app_model.id, annotation_id)
return {"result": "success"}, 204
diff --git a/api/controllers/service_api/dataset/dataset.py b/api/controllers/service_api/dataset/dataset.py
index 9d5566919b..4cca3e6ce8 100644
--- a/api/controllers/service_api/dataset/dataset.py
+++ b/api/controllers/service_api/dataset/dataset.py
@@ -5,6 +5,7 @@ from flask_restx import marshal, reqparse
from werkzeug.exceptions import Forbidden, NotFound
import services
+from controllers.console.wraps import edit_permission_required
from controllers.service_api import service_api_ns
from controllers.service_api.dataset.error import DatasetInUseError, DatasetNameDuplicateError, InvalidActionError
from controllers.service_api.wraps import (
@@ -619,11 +620,9 @@ class DatasetTagsApi(DatasetApiResource):
}
)
@validate_dataset_token
+ @edit_permission_required
def delete(self, _, dataset_id):
"""Delete a knowledge type tag."""
- assert isinstance(current_user, Account)
- if not current_user.has_edit_permission:
- raise Forbidden()
args = tag_delete_parser.parse_args()
TagService.delete_tag(args["tag_id"])
From 4486b54680bb3b59ca2414aadc3670acb5a5c4be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E8=80=90=E5=B0=8F=E5=BF=83?=
Date: Fri, 21 Nov 2025 14:26:57 +0800
Subject: [PATCH 031/191] Clean up legacy conditions data in if-else nodes to
prevent misjudgments (#28148)
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
.../nodes/_base/components/variable/utils.ts | 33 ++++++++++---------
.../if-else/use-single-run-form-params.ts | 16 ---------
.../workflow/utils/workflow-init.ts | 5 +++
3 files changed, 23 insertions(+), 31 deletions(-)
diff --git a/web/app/components/workflow/nodes/_base/components/variable/utils.ts b/web/app/components/workflow/nodes/_base/components/variable/utils.ts
index 3bd43bd29a..84dd410565 100644
--- a/web/app/components/workflow/nodes/_base/components/variable/utils.ts
+++ b/web/app/components/workflow/nodes/_base/components/variable/utils.ts
@@ -42,7 +42,7 @@ import type { RAGPipelineVariable } from '@/models/pipeline'
import type { WebhookTriggerNodeType } from '@/app/components/workflow/nodes/trigger-webhook/types'
import type { PluginTriggerNodeType } from '@/app/components/workflow/nodes/trigger-plugin/types'
import PluginTriggerNodeDefault from '@/app/components/workflow/nodes/trigger-plugin/default'
-
+import type { CaseItem, Condition } from '@/app/components/workflow/nodes/if-else/types'
import {
AGENT_OUTPUT_STRUCT,
FILE_STRUCT,
@@ -1305,10 +1305,7 @@ export const getNodeUsedVars = (node: Node): ValueSelector[] => {
break
}
case BlockEnum.IfElse: {
- res
- = (data as IfElseNodeType).conditions?.map((c) => {
- return c.variable_selector || []
- }) || []
+ res = []
res.push(
...((data as IfElseNodeType).cases || [])
.flatMap(c => c.conditions || [])
@@ -1480,9 +1477,22 @@ export const getNodeUsedVarPassToServerKey = (
break
}
case BlockEnum.IfElse: {
- const targetVar = (data as IfElseNodeType).conditions?.find(
- c => c.variable_selector?.join('.') === valueSelector.join('.'),
- )
+ const findConditionInCases = (cases: CaseItem[]): Condition | undefined => {
+ for (const caseItem of cases) {
+ for (const condition of caseItem.conditions || []) {
+ if (condition.variable_selector?.join('.') === valueSelector.join('.'))
+ return condition
+
+ if (condition.sub_variable_condition) {
+ const found = findConditionInCases([condition.sub_variable_condition])
+ if (found)
+ return found
+ }
+ }
+ }
+ return undefined
+ }
+ const targetVar = findConditionInCases((data as IfElseNodeType).cases || [])
if (targetVar) res = `#${valueSelector.join('.')}#`
break
}
@@ -1634,13 +1644,6 @@ export const updateNodeVars = (
}
case BlockEnum.IfElse: {
const payload = data as IfElseNodeType
- if (payload.conditions) {
- payload.conditions = payload.conditions.map((c) => {
- if (c.variable_selector?.join('.') === oldVarSelector.join('.'))
- c.variable_selector = newVarSelector
- return c
- })
- }
if (payload.cases) {
payload.cases = payload.cases.map((caseItem) => {
if (caseItem.conditions) {
diff --git a/web/app/components/workflow/nodes/if-else/use-single-run-form-params.ts b/web/app/components/workflow/nodes/if-else/use-single-run-form-params.ts
index 8bf667e0cc..4f07f072cc 100644
--- a/web/app/components/workflow/nodes/if-else/use-single-run-form-params.ts
+++ b/web/app/components/workflow/nodes/if-else/use-single-run-form-params.ts
@@ -89,15 +89,6 @@ const useSingleRunFormParams = ({
inputVarsFromValue.push(...getInputVarsFromCase(caseItem))
})
}
-
- if (payload.conditions && payload.conditions.length) {
- payload.conditions.forEach((condition) => {
- const conditionVars = getVarSelectorsFromCondition(condition)
- allInputs.push(...conditionVars)
- inputVarsFromValue.push(...getInputVarsFromConditionValue(condition))
- })
- }
-
const varInputs = [...varSelectorsToVarInputs(allInputs), ...inputVarsFromValue]
// remove duplicate inputs
const existVarsKey: Record = {}
@@ -148,13 +139,6 @@ const useSingleRunFormParams = ({
vars.push(...caseVars)
})
}
-
- if (payload.conditions && payload.conditions.length) {
- payload.conditions.forEach((condition) => {
- const conditionVars = getVarFromCondition(condition)
- vars.push(...conditionVars)
- })
- }
return vars
}
return {
diff --git a/web/app/components/workflow/utils/workflow-init.ts b/web/app/components/workflow/utils/workflow-init.ts
index 92233f8d08..08d0d82e79 100644
--- a/web/app/components/workflow/utils/workflow-init.ts
+++ b/web/app/components/workflow/utils/workflow-init.ts
@@ -242,6 +242,11 @@ export const initialNodes = (originNodes: Node[], originEdges: Edge[]) => {
...(node.data as IfElseNodeType).cases.map(item => ({ id: item.case_id, name: '' })),
{ id: 'false', name: '' },
])
+ // delete conditions and logical_operator if cases is not empty
+ if (nodeData.cases.length > 0 && nodeData.conditions && nodeData.logical_operator) {
+ delete nodeData.conditions
+ delete nodeData.logical_operator
+ }
}
if (node.data.type === BlockEnum.QuestionClassifier) {
From 237bb4595b0dd40ad6744ffc8c6afa0dc401eb16 Mon Sep 17 00:00:00 2001
From: Asuka Minato
Date: Fri, 21 Nov 2025 16:42:27 +0900
Subject: [PATCH 032/191] more typed orm (#28494)
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
.../apps/workflow/generate_task_pipeline.py | 17 ++---
api/models/model.py | 66 +++++++++++--------
api/models/provider.py | 50 ++++++++------
api/models/trigger.py | 29 +++++---
api/models/workflow.py | 43 ++++++------
.../services/test_webhook_service.py | 4 +-
.../services/test_workflow_app_service.py | 44 ++++++-------
.../unit_tests/core/test_provider_manager.py | 65 +++++++++---------
8 files changed, 177 insertions(+), 141 deletions(-)
diff --git a/api/core/app/apps/workflow/generate_task_pipeline.py b/api/core/app/apps/workflow/generate_task_pipeline.py
index 08e2fce48c..4157870620 100644
--- a/api/core/app/apps/workflow/generate_task_pipeline.py
+++ b/api/core/app/apps/workflow/generate_task_pipeline.py
@@ -644,14 +644,15 @@ class WorkflowAppGenerateTaskPipeline(GraphRuntimeStateSupport):
if not workflow_run_id:
return
- workflow_app_log = WorkflowAppLog()
- workflow_app_log.tenant_id = self._application_generate_entity.app_config.tenant_id
- workflow_app_log.app_id = self._application_generate_entity.app_config.app_id
- workflow_app_log.workflow_id = self._workflow.id
- workflow_app_log.workflow_run_id = workflow_run_id
- workflow_app_log.created_from = created_from.value
- workflow_app_log.created_by_role = self._created_by_role
- workflow_app_log.created_by = self._user_id
+ workflow_app_log = WorkflowAppLog(
+ tenant_id=self._application_generate_entity.app_config.tenant_id,
+ app_id=self._application_generate_entity.app_config.app_id,
+ workflow_id=self._workflow.id,
+ workflow_run_id=workflow_run_id,
+ created_from=created_from.value,
+ created_by_role=self._created_by_role,
+ created_by=self._user_id,
+ )
session.add(workflow_app_log)
session.commit()
diff --git a/api/models/model.py b/api/models/model.py
index 9949d4c20f..fb287bcea5 100644
--- a/api/models/model.py
+++ b/api/models/model.py
@@ -24,7 +24,7 @@ from libs.helper import generate_string # type: ignore[import-not-found]
from libs.uuid_utils import uuidv7
from .account import Account, Tenant
-from .base import Base
+from .base import Base, TypeBase
from .engine import db
from .enums import CreatorUserRole
from .provider_ids import GenericProviderID
@@ -34,12 +34,14 @@ if TYPE_CHECKING:
from models.workflow import Workflow
-class DifySetup(Base):
+class DifySetup(TypeBase):
__tablename__ = "dify_setups"
__table_args__ = (sa.PrimaryKeyConstraint("version", name="dify_setup_pkey"),)
version: Mapped[str] = mapped_column(String(255), nullable=False)
- setup_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+ setup_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
class AppMode(StrEnum):
@@ -561,7 +563,7 @@ class RecommendedApp(Base):
return app
-class InstalledApp(Base):
+class InstalledApp(TypeBase):
__tablename__ = "installed_apps"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="installed_app_pkey"),
@@ -570,14 +572,16 @@ class InstalledApp(Base):
sa.UniqueConstraint("tenant_id", "app_id", name="unique_tenant_app"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuid4()))
- tenant_id = mapped_column(StringUUID, nullable=False)
- app_id = mapped_column(StringUUID, nullable=False)
- app_owner_tenant_id = mapped_column(StringUUID, nullable=False)
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ app_owner_tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
position: Mapped[int] = mapped_column(sa.Integer, nullable=False, default=0)
- is_pinned: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"))
- last_used_at = mapped_column(sa.DateTime, nullable=True)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+ is_pinned: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"), default=False)
+ last_used_at: Mapped[datetime | None] = mapped_column(sa.DateTime, nullable=True, default=None)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
@property
def app(self) -> App | None:
@@ -1533,25 +1537,31 @@ class EndUser(Base, UserMixin):
)
-class AppMCPServer(Base):
+class AppMCPServer(TypeBase):
__tablename__ = "app_mcp_servers"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="app_mcp_server_pkey"),
sa.UniqueConstraint("tenant_id", "app_id", name="unique_app_mcp_server_tenant_app_id"),
sa.UniqueConstraint("server_code", name="unique_app_mcp_server_server_code"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuid4()))
- tenant_id = mapped_column(StringUUID, nullable=False)
- app_id = mapped_column(StringUUID, nullable=False)
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
name: Mapped[str] = mapped_column(String(255), nullable=False)
description: Mapped[str] = mapped_column(String(255), nullable=False)
server_code: Mapped[str] = mapped_column(String(255), nullable=False)
- status = mapped_column(String(255), nullable=False, server_default=sa.text("'normal'"))
- parameters = mapped_column(LongText, nullable=False)
+ status: Mapped[str] = mapped_column(String(255), nullable=False, server_default=sa.text("'normal'"))
+ parameters: Mapped[str] = mapped_column(LongText, nullable=False)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
- updated_at = mapped_column(
- sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
+ updated_at: Mapped[datetime] = mapped_column(
+ sa.DateTime,
+ nullable=False,
+ server_default=func.current_timestamp(),
+ onupdate=func.current_timestamp(),
+ init=False,
)
@staticmethod
@@ -1928,7 +1938,7 @@ class Tag(Base):
created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
-class TagBinding(Base):
+class TagBinding(TypeBase):
__tablename__ = "tag_bindings"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="tag_binding_pkey"),
@@ -1936,12 +1946,14 @@ class TagBinding(Base):
sa.Index("tag_bind_tag_id_idx", "tag_id"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuid4()))
- tenant_id = mapped_column(StringUUID, nullable=True)
- tag_id = mapped_column(StringUUID, nullable=True)
- target_id = mapped_column(StringUUID, nullable=True)
- created_by = mapped_column(StringUUID, nullable=False)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+ tenant_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+ tag_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+ target_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+ created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
class TraceAppConfig(Base):
diff --git a/api/models/provider.py b/api/models/provider.py
index 07e7384ad5..5f54676389 100644
--- a/api/models/provider.py
+++ b/api/models/provider.py
@@ -118,7 +118,7 @@ class Provider(TypeBase):
return self.is_valid and self.token_is_set
-class ProviderModel(Base):
+class ProviderModel(TypeBase):
"""
Provider model representing the API provider_models and their configurations.
"""
@@ -132,16 +132,18 @@ class ProviderModel(Base):
),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
model_name: Mapped[str] = mapped_column(String(255), nullable=False)
model_type: Mapped[str] = mapped_column(String(40), nullable=False)
- credential_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
- is_valid: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("false"))
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ credential_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True, default=None)
+ is_valid: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("false"), default=False)
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
- DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
)
@cached_property
@@ -182,31 +184,33 @@ class TenantDefaultModel(Base):
)
-class TenantPreferredModelProvider(Base):
+class TenantPreferredModelProvider(TypeBase):
__tablename__ = "tenant_preferred_model_providers"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="tenant_preferred_model_provider_pkey"),
sa.Index("tenant_preferred_model_provider_tenant_provider_idx", "tenant_id", "provider_name"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
preferred_provider_type: Mapped[str] = mapped_column(String(40), nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
- DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
)
-class ProviderOrder(Base):
+class ProviderOrder(TypeBase):
__tablename__ = "provider_orders"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="provider_order_pkey"),
sa.Index("provider_order_tenant_provider_idx", "tenant_id", "provider_name"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
account_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
@@ -220,13 +224,15 @@ class ProviderOrder(Base):
paid_at: Mapped[datetime | None] = mapped_column(DateTime)
pay_failed_at: Mapped[datetime | None] = mapped_column(DateTime)
refunded_at: Mapped[datetime | None] = mapped_column(DateTime)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
- DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
)
-class ProviderModelSetting(Base):
+class ProviderModelSetting(TypeBase):
"""
Provider model settings for record the model enabled status and load balancing status.
"""
@@ -237,16 +243,20 @@ class ProviderModelSetting(Base):
sa.Index("provider_model_setting_tenant_provider_model_idx", "tenant_id", "provider_name", "model_type"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
model_name: Mapped[str] = mapped_column(String(255), nullable=False)
model_type: Mapped[str] = mapped_column(String(40), nullable=False)
- enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("true"))
- load_balancing_enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("false"))
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ enabled: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=text("true"), default=True)
+ load_balancing_enabled: Mapped[bool] = mapped_column(
+ sa.Boolean, nullable=False, server_default=text("false"), default=False
+ )
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
- DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
)
diff --git a/api/models/trigger.py b/api/models/trigger.py
index 932803670a..92384b0d02 100644
--- a/api/models/trigger.py
+++ b/api/models/trigger.py
@@ -271,7 +271,7 @@ class WorkflowTriggerLog(Base):
}
-class WorkflowWebhookTrigger(Base):
+class WorkflowWebhookTrigger(TypeBase):
"""
Workflow Webhook Trigger
@@ -294,18 +294,21 @@ class WorkflowWebhookTrigger(Base):
sa.UniqueConstraint("webhook_id", name="uniq_webhook_id"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
node_id: Mapped[str] = mapped_column(String(64), nullable=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
webhook_id: Mapped[str] = mapped_column(String(24), nullable=False)
created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.current_timestamp(),
server_onupdate=func.current_timestamp(),
+ init=False,
)
@cached_property
@@ -323,7 +326,7 @@ class WorkflowWebhookTrigger(Base):
return generate_webhook_trigger_endpoint(self.webhook_id, True)
-class WorkflowPluginTrigger(Base):
+class WorkflowPluginTrigger(TypeBase):
"""
Workflow Plugin Trigger
@@ -348,23 +351,26 @@ class WorkflowPluginTrigger(Base):
sa.UniqueConstraint("app_id", "node_id", name="uniq_app_node_subscription"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
node_id: Mapped[str] = mapped_column(String(64), nullable=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
provider_id: Mapped[str] = mapped_column(String(512), nullable=False)
event_name: Mapped[str] = mapped_column(String(255), nullable=False)
subscription_id: Mapped[str] = mapped_column(String(255), nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
server_default=func.current_timestamp(),
server_onupdate=func.current_timestamp(),
+ init=False,
)
-class AppTrigger(Base):
+class AppTrigger(TypeBase):
"""
App Trigger
@@ -389,22 +395,25 @@ class AppTrigger(Base):
sa.Index("app_trigger_tenant_app_idx", "tenant_id", "app_id"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
node_id: Mapped[str | None] = mapped_column(String(64), nullable=False)
trigger_type: Mapped[str] = mapped_column(EnumText(AppTriggerType, length=50), nullable=False)
title: Mapped[str] = mapped_column(String(255), nullable=False)
- provider_name: Mapped[str] = mapped_column(String(255), server_default="", nullable=True)
+ provider_name: Mapped[str] = mapped_column(String(255), server_default="", default="") # why it is nullable?
status: Mapped[str] = mapped_column(
EnumText(AppTriggerStatus, length=50), nullable=False, default=AppTriggerStatus.ENABLED
)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
DateTime,
nullable=False,
default=naive_utc_now(),
server_onupdate=func.current_timestamp(),
+ init=False,
)
diff --git a/api/models/workflow.py b/api/models/workflow.py
index fbdaf25da0..d8d3e1e540 100644
--- a/api/models/workflow.py
+++ b/api/models/workflow.py
@@ -7,7 +7,19 @@ from typing import TYPE_CHECKING, Any, Optional, Union, cast
from uuid import uuid4
import sqlalchemy as sa
-from sqlalchemy import DateTime, Select, exists, orm, select
+from sqlalchemy import (
+ DateTime,
+ Index,
+ PrimaryKeyConstraint,
+ Select,
+ String,
+ UniqueConstraint,
+ exists,
+ func,
+ orm,
+ select,
+)
+from sqlalchemy.orm import Mapped, declared_attr, mapped_column
from core.file.constants import maybe_file_object
from core.file.models import File
@@ -26,10 +38,8 @@ from libs.uuid_utils import uuidv7
from ._workflow_exc import NodeNotFoundError, WorkflowDataError
if TYPE_CHECKING:
- from models.model import AppMode, UploadFile
+ from .model import AppMode, UploadFile
-from sqlalchemy import Index, PrimaryKeyConstraint, String, UniqueConstraint, func
-from sqlalchemy.orm import Mapped, declared_attr, mapped_column
from constants import DEFAULT_FILE_NUMBER_LIMITS, HIDDEN_VALUE
from core.helper import encrypter
@@ -38,7 +48,7 @@ from factories import variable_factory
from libs import helper
from .account import Account
-from .base import Base, DefaultFieldsMixin
+from .base import Base, DefaultFieldsMixin, TypeBase
from .engine import db
from .enums import CreatorUserRole, DraftVariableType, ExecutionOffLoadType
from .types import EnumText, LongText, StringUUID
@@ -1052,7 +1062,7 @@ class WorkflowAppLogCreatedFrom(StrEnum):
raise ValueError(f"invalid workflow app log created from value {value}")
-class WorkflowAppLog(Base):
+class WorkflowAppLog(TypeBase):
"""
Workflow App execution log, excluding workflow debugging records.
@@ -1088,7 +1098,7 @@ class WorkflowAppLog(Base):
sa.Index("workflow_app_log_workflow_run_id_idx", "workflow_run_id"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
tenant_id: Mapped[str] = mapped_column(StringUUID)
app_id: Mapped[str] = mapped_column(StringUUID)
workflow_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
@@ -1096,7 +1106,9 @@ class WorkflowAppLog(Base):
created_from: Mapped[str] = mapped_column(String(255), nullable=False)
created_by_role: Mapped[str] = mapped_column(String(255), nullable=False)
created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
@property
def workflow_run(self):
@@ -1137,7 +1149,7 @@ class WorkflowAppLog(Base):
}
-class ConversationVariable(Base):
+class ConversationVariable(TypeBase):
__tablename__ = "workflow_conversation_variables"
id: Mapped[str] = mapped_column(StringUUID, primary_key=True)
@@ -1145,21 +1157,12 @@ class ConversationVariable(Base):
app_id: Mapped[str] = mapped_column(StringUUID, nullable=False, index=True)
data: Mapped[str] = mapped_column(LongText, nullable=False)
created_at: Mapped[datetime] = mapped_column(
- DateTime, nullable=False, server_default=func.current_timestamp(), index=True
+ DateTime, nullable=False, server_default=func.current_timestamp(), index=True, init=False
)
updated_at: Mapped[datetime] = mapped_column(
- DateTime,
- nullable=False,
- server_default=func.current_timestamp(),
- onupdate=func.current_timestamp(),
+ DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
)
- def __init__(self, *, id: str, app_id: str, conversation_id: str, data: str):
- self.id = id
- self.app_id = app_id
- self.conversation_id = conversation_id
- self.data = data
-
@classmethod
def from_variable(cls, *, app_id: str, conversation_id: str, variable: Variable) -> "ConversationVariable":
obj = cls(
diff --git a/api/tests/test_containers_integration_tests/services/test_webhook_service.py b/api/tests/test_containers_integration_tests/services/test_webhook_service.py
index 09a2deb8cc..8328db950c 100644
--- a/api/tests/test_containers_integration_tests/services/test_webhook_service.py
+++ b/api/tests/test_containers_integration_tests/services/test_webhook_service.py
@@ -67,6 +67,7 @@ class TestWebhookService:
)
TenantService.create_owner_tenant_if_not_exist(account, name=fake.company())
tenant = account.current_tenant
+ assert tenant is not None
# Create app
app = App(
@@ -131,7 +132,7 @@ class TestWebhookService:
app_id=app.id,
node_id="webhook_node",
tenant_id=tenant.id,
- webhook_id=webhook_id,
+ webhook_id=str(webhook_id),
created_by=account.id,
)
db_session_with_containers.add(webhook_trigger)
@@ -143,6 +144,7 @@ class TestWebhookService:
app_id=app.id,
node_id="webhook_node",
trigger_type=AppTriggerType.TRIGGER_WEBHOOK,
+ provider_name="webhook",
title="Test Webhook",
status=AppTriggerStatus.ENABLED,
)
diff --git a/api/tests/test_containers_integration_tests/services/test_workflow_app_service.py b/api/tests/test_containers_integration_tests/services/test_workflow_app_service.py
index 66bd4d3cd9..7b95944bbe 100644
--- a/api/tests/test_containers_integration_tests/services/test_workflow_app_service.py
+++ b/api/tests/test_containers_integration_tests/services/test_workflow_app_service.py
@@ -209,7 +209,6 @@ class TestWorkflowAppService:
# Create workflow app log
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -217,8 +216,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC),
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = datetime.now(UTC)
db.session.add(workflow_app_log)
db.session.commit()
@@ -365,7 +365,6 @@ class TestWorkflowAppService:
db.session.commit()
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -373,8 +372,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC) + timedelta(minutes=i),
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = datetime.now(UTC) + timedelta(minutes=i)
db.session.add(workflow_app_log)
db.session.commit()
@@ -473,7 +473,6 @@ class TestWorkflowAppService:
db.session.commit()
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -481,8 +480,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=timestamp,
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = timestamp
db.session.add(workflow_app_log)
db.session.commit()
@@ -580,7 +580,6 @@ class TestWorkflowAppService:
db.session.commit()
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -588,8 +587,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC) + timedelta(minutes=i),
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = datetime.now(UTC) + timedelta(minutes=i)
db.session.add(workflow_app_log)
db.session.commit()
@@ -710,7 +710,6 @@ class TestWorkflowAppService:
db.session.commit()
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -718,8 +717,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC) + timedelta(minutes=i),
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = datetime.now(UTC) + timedelta(minutes=i)
db.session.add(workflow_app_log)
db.session.commit()
@@ -752,7 +752,6 @@ class TestWorkflowAppService:
db.session.commit()
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -760,8 +759,9 @@ class TestWorkflowAppService:
created_from="web-app",
created_by_role=CreatorUserRole.END_USER,
created_by=end_user.id,
- created_at=datetime.now(UTC) + timedelta(minutes=i + 10),
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = datetime.now(UTC) + timedelta(minutes=i + 10)
db.session.add(workflow_app_log)
db.session.commit()
@@ -889,7 +889,6 @@ class TestWorkflowAppService:
# Create workflow app log
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -897,8 +896,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC),
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = datetime.now(UTC)
db.session.add(workflow_app_log)
db.session.commit()
@@ -979,7 +979,6 @@ class TestWorkflowAppService:
# Create workflow app log
workflow_app_log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -987,8 +986,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC),
)
+ workflow_app_log.id = str(uuid.uuid4())
+ workflow_app_log.created_at = datetime.now(UTC)
db.session.add(workflow_app_log)
db.session.commit()
@@ -1133,7 +1133,6 @@ class TestWorkflowAppService:
db_session_with_containers.flush()
log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -1141,8 +1140,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC) + timedelta(minutes=i),
)
+ log.id = str(uuid.uuid4())
+ log.created_at = datetime.now(UTC) + timedelta(minutes=i)
db_session_with_containers.add(log)
logs_data.append((log, workflow_run))
@@ -1233,7 +1233,6 @@ class TestWorkflowAppService:
db_session_with_containers.flush()
log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -1241,8 +1240,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC) + timedelta(minutes=i),
)
+ log.id = str(uuid.uuid4())
+ log.created_at = datetime.now(UTC) + timedelta(minutes=i)
db_session_with_containers.add(log)
logs_data.append((log, workflow_run))
@@ -1335,7 +1335,6 @@ class TestWorkflowAppService:
db_session_with_containers.flush()
log = WorkflowAppLog(
- id=str(uuid.uuid4()),
tenant_id=app.tenant_id,
app_id=app.id,
workflow_id=workflow.id,
@@ -1343,8 +1342,9 @@ class TestWorkflowAppService:
created_from="service-api",
created_by_role=CreatorUserRole.ACCOUNT,
created_by=account.id,
- created_at=datetime.now(UTC) + timedelta(minutes=i * 10 + j),
)
+ log.id = str(uuid.uuid4())
+ log.created_at = datetime.now(UTC) + timedelta(minutes=i * 10 + j)
db_session_with_containers.add(log)
db_session_with_containers.commit()
diff --git a/api/tests/unit_tests/core/test_provider_manager.py b/api/tests/unit_tests/core/test_provider_manager.py
index 0c3887beab..dbbda5f74c 100644
--- a/api/tests/unit_tests/core/test_provider_manager.py
+++ b/api/tests/unit_tests/core/test_provider_manager.py
@@ -28,17 +28,17 @@ def mock_provider_entity(mocker: MockerFixture):
def test__to_model_settings(mocker: MockerFixture, mock_provider_entity):
# Mocking the inputs
- provider_model_settings = [
- ProviderModelSetting(
- id="id",
- tenant_id="tenant_id",
- provider_name="openai",
- model_name="gpt-4",
- model_type="text-generation",
- enabled=True,
- load_balancing_enabled=True,
- )
- ]
+ ps = ProviderModelSetting(
+ tenant_id="tenant_id",
+ provider_name="openai",
+ model_name="gpt-4",
+ model_type="text-generation",
+ enabled=True,
+ load_balancing_enabled=True,
+ )
+ ps.id = "id"
+
+ provider_model_settings = [ps]
load_balancing_model_configs = [
LoadBalancingModelConfig(
id="id1",
@@ -88,17 +88,17 @@ def test__to_model_settings(mocker: MockerFixture, mock_provider_entity):
def test__to_model_settings_only_one_lb(mocker: MockerFixture, mock_provider_entity):
# Mocking the inputs
- provider_model_settings = [
- ProviderModelSetting(
- id="id",
- tenant_id="tenant_id",
- provider_name="openai",
- model_name="gpt-4",
- model_type="text-generation",
- enabled=True,
- load_balancing_enabled=True,
- )
- ]
+
+ ps = ProviderModelSetting(
+ tenant_id="tenant_id",
+ provider_name="openai",
+ model_name="gpt-4",
+ model_type="text-generation",
+ enabled=True,
+ load_balancing_enabled=True,
+ )
+ ps.id = "id"
+ provider_model_settings = [ps]
load_balancing_model_configs = [
LoadBalancingModelConfig(
id="id1",
@@ -136,17 +136,16 @@ def test__to_model_settings_only_one_lb(mocker: MockerFixture, mock_provider_ent
def test__to_model_settings_lb_disabled(mocker: MockerFixture, mock_provider_entity):
# Mocking the inputs
- provider_model_settings = [
- ProviderModelSetting(
- id="id",
- tenant_id="tenant_id",
- provider_name="openai",
- model_name="gpt-4",
- model_type="text-generation",
- enabled=True,
- load_balancing_enabled=False,
- )
- ]
+ ps = ProviderModelSetting(
+ tenant_id="tenant_id",
+ provider_name="openai",
+ model_name="gpt-4",
+ model_type="text-generation",
+ enabled=True,
+ load_balancing_enabled=False,
+ )
+ ps.id = "id"
+ provider_model_settings = [ps]
load_balancing_model_configs = [
LoadBalancingModelConfig(
id="id1",
From 2e0964e0b066cadee3b1b75ab5a5bf2e5f1d2379 Mon Sep 17 00:00:00 2001
From: wangxiaolei
Date: Fri, 21 Nov 2025 15:43:09 +0800
Subject: [PATCH 033/191] fix(api): `SegmentType.is_valid()` raises
`AssertionError` for `SegmentType.GROUP` (#28249)
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
api/core/variables/types.py | 16 ++-
.../variables/test_segment_type_validation.py | 132 +++++++++++++++++-
2 files changed, 141 insertions(+), 7 deletions(-)
diff --git a/api/core/variables/types.py b/api/core/variables/types.py
index b537ff7180..ce71711344 100644
--- a/api/core/variables/types.py
+++ b/api/core/variables/types.py
@@ -1,9 +1,12 @@
from collections.abc import Mapping
from enum import StrEnum
-from typing import Any, Optional
+from typing import TYPE_CHECKING, Any, Optional
from core.file.models import File
+if TYPE_CHECKING:
+ pass
+
class ArrayValidation(StrEnum):
"""Strategy for validating array elements.
@@ -155,6 +158,17 @@ class SegmentType(StrEnum):
return isinstance(value, File)
elif self == SegmentType.NONE:
return value is None
+ elif self == SegmentType.GROUP:
+ from .segment_group import SegmentGroup
+ from .segments import Segment
+
+ if isinstance(value, SegmentGroup):
+ return all(isinstance(item, Segment) for item in value.value)
+
+ if isinstance(value, list):
+ return all(isinstance(item, Segment) for item in value)
+
+ return False
else:
raise AssertionError("this statement should be unreachable.")
diff --git a/api/tests/unit_tests/core/variables/test_segment_type_validation.py b/api/tests/unit_tests/core/variables/test_segment_type_validation.py
index e0541280d3..3a0054cd46 100644
--- a/api/tests/unit_tests/core/variables/test_segment_type_validation.py
+++ b/api/tests/unit_tests/core/variables/test_segment_type_validation.py
@@ -12,6 +12,16 @@ import pytest
from core.file.enums import FileTransferMethod, FileType
from core.file.models import File
+from core.variables.segment_group import SegmentGroup
+from core.variables.segments import (
+ ArrayFileSegment,
+ BooleanSegment,
+ FileSegment,
+ IntegerSegment,
+ NoneSegment,
+ ObjectSegment,
+ StringSegment,
+)
from core.variables.types import ArrayValidation, SegmentType
@@ -202,6 +212,45 @@ def get_none_cases() -> list[ValidationTestCase]:
]
+def get_group_cases() -> list[ValidationTestCase]:
+ """Get test cases for valid group values."""
+ test_file = create_test_file()
+ segments = [
+ StringSegment(value="hello"),
+ IntegerSegment(value=42),
+ BooleanSegment(value=True),
+ ObjectSegment(value={"key": "value"}),
+ FileSegment(value=test_file),
+ NoneSegment(value=None),
+ ]
+
+ return [
+ # valid cases
+ ValidationTestCase(
+ SegmentType.GROUP, SegmentGroup(value=segments), True, "Valid SegmentGroup with mixed segments"
+ ),
+ ValidationTestCase(
+ SegmentType.GROUP, [StringSegment(value="test"), IntegerSegment(value=123)], True, "List of Segment objects"
+ ),
+ ValidationTestCase(SegmentType.GROUP, SegmentGroup(value=[]), True, "Empty SegmentGroup"),
+ ValidationTestCase(SegmentType.GROUP, [], True, "Empty list"),
+ # invalid cases
+ ValidationTestCase(SegmentType.GROUP, "not a list", False, "String value"),
+ ValidationTestCase(SegmentType.GROUP, 123, False, "Integer value"),
+ ValidationTestCase(SegmentType.GROUP, True, False, "Boolean value"),
+ ValidationTestCase(SegmentType.GROUP, None, False, "None value"),
+ ValidationTestCase(SegmentType.GROUP, {"key": "value"}, False, "Dict value"),
+ ValidationTestCase(SegmentType.GROUP, test_file, False, "File value"),
+ ValidationTestCase(SegmentType.GROUP, ["string", 123, True], False, "List with non-Segment objects"),
+ ValidationTestCase(
+ SegmentType.GROUP,
+ [StringSegment(value="test"), "not a segment"],
+ False,
+ "Mixed list with some non-Segment objects",
+ ),
+ ]
+
+
def get_array_any_validation_cases() -> list[ArrayValidationTestCase]:
"""Get test cases for ARRAY_ANY validation."""
return [
@@ -477,11 +526,77 @@ class TestSegmentTypeIsValid:
def test_none_validation_valid_cases(self, case):
assert case.segment_type.is_valid(case.value) == case.expected
- def test_unsupported_segment_type_raises_assertion_error(self):
- """Test that unsupported SegmentType values raise AssertionError."""
- # GROUP is not handled in is_valid method
- with pytest.raises(AssertionError, match="this statement should be unreachable"):
- SegmentType.GROUP.is_valid("any value")
+ @pytest.mark.parametrize("case", get_group_cases(), ids=lambda case: case.description)
+ def test_group_validation(self, case):
+ """Test GROUP type validation with various inputs."""
+ assert case.segment_type.is_valid(case.value) == case.expected
+
+ def test_group_validation_edge_cases(self):
+ """Test GROUP validation edge cases."""
+ test_file = create_test_file()
+
+ # Test with nested SegmentGroups
+ inner_group = SegmentGroup(value=[StringSegment(value="inner"), IntegerSegment(value=42)])
+ outer_group = SegmentGroup(value=[StringSegment(value="outer"), inner_group])
+ assert SegmentType.GROUP.is_valid(outer_group) is True
+
+ # Test with ArrayFileSegment (which is also a Segment)
+ file_segment = FileSegment(value=test_file)
+ array_file_segment = ArrayFileSegment(value=[test_file, test_file])
+ group_with_arrays = SegmentGroup(value=[file_segment, array_file_segment, StringSegment(value="test")])
+ assert SegmentType.GROUP.is_valid(group_with_arrays) is True
+
+ # Test performance with large number of segments
+ large_segment_list = [StringSegment(value=f"item_{i}") for i in range(1000)]
+ large_group = SegmentGroup(value=large_segment_list)
+ assert SegmentType.GROUP.is_valid(large_group) is True
+
+ def test_no_truly_unsupported_segment_types_exist(self):
+ """Test that all SegmentType enum values are properly handled in is_valid method.
+
+ This test ensures there are no SegmentType values that would raise AssertionError.
+ If this test fails, it means a new SegmentType was added without proper validation support.
+ """
+ # Test that ALL segment types are handled and don't raise AssertionError
+ all_segment_types = set(SegmentType)
+
+ for segment_type in all_segment_types:
+ # Create a valid test value for each type
+ test_value: Any = None
+ if segment_type == SegmentType.STRING:
+ test_value = "test"
+ elif segment_type in {SegmentType.NUMBER, SegmentType.INTEGER}:
+ test_value = 42
+ elif segment_type == SegmentType.FLOAT:
+ test_value = 3.14
+ elif segment_type == SegmentType.BOOLEAN:
+ test_value = True
+ elif segment_type == SegmentType.OBJECT:
+ test_value = {"key": "value"}
+ elif segment_type == SegmentType.SECRET:
+ test_value = "secret"
+ elif segment_type == SegmentType.FILE:
+ test_value = create_test_file()
+ elif segment_type == SegmentType.NONE:
+ test_value = None
+ elif segment_type == SegmentType.GROUP:
+ test_value = SegmentGroup(value=[StringSegment(value="test")])
+ elif segment_type.is_array_type():
+ test_value = [] # Empty array is valid for all array types
+ else:
+ # If we get here, there's a segment type we don't know how to test
+ # This should prompt us to add validation logic
+ pytest.fail(f"Unknown segment type {segment_type} needs validation logic and test case")
+
+ # This should NOT raise AssertionError
+ try:
+ result = segment_type.is_valid(test_value)
+ assert isinstance(result, bool), f"is_valid should return boolean for {segment_type}"
+ except AssertionError as e:
+ pytest.fail(
+ f"SegmentType.{segment_type.name}.is_valid() raised AssertionError: {e}. "
+ "This segment type needs to be handled in the is_valid method."
+ )
class TestSegmentTypeArrayValidation:
@@ -611,6 +726,7 @@ class TestSegmentTypeValidationIntegration:
SegmentType.SECRET,
SegmentType.FILE,
SegmentType.NONE,
+ SegmentType.GROUP,
]
for segment_type in non_array_types:
@@ -630,6 +746,8 @@ class TestSegmentTypeValidationIntegration:
valid_value = create_test_file()
elif segment_type == SegmentType.NONE:
valid_value = None
+ elif segment_type == SegmentType.GROUP:
+ valid_value = SegmentGroup(value=[StringSegment(value="test")])
else:
continue # Skip unsupported types
@@ -656,6 +774,7 @@ class TestSegmentTypeValidationIntegration:
SegmentType.SECRET,
SegmentType.FILE,
SegmentType.NONE,
+ SegmentType.GROUP,
# Array types
SegmentType.ARRAY_ANY,
SegmentType.ARRAY_STRING,
@@ -667,7 +786,6 @@ class TestSegmentTypeValidationIntegration:
# Types that are not handled by is_valid (should raise AssertionError)
unhandled_types = {
- SegmentType.GROUP,
SegmentType.INTEGER, # Handled by NUMBER validation logic
SegmentType.FLOAT, # Handled by NUMBER validation logic
}
@@ -696,6 +814,8 @@ class TestSegmentTypeValidationIntegration:
assert segment_type.is_valid(create_test_file()) is True
elif segment_type == SegmentType.NONE:
assert segment_type.is_valid(None) is True
+ elif segment_type == SegmentType.GROUP:
+ assert segment_type.is_valid(SegmentGroup(value=[StringSegment(value="test")])) is True
def test_boolean_vs_integer_type_distinction(self):
"""Test the important distinction between boolean and integer types in validation."""
From 9fed2dc065f8f718918ff224f8ea19ea69611620 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E9=9D=9E=E6=B3=95=E6=93=8D=E4=BD=9C?=
Date: Fri, 21 Nov 2025 16:48:35 +0800
Subject: [PATCH 034/191] fix: Code editor throws dozen of errors (#28500)
---
.../nodes/_base/components/editor/code-editor/index.tsx | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx b/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx
index 2a69161bef..558dec7734 100644
--- a/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx
+++ b/web/app/components/workflow/nodes/_base/components/editor/code-editor/index.tsx
@@ -15,7 +15,8 @@ import { noop } from 'lodash-es'
import { basePath } from '@/utils/var'
// load file from local instead of cdn https://github.com/suren-atoyan/monaco-react/issues/482
-loader.config({ paths: { vs: `${basePath}/vs` } })
+if (typeof window !== 'undefined')
+ loader.config({ paths: { vs: `${window.location.origin}${basePath}/vs` } })
const CODE_EDITOR_LINE_HEIGHT = 18
From ae126fd56f2bfed192c0ae2b715df90b9379b1cc Mon Sep 17 00:00:00 2001
From: Charles Liu
Date: Fri, 21 Nov 2025 17:49:12 +0800
Subject: [PATCH 035/191] Fix/24655 (#26527)
Co-authored-by: charles liu
Co-authored-by: crazywoola <100913391+crazywoola@users.noreply.github.com>
---
api/fields/dataset_fields.py | 1 +
api/models/dataset.py | 7 +++++++
web/app/components/datasets/list/dataset-card/index.tsx | 8 ++++++++
web/models/datasets.ts | 1 +
4 files changed, 17 insertions(+)
diff --git a/api/fields/dataset_fields.py b/api/fields/dataset_fields.py
index 73002b6736..89c4d8fba9 100644
--- a/api/fields/dataset_fields.py
+++ b/api/fields/dataset_fields.py
@@ -75,6 +75,7 @@ dataset_detail_fields = {
"document_count": fields.Integer,
"word_count": fields.Integer,
"created_by": fields.String,
+ "author_name": fields.String,
"created_at": TimestampField,
"updated_by": fields.String,
"updated_at": TimestampField,
diff --git a/api/models/dataset.py b/api/models/dataset.py
index 6cff6b530c..04f107f858 100644
--- a/api/models/dataset.py
+++ b/api/models/dataset.py
@@ -121,6 +121,13 @@ class Dataset(Base):
def created_by_account(self):
return db.session.get(Account, self.created_by)
+ @property
+ def author_name(self) -> str | None:
+ account = db.session.get(Account, self.created_by)
+ if account:
+ return account.name
+ return None
+
@property
def latest_process_rule(self):
return (
diff --git a/web/app/components/datasets/list/dataset-card/index.tsx b/web/app/components/datasets/list/dataset-card/index.tsx
index b1304e578e..ef6650a75d 100644
--- a/web/app/components/datasets/list/dataset-card/index.tsx
+++ b/web/app/components/datasets/list/dataset-card/index.tsx
@@ -85,6 +85,9 @@ const DatasetCard = ({
}, [t, dataset.document_count, dataset.total_available_documents])
const { formatTimeFromNow } = useFormatTimeFromNow()
+ const editTimeText = useMemo(() => {
+ return `${t('datasetDocuments.segment.editedAt')} ${formatTimeFromNow(dataset.updated_at * 1000)}`
+ }, [t, dataset.updated_at, formatTimeFromNow])
const openRenameModal = useCallback(() => {
setShowRenameModal(true)
@@ -193,6 +196,11 @@ const DatasetCard = ({
>
{dataset.name}
+
+
{dataset.author_name}
+
·
+
{editTimeText}
+
{isExternalProvider && {t('dataset.externalKnowledgeBase')}}
{!isExternalProvider && isShowDocModeInfo && (
diff --git a/web/models/datasets.ts b/web/models/datasets.ts
index eb7b7de4a2..12e53b78a8 100644
--- a/web/models/datasets.ts
+++ b/web/models/datasets.ts
@@ -50,6 +50,7 @@ export type DataSet = {
permission: DatasetPermission
data_source_type: DataSourceType
indexing_technique: IndexingType
+ author_name?: string
created_by: string
updated_by: string
updated_at: number
From 33ff01d04c59bebf269a5fd32b10cbc353bf2a1e Mon Sep 17 00:00:00 2001
From: goofy <38034027+goofy-z@users.noreply.github.com>
Date: Fri, 21 Nov 2025 17:54:57 +0800
Subject: [PATCH 036/191] Support node reference multiple structured_output
variables in single-step run (#26661)
Co-authored-by: crazywoola <100913391+crazywoola@users.noreply.github.com>
Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>
---
api/core/workflow/workflow_entry.py | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/api/core/workflow/workflow_entry.py b/api/core/workflow/workflow_entry.py
index 742c42ec2b..a6c6784e39 100644
--- a/api/core/workflow/workflow_entry.py
+++ b/api/core/workflow/workflow_entry.py
@@ -421,4 +421,10 @@ class WorkflowEntry:
if len(variable_key_list) == 2 and variable_key_list[0] == "structured_output":
input_value = {variable_key_list[1]: input_value}
variable_key_list = variable_key_list[0:1]
+
+ # Support for a single node to reference multiple structured_output variables
+ current_variable = variable_pool.get([variable_node_id] + variable_key_list)
+ if current_variable and isinstance(current_variable.value, dict):
+ input_value = current_variable.value | input_value
+
variable_pool.add([variable_node_id] + variable_key_list, input_value)
From 63b8bbbab349cc015194b397da69e15b6235f3d4 Mon Sep 17 00:00:00 2001
From: Gritty_dev <101377478+codomposer@users.noreply.github.com>
Date: Fri, 21 Nov 2025 08:37:25 -0500
Subject: [PATCH 037/191] feat: complete test script for dataset models
(#28512)
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>
---
.../unit_tests/models/test_dataset_models.py | 1341 +++++++++++++++++
1 file changed, 1341 insertions(+)
create mode 100644 api/tests/unit_tests/models/test_dataset_models.py
diff --git a/api/tests/unit_tests/models/test_dataset_models.py b/api/tests/unit_tests/models/test_dataset_models.py
new file mode 100644
index 0000000000..2322c556e2
--- /dev/null
+++ b/api/tests/unit_tests/models/test_dataset_models.py
@@ -0,0 +1,1341 @@
+"""
+Comprehensive unit tests for Dataset models.
+
+This test suite covers:
+- Dataset model validation
+- Document model relationships
+- Segment model indexing
+- Dataset-Document cascade deletes
+- Embedding storage validation
+"""
+
+import json
+import pickle
+from datetime import UTC, datetime
+from unittest.mock import MagicMock, patch
+from uuid import uuid4
+
+from models.dataset import (
+ AppDatasetJoin,
+ ChildChunk,
+ Dataset,
+ DatasetKeywordTable,
+ DatasetProcessRule,
+ Document,
+ DocumentSegment,
+ Embedding,
+)
+
+
+class TestDatasetModelValidation:
+ """Test suite for Dataset model validation and basic operations."""
+
+ def test_dataset_creation_with_required_fields(self):
+ """Test creating a dataset with all required fields."""
+ # Arrange
+ tenant_id = str(uuid4())
+ created_by = str(uuid4())
+
+ # Act
+ dataset = Dataset(
+ tenant_id=tenant_id,
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=created_by,
+ )
+
+ # Assert
+ assert dataset.name == "Test Dataset"
+ assert dataset.tenant_id == tenant_id
+ assert dataset.data_source_type == "upload_file"
+ assert dataset.created_by == created_by
+ # Note: Default values are set by database, not by model instantiation
+
+ def test_dataset_creation_with_optional_fields(self):
+ """Test creating a dataset with optional fields."""
+ # Arrange & Act
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ description="Test description",
+ indexing_technique="high_quality",
+ embedding_model="text-embedding-ada-002",
+ embedding_model_provider="openai",
+ )
+
+ # Assert
+ assert dataset.description == "Test description"
+ assert dataset.indexing_technique == "high_quality"
+ assert dataset.embedding_model == "text-embedding-ada-002"
+ assert dataset.embedding_model_provider == "openai"
+
+ def test_dataset_indexing_technique_validation(self):
+ """Test dataset indexing technique values."""
+ # Arrange & Act
+ dataset_high_quality = Dataset(
+ tenant_id=str(uuid4()),
+ name="High Quality Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ indexing_technique="high_quality",
+ )
+ dataset_economy = Dataset(
+ tenant_id=str(uuid4()),
+ name="Economy Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ indexing_technique="economy",
+ )
+
+ # Assert
+ assert dataset_high_quality.indexing_technique == "high_quality"
+ assert dataset_economy.indexing_technique == "economy"
+ assert "high_quality" in Dataset.INDEXING_TECHNIQUE_LIST
+ assert "economy" in Dataset.INDEXING_TECHNIQUE_LIST
+
+ def test_dataset_provider_validation(self):
+ """Test dataset provider values."""
+ # Arrange & Act
+ dataset_vendor = Dataset(
+ tenant_id=str(uuid4()),
+ name="Vendor Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ provider="vendor",
+ )
+ dataset_external = Dataset(
+ tenant_id=str(uuid4()),
+ name="External Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ provider="external",
+ )
+
+ # Assert
+ assert dataset_vendor.provider == "vendor"
+ assert dataset_external.provider == "external"
+ assert "vendor" in Dataset.PROVIDER_LIST
+ assert "external" in Dataset.PROVIDER_LIST
+
+ def test_dataset_index_struct_dict_property(self):
+ """Test index_struct_dict property parsing."""
+ # Arrange
+ index_struct_data = {"type": "vector", "dimension": 1536}
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ index_struct=json.dumps(index_struct_data),
+ )
+
+ # Act
+ result = dataset.index_struct_dict
+
+ # Assert
+ assert result == index_struct_data
+ assert result["type"] == "vector"
+ assert result["dimension"] == 1536
+
+ def test_dataset_index_struct_dict_property_none(self):
+ """Test index_struct_dict property when index_struct is None."""
+ # Arrange
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+
+ # Act
+ result = dataset.index_struct_dict
+
+ # Assert
+ assert result is None
+
+ def test_dataset_external_retrieval_model_property(self):
+ """Test external_retrieval_model property with default values."""
+ # Arrange
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+
+ # Act
+ result = dataset.external_retrieval_model
+
+ # Assert
+ assert result["top_k"] == 2
+ assert result["score_threshold"] == 0.0
+
+ def test_dataset_retrieval_model_dict_property(self):
+ """Test retrieval_model_dict property with default values."""
+ # Arrange
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+
+ # Act
+ result = dataset.retrieval_model_dict
+
+ # Assert
+ assert result["top_k"] == 2
+ assert result["reranking_enable"] is False
+ assert result["score_threshold_enabled"] is False
+
+ def test_dataset_gen_collection_name_by_id(self):
+ """Test static method for generating collection name."""
+ # Arrange
+ dataset_id = "12345678-1234-1234-1234-123456789abc"
+
+ # Act
+ collection_name = Dataset.gen_collection_name_by_id(dataset_id)
+
+ # Assert
+ assert "12345678_1234_1234_1234_123456789abc" in collection_name
+ assert "-" not in collection_name.split("_")[-1]
+
+
+class TestDocumentModelRelationships:
+ """Test suite for Document model relationships and properties."""
+
+ def test_document_creation_with_required_fields(self):
+ """Test creating a document with all required fields."""
+ # Arrange
+ tenant_id = str(uuid4())
+ dataset_id = str(uuid4())
+ created_by = str(uuid4())
+
+ # Act
+ document = Document(
+ tenant_id=tenant_id,
+ dataset_id=dataset_id,
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test_document.pdf",
+ created_from="web",
+ created_by=created_by,
+ )
+
+ # Assert
+ assert document.tenant_id == tenant_id
+ assert document.dataset_id == dataset_id
+ assert document.position == 1
+ assert document.data_source_type == "upload_file"
+ assert document.batch == "batch_001"
+ assert document.name == "test_document.pdf"
+ assert document.created_from == "web"
+ assert document.created_by == created_by
+ # Note: Default values are set by database, not by model instantiation
+
+ def test_document_data_source_types(self):
+ """Test document data source type validation."""
+ # Assert
+ assert "upload_file" in Document.DATA_SOURCES
+ assert "notion_import" in Document.DATA_SOURCES
+ assert "website_crawl" in Document.DATA_SOURCES
+
+ def test_document_display_status_queuing(self):
+ """Test document display_status property for queuing state."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ indexing_status="waiting",
+ )
+
+ # Act
+ status = document.display_status
+
+ # Assert
+ assert status == "queuing"
+
+ def test_document_display_status_paused(self):
+ """Test document display_status property for paused state."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ indexing_status="parsing",
+ is_paused=True,
+ )
+
+ # Act
+ status = document.display_status
+
+ # Assert
+ assert status == "paused"
+
+ def test_document_display_status_indexing(self):
+ """Test document display_status property for indexing state."""
+ # Arrange
+ for indexing_status in ["parsing", "cleaning", "splitting", "indexing"]:
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ indexing_status=indexing_status,
+ )
+
+ # Act
+ status = document.display_status
+
+ # Assert
+ assert status == "indexing"
+
+ def test_document_display_status_error(self):
+ """Test document display_status property for error state."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ indexing_status="error",
+ )
+
+ # Act
+ status = document.display_status
+
+ # Assert
+ assert status == "error"
+
+ def test_document_display_status_available(self):
+ """Test document display_status property for available state."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ indexing_status="completed",
+ enabled=True,
+ archived=False,
+ )
+
+ # Act
+ status = document.display_status
+
+ # Assert
+ assert status == "available"
+
+ def test_document_display_status_disabled(self):
+ """Test document display_status property for disabled state."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ indexing_status="completed",
+ enabled=False,
+ archived=False,
+ )
+
+ # Act
+ status = document.display_status
+
+ # Assert
+ assert status == "disabled"
+
+ def test_document_display_status_archived(self):
+ """Test document display_status property for archived state."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ indexing_status="completed",
+ archived=True,
+ )
+
+ # Act
+ status = document.display_status
+
+ # Assert
+ assert status == "archived"
+
+ def test_document_data_source_info_dict_property(self):
+ """Test data_source_info_dict property parsing."""
+ # Arrange
+ data_source_info = {"upload_file_id": str(uuid4()), "file_name": "test.pdf"}
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ data_source_info=json.dumps(data_source_info),
+ )
+
+ # Act
+ result = document.data_source_info_dict
+
+ # Assert
+ assert result == data_source_info
+ assert "upload_file_id" in result
+ assert "file_name" in result
+
+ def test_document_data_source_info_dict_property_empty(self):
+ """Test data_source_info_dict property when data_source_info is None."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ )
+
+ # Act
+ result = document.data_source_info_dict
+
+ # Assert
+ assert result == {}
+
+ def test_document_average_segment_length(self):
+ """Test average_segment_length property calculation."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ word_count=1000,
+ )
+
+ # Mock segment_count property
+ with patch.object(Document, "segment_count", new_callable=lambda: property(lambda self: 10)):
+ # Act
+ result = document.average_segment_length
+
+ # Assert
+ assert result == 100
+
+ def test_document_average_segment_length_zero(self):
+ """Test average_segment_length property when word_count is zero."""
+ # Arrange
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ word_count=0,
+ )
+
+ # Act
+ result = document.average_segment_length
+
+ # Assert
+ assert result == 0
+
+
+class TestDocumentSegmentIndexing:
+ """Test suite for DocumentSegment model indexing and operations."""
+
+ def test_document_segment_creation_with_required_fields(self):
+ """Test creating a document segment with all required fields."""
+ # Arrange
+ tenant_id = str(uuid4())
+ dataset_id = str(uuid4())
+ document_id = str(uuid4())
+ created_by = str(uuid4())
+
+ # Act
+ segment = DocumentSegment(
+ tenant_id=tenant_id,
+ dataset_id=dataset_id,
+ document_id=document_id,
+ position=1,
+ content="This is a test segment content.",
+ word_count=6,
+ tokens=10,
+ created_by=created_by,
+ )
+
+ # Assert
+ assert segment.tenant_id == tenant_id
+ assert segment.dataset_id == dataset_id
+ assert segment.document_id == document_id
+ assert segment.position == 1
+ assert segment.content == "This is a test segment content."
+ assert segment.word_count == 6
+ assert segment.tokens == 10
+ assert segment.created_by == created_by
+ # Note: Default values are set by database, not by model instantiation
+
+ def test_document_segment_with_indexing_fields(self):
+ """Test creating a document segment with indexing fields."""
+ # Arrange
+ index_node_id = str(uuid4())
+ index_node_hash = "abc123hash"
+ keywords = ["test", "segment", "indexing"]
+
+ # Act
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ position=1,
+ content="Test content",
+ word_count=2,
+ tokens=5,
+ created_by=str(uuid4()),
+ index_node_id=index_node_id,
+ index_node_hash=index_node_hash,
+ keywords=keywords,
+ )
+
+ # Assert
+ assert segment.index_node_id == index_node_id
+ assert segment.index_node_hash == index_node_hash
+ assert segment.keywords == keywords
+
+ def test_document_segment_with_answer_field(self):
+ """Test creating a document segment with answer field for QA model."""
+ # Arrange
+ content = "What is AI?"
+ answer = "AI stands for Artificial Intelligence."
+
+ # Act
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ position=1,
+ content=content,
+ answer=answer,
+ word_count=3,
+ tokens=8,
+ created_by=str(uuid4()),
+ )
+
+ # Assert
+ assert segment.content == content
+ assert segment.answer == answer
+
+ def test_document_segment_status_transitions(self):
+ """Test document segment status field values."""
+ # Arrange & Act
+ segment_waiting = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ status="waiting",
+ )
+ segment_completed = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ status="completed",
+ )
+
+ # Assert
+ assert segment_waiting.status == "waiting"
+ assert segment_completed.status == "completed"
+
+ def test_document_segment_enabled_disabled_tracking(self):
+ """Test document segment enabled/disabled state tracking."""
+ # Arrange
+ disabled_by = str(uuid4())
+ disabled_at = datetime.now(UTC)
+
+ # Act
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ enabled=False,
+ disabled_by=disabled_by,
+ disabled_at=disabled_at,
+ )
+
+ # Assert
+ assert segment.enabled is False
+ assert segment.disabled_by == disabled_by
+ assert segment.disabled_at == disabled_at
+
+ def test_document_segment_hit_count_tracking(self):
+ """Test document segment hit count tracking."""
+ # Arrange & Act
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ hit_count=5,
+ )
+
+ # Assert
+ assert segment.hit_count == 5
+
+ def test_document_segment_error_tracking(self):
+ """Test document segment error tracking."""
+ # Arrange
+ error_message = "Indexing failed due to timeout"
+ stopped_at = datetime.now(UTC)
+
+ # Act
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ error=error_message,
+ stopped_at=stopped_at,
+ )
+
+ # Assert
+ assert segment.error == error_message
+ assert segment.stopped_at == stopped_at
+
+
+class TestEmbeddingStorage:
+ """Test suite for Embedding model storage and retrieval."""
+
+ def test_embedding_creation_with_required_fields(self):
+ """Test creating an embedding with required fields."""
+ # Arrange
+ model_name = "text-embedding-ada-002"
+ hash_value = "abc123hash"
+ provider_name = "openai"
+
+ # Act
+ embedding = Embedding(
+ model_name=model_name,
+ hash=hash_value,
+ provider_name=provider_name,
+ embedding=b"binary_data",
+ )
+
+ # Assert
+ assert embedding.model_name == model_name
+ assert embedding.hash == hash_value
+ assert embedding.provider_name == provider_name
+ assert embedding.embedding == b"binary_data"
+
+ def test_embedding_set_and_get_embedding(self):
+ """Test setting and getting embedding data."""
+ # Arrange
+ embedding_data = [0.1, 0.2, 0.3, 0.4, 0.5]
+ embedding = Embedding(
+ model_name="text-embedding-ada-002",
+ hash="test_hash",
+ provider_name="openai",
+ embedding=b"",
+ )
+
+ # Act
+ embedding.set_embedding(embedding_data)
+ retrieved_data = embedding.get_embedding()
+
+ # Assert
+ assert retrieved_data == embedding_data
+ assert len(retrieved_data) == 5
+ assert retrieved_data[0] == 0.1
+ assert retrieved_data[4] == 0.5
+
+ def test_embedding_pickle_serialization(self):
+ """Test embedding data is properly pickled."""
+ # Arrange
+ embedding_data = [0.1, 0.2, 0.3]
+ embedding = Embedding(
+ model_name="text-embedding-ada-002",
+ hash="test_hash",
+ provider_name="openai",
+ embedding=b"",
+ )
+
+ # Act
+ embedding.set_embedding(embedding_data)
+
+ # Assert
+ # Verify the embedding is stored as pickled binary data
+ assert isinstance(embedding.embedding, bytes)
+ # Verify we can unpickle it
+ unpickled_data = pickle.loads(embedding.embedding) # noqa: S301
+ assert unpickled_data == embedding_data
+
+ def test_embedding_with_large_vector(self):
+ """Test embedding with large dimension vector."""
+ # Arrange
+ # Simulate a 1536-dimension vector (OpenAI ada-002 size)
+ large_embedding_data = [0.001 * i for i in range(1536)]
+ embedding = Embedding(
+ model_name="text-embedding-ada-002",
+ hash="large_vector_hash",
+ provider_name="openai",
+ embedding=b"",
+ )
+
+ # Act
+ embedding.set_embedding(large_embedding_data)
+ retrieved_data = embedding.get_embedding()
+
+ # Assert
+ assert len(retrieved_data) == 1536
+ assert retrieved_data[0] == 0.0
+ assert abs(retrieved_data[1535] - 1.535) < 0.0001 # Float comparison with tolerance
+
+
+class TestDatasetProcessRule:
+ """Test suite for DatasetProcessRule model."""
+
+ def test_dataset_process_rule_creation(self):
+ """Test creating a dataset process rule."""
+ # Arrange
+ dataset_id = str(uuid4())
+ created_by = str(uuid4())
+
+ # Act
+ process_rule = DatasetProcessRule(
+ dataset_id=dataset_id,
+ mode="automatic",
+ created_by=created_by,
+ )
+
+ # Assert
+ assert process_rule.dataset_id == dataset_id
+ assert process_rule.mode == "automatic"
+ assert process_rule.created_by == created_by
+
+ def test_dataset_process_rule_modes(self):
+ """Test dataset process rule mode validation."""
+ # Assert
+ assert "automatic" in DatasetProcessRule.MODES
+ assert "custom" in DatasetProcessRule.MODES
+ assert "hierarchical" in DatasetProcessRule.MODES
+
+ def test_dataset_process_rule_with_rules_dict(self):
+ """Test dataset process rule with rules dictionary."""
+ # Arrange
+ rules_data = {
+ "pre_processing_rules": [
+ {"id": "remove_extra_spaces", "enabled": True},
+ {"id": "remove_urls_emails", "enabled": False},
+ ],
+ "segmentation": {"delimiter": "\n", "max_tokens": 500, "chunk_overlap": 50},
+ }
+ process_rule = DatasetProcessRule(
+ dataset_id=str(uuid4()),
+ mode="custom",
+ created_by=str(uuid4()),
+ rules=json.dumps(rules_data),
+ )
+
+ # Act
+ result = process_rule.rules_dict
+
+ # Assert
+ assert result == rules_data
+ assert "pre_processing_rules" in result
+ assert "segmentation" in result
+
+ def test_dataset_process_rule_to_dict(self):
+ """Test dataset process rule to_dict method."""
+ # Arrange
+ dataset_id = str(uuid4())
+ rules_data = {"test": "data"}
+ process_rule = DatasetProcessRule(
+ dataset_id=dataset_id,
+ mode="automatic",
+ created_by=str(uuid4()),
+ rules=json.dumps(rules_data),
+ )
+
+ # Act
+ result = process_rule.to_dict()
+
+ # Assert
+ assert result["dataset_id"] == dataset_id
+ assert result["mode"] == "automatic"
+ assert result["rules"] == rules_data
+
+ def test_dataset_process_rule_automatic_rules(self):
+ """Test dataset process rule automatic rules constant."""
+ # Act
+ automatic_rules = DatasetProcessRule.AUTOMATIC_RULES
+
+ # Assert
+ assert "pre_processing_rules" in automatic_rules
+ assert "segmentation" in automatic_rules
+ assert automatic_rules["segmentation"]["max_tokens"] == 500
+
+
+class TestDatasetKeywordTable:
+ """Test suite for DatasetKeywordTable model."""
+
+ def test_dataset_keyword_table_creation(self):
+ """Test creating a dataset keyword table."""
+ # Arrange
+ dataset_id = str(uuid4())
+ keyword_data = {"test": ["node1", "node2"], "keyword": ["node3"]}
+
+ # Act
+ keyword_table = DatasetKeywordTable(
+ dataset_id=dataset_id,
+ keyword_table=json.dumps(keyword_data),
+ )
+
+ # Assert
+ assert keyword_table.dataset_id == dataset_id
+ assert keyword_table.data_source_type == "database" # Default value
+
+ def test_dataset_keyword_table_data_source_type(self):
+ """Test dataset keyword table data source type."""
+ # Arrange & Act
+ keyword_table = DatasetKeywordTable(
+ dataset_id=str(uuid4()),
+ keyword_table="{}",
+ data_source_type="file",
+ )
+
+ # Assert
+ assert keyword_table.data_source_type == "file"
+
+
+class TestAppDatasetJoin:
+ """Test suite for AppDatasetJoin model."""
+
+ def test_app_dataset_join_creation(self):
+ """Test creating an app-dataset join relationship."""
+ # Arrange
+ app_id = str(uuid4())
+ dataset_id = str(uuid4())
+
+ # Act
+ join = AppDatasetJoin(
+ app_id=app_id,
+ dataset_id=dataset_id,
+ )
+
+ # Assert
+ assert join.app_id == app_id
+ assert join.dataset_id == dataset_id
+ # Note: ID is auto-generated when saved to database
+
+
+class TestChildChunk:
+ """Test suite for ChildChunk model."""
+
+ def test_child_chunk_creation(self):
+ """Test creating a child chunk."""
+ # Arrange
+ tenant_id = str(uuid4())
+ dataset_id = str(uuid4())
+ document_id = str(uuid4())
+ segment_id = str(uuid4())
+ created_by = str(uuid4())
+
+ # Act
+ child_chunk = ChildChunk(
+ tenant_id=tenant_id,
+ dataset_id=dataset_id,
+ document_id=document_id,
+ segment_id=segment_id,
+ position=1,
+ content="Child chunk content",
+ word_count=3,
+ created_by=created_by,
+ )
+
+ # Assert
+ assert child_chunk.tenant_id == tenant_id
+ assert child_chunk.dataset_id == dataset_id
+ assert child_chunk.document_id == document_id
+ assert child_chunk.segment_id == segment_id
+ assert child_chunk.position == 1
+ assert child_chunk.content == "Child chunk content"
+ assert child_chunk.word_count == 3
+ assert child_chunk.created_by == created_by
+ # Note: Default values are set by database, not by model instantiation
+
+ def test_child_chunk_with_indexing_fields(self):
+ """Test creating a child chunk with indexing fields."""
+ # Arrange
+ index_node_id = str(uuid4())
+ index_node_hash = "child_hash_123"
+
+ # Act
+ child_chunk = ChildChunk(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=str(uuid4()),
+ segment_id=str(uuid4()),
+ position=1,
+ content="Test content",
+ word_count=2,
+ created_by=str(uuid4()),
+ index_node_id=index_node_id,
+ index_node_hash=index_node_hash,
+ )
+
+ # Assert
+ assert child_chunk.index_node_id == index_node_id
+ assert child_chunk.index_node_hash == index_node_hash
+
+
+class TestDatasetDocumentCascadeDeletes:
+ """Test suite for Dataset-Document cascade delete operations."""
+
+ def test_dataset_with_documents_relationship(self):
+ """Test dataset can track its documents."""
+ # Arrange
+ dataset_id = str(uuid4())
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+ dataset.id = dataset_id
+
+ # Mock the database session query
+ mock_query = MagicMock()
+ mock_query.where.return_value.scalar.return_value = 3
+
+ with patch("models.dataset.db.session.query", return_value=mock_query):
+ # Act
+ total_docs = dataset.total_documents
+
+ # Assert
+ assert total_docs == 3
+
+ def test_dataset_available_documents_count(self):
+ """Test dataset can count available documents."""
+ # Arrange
+ dataset_id = str(uuid4())
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+ dataset.id = dataset_id
+
+ # Mock the database session query
+ mock_query = MagicMock()
+ mock_query.where.return_value.scalar.return_value = 2
+
+ with patch("models.dataset.db.session.query", return_value=mock_query):
+ # Act
+ available_docs = dataset.total_available_documents
+
+ # Assert
+ assert available_docs == 2
+
+ def test_dataset_word_count_aggregation(self):
+ """Test dataset can aggregate word count from documents."""
+ # Arrange
+ dataset_id = str(uuid4())
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+ dataset.id = dataset_id
+
+ # Mock the database session query
+ mock_query = MagicMock()
+ mock_query.with_entities.return_value.where.return_value.scalar.return_value = 5000
+
+ with patch("models.dataset.db.session.query", return_value=mock_query):
+ # Act
+ total_words = dataset.word_count
+
+ # Assert
+ assert total_words == 5000
+
+ def test_dataset_available_segment_count(self):
+ """Test dataset can count available segments."""
+ # Arrange
+ dataset_id = str(uuid4())
+ dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+ dataset.id = dataset_id
+
+ # Mock the database session query
+ mock_query = MagicMock()
+ mock_query.where.return_value.scalar.return_value = 15
+
+ with patch("models.dataset.db.session.query", return_value=mock_query):
+ # Act
+ segment_count = dataset.available_segment_count
+
+ # Assert
+ assert segment_count == 15
+
+ def test_document_segment_count_property(self):
+ """Test document can count its segments."""
+ # Arrange
+ document_id = str(uuid4())
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ )
+ document.id = document_id
+
+ # Mock the database session query
+ mock_query = MagicMock()
+ mock_query.where.return_value.count.return_value = 10
+
+ with patch("models.dataset.db.session.query", return_value=mock_query):
+ # Act
+ segment_count = document.segment_count
+
+ # Assert
+ assert segment_count == 10
+
+ def test_document_hit_count_aggregation(self):
+ """Test document can aggregate hit count from segments."""
+ # Arrange
+ document_id = str(uuid4())
+ document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ )
+ document.id = document_id
+
+ # Mock the database session query
+ mock_query = MagicMock()
+ mock_query.with_entities.return_value.where.return_value.scalar.return_value = 25
+
+ with patch("models.dataset.db.session.query", return_value=mock_query):
+ # Act
+ hit_count = document.hit_count
+
+ # Assert
+ assert hit_count == 25
+
+
+class TestDocumentSegmentNavigation:
+ """Test suite for DocumentSegment navigation properties."""
+
+ def test_document_segment_dataset_property(self):
+ """Test segment can access its parent dataset."""
+ # Arrange
+ dataset_id = str(uuid4())
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=dataset_id,
+ document_id=str(uuid4()),
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ )
+
+ mock_dataset = Dataset(
+ tenant_id=str(uuid4()),
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=str(uuid4()),
+ )
+ mock_dataset.id = dataset_id
+
+ # Mock the database session scalar
+ with patch("models.dataset.db.session.scalar", return_value=mock_dataset):
+ # Act
+ dataset = segment.dataset
+
+ # Assert
+ assert dataset is not None
+ assert dataset.id == dataset_id
+
+ def test_document_segment_document_property(self):
+ """Test segment can access its parent document."""
+ # Arrange
+ document_id = str(uuid4())
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=document_id,
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ )
+
+ mock_document = Document(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=str(uuid4()),
+ )
+ mock_document.id = document_id
+
+ # Mock the database session scalar
+ with patch("models.dataset.db.session.scalar", return_value=mock_document):
+ # Act
+ document = segment.document
+
+ # Assert
+ assert document is not None
+ assert document.id == document_id
+
+ def test_document_segment_previous_segment(self):
+ """Test segment can access previous segment."""
+ # Arrange
+ document_id = str(uuid4())
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=document_id,
+ position=2,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ )
+
+ previous_segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=document_id,
+ position=1,
+ content="Previous",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ )
+
+ # Mock the database session scalar
+ with patch("models.dataset.db.session.scalar", return_value=previous_segment):
+ # Act
+ prev_seg = segment.previous_segment
+
+ # Assert
+ assert prev_seg is not None
+ assert prev_seg.position == 1
+
+ def test_document_segment_next_segment(self):
+ """Test segment can access next segment."""
+ # Arrange
+ document_id = str(uuid4())
+ segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=document_id,
+ position=1,
+ content="Test",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ )
+
+ next_segment = DocumentSegment(
+ tenant_id=str(uuid4()),
+ dataset_id=str(uuid4()),
+ document_id=document_id,
+ position=2,
+ content="Next",
+ word_count=1,
+ tokens=2,
+ created_by=str(uuid4()),
+ )
+
+ # Mock the database session scalar
+ with patch("models.dataset.db.session.scalar", return_value=next_segment):
+ # Act
+ next_seg = segment.next_segment
+
+ # Assert
+ assert next_seg is not None
+ assert next_seg.position == 2
+
+
+class TestModelIntegration:
+ """Test suite for model integration scenarios."""
+
+ def test_complete_dataset_document_segment_hierarchy(self):
+ """Test complete hierarchy from dataset to segment."""
+ # Arrange
+ tenant_id = str(uuid4())
+ dataset_id = str(uuid4())
+ document_id = str(uuid4())
+ created_by = str(uuid4())
+
+ # Create dataset
+ dataset = Dataset(
+ tenant_id=tenant_id,
+ name="Test Dataset",
+ data_source_type="upload_file",
+ created_by=created_by,
+ indexing_technique="high_quality",
+ )
+ dataset.id = dataset_id
+
+ # Create document
+ document = Document(
+ tenant_id=tenant_id,
+ dataset_id=dataset_id,
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=created_by,
+ word_count=100,
+ )
+ document.id = document_id
+
+ # Create segment
+ segment = DocumentSegment(
+ tenant_id=tenant_id,
+ dataset_id=dataset_id,
+ document_id=document_id,
+ position=1,
+ content="Test segment content",
+ word_count=3,
+ tokens=5,
+ created_by=created_by,
+ status="completed",
+ )
+
+ # Assert
+ assert dataset.id == dataset_id
+ assert document.dataset_id == dataset_id
+ assert segment.dataset_id == dataset_id
+ assert segment.document_id == document_id
+ assert dataset.indexing_technique == "high_quality"
+ assert document.word_count == 100
+ assert segment.status == "completed"
+
+ def test_document_to_dict_serialization(self):
+ """Test document to_dict method for serialization."""
+ # Arrange
+ tenant_id = str(uuid4())
+ dataset_id = str(uuid4())
+ created_by = str(uuid4())
+
+ document = Document(
+ tenant_id=tenant_id,
+ dataset_id=dataset_id,
+ position=1,
+ data_source_type="upload_file",
+ batch="batch_001",
+ name="test.pdf",
+ created_from="web",
+ created_by=created_by,
+ word_count=100,
+ indexing_status="completed",
+ )
+
+ # Mock segment_count and hit_count
+ with (
+ patch.object(Document, "segment_count", new_callable=lambda: property(lambda self: 5)),
+ patch.object(Document, "hit_count", new_callable=lambda: property(lambda self: 10)),
+ ):
+ # Act
+ result = document.to_dict()
+
+ # Assert
+ assert result["tenant_id"] == tenant_id
+ assert result["dataset_id"] == dataset_id
+ assert result["name"] == "test.pdf"
+ assert result["word_count"] == 100
+ assert result["indexing_status"] == "completed"
+ assert result["segment_count"] == 5
+ assert result["hit_count"] == 10
From a6c6bcf95cb21de7b1b36b1c3edce4ca9edb7422 Mon Sep 17 00:00:00 2001
From: Asuka Minato
Date: Fri, 21 Nov 2025 22:45:51 +0900
Subject: [PATCH 038/191] more typed orm (#28507)
---
.../app/apps/pipeline/pipeline_generator.py | 2 +-
api/core/ops/ops_trace_manager.py | 2 +
api/core/provider_manager.py | 11 +-
api/models/account.py | 3 +-
api/models/base.py | 5 +-
api/models/dataset.py | 171 ++++++++++--------
api/models/model.py | 56 +++---
api/models/provider.py | 10 +-
api/models/source.py | 3 +-
api/models/task.py | 2 +-
api/models/tools.py | 2 +-
api/models/trigger.py | 2 +-
api/models/web.py | 3 +-
api/models/workflow.py | 12 +-
api/services/dataset_service.py | 2 +
api/services/external_knowledge_service.py | 8 +-
api/services/hit_testing_service.py | 14 +-
api/services/ops_service.py | 2 +
api/services/rag_pipeline/rag_pipeline.py | 14 +-
.../rag_pipeline_transform_service.py | 6 +-
20 files changed, 196 insertions(+), 134 deletions(-)
diff --git a/api/core/app/apps/pipeline/pipeline_generator.py b/api/core/app/apps/pipeline/pipeline_generator.py
index a1390ad0be..13eb40fd60 100644
--- a/api/core/app/apps/pipeline/pipeline_generator.py
+++ b/api/core/app/apps/pipeline/pipeline_generator.py
@@ -163,7 +163,7 @@ class PipelineGenerator(BaseAppGenerator):
datasource_type=datasource_type,
datasource_info=json.dumps(datasource_info),
datasource_node_id=start_node_id,
- input_data=inputs,
+ input_data=dict(inputs),
pipeline_id=pipeline.id,
created_by=user.id,
)
diff --git a/api/core/ops/ops_trace_manager.py b/api/core/ops/ops_trace_manager.py
index 5bb539b7dc..e8ba2d7aab 100644
--- a/api/core/ops/ops_trace_manager.py
+++ b/api/core/ops/ops_trace_manager.py
@@ -274,6 +274,8 @@ class OpsTraceManager:
raise ValueError("App not found")
tenant_id = app.tenant_id
+ if trace_config_data.tracing_config is None:
+ raise ValueError("Tracing config cannot be None.")
decrypt_tracing_config = cls.decrypt_tracing_config(
tenant_id, tracing_provider, trace_config_data.tracing_config
)
diff --git a/api/core/provider_manager.py b/api/core/provider_manager.py
index 6cf6620d8d..6c818bdc8b 100644
--- a/api/core/provider_manager.py
+++ b/api/core/provider_manager.py
@@ -309,11 +309,12 @@ class ProviderManager:
(model for model in available_models if model.model == "gpt-4"), available_models[0]
)
- default_model = TenantDefaultModel()
- default_model.tenant_id = tenant_id
- default_model.model_type = model_type.to_origin_model_type()
- default_model.provider_name = available_model.provider.provider
- default_model.model_name = available_model.model
+ default_model = TenantDefaultModel(
+ tenant_id=tenant_id,
+ model_type=model_type.to_origin_model_type(),
+ provider_name=available_model.provider.provider,
+ model_name=available_model.model,
+ )
db.session.add(default_model)
db.session.commit()
diff --git a/api/models/account.py b/api/models/account.py
index 615883f01a..b1dafed0ed 100644
--- a/api/models/account.py
+++ b/api/models/account.py
@@ -11,8 +11,7 @@ from sqlalchemy import DateTime, String, func, select
from sqlalchemy.orm import Mapped, Session, mapped_column
from typing_extensions import deprecated
-from models.base import TypeBase
-
+from .base import TypeBase
from .engine import db
from .types import LongText, StringUUID
diff --git a/api/models/base.py b/api/models/base.py
index 78a1fdc2b7..c8a5e20f25 100644
--- a/api/models/base.py
+++ b/api/models/base.py
@@ -5,8 +5,9 @@ from sqlalchemy.orm import DeclarativeBase, Mapped, MappedAsDataclass, mapped_co
from libs.datetime_utils import naive_utc_now
from libs.uuid_utils import uuidv7
-from models.engine import metadata
-from models.types import StringUUID
+
+from .engine import metadata
+from .types import StringUUID
class Base(DeclarativeBase):
diff --git a/api/models/dataset.py b/api/models/dataset.py
index 04f107f858..4bc802bb1c 100644
--- a/api/models/dataset.py
+++ b/api/models/dataset.py
@@ -22,11 +22,10 @@ from core.rag.index_processor.constant.built_in_field import BuiltInField, Metad
from core.rag.retrieval.retrieval_methods import RetrievalMethod
from extensions.ext_storage import storage
from libs.uuid_utils import uuidv7
-from models.base import TypeBase
from services.entities.knowledge_entities.knowledge_entities import ParentMode, Rule
from .account import Account
-from .base import Base
+from .base import Base, TypeBase
from .engine import db
from .model import App, Tag, TagBinding, UploadFile
from .types import AdjustedJSON, BinaryData, LongText, StringUUID, adjusted_json_index
@@ -934,21 +933,25 @@ class AppDatasetJoin(TypeBase):
return db.session.get(App, self.app_id)
-class DatasetQuery(Base):
+class DatasetQuery(TypeBase):
__tablename__ = "dataset_queries"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="dataset_query_pkey"),
sa.Index("dataset_query_dataset_id_idx", "dataset_id"),
)
- id = mapped_column(StringUUID, primary_key=True, nullable=False, default=lambda: str(uuid4()))
- dataset_id = mapped_column(StringUUID, nullable=False)
- content = mapped_column(LongText, nullable=False)
+ id: Mapped[str] = mapped_column(
+ StringUUID, primary_key=True, nullable=False, default=lambda: str(uuid4()), init=False
+ )
+ dataset_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ content: Mapped[str] = mapped_column(LongText, nullable=False)
source: Mapped[str] = mapped_column(String(255), nullable=False)
- source_app_id = mapped_column(StringUUID, nullable=True)
- created_by_role = mapped_column(String(255), nullable=False)
- created_by = mapped_column(StringUUID, nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=sa.func.current_timestamp())
+ source_app_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+ created_by_role: Mapped[str] = mapped_column(String(255), nullable=False)
+ created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=sa.func.current_timestamp(), init=False
+ )
class DatasetKeywordTable(TypeBase):
@@ -1047,12 +1050,12 @@ class TidbAuthBinding(Base):
sa.Index("tidb_auth_bindings_created_at_idx", "created_at"),
sa.Index("tidb_auth_bindings_status_idx", "status"),
)
- id = mapped_column(StringUUID, primary_key=True, default=lambda: str(uuid4()))
- tenant_id = mapped_column(StringUUID, nullable=True)
+ id: Mapped[str] = mapped_column(StringUUID, primary_key=True, default=lambda: str(uuid4()))
+ tenant_id: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
cluster_id: Mapped[str] = mapped_column(String(255), nullable=False)
cluster_name: Mapped[str] = mapped_column(String(255), nullable=False)
active: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("false"))
- status = mapped_column(sa.String(255), nullable=False, server_default=sa.text("'CREATING'"))
+ status: Mapped[str] = mapped_column(sa.String(255), nullable=False, server_default=sa.text("'CREATING'"))
account: Mapped[str] = mapped_column(String(255), nullable=False)
password: Mapped[str] = mapped_column(String(255), nullable=False)
created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
@@ -1148,7 +1151,7 @@ class ExternalKnowledgeApis(TypeBase):
return dataset_bindings
-class ExternalKnowledgeBindings(Base):
+class ExternalKnowledgeBindings(TypeBase):
__tablename__ = "external_knowledge_bindings"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="external_knowledge_bindings_pkey"),
@@ -1158,16 +1161,18 @@ class ExternalKnowledgeBindings(Base):
sa.Index("external_knowledge_bindings_external_knowledge_api_idx", "external_knowledge_api_id"),
)
- id = mapped_column(StringUUID, nullable=False, default=lambda: str(uuid4()))
- tenant_id = mapped_column(StringUUID, nullable=False)
- external_knowledge_api_id = mapped_column(StringUUID, nullable=False)
- dataset_id = mapped_column(StringUUID, nullable=False)
- external_knowledge_id = mapped_column(String(512), nullable=False)
- created_by = mapped_column(StringUUID, nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
- updated_by = mapped_column(StringUUID, nullable=True)
+ id: Mapped[str] = mapped_column(StringUUID, nullable=False, default=lambda: str(uuid4()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ external_knowledge_api_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ dataset_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ external_knowledge_id: Mapped[str] = mapped_column(String(512), nullable=False)
+ created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
+ updated_by: Mapped[str | None] = mapped_column(StringUUID, nullable=True, default=None, init=False)
updated_at: Mapped[datetime] = mapped_column(
- DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
)
@@ -1245,49 +1250,61 @@ class DatasetMetadataBinding(Base):
created_by = mapped_column(StringUUID, nullable=False)
-class PipelineBuiltInTemplate(Base): # type: ignore[name-defined]
+class PipelineBuiltInTemplate(TypeBase):
__tablename__ = "pipeline_built_in_templates"
__table_args__ = (sa.PrimaryKeyConstraint("id", name="pipeline_built_in_template_pkey"),)
- id = mapped_column(StringUUID, default=lambda: str(uuidv7()))
- name = mapped_column(sa.String(255), nullable=False)
- description = mapped_column(LongText, nullable=False)
- chunk_structure = mapped_column(sa.String(255), nullable=False)
- icon = mapped_column(sa.JSON, nullable=False)
- yaml_content = mapped_column(LongText, nullable=False)
- copyright = mapped_column(sa.String(255), nullable=False)
- privacy_policy = mapped_column(sa.String(255), nullable=False)
- position = mapped_column(sa.Integer, nullable=False)
- install_count = mapped_column(sa.Integer, nullable=False, default=0)
- language = mapped_column(sa.String(255), nullable=False)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
- updated_at = mapped_column(
- sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
+ name: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ description: Mapped[str] = mapped_column(LongText, nullable=False)
+ chunk_structure: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ icon: Mapped[dict] = mapped_column(sa.JSON, nullable=False)
+ yaml_content: Mapped[str] = mapped_column(LongText, nullable=False)
+ copyright: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ privacy_policy: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ position: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+ install_count: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+ language: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
+ updated_at: Mapped[datetime] = mapped_column(
+ sa.DateTime,
+ nullable=False,
+ server_default=func.current_timestamp(),
+ onupdate=func.current_timestamp(),
+ init=False,
)
-class PipelineCustomizedTemplate(Base): # type: ignore[name-defined]
+class PipelineCustomizedTemplate(TypeBase):
__tablename__ = "pipeline_customized_templates"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="pipeline_customized_template_pkey"),
sa.Index("pipeline_customized_template_tenant_idx", "tenant_id"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuidv7()))
- tenant_id = mapped_column(StringUUID, nullable=False)
- name = mapped_column(sa.String(255), nullable=False)
- description = mapped_column(LongText, nullable=False)
- chunk_structure = mapped_column(sa.String(255), nullable=False)
- icon = mapped_column(sa.JSON, nullable=False)
- position = mapped_column(sa.Integer, nullable=False)
- yaml_content = mapped_column(LongText, nullable=False)
- install_count = mapped_column(sa.Integer, nullable=False, default=0)
- language = mapped_column(sa.String(255), nullable=False)
- created_by = mapped_column(StringUUID, nullable=False)
- updated_by = mapped_column(StringUUID, nullable=True)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
- updated_at = mapped_column(
- sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ name: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ description: Mapped[str] = mapped_column(LongText, nullable=False)
+ chunk_structure: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ icon: Mapped[dict] = mapped_column(sa.JSON, nullable=False)
+ position: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+ yaml_content: Mapped[str] = mapped_column(LongText, nullable=False)
+ install_count: Mapped[int] = mapped_column(sa.Integer, nullable=False)
+ language: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ created_by: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ updated_by: Mapped[str | None] = mapped_column(StringUUID, nullable=True, default=None, init=False)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
+ updated_at: Mapped[datetime] = mapped_column(
+ sa.DateTime,
+ nullable=False,
+ server_default=func.current_timestamp(),
+ onupdate=func.current_timestamp(),
+ init=False,
)
@property
@@ -1320,34 +1337,42 @@ class Pipeline(Base): # type: ignore[name-defined]
return session.query(Dataset).where(Dataset.pipeline_id == self.id).first()
-class DocumentPipelineExecutionLog(Base):
+class DocumentPipelineExecutionLog(TypeBase):
__tablename__ = "document_pipeline_execution_logs"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="document_pipeline_execution_log_pkey"),
sa.Index("document_pipeline_execution_logs_document_id_idx", "document_id"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuidv7()))
- pipeline_id = mapped_column(StringUUID, nullable=False)
- document_id = mapped_column(StringUUID, nullable=False)
- datasource_type = mapped_column(sa.String(255), nullable=False)
- datasource_info = mapped_column(LongText, nullable=False)
- datasource_node_id = mapped_column(sa.String(255), nullable=False)
- input_data = mapped_column(sa.JSON, nullable=False)
- created_by = mapped_column(StringUUID, nullable=True)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
+ pipeline_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ document_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ datasource_type: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ datasource_info: Mapped[str] = mapped_column(LongText, nullable=False)
+ datasource_node_id: Mapped[str] = mapped_column(sa.String(255), nullable=False)
+ input_data: Mapped[dict] = mapped_column(sa.JSON, nullable=False)
+ created_by: Mapped[str | None] = mapped_column(StringUUID, nullable=True)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
-class PipelineRecommendedPlugin(Base):
+class PipelineRecommendedPlugin(TypeBase):
__tablename__ = "pipeline_recommended_plugins"
__table_args__ = (sa.PrimaryKeyConstraint("id", name="pipeline_recommended_plugin_pkey"),)
- id = mapped_column(StringUUID, default=lambda: str(uuidv7()))
- plugin_id = mapped_column(LongText, nullable=False)
- provider_name = mapped_column(LongText, nullable=False)
- position = mapped_column(sa.Integer, nullable=False, default=0)
- active = mapped_column(sa.Boolean, nullable=False, default=True)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
- updated_at = mapped_column(
- sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuidv7()), init=False)
+ plugin_id: Mapped[str] = mapped_column(LongText, nullable=False)
+ provider_name: Mapped[str] = mapped_column(LongText, nullable=False)
+ position: Mapped[int] = mapped_column(sa.Integer, nullable=False, default=0)
+ active: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, default=True)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
+ updated_at: Mapped[datetime] = mapped_column(
+ sa.DateTime,
+ nullable=False,
+ server_default=func.current_timestamp(),
+ onupdate=func.current_timestamp(),
+ init=False,
)
diff --git a/api/models/model.py b/api/models/model.py
index fb287bcea5..b0bf46e7d7 100644
--- a/api/models/model.py
+++ b/api/models/model.py
@@ -31,7 +31,7 @@ from .provider_ids import GenericProviderID
from .types import LongText, StringUUID
if TYPE_CHECKING:
- from models.workflow import Workflow
+ from .workflow import Workflow
class DifySetup(TypeBase):
@@ -1747,36 +1747,40 @@ class UploadFile(Base):
self.source_url = source_url
-class ApiRequest(Base):
+class ApiRequest(TypeBase):
__tablename__ = "api_requests"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="api_request_pkey"),
sa.Index("api_request_token_idx", "tenant_id", "api_token_id"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuid4()))
- tenant_id = mapped_column(StringUUID, nullable=False)
- api_token_id = mapped_column(StringUUID, nullable=False)
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+ tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ api_token_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
path: Mapped[str] = mapped_column(String(255), nullable=False)
- request = mapped_column(LongText, nullable=True)
- response = mapped_column(LongText, nullable=True)
+ request: Mapped[str | None] = mapped_column(LongText, nullable=True)
+ response: Mapped[str | None] = mapped_column(LongText, nullable=True)
ip: Mapped[str] = mapped_column(String(255), nullable=False)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
-class MessageChain(Base):
+class MessageChain(TypeBase):
__tablename__ = "message_chains"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="message_chain_pkey"),
sa.Index("message_chain_message_id_idx", "message_id"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuid4()))
- message_id = mapped_column(StringUUID, nullable=False)
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+ message_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
type: Mapped[str] = mapped_column(String(255), nullable=False)
- input = mapped_column(LongText, nullable=True)
- output = mapped_column(LongText, nullable=True)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=sa.func.current_timestamp())
+ input: Mapped[str | None] = mapped_column(LongText, nullable=True)
+ output: Mapped[str | None] = mapped_column(LongText, nullable=True)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=sa.func.current_timestamp(), init=False
+ )
class MessageAgentThought(Base):
@@ -1956,22 +1960,28 @@ class TagBinding(TypeBase):
)
-class TraceAppConfig(Base):
+class TraceAppConfig(TypeBase):
__tablename__ = "trace_app_config"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="tracing_app_config_pkey"),
sa.Index("trace_app_config_app_id_idx", "app_id"),
)
- id = mapped_column(StringUUID, default=lambda: str(uuid4()))
- app_id = mapped_column(StringUUID, nullable=False)
- tracing_provider = mapped_column(String(255), nullable=True)
- tracing_config = mapped_column(sa.JSON, nullable=True)
- created_at = mapped_column(sa.DateTime, nullable=False, server_default=func.current_timestamp())
- updated_at = mapped_column(
- sa.DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
+ app_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
+ tracing_provider: Mapped[str | None] = mapped_column(String(255), nullable=True)
+ tracing_config: Mapped[dict | None] = mapped_column(sa.JSON, nullable=True)
+ created_at: Mapped[datetime] = mapped_column(
+ sa.DateTime, nullable=False, server_default=func.current_timestamp(), init=False
)
- is_active: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true"))
+ updated_at: Mapped[datetime] = mapped_column(
+ sa.DateTime,
+ nullable=False,
+ server_default=func.current_timestamp(),
+ onupdate=func.current_timestamp(),
+ init=False,
+ )
+ is_active: Mapped[bool] = mapped_column(sa.Boolean, nullable=False, server_default=sa.text("true"), default=True)
@property
def tracing_config_dict(self) -> dict[str, Any]:
diff --git a/api/models/provider.py b/api/models/provider.py
index 5f54676389..a840a483ab 100644
--- a/api/models/provider.py
+++ b/api/models/provider.py
@@ -166,21 +166,23 @@ class ProviderModel(TypeBase):
return credential.encrypted_config if credential else None
-class TenantDefaultModel(Base):
+class TenantDefaultModel(TypeBase):
__tablename__ = "tenant_default_models"
__table_args__ = (
sa.PrimaryKeyConstraint("id", name="tenant_default_model_pkey"),
sa.Index("tenant_default_model_tenant_id_provider_type_idx", "tenant_id", "provider_name", "model_type"),
)
- id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()))
+ id: Mapped[str] = mapped_column(StringUUID, default=lambda: str(uuid4()), init=False)
tenant_id: Mapped[str] = mapped_column(StringUUID, nullable=False)
provider_name: Mapped[str] = mapped_column(String(255), nullable=False)
model_name: Mapped[str] = mapped_column(String(255), nullable=False)
model_type: Mapped[str] = mapped_column(String(40), nullable=False)
- created_at: Mapped[datetime] = mapped_column(DateTime, nullable=False, server_default=func.current_timestamp())
+ created_at: Mapped[datetime] = mapped_column(
+ DateTime, nullable=False, server_default=func.current_timestamp(), init=False
+ )
updated_at: Mapped[datetime] = mapped_column(
- DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp()
+ DateTime, nullable=False, server_default=func.current_timestamp(), onupdate=func.current_timestamp(), init=False
)
diff --git a/api/models/source.py b/api/models/source.py
index ed5d30b48a..f093048c00 100644
--- a/api/models/source.py
+++ b/api/models/source.py
@@ -6,8 +6,7 @@ import sqlalchemy as sa
from sqlalchemy import DateTime, String, func
from sqlalchemy.orm import Mapped, mapped_column
-from models.base import TypeBase
-
+from .base import TypeBase
from .types import AdjustedJSON, LongText, StringUUID, adjusted_json_index
diff --git a/api/models/task.py b/api/models/task.py
index 1e00e46643..539945b251 100644
--- a/api/models/task.py
+++ b/api/models/task.py
@@ -6,8 +6,8 @@ from sqlalchemy import DateTime, String
from sqlalchemy.orm import Mapped, mapped_column
from libs.datetime_utils import naive_utc_now
-from models.base import TypeBase
+from .base import TypeBase
from .types import BinaryData, LongText
diff --git a/api/models/tools.py b/api/models/tools.py
index a4aeda93e5..0a79f95a70 100644
--- a/api/models/tools.py
+++ b/api/models/tools.py
@@ -12,8 +12,8 @@ from sqlalchemy.orm import Mapped, mapped_column
from core.tools.entities.common_entities import I18nObject
from core.tools.entities.tool_bundle import ApiToolBundle
from core.tools.entities.tool_entities import ApiProviderSchemaType, WorkflowToolParameterConfiguration
-from models.base import TypeBase
+from .base import TypeBase
from .engine import db
from .model import Account, App, Tenant
from .types import LongText, StringUUID
diff --git a/api/models/trigger.py b/api/models/trigger.py
index 92384b0d02..753fdb227b 100644
--- a/api/models/trigger.py
+++ b/api/models/trigger.py
@@ -237,7 +237,7 @@ class WorkflowTriggerLog(Base):
@property
def created_by_end_user(self):
- from models.model import EndUser
+ from .model import EndUser
created_by_role = CreatorUserRole(self.created_by_role)
return db.session.get(EndUser, self.created_by) if created_by_role == CreatorUserRole.END_USER else None
diff --git a/api/models/web.py b/api/models/web.py
index 6e1a90af87..4f0bf7c7da 100644
--- a/api/models/web.py
+++ b/api/models/web.py
@@ -5,8 +5,7 @@ import sqlalchemy as sa
from sqlalchemy import DateTime, String, func
from sqlalchemy.orm import Mapped, mapped_column
-from models.base import TypeBase
-
+from .base import TypeBase
from .engine import db
from .model import Message
from .types import StringUUID
diff --git a/api/models/workflow.py b/api/models/workflow.py
index d8d3e1e540..3ebc36bee3 100644
--- a/api/models/workflow.py
+++ b/api/models/workflow.py
@@ -86,7 +86,7 @@ class WorkflowType(StrEnum):
:param app_mode: app mode
:return: workflow type
"""
- from models.model import AppMode
+ from .model import AppMode
app_mode = app_mode if isinstance(app_mode, AppMode) else AppMode.value_of(app_mode)
return cls.WORKFLOW if app_mode == AppMode.WORKFLOW else cls.CHAT
@@ -413,7 +413,7 @@ class Workflow(Base):
For accurate checking, use a direct query with tenant_id, app_id, and version.
"""
- from models.tools import WorkflowToolProvider
+ from .tools import WorkflowToolProvider
stmt = select(
exists().where(
@@ -634,7 +634,7 @@ class WorkflowRun(Base):
@property
def created_by_end_user(self):
- from models.model import EndUser
+ from .model import EndUser
created_by_role = CreatorUserRole(self.created_by_role)
return db.session.get(EndUser, self.created_by) if created_by_role == CreatorUserRole.END_USER else None
@@ -653,7 +653,7 @@ class WorkflowRun(Base):
@property
def message(self):
- from models.model import Message
+ from .model import Message
return (
db.session.query(Message).where(Message.app_id == self.app_id, Message.workflow_run_id == self.id).first()
@@ -874,7 +874,7 @@ class WorkflowNodeExecutionModel(Base): # This model is expected to have `offlo
@property
def created_by_end_user(self):
- from models.model import EndUser
+ from .model import EndUser
created_by_role = CreatorUserRole(self.created_by_role)
# TODO(-LAN-): Avoid using db.session.get() here.
@@ -1130,7 +1130,7 @@ class WorkflowAppLog(TypeBase):
@property
def created_by_end_user(self):
- from models.model import EndUser
+ from .model import EndUser
created_by_role = CreatorUserRole(self.created_by_role)
return db.session.get(EndUser, self.created_by) if created_by_role == CreatorUserRole.END_USER else None
diff --git a/api/services/dataset_service.py b/api/services/dataset_service.py
index 037ef469d2..abfb4baeec 100644
--- a/api/services/dataset_service.py
+++ b/api/services/dataset_service.py
@@ -254,6 +254,8 @@ class DatasetService:
external_knowledge_api = ExternalDatasetService.get_external_knowledge_api(external_knowledge_api_id)
if not external_knowledge_api:
raise ValueError("External API template not found.")
+ if external_knowledge_id is None:
+ raise ValueError("external_knowledge_id is required")
external_knowledge_binding = ExternalKnowledgeBindings(
tenant_id=tenant_id,
dataset_id=dataset.id,
diff --git a/api/services/external_knowledge_service.py b/api/services/external_knowledge_service.py
index 0c2a80d067..27936f6278 100644
--- a/api/services/external_knowledge_service.py
+++ b/api/services/external_knowledge_service.py
@@ -257,12 +257,16 @@ class ExternalDatasetService:
db.session.add(dataset)
db.session.flush()
+ if args.get("external_knowledge_id") is None:
+ raise ValueError("external_knowledge_id is required")
+ if args.get("external_knowledge_api_id") is None:
+ raise ValueError("external_knowledge_api_id is required")
external_knowledge_binding = ExternalKnowledgeBindings(
tenant_id=tenant_id,
dataset_id=dataset.id,
- external_knowledge_api_id=args.get("external_knowledge_api_id"),
- external_knowledge_id=args.get("external_knowledge_id"),
+ external_knowledge_api_id=args.get("external_knowledge_api_id") or "",
+ external_knowledge_id=args.get("external_knowledge_id") or "",
created_by=user_id,
)
db.session.add(external_knowledge_binding)
diff --git a/api/services/hit_testing_service.py b/api/services/hit_testing_service.py
index 337181728c..cdbd2355ca 100644
--- a/api/services/hit_testing_service.py
+++ b/api/services/hit_testing_service.py
@@ -82,7 +82,12 @@ class HitTestingService:
logger.debug("Hit testing retrieve in %s seconds", end - start)
dataset_query = DatasetQuery(
- dataset_id=dataset.id, content=query, source="hit_testing", created_by_role="account", created_by=account.id
+ dataset_id=dataset.id,
+ content=query,
+ source="hit_testing",
+ source_app_id=None,
+ created_by_role="account",
+ created_by=account.id,
)
db.session.add(dataset_query)
@@ -118,7 +123,12 @@ class HitTestingService:
logger.debug("External knowledge hit testing retrieve in %s seconds", end - start)
dataset_query = DatasetQuery(
- dataset_id=dataset.id, content=query, source="hit_testing", created_by_role="account", created_by=account.id
+ dataset_id=dataset.id,
+ content=query,
+ source="hit_testing",
+ source_app_id=None,
+ created_by_role="account",
+ created_by=account.id,
)
db.session.add(dataset_query)
diff --git a/api/services/ops_service.py b/api/services/ops_service.py
index e490b7ed3c..a2c8e9118e 100644
--- a/api/services/ops_service.py
+++ b/api/services/ops_service.py
@@ -29,6 +29,8 @@ class OpsService:
if not app:
return None
tenant_id = app.tenant_id
+ if trace_config_data.tracing_config is None:
+ raise ValueError("Tracing config cannot be None.")
decrypt_tracing_config = OpsTraceManager.decrypt_tracing_config(
tenant_id, tracing_provider, trace_config_data.tracing_config
)
diff --git a/api/services/rag_pipeline/rag_pipeline.py b/api/services/rag_pipeline/rag_pipeline.py
index fed7a25e21..097d16e2a7 100644
--- a/api/services/rag_pipeline/rag_pipeline.py
+++ b/api/services/rag_pipeline/rag_pipeline.py
@@ -1119,13 +1119,19 @@ class RagPipelineService:
with Session(db.engine) as session:
rag_pipeline_dsl_service = RagPipelineDslService(session)
dsl = rag_pipeline_dsl_service.export_rag_pipeline_dsl(pipeline=pipeline, include_secret=True)
-
+ if args.get("icon_info") is None:
+ args["icon_info"] = {}
+ if args.get("description") is None:
+ raise ValueError("Description is required")
+ if args.get("name") is None:
+ raise ValueError("Name is required")
pipeline_customized_template = PipelineCustomizedTemplate(
- name=args.get("name"),
- description=args.get("description"),
- icon=args.get("icon_info"),
+ name=args.get("name") or "",
+ description=args.get("description") or "",
+ icon=args.get("icon_info") or {},
tenant_id=pipeline.tenant_id,
yaml_content=dsl,
+ install_count=0,
position=max_position + 1 if max_position else 1,
chunk_structure=dataset.chunk_structure,
language="en-US",
diff --git a/api/services/rag_pipeline/rag_pipeline_transform_service.py b/api/services/rag_pipeline/rag_pipeline_transform_service.py
index d79ab71668..22025dd44a 100644
--- a/api/services/rag_pipeline/rag_pipeline_transform_service.py
+++ b/api/services/rag_pipeline/rag_pipeline_transform_service.py
@@ -322,9 +322,9 @@ class RagPipelineTransformService:
datasource_info=data_source_info,
input_data={},
created_by=document.created_by,
- created_at=document.created_at,
datasource_node_id=file_node_id,
)
+ document_pipeline_execution_log.created_at = document.created_at
db.session.add(document)
db.session.add(document_pipeline_execution_log)
elif document.data_source_type == "notion_import":
@@ -350,9 +350,9 @@ class RagPipelineTransformService:
datasource_info=data_source_info,
input_data={},
created_by=document.created_by,
- created_at=document.created_at,
datasource_node_id=notion_node_id,
)
+ document_pipeline_execution_log.created_at = document.created_at
db.session.add(document)
db.session.add(document_pipeline_execution_log)
elif document.data_source_type == "website_crawl":
@@ -379,8 +379,8 @@ class RagPipelineTransformService:
datasource_info=data_source_info,
input_data={},
created_by=document.created_by,
- created_at=document.created_at,
datasource_node_id=datasource_node_id,
)
+ document_pipeline_execution_log.created_at = document.created_at
db.session.add(document)
db.session.add(document_pipeline_execution_log)
From 6d3ed468d8c1195a033b47f744fac39e9d0fe6cb Mon Sep 17 00:00:00 2001
From: 55Kamiryo <139614715+55Kamiryo@users.noreply.github.com>
Date: Fri, 21 Nov 2025 23:26:30 +0900
Subject: [PATCH 039/191] feat: add a stop run button to the published app UI
(#27509)
Co-authored-by: crazywoola <100913391+crazywoola@users.noreply.github.com>
---
.../share/text-generation/index.tsx | 10 +
.../share/text-generation/result/index.tsx | 186 +++++++++++++++---
.../share/text-generation/run-once/index.tsx | 38 +++-
.../workflow-app/hooks/use-workflow-run.ts | 3 +-
web/i18n/en-US/share.ts | 1 +
web/service/share.ts | 11 +-
6 files changed, 209 insertions(+), 40 deletions(-)
diff --git a/web/app/components/share/text-generation/index.tsx b/web/app/components/share/text-generation/index.tsx
index 98804c7311..f5cb7005b8 100644
--- a/web/app/components/share/text-generation/index.tsx
+++ b/web/app/components/share/text-generation/index.tsx
@@ -125,6 +125,12 @@ const TextGeneration: FC = ({
transfer_methods: [TransferMethod.local_file],
})
const [completionFiles, setCompletionFiles] = useState([])
+ const [runControl, setRunControl] = useState<{ onStop: () => Promise | void; isStopping: boolean } | null>(null)
+
+ useEffect(() => {
+ if (isCallBatchAPI)
+ setRunControl(null)
+ }, [isCallBatchAPI])
const handleSend = () => {
setIsCallBatchAPI(false)
@@ -417,6 +423,7 @@ const TextGeneration: FC = ({
isPC={isPC}
isMobile={!isPC}
isInstalledApp={isInstalledApp}
+ appId={appId}
installedAppInfo={installedAppInfo}
isError={task?.status === TaskStatus.failed}
promptConfig={promptConfig}
@@ -434,6 +441,8 @@ const TextGeneration: FC = ({
isShowTextToSpeech={!!textToSpeechConfig?.enabled}
siteInfo={siteInfo}
onRunStart={() => setResultExisted(true)}
+ onRunControlChange={!isCallBatchAPI ? setRunControl : undefined}
+ hideInlineStopButton={!isCallBatchAPI}
/>)
const renderBatchRes = () => {
@@ -565,6 +574,7 @@ const TextGeneration: FC = ({
onSend={handleSend}
visionConfig={visionConfig}
onVisionFilesChange={setCompletionFiles}
+ runControl={runControl}
/>
diff --git a/web/app/components/share/text-generation/result/index.tsx b/web/app/components/share/text-generation/result/index.tsx
index 7d21df448d..8cf5494bc9 100644
--- a/web/app/components/share/text-generation/result/index.tsx
+++ b/web/app/components/share/text-generation/result/index.tsx
@@ -1,13 +1,16 @@
'use client'
import type { FC } from 'react'
-import React, { useEffect, useRef, useState } from 'react'
+import React, { useCallback, useEffect, useRef, useState } from 'react'
import { useBoolean } from 'ahooks'
import { t } from 'i18next'
import { produce } from 'immer'
import TextGenerationRes from '@/app/components/app/text-generate/item'
import NoData from '@/app/components/share/text-generation/no-data'
import Toast from '@/app/components/base/toast'
-import { sendCompletionMessage, sendWorkflowMessage, updateFeedback } from '@/service/share'
+import Button from '@/app/components/base/button'
+import { StopCircle } from '@/app/components/base/icons/src/vender/solid/mediaAndDevices'
+import { RiLoader2Line } from '@remixicon/react'
+import { sendCompletionMessage, sendWorkflowMessage, stopChatMessageResponding, stopWorkflowMessage, updateFeedback } from '@/service/share'
import type { FeedbackType } from '@/app/components/base/chat/chat/type'
import Loading from '@/app/components/base/loading'
import type { PromptConfig } from '@/models/debug'
@@ -31,6 +34,7 @@ export type IResultProps = {
isPC: boolean
isMobile: boolean
isInstalledApp: boolean
+ appId: string
installedAppInfo?: InstalledApp
isError: boolean
isShowTextToSpeech: boolean
@@ -48,6 +52,8 @@ export type IResultProps = {
completionFiles: VisionFile[]
siteInfo: SiteInfo | null
onRunStart: () => void
+ onRunControlChange?: (control: { onStop: () => Promise
| void; isStopping: boolean } | null) => void
+ hideInlineStopButton?: boolean
}
const Result: FC = ({
@@ -56,6 +62,7 @@ const Result: FC = ({
isPC,
isMobile,
isInstalledApp,
+ appId,
installedAppInfo,
isError,
isShowTextToSpeech,
@@ -73,13 +80,10 @@ const Result: FC = ({
completionFiles,
siteInfo,
onRunStart,
+ onRunControlChange,
+ hideInlineStopButton = false,
}) => {
const [isResponding, { setTrue: setRespondingTrue, setFalse: setRespondingFalse }] = useBoolean(false)
- useEffect(() => {
- if (controlStopResponding)
- setRespondingFalse()
- }, [controlStopResponding])
-
const [completionRes, doSetCompletionRes] = useState('')
const completionResRef = useRef('')
const setCompletionRes = (res: string) => {
@@ -94,6 +98,29 @@ const Result: FC = ({
doSetWorkflowProcessData(data)
}
const getWorkflowProcessData = () => workflowProcessDataRef.current
+ const [currentTaskId, setCurrentTaskId] = useState(null)
+ const [isStopping, setIsStopping] = useState(false)
+ const abortControllerRef = useRef(null)
+ const resetRunState = useCallback(() => {
+ setCurrentTaskId(null)
+ setIsStopping(false)
+ abortControllerRef.current = null
+ onRunControlChange?.(null)
+ }, [onRunControlChange])
+
+ useEffect(() => {
+ const abortCurrentRequest = () => {
+ abortControllerRef.current?.abort()
+ }
+
+ if (controlStopResponding) {
+ abortCurrentRequest()
+ setRespondingFalse()
+ resetRunState()
+ }
+
+ return abortCurrentRequest
+ }, [controlStopResponding, resetRunState, setRespondingFalse])
const { notify } = Toast
const isNoData = !completionRes
@@ -112,6 +139,40 @@ const Result: FC = ({
notify({ type: 'error', message })
}
+ const handleStop = useCallback(async () => {
+ if (!currentTaskId || isStopping)
+ return
+ setIsStopping(true)
+ try {
+ if (isWorkflow)
+ await stopWorkflowMessage(appId, currentTaskId, isInstalledApp, installedAppInfo?.id || '')
+ else
+ await stopChatMessageResponding(appId, currentTaskId, isInstalledApp, installedAppInfo?.id || '')
+ abortControllerRef.current?.abort()
+ }
+ catch (error) {
+ const message = error instanceof Error ? error.message : String(error)
+ notify({ type: 'error', message })
+ }
+ finally {
+ setIsStopping(false)
+ }
+ }, [appId, currentTaskId, installedAppInfo?.id, isInstalledApp, isStopping, isWorkflow, notify])
+
+ useEffect(() => {
+ if (!onRunControlChange)
+ return
+ if (isResponding && currentTaskId) {
+ onRunControlChange({
+ onStop: handleStop,
+ isStopping,
+ })
+ }
+ else {
+ onRunControlChange(null)
+ }
+ }, [currentTaskId, handleStop, isResponding, isStopping, onRunControlChange])
+
const checkCanSend = () => {
// batch will check outer
if (isCallBatchAPI)
@@ -196,6 +257,7 @@ const Result: FC = ({
rating: null,
})
setCompletionRes('')
+ resetRunState()
let res: string[] = []
let tempMessageId = ''
@@ -213,6 +275,7 @@ const Result: FC = ({
if (!isEnd) {
setRespondingFalse()
onCompleted(getCompletionRes(), taskId, false)
+ resetRunState()
isTimeout = true
}
})()
@@ -221,8 +284,10 @@ const Result: FC = ({
sendWorkflowMessage(
data,
{
- onWorkflowStarted: ({ workflow_run_id }) => {
+ onWorkflowStarted: ({ workflow_run_id, task_id }) => {
tempMessageId = workflow_run_id
+ setCurrentTaskId(task_id || null)
+ setIsStopping(false)
setWorkflowProcessData({
status: WorkflowRunningStatus.Running,
tracing: [],
@@ -330,12 +395,38 @@ const Result: FC = ({
notify({ type: 'warning', message: t('appDebug.warningMessage.timeoutExceeded') })
return
}
+ const workflowStatus = data.status as WorkflowRunningStatus | undefined
+ const markNodesStopped = (traces?: WorkflowProcess['tracing']) => {
+ if (!traces)
+ return
+ const markTrace = (trace: WorkflowProcess['tracing'][number]) => {
+ if ([NodeRunningStatus.Running, NodeRunningStatus.Waiting].includes(trace.status as NodeRunningStatus))
+ trace.status = NodeRunningStatus.Stopped
+ trace.details?.forEach(detailGroup => detailGroup.forEach(markTrace))
+ trace.retryDetail?.forEach(markTrace)
+ trace.parallelDetail?.children?.forEach(markTrace)
+ }
+ traces.forEach(markTrace)
+ }
+ if (workflowStatus === WorkflowRunningStatus.Stopped) {
+ setWorkflowProcessData(produce(getWorkflowProcessData()!, (draft) => {
+ draft.status = WorkflowRunningStatus.Stopped
+ markNodesStopped(draft.tracing)
+ }))
+ setRespondingFalse()
+ resetRunState()
+ onCompleted(getCompletionRes(), taskId, false)
+ isEnd = true
+ return
+ }
if (data.error) {
notify({ type: 'error', message: data.error })
setWorkflowProcessData(produce(getWorkflowProcessData()!, (draft) => {
draft.status = WorkflowRunningStatus.Failed
+ markNodesStopped(draft.tracing)
}))
setRespondingFalse()
+ resetRunState()
onCompleted(getCompletionRes(), taskId, false)
isEnd = true
return
@@ -357,6 +448,7 @@ const Result: FC = ({
}
}
setRespondingFalse()
+ resetRunState()
setMessageId(tempMessageId)
onCompleted(getCompletionRes(), taskId, true)
isEnd = true
@@ -376,12 +468,19 @@ const Result: FC = ({
},
isInstalledApp,
installedAppInfo?.id,
- )
+ ).catch((error) => {
+ setRespondingFalse()
+ resetRunState()
+ const message = error instanceof Error ? error.message : String(error)
+ notify({ type: 'error', message })
+ })
}
else {
sendCompletionMessage(data, {
- onData: (data: string, _isFirstMessage: boolean, { messageId }) => {
+ onData: (data: string, _isFirstMessage: boolean, { messageId, taskId }) => {
tempMessageId = messageId
+ if (taskId && typeof taskId === 'string' && taskId.trim() !== '')
+ setCurrentTaskId(prev => prev ?? taskId)
res.push(data)
setCompletionRes(res.join(''))
},
@@ -391,6 +490,7 @@ const Result: FC = ({
return
}
setRespondingFalse()
+ resetRunState()
setMessageId(tempMessageId)
onCompleted(getCompletionRes(), taskId, true)
isEnd = true
@@ -405,9 +505,13 @@ const Result: FC = ({
return
}
setRespondingFalse()
+ resetRunState()
onCompleted(getCompletionRes(), taskId, false)
isEnd = true
},
+ getAbortController: (abortController) => {
+ abortControllerRef.current = abortController
+ },
}, isInstalledApp, installedAppInfo?.id)
}
}
@@ -426,28 +530,46 @@ const Result: FC = ({
}, [controlRetry])
const renderTextGenerationRes = () => (
-
+ <>
+ {!hideInlineStopButton && isResponding && currentTaskId && (
+
+
+
+ )}
+
+
)
return (
diff --git a/web/app/components/share/text-generation/run-once/index.tsx b/web/app/components/share/text-generation/run-once/index.tsx
index 112f08a1d7..379d885ff1 100644
--- a/web/app/components/share/text-generation/run-once/index.tsx
+++ b/web/app/components/share/text-generation/run-once/index.tsx
@@ -3,6 +3,7 @@ import { useEffect, useState } from 'react'
import React, { useCallback } from 'react'
import { useTranslation } from 'react-i18next'
import {
+ RiLoader2Line,
RiPlayLargeLine,
} from '@remixicon/react'
import Select from '@/app/components/base/select'
@@ -20,6 +21,7 @@ import cn from '@/utils/classnames'
import BoolInput from '@/app/components/workflow/nodes/_base/components/before-run-form/bool-input'
import CodeEditor from '@/app/components/workflow/nodes/_base/components/editor/code-editor'
import { CodeLanguage } from '@/app/components/workflow/nodes/code/types'
+import { StopCircle } from '@/app/components/base/icons/src/vender/solid/mediaAndDevices'
export type IRunOnceProps = {
siteInfo: SiteInfo
@@ -30,6 +32,10 @@ export type IRunOnceProps = {
onSend: () => void
visionConfig: VisionSettings
onVisionFilesChange: (files: VisionFile[]) => void
+ runControl?: {
+ onStop: () => Promise | void
+ isStopping: boolean
+ } | null
}
const RunOnce: FC = ({
promptConfig,
@@ -39,6 +45,7 @@ const RunOnce: FC = ({
onSend,
visionConfig,
onVisionFilesChange,
+ runControl,
}) => {
const { t } = useTranslation()
const media = useBreakpoints()
@@ -62,6 +69,14 @@ const RunOnce: FC = ({
e.preventDefault()
onSend()
}
+ const isRunning = !!runControl
+ const stopLabel = t('share.generation.stopRun', { defaultValue: 'Stop Run' })
+ const handlePrimaryClick = useCallback((e: React.MouseEvent) => {
+ if (!isRunning)
+ return
+ e.preventDefault()
+ runControl?.onStop?.()
+ }, [isRunning, runControl])
const handleInputsChange = useCallback((newInputs: Record) => {
onInputsChange(newInputs)
@@ -211,12 +226,25 @@ const RunOnce: FC = ({
diff --git a/web/app/components/workflow-app/hooks/use-workflow-run.ts b/web/app/components/workflow-app/hooks/use-workflow-run.ts
index c8949651e5..6164969b3d 100644
--- a/web/app/components/workflow-app/hooks/use-workflow-run.ts
+++ b/web/app/components/workflow-app/hooks/use-workflow-run.ts
@@ -7,6 +7,7 @@ import { produce } from 'immer'
import { v4 as uuidV4 } from 'uuid'
import { usePathname } from 'next/navigation'
import { useWorkflowStore } from '@/app/components/workflow/store'
+import type { Node } from '@/app/components/workflow/types'
import { WorkflowRunningStatus } from '@/app/components/workflow/types'
import { useWorkflowUpdate } from '@/app/components/workflow/hooks/use-workflow-interactions'
import { useWorkflowRunEvent } from '@/app/components/workflow/hooks/use-workflow-run-event/use-workflow-run-event'
@@ -152,7 +153,7 @@ export const useWorkflowRun = () => {
getNodes,
setNodes,
} = store.getState()
- const newNodes = produce(getNodes(), (draft) => {
+ const newNodes = produce(getNodes(), (draft: Node[]) => {
draft.forEach((node) => {
node.data.selected = false
node.data._runningStatus = undefined
diff --git a/web/i18n/en-US/share.ts b/web/i18n/en-US/share.ts
index ab589ffb76..461a35d7bc 100644
--- a/web/i18n/en-US/share.ts
+++ b/web/i18n/en-US/share.ts
@@ -63,6 +63,7 @@ const translation = {
csvStructureTitle: 'The CSV file must conform to the following structure:',
downloadTemplate: 'Download the template here',
field: 'Field',
+ stopRun: 'Stop Run',
batchFailed: {
info: '{{num}} failed executions',
retry: 'Retry',
diff --git a/web/service/share.ts b/web/service/share.ts
index df08f0f3d6..dffd3aecb7 100644
--- a/web/service/share.ts
+++ b/web/service/share.ts
@@ -78,18 +78,19 @@ export const stopChatMessageResponding = async (appId: string, taskId: string, i
return getAction('post', isInstalledApp)(getUrl(`chat-messages/${taskId}/stop`, isInstalledApp, installedAppId))
}
-export const sendCompletionMessage = async (body: Record