🎉 Improved backend structure & added utility modules 🎨📚

backend/utils/multi_location_system.py

@@ -520,23 +520,138 @@ class MultiLocationManager:
         }
 
 # Globale Instanz
-multi_location_manager = MultiLocationManager()
+location_manager = MultiLocationManager()
+
+# Alias für Import-Kompatibilität
+LocationManager = MultiLocationManager
+
+def create_location(name: str, code: str, location_type: LocationType = LocationType.BRANCH,
+                   address: str = "", city: str = "", country: str = "",
+                   parent_id: Optional[int] = None) -> int:
+    """
+    Erstellt einen neuen Standort (globale Funktion).
+    
+    Args:
+        name: Name des Standorts
+        code: Kurzer Code für den Standort
+        location_type: Art des Standorts
+        address: Adresse
+        city: Stadt
+        country: Land
+        parent_id: Parent-Standort ID
+    
+    Returns:
+        int: ID des erstellten Standorts
+    """
+    location = Location(
+        name=name,
+        code=code,
+        location_type=location_type,
+        address=address,
+        city=city,
+        country=country,
+        parent_id=parent_id
+    )
+    
+    return location_manager.create_location(location)
+
+def assign_user_to_location(user_id: int, location_id: int, 
+                          access_level: AccessLevel = AccessLevel.READ_WRITE,
+                          granted_by: int = 1, is_primary: bool = False) -> bool:
+    """
+    Weist einen Benutzer einem Standort zu.
+    
+    Args:
+        user_id: ID des Benutzers
+        location_id: ID des Standorts
+        access_level: Zugriffslevel
+        granted_by: ID des gewährenden Benutzers
+        is_primary: Ob dies der primäre Standort ist
+    
+    Returns:
+        bool: True wenn erfolgreich
+    """
+    return location_manager.grant_location_access(
+        user_id=user_id,
+        location_id=location_id,
+        access_level=access_level,
+        granted_by=granted_by,
+        is_primary=is_primary
+    )
+
+def get_user_locations(user_id: int) -> List[Location]:
+    """
+    Holt alle Standorte eines Benutzers (globale Funktion).
+    
+    Args:
+        user_id: ID des Benutzers
+    
+    Returns:
+        List[Location]: Liste der zugänglichen Standorte
+    """
+    return location_manager.get_user_locations(user_id)
+
+def calculate_distance(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """
+    Berechnet die Entfernung zwischen zwei Koordinaten (Haversine-Formel).
+    
+    Args:
+        lat1, lon1: Koordinaten des ersten Punkts
+        lat2, lon2: Koordinaten des zweiten Punkts
+    
+    Returns:
+        float: Entfernung in Kilometern
+    """
+    from math import radians, sin, cos, sqrt, atan2
+    
+    R = 6371  # Erdradius in km
+    
+    lat1, lon1, lat2, lon2 = map(radians, [lat1, lon1, lat2, lon2])
+    dlat = lat2 - lat1
+    dlon = lon2 - lon1
+    
+    a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2
+    c = 2 * atan2(sqrt(a), sqrt(1-a))
+    
+    return R * c
+
+def find_nearest_location(latitude: float, longitude: float, 
+                         radius_km: float = 50) -> Optional[Location]:
+    """
+    Findet den nächstgelegenen Standort.
+    
+    Args:
+        latitude: Breitengrad
+        longitude: Längengrad
+        radius_km: Suchradius in Kilometern
+    
+    Returns:
+        Optional[Location]: Nächstgelegener Standort oder None
+    """
+    nearest_locations = location_manager.find_nearest_locations(
+        latitude=latitude,
+        longitude=longitude,
+        radius_km=radius_km,
+        limit=1
+    )
+    
+    return nearest_locations[0][0] if nearest_locations else None
 
 def get_location_dashboard_data(user_id: int) -> Dict[str, Any]:
     """Holt Dashboard-Daten für Standorte eines Benutzers"""
-    user_locations = multi_location_manager.get_user_locations(user_id)
-    primary_location = multi_location_manager.get_user_primary_location(user_id)
+    user_locations = location_manager.get_user_locations(user_id)
+    primary_location = location_manager.get_user_primary_location(user_id)
     
     dashboard_data = {
         'user_locations': [asdict(loc) for loc in user_locations],
         'primary_location': asdict(primary_location) if primary_location else None,
         'location_count': len(user_locations),
-        'hierarchy': multi_location_manager.get_location_hierarchy()
+        'hierarchy': location_manager.get_location_hierarchy()
     }
     
     # Füge Statistiken für jeden Standort hinzu
     for location in user_locations:
-        location_stats = multi_location_manager.get_location_statistics(location.id)
+        location_stats = location_manager.get_location_statistics(location.id)
         dashboard_data[f'stats_{location.id}'] = location_stats
     
     return dashboard_data
@@ -553,7 +668,7 @@ def create_location_from_address(name: str, address: str, city: str,
         country=country
     )
     
-    return multi_location_manager.create_location(location)
+    return location_manager.create_location(location)
 
 # JavaScript für Multi-Location Frontend
 def get_multi_location_javascript() -> str: