Update app.py

app.py

@@ -82,74 +82,204 @@ class SafeGeocoder:
             self.cache[location] = None
             return None
 
-        def process_excel(file, places_column):
-            if file is None:
-                return None, "No file uploaded", None
+
+def process_excel(file, places_column):
+    if file is None:
+        return None, "No file uploaded", None
+    
+    try:
+        if hasattr(file, 'name'):
+            df = pd.read_excel(file.name)
+        elif isinstance(file, bytes):
+            df = pd.read_excel(io.BytesIO(file))
+        else:
+            df = pd.read_excel(file)
+        
+        print(f"Spalten in der Excel-Tabelle: {list(df.columns)}")
+        
+        if places_column not in df.columns:
+            return None, f"Spalte '{places_column}' wurde in der Excel-Datei nicht gefunden. Verfügbare Spalten: {', '.join(df.columns)}", None
+        
+        # Create coordinates columns
+        df['latitude'] = None
+        df['longitude'] = None
+        # Add column for structured location data
+        df['location_data'] = None
+        
+        geocoder = SafeGeocoder()
+        coords = []
+        processed_count = 0
+        
+        # Process each location and store as JSON
+        for idx, row in df.iterrows():
+            if pd.isna(row[places_column]):
+                continue
+                
+            location = str(row[places_column]).strip()
             
             try:
-                if hasattr(file, 'name'):
-                    df = pd.read_excel(file.name)
-                elif isinstance(file, bytes):
-                    df = pd.read_excel(io.BytesIO(file))
-                else:
-                    df = pd.read_excel(file)
-                
-                print(f"Spalten in der Excel-Tabelle: {list(df.columns)}")
-                
-                if places_column not in df.columns:
-                    return None, f"Spalte '{places_column}' wurde in der Excel-Datei nicht gefunden. Verfügbare Spalten: {', '.join(df.columns)}", None
-                
-                # Create coordinates columns
-                df['latitude'] = None
-                df['longitude'] = None
-                
-                geocoder = SafeGeocoder()
-                coords = []
-                processed_count = 0
+                locations = [loc.strip() for loc in location.split(',') if loc.strip()]
+                if not locations:
+                    locations = [location]
+            except:
+                locations = [location]
+            
+            # Process all locations and store as JSON
+            location_data = []
+            for loc in locations:
+                point = geocoder.get_coords(loc)
+                if point:
+                    location_data.append({
+                        'location': loc,
+                        'latitude': point[0],
+                        'longitude': point[1]
+                    })
+                    coords.append(point)
+                    processed_count += 1
+            
+            if location_data:
+                df.at[idx, 'location_data'] = json.dumps(location_data)
+                # Store first location's coordinates in main columns for compatibility
+                df.at[idx, 'latitude'] = location_data[0]['latitude']
+                df.at[idx, 'longitude'] = location_data[0]['longitude']
+        
+        # Create the map
+        map_html, _ = create_map(df, places_column)
+        
+        # Save the updated DataFrame to a new Excel file
+        with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
+            processed_path = tmp.name
+            df.to_excel(processed_path, index=False)
+        
+        total_locations = df[places_column].count()
+        success_rate = (processed_count / total_locations * 100) if total_locations > 0 else 0
+        
+        stats = f"Gefunden: {processed_count} von {total_locations} Orten ({success_rate:.1f}%)"
+        
+        return map_html, stats, processed_path
+    except Exception as e:
+        import traceback
+        trace = traceback.format_exc()
+        print(f"Error processing file: {e}\n{trace}")
+        return None, f"Fehler bei der Verarbeitung der Datei: {str(e)}", None
+
+
+def create_map(df, location_col):
+    m = folium.Map(
+        location=[20, 0],
+        zoom_start=2, 
+        control_scale=True
+    )
+    
+    folium.TileLayer(
+        tiles=MAP_TILES["GreenMap"]["url"],
+        attr=MAP_TILES["GreenMap"]["attr"],
+        name="GreenMap",
+        overlay=False,
+        control=False
+    ).add_to(m)
+    
+    Fullscreen().add_to(m)
+    MeasureControl(position='topright', primary_length_unit='kilometers').add_to(m)
+    
+    coords = []
+    marker_cluster = MarkerCluster(name="Locations").add_to(m)
+    processed_count = 0
+    
+    for idx, row in df.iterrows():
+        # Check if we have JSON location data
+        if 'location_data' in df.columns and not pd.isna(row['location_data']):
+            try:
+                # Parse the JSON location data
+                location_data = json.loads(row['location_data'])
                 
