Upload 94 files

app/core/config.py

@@ -8,11 +8,13 @@ class Settings(BaseSettings):
     VERSION: str = "1.0.0"
 
     # Service Authentication
-    SERVICE_TOKEN: str = "6f9aee88d5b94b0190c317abcbf4e6e7834cc2c7f02e45693e123456789abcde"
-    POS_API_URL: str = "https://fred808-desk-back2.hf.space"  # Default value, should be overridden in environment
+    SERVICE_TOKEN: str
+    POS_API_URL: str
+    POS_API_KEY: str
+    POS_API_VERSION: str
 
     # PostgreSQL Database settings
-    DATABASE_URL: ClassVar[str] = "postgresql+asyncpg://postgres.juycnkjuzylnbruwaqmp:Lovyelias5584.@aws-0-eu-central-1.pooler.supabase.com:5432/postgres"
+    DATABASE_URL: str
 
     # JWT Settings
     SECRET_KEY: str = "your-secret-key-here"
@@ -20,9 +22,16 @@ class Settings(BaseSettings):
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
 
     # Redis settings
-    REDIS_HOST: str = "localhost"
-    REDIS_PORT: int = 6379
-    REDIS_URL: str = f"redis://{REDIS_HOST}:{REDIS_PORT}"
+    REDIS_HOST: str
+    REDIS_PORT: int
+    REDIS_PASSWORD: str
+    REDIS_USERNAME: str = "default"
+    
+    @property
+    def REDIS_URL(self) -> str:
+        if self.REDIS_PASSWORD:
+            return f"redis://{self.REDIS_USERNAME}:{self.REDIS_PASSWORD}@{self.REDIS_HOST}:{self.REDIS_PORT}"
+        return f"redis://{self.REDIS_HOST}:{self.REDIS_PORT}"
 
     # Email settings
     MAIL_USERNAME: str = "yungdml31@gmail.com"
@@ -36,6 +45,7 @@ class Settings(BaseSettings):
 
     class Config:
         case_sensitive = True
+        env_file = ".env"
 
 
 settings = Settings()

app/main.py

@@ -13,7 +13,7 @@ import socketio
 import time
 import logging
 import asyncio
