optimize edge creation

Author: yilinxia

backend/app/main.py

@@ -499,6 +499,124 @@ def get_unique_repos():
         }), 500
 
 
+@app.route("/api/create-edges-on-graph", methods=["POST"])
+def create_edges_on_graph():
+    """
+    Create edges on an existing graph based on specified criteria.
+    
+    Expected request body:
+    {
+        "gexfContent": "existing GEXF content",
+        "criteria_config": {
+            "topic_based_linking": true,
+            "topic_threshold": 2,
+            "contributor_overlap_enabled": true,
+            "contributor_threshold": 1,
+            "shared_organization_enabled": false,
+            "common_stargazers_enabled": true,
+            "stargazer_threshold": 5,
+            "use_and_logic": false
+        }
+    }
+    """
+    try:
+        data = request.get_json()
+        gexf_content = data.get("gexfContent", "")
+        criteria_config = data.get("criteria_config", {})
+        
+        if not gexf_content:
+            return jsonify({
+                "success": False,
+                "error": "No GEXF content provided"
+            }), 400
+        
+        # Parse the existing GEXF content
+        import tempfile
+        import networkx as nx
+        
+        # Create a temporary file to parse the GEXF
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.gexf', delete=False) as temp_file:
+            temp_file.write(gexf_content)
+            temp_file_path = temp_file.name
+        
+        try:
+            # Read the existing graph
+            G = nx.read_gexf(temp_file_path)
+        finally:
+            # Clean up temporary file
+            import os
+            os.unlink(temp_file_path)
+        
+        if not G.nodes():
+            return jsonify({
+                "success": False,
+                "error": "No nodes found in the provided GEXF content"
+            }), 404
+        
+        # Validate that at least one criterion is enabled
+        enabled_criteria = [
+            criteria_config.get('topic_based_linking', False),
+            criteria_config.get('contributor_overlap_enabled', False),
+            criteria_config.get('shared_organization_enabled', False),
+            criteria_config.get('common_stargazers_enabled', False)
+        ]
+        
+        if not any(enabled_criteria):
+            return jsonify({
+                "success": False,
+                "error": "At least one edge creation criterion must be enabled"
+            }), 400
+        
+        # Create a new service instance for edge creation on existing graphs
+        from services.edge_generation_service import EdgeGenerationService
+        edge_service = EdgeGenerationService()
+        
+        # Create edges based on the criteria
+        edges_created = edge_service.create_edges_on_existing_graph(G, criteria_config)
+        
+        # Save the updated graph
+        import hashlib
+        from datetime import datetime
+        
+        # Create hash from criteria
+        criteria_str = json.dumps(criteria_config, sort_keys=True)
+        hash_object = hashlib.md5(criteria_str.encode())
+        hash_hex = hash_object.hexdigest()[:12]
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"updated_graph_{hash_hex}_{timestamp}.gexf"
+        
+        # Save to gexf directory
+        gexf_dir = os.path.join(os.path.dirname(__file__), "gexf")
+        os.makedirs(gexf_dir, exist_ok=True)
+        gexf_path = os.path.join(gexf_dir, filename)
+        
+        # Save updated graph
+        edge_service.save_graph_with_edges(G, gexf_path)
+        
+        # Read the updated GEXF file content
+        with open(gexf_path, "r", encoding="utf-8") as f:
+            updated_gexf_content = f.read()
+        
+        # Get statistics
+        graph_stats = edge_service.get_edge_statistics(G)
+        
+        return jsonify({
+            "success": True,
+            "gexfContent": updated_gexf_content,
+            "filename": filename,
+            "edgesCreated": edges_created,
+            "graph_statistics": graph_stats
+        })
+        
+    except Exception as e:
+        print(f"Error creating edges on graph: {str(e)}")
+        return jsonify({
+            "success": False,
+            "error": str(e),
+            "message": "An error occurred while creating edges on the graph"
+        }), 500
+
+
 @app.route("/")
 def home():
     return "Hello World!"