-                # Geocode each location and store coordinates in the DataFrame
-                for idx, row in df.iterrows():
-                    if pd.isna(row[places_column]):
-                        continue
-                        
-                    location = str(row[places_column]).strip()
+                # Process each location in the JSON data
+                for loc_item in location_data:
+                    location_name = loc_item['location']
+                    point = (loc_item['latitude'], loc_item['longitude'])
                     
-                    try:
-                        locations = [loc.strip() for loc in location.split(',') if loc.strip()]
-                        if not locations:
-                            locations = [location]
-                    except:
-                        locations = [location]
-                        
-                    for loc in locations:
-                        point = geocoder.get_coords(loc)
-                        if point:
-                            df.at[idx, 'latitude'] = point[0]
-                            df.at[idx, 'longitude'] = point[1]
-                            coords.append(point)
-                            processed_count += 1
-                            break  # Use first successfully geocoded location
-        
-                # Create the map
-                map_html, _ = create_map(df, places_column)
-                
-                # Save the updated DataFrame to a new Excel file
-                with tempfile.NamedTemporaryFile(suffix=".xlsx", delete=False) as tmp:
-                    processed_path = tmp.name
-                    df.to_excel(processed_path, index=False)
+                    # Create additional info for popup
+                    additional_info = ""
+                    for col in df.columns:
+                        if col not in [location_col, 'location_data', 'latitude', 'longitude'] and not pd.isna(row[col]):
+                            additional_info += f"<br><b>{col}:</b> {row[col]}"
+                    
+                    # Add marker to map
+                    popup_content = f"""
+                    <div style="min-width: 200px; max-width: 300px">
+                        <h4 style="font-family: 'Source Sans Pro', sans-serif; margin-bottom: 5px;">{location_name}</h4>
+                        <div style="font-family: 'Source Sans Pro', sans-serif; font-size: 14px;">
+                            {additional_info}
+                        </div>
+                    </div>
+                    """
+                    
+                    folium.Marker(
+                        location=point,
+                        popup=folium.Popup(popup_content, max_width=300),
+                        tooltip=location_name,
+                        icon=folium.Icon(color="blue", icon="info-sign")
+                    ).add_to(marker_cluster)
+                    
+                    coords.append(point)
+                    processed_count += 1
+            except (json.JSONDecodeError, KeyError) as e:
+                print(f"Error processing JSON location data for row {idx}: {e}")
+                # Continue with fallback method if JSON processing fails
+        
+        # Fallback to the old method if no JSON data is present
+        elif not pd.isna(row[location_col]):
+            location = str(row[location_col]).strip()
+            
+            additional_info = ""
+            for col in df.columns:
+                if col != location_col and not pd.isna(row[col]):
+                    additional_info += f"<br><b>{col}:</b> {row[col]}"
+            
+            # If we have latitude and longitude directly
+            if 'latitude' in df.columns and 'longitude' in df.columns and not pd.isna(row['latitude']) and not pd.isna(row['longitude']):
+                point = (row['latitude'], row['longitude'])
                 
-                total_locations = df[places_column].count()
-                success_rate = (processed_count / total_locations * 100) if total_locations > 0 else 0
+                popup_content = f"""
+                <div style="min-width: 200px; max-width: 300px">
+                    <h4 style="font-family: 'Source Sans Pro', sans-serif; margin-bottom: 5px;">{location}</h4>
+                    <div style="font-family: 'Source Sans Pro', sans-serif; font-size: 14px;">
+                        {additional_info}
+                    </div>
+                </div>
+                """
                 
-                stats = f"Gefunden: {processed_count} von {total_locations} Orten ({success_rate:.1f}%)"
+                folium.Marker(
+                    location=point,
+                    popup=folium.Popup(popup_content, max_width=300),
+                    tooltip=location,
+                    icon=folium.Icon(color="blue", icon="info-sign")
+                ).add_to(marker_cluster)
                 
-                return map_html, stats, processed_path
-            except Exception as e:
-                import traceback
-                trace = traceback.format_exc()
-                print(f"Error processing file: {e}\n{trace}")
-                return None, f"Fehler bei der Verarbeitung der Datei: {str(e)}", None
-
+                coords.append(point)
+                processed_count += 1
+    
+    if coords:
+        m.fit_bounds(coords)
+    
+    custom_css = """
+    <style>
+    @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600&display=swap');
+    .leaflet-container {
+        font-family: 'Source Sans Pro', sans-serif;
+    }
+    .leaflet-popup-content {
+        font-family: 'Source Sans Pro', sans-serif;
+    }
+    .leaflet-popup-content h4 {
+        font-weight: 600;
+        margin-bottom: 8px;
+    }
+    </style>
+    """
+    m.get_root().header.add_child(folium.Element(custom_css))
+    
+    return m._repr_html_(), processed_count
 
 # Corrected model loading function based on official usage example