-from typing import List, Dict
+from typing import List, Dict, Optional
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -39,15 +39,16 @@ app.add_middleware(
 
 # Socket.IO event handlers
 @sio.event
-async def connect(sid, environ):
+async def connect(sid: str, environ: dict, auth: Optional[dict] = None):
     logger.info(f"Client connected: {sid}")
+    return True
 
 @sio.event
-async def disconnect(sid):
+async def disconnect(sid: str):
     logger.info(f"Client disconnected: {sid}")
 
 @sio.event
-async def message(sid, data):
+async def message(sid: str, data: dict):
     logger.info(f"Message from {sid}: {data}")
     await sio.emit('message', {'response': 'Message received'}, room=sid)
 

app/realtime/subscriber.py

@@ -12,6 +12,8 @@ async def subscribe_order_events(manager: ConnectionManager) -> None:
         r = redis.Redis(
             host=settings.REDIS_HOST,
             port=settings.REDIS_PORT,
+            password=settings.REDIS_PASSWORD,
+            username=settings.REDIS_USERNAME,
             decode_responses=True
         )
         

app/utils/cache.py

@@ -1,9 +1,8 @@
-import redis.asyncio as redis
+from typing import Optional, Any, Dict, Callable, TypeVar
 import json
 import inspect
-import functools
+import redis.asyncio as redis
 from ..core.config import settings
-from typing import Any, Optional, Callable, TypeVar
 from ..utils.logger import logger
 
 T = TypeVar('T')
@@ -19,6 +18,8 @@ class RedisCache:
             cls._instance.redis = redis.Redis(
                 host=settings.REDIS_HOST,
                 port=settings.REDIS_PORT,
+                password=settings.REDIS_PASSWORD,
+                username=settings.REDIS_USERNAME,
                 decode_responses=True
             )
         return cls._instance
@@ -37,10 +38,11 @@ class RedisCache:
     async def set_cache(self, key: str, value: Any, expire: int = 3600):
         """Set a cache entry with optional expiration time (default 1 hour)"""
         try:
-            if self.is_connected:
-                await self.redis.set(key, json.dumps(value), ex=expire)
-            else:
+            if not self.is_connected:
                 self.fallback_cache[key] = value
+                return
+            
+            await self.redis.set(key, json.dumps(value), ex=expire)
         except Exception as e:
             logger.error(f"Cache set error: {str(e)}")
             self.fallback_cache[key] = value
@@ -48,21 +50,24 @@ class RedisCache:
     async def get_cache(self, key: str) -> Optional[Any]:
         """Get a cached value by key"""
         try:
-            if self.is_connected:
-                value = await self.redis.get(key)
-                return json.loads(value) if value else None
-            return self.fallback_cache.get(key)
+            if not self.is_connected:
+                return self.fallback_cache.get(key)
+            
+            value = await self.redis.get(key)
+            if value:
+                return json.loads(value)
         except Exception as e:
             logger.error(f"Cache get error: {str(e)}")
             return self.fallback_cache.get(key)
+        return None
 
     async def delete_cache(self, key: str) -> bool:
         """Delete a cache entry by key"""
         try:
-            if self.is_connected:
-                return bool(await self.redis.delete(key))
-            self.fallback_cache.pop(key, None)
-            return True
+            if not self.is_connected:
+                return bool(self.fallback_cache.pop(key, None))
+            
+            return bool(await self.redis.delete(key))
         except Exception as e:
             logger.error(f"Cache delete error: {str(e)}")
             return False
@@ -70,67 +75,78 @@ class RedisCache:
     async def clear_cache_pattern(self, pattern: str) -> bool:
         """Clear all cache entries matching a pattern"""
         try:
-            if self.is_connected:
-                keys = await self.redis.keys(pattern)
-                if keys:
-                    return bool(await self.redis.delete(*keys))
-            return True
+            if not self.is_connected:
+                # Basic pattern matching for fallback cache
+                removed = 0
+                for key in list(self.fallback_cache.keys()):
+                    if pattern in key:
+                        del self.fallback_cache[key]
+                        removed += 1
+                return removed > 0
+            
+            # Get all keys matching pattern
+            keys = [key async for key in self.redis.scan_iter(pattern)]
+            if keys:
+                await self.redis.delete(*keys)
+            return bool(keys)
         except Exception as e:
-            logger.error(f"Cache clear pattern error: {str(e)}")
+            logger.error(f"Cache pattern clear error: {str(e)}")
             return False
 
     async def check_connection(self) -> bool:
         """Check if Redis connection is alive"""
         try:
-            if self.is_connected:
-                await self.redis.ping()
-                return True
-            return False
+            await self.redis.ping()
+            self.is_connected = True
+            return True
         except Exception:
+            self.is_connected = False
             return False
 
+    async def cleanup_expired(self):
+        """Clean up expired cache entries"""
+        # Redis automatically handles expiration, only need to clean fallback
+        if not self.is_connected:
+            self.fallback_cache = {}
+
 def cached(ttl_seconds: int):
     """Decorator to cache function results"""
     def decorator(func: Callable[..., T]) -> Callable[..., T]:
-        if inspect.iscoroutinefunction(func):
-            @functools.wraps(func)
-            async def async_wrapper(*args, **kwargs) -> T:
-                cache_key = f"{func.__name__}:{args}:{kwargs}"
-                cached_value = await cache.get_cache(cache_key)
-                if cached_value is not None:
-                    return cached_value
-                
-                result = await func(*args, **kwargs)
-                await cache.set_cache(cache_key, result, expire=ttl_seconds)
-                return result
-            return async_wrapper
-        else:
-            @functools.wraps(func)
-            def sync_wrapper(*args, **kwargs) -> T:
-                cache_key = f"{func.__name__}:{args}:{kwargs}"
-                try:
-                    cached_value = cache.redis.get(cache_key)
-                    if cached_value:
-                        return json.loads(cached_value)
-                except:
-                    if cache.is_connected:
-                        logger.error("Redis error in sync cache access")
-                    return cache.fallback_cache.get(cache_key)
-                
-                result = func(*args, **kwargs)
-                try:
-                    if cache.is_connected:
-                        cache.redis.setex(
-                            cache_key,
-                            ttl_seconds,
-                            json.dumps(result)
-                        )
-                    else:
-                        cache.fallback_cache[cache_key] = result
-                except Exception as e:
-                    logger.error(f"Cache set error in sync wrapper: {str(e)}")
-                return result
-            return sync_wrapper
+        async def async_wrapper(*args, **kwargs) -> T:
+            # Create cache key from function name and arguments
+            key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+            
+            # Try to get from cache first
+            cached_value = await cache.get_cache(key)
+            if cached_value is not None:
+                return cached_value
+            
+            # If not in cache, execute function
+            result = await func(*args, **kwargs)
+            
+            # Cache the result
+            await cache.set_cache(key, result, expire=ttl_seconds)
+            
+            return result
+
+        def sync_wrapper(*args, **kwargs) -> T:
+            # Create cache key from function name and arguments
+            key = f"{func.__name__}:{str(args)}:{str(kwargs)}"
+            
+            # For sync functions, we can't use async cache directly
+            # So we use the fallback cache
+            if key in cache.fallback_cache:
+                return cache.fallback_cache[key]
+            
+            # If not in cache, execute function
+            result = func(*args, **kwargs)
+            
+            # Cache the result in fallback
+            cache.fallback_cache[key] = result
+            
+            return result
+
+        return async_wrapper if inspect.iscoroutinefunction(func) else sync_wrapper
     return decorator
 
 cache = RedisCache()