Merge pull request #58 from ResilientApp/test_brushes

Test brushes fixed persisting and stamps not appearing issues

Author: bchou9

backend/app.py

@@ -179,13 +179,15 @@ def handle_all_exceptions(e):
 from api_v1.collaborations import collaborations_v1_bp
 from api_v1.notifications import notifications_v1_bp
 from api_v1.users import users_v1_bp
+from routes.stamps import stamps_bp
 from api_v1.templates import templates_v1_bp
 
 app.register_blueprint(auth_v1_bp)
 app.register_blueprint(canvases_v1_bp)
 app.register_blueprint(collaborations_v1_bp)
 app.register_blueprint(notifications_v1_bp)
 app.register_blueprint(users_v1_bp)
+app.register_blueprint(stamps_bp, url_prefix='/api')
 app.register_blueprint(templates_v1_bp)
 
 # Frontend serving must be last to avoid route conflicts

backend/incubator-resilientdb-resilient-python-cache/resilient_python_cache/cache.py

@@ -21,6 +21,7 @@
 import asyncio
 import json
 import logging
+import ssl
 from typing import Optional
 
 import httpx
@@ -114,7 +115,7 @@ async def fetch_and_sync_initial_blocks(self):
             batch_ranges = []
             blocks_fetched = True
 
-            async with httpx.AsyncClient() as client:
+            async with httpx.AsyncClient(verify=False) as client:
                 while blocks_fetched:
                     min_seq = self.current_block_number + 1
                     max_seq = min_seq + batch_size - 1
@@ -158,7 +159,7 @@ async def fetch_and_sync_initial_blocks(self):
     async def fetch_and_sync_batch(self, min_seq: int, max_seq: int, semaphore: asyncio.Semaphore):
         async with semaphore:
             try:
-                async with httpx.AsyncClient() as client:
+                async with httpx.AsyncClient(verify=False) as client:
                     url = f"{self.http_endpoint}/{min_seq}/{max_seq}"
                     logger.info(f"Fetching blocks from {min_seq} to {max_seq}")
                     response = await client.get(url)
@@ -217,7 +218,7 @@ async def fetch_and_sync_new_blocks(self):
             batch_ranges = []
             blocks_fetched = True
 
-            async with httpx.AsyncClient() as client:
+            async with httpx.AsyncClient(verify=False) as client:
                 while blocks_fetched:
                     min_seq = self.current_block_number + 1
                     max_seq = min_seq + batch_size - 1
@@ -251,7 +252,12 @@ async def fetch_and_sync_new_blocks(self):
 
     async def connect_websocket(self):
         try:
-            async with websockets.connect(self.ws_endpoint) as websocket:
+            # Create SSL context that doesn't verify certificates
+            ssl_context = ssl.create_default_context()
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+            
+            async with websockets.connect(self.ws_endpoint, ssl=ssl_context) as websocket:
                 logger.info(f"Connected to WebSocket: {self.ws_endpoint}")
                 self.reconnect_attempts = 0
                 self.emit('connected')
@@ -318,4 +324,4 @@ async def close(self):
         except Exception as e:
             logger.error("Error closing connections:")
             logger.error(e)
-            raise ResilientPythonCacheError(str(e)) from e
+            raise ResilientPythonCacheError(str(e)) from e

backend/middleware/validators.py

@@ -8,6 +8,46 @@
 
 import re
 from typing import Tuple
+from functools import wraps
+from flask import request, jsonify
+
+
+def validate_json(required_fields=None):
+    """
+    Decorator to validate JSON request data.
+    
+    Args:
+        required_fields (list): List of required field names
+    
+    Returns:
+        Decorator function that validates request JSON
+    """
+    def decorator(f):
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            # Check if request has JSON data
+            if not request.is_json:
+                return jsonify({'error': 'Request must be JSON'}), 400
+            
+            data = request.get_json()
+            if not data:
+                return jsonify({'error': 'Request body cannot be empty'}), 400
+            
+            # Check required fields
+            if required_fields:
+                missing_fields = []
+                for field in required_fields:
+                    if field not in data or data[field] is None or data[field] == '':
+                        missing_fields.append(field)
+                
+                if missing_fields:
+                    return jsonify({
+                        'error': f'Missing required fields: {", ".join(missing_fields)}'
+                    }), 400
+            
+            return f(*args, **kwargs)
+        return decorated_function
+    return decorator
 
 
 def validate_username(value: str) -> Tuple[bool, str]: