OOPS & MVC Architecture, New UI, Graphical View, Autosave to DB

Author: DarshanScripts

src/app.py

@@ -32,7 +32,6 @@ def reset_controllers():
     """Reset all controllers."""
     global chat_controller
     chat_controller = None
-    # Don't reset project_controller as it maintains DB connections
 
 # Routes
 @app.route("/")
@@ -48,31 +47,19 @@ def chat():
     controller = get_chat_controller()
     return controller.handle_chat_request()
 
-@app.route("/submit_name", methods=["POST"])
-def submit_name():
-    """Submit name endpoint."""
-    controller = get_chat_controller()
-    return controller.submit_name()
-
 @app.route("/generate_uml", methods=["POST"])
 def generate_uml():
     """Generate UML endpoint."""
     controller = get_chat_controller()
     return controller.generate_uml()
 
-@app.route("/get_scenarios", methods=["GET"])
-def get_scenarios():
-    """Get scenarios endpoint."""
+@app.route("/get_domain_model_descriptions", methods=["GET"])
+def get_domain_model_descriptions():
+    """Get domain model descriptions endpoint."""
     controller = get_chat_controller()
-    return controller.get_current_scenario()
-
-# Project routes
-@app.route("/save_to_database", methods=["POST"])
-def save_to_database():
-    """Save to database endpoint."""
-    controller = get_project_controller()
-    return controller.submit_to_database()  # Keep the controller method name the same
+    return controller.get_current_domain_model_description()
 
+# Project routes (simplified to remove file management)
 @app.route("/get_projects", methods=["GET"])
 def get_projects():
     """Get projects endpoint."""
@@ -85,17 +72,23 @@ def create_project():
     controller = get_project_controller()
     return controller.create_project()
 
-@app.route("/create_file", methods=["POST"])
-def create_file():
-    """Create file endpoint."""
+@app.route("/rename_project", methods=["POST"])
+def rename_project():
+    """Rename project endpoint."""
+    controller = get_project_controller()
+    return controller.rename_project()
+
+@app.route("/get_project_data", methods=["GET"])
+def get_project_data():
+    """Get project data endpoint."""
     controller = get_project_controller()
-    return controller.create_file()
+    return controller.get_project_data()
 
-@app.route("/get_files", methods=["GET"])
-def get_files():
-    """Get files endpoint."""
+@app.route("/save_project_data", methods=["POST"])
+def save_project_data():
+    """Save project data endpoint."""
     controller = get_project_controller()
-    return controller.get_files()
+    return controller.save_project_data()
 
 # Run the application
 if __name__ == "__main__":

src/controller/chat_controller.py

@@ -15,72 +15,84 @@ def handle_chat_request(self):
             user_input = request.json.get("message", "").strip()
             if not user_input:
                 return jsonify({"error": "User input is required"}), 400
-
-            user_name = session.get("user_name")
-            if not user_name:
-                return jsonify({"error": "User name is not set"}), 400
 
             # Add current input to chat history
             self.llm_service.add_to_chat_history("user", user_input)
 
             # Get updated chat history after adding the new message
             updated_chat_history = self.llm_service.chat_history.get_messages()
 
-            result = self.llm_service.determine_input_type(updated_chat_history)
+            # Format chat history as a single string
+            chat_history_text = "\n".join([
+                f"{'User' if msg['role'] == 'user' else 'Assistant'}: {msg['content']}"
+                for msg in updated_chat_history
+            ])
+            
+            # Determine input type with enhanced analysis
+            result = self.llm_service.determine_input_type(chat_history_text)
+            
+            # Extract all classification fields
+            decision = result.get("decision", False)
+            is_update = result.get("is_update", False)
+            is_casual_comment = result.get("is_casual_comment", False)
             suggestions = result.get("suggestions", [])
 
-            # Check if there's enough info for a domain model based on decision
-            if result.get("decision", False):
-                # Generate domain model description if there's enough information
-                scenario = self.llm_service.generate_scenario(user_input)
-                formatted_suggestions = "**Suggestions to improve your domain model:**\n" + "\n".join([f"- {suggestion}" for suggestion in suggestions])
+            # Format the response from the suggestions array
+            formatted_suggestions = "\n".join(suggestions) if isinstance(suggestions, list) else suggestions
+            
+            # Handle each case appropriately
+            if is_casual_comment:
+                # Casual comment - don't regenerate the domain model
+                self.llm_service.add_to_chat_history("assistant", formatted_suggestions)
+                return jsonify({
+                    "response": formatted_suggestions, 
+                    "history": self.llm_service.get_chat_history()
+                })
+                
+            elif decision:
+                # Enough information for domain modeling (either new model or update)
+                domain_model_description = self.llm_service.generate_domain_model_description(chat_history_text)
 
-                # Add suggestions to chat history
+                # Add response to chat history
                 self.llm_service.add_to_chat_history("assistant", formatted_suggestions)
 
-                return jsonify({"scenario": scenario, "suggestion": formatted_suggestions})
-            else:
-                # Not enough info for domain modeling - show suggestions for what's needed
-                formatted_suggestions = "**To create a domain model, I need more information:**\n" + "\n".join([f"- {suggestion}" for suggestion in suggestions])
+                return jsonify({
+                    "domain_model_description": domain_model_description, 
+                    "suggestion": formatted_suggestions
+                })
 
-                # Add suggestions to chat history
+            else:
+                # Not enough info for domain modeling
                 self.llm_service.add_to_chat_history("assistant", formatted_suggestions)
 
-                # Return response in a format that won't trigger domain model description display
-                return jsonify({"response": formatted_suggestions, "history": self.llm_service.get_chat_history()})
+                return jsonify({
+                    "response": formatted_suggestions, 
+                    "history": self.llm_service.get_chat_history()
+                })
 
         except Exception as e:
             print(f"Error in chat request: {e}")
+            import traceback
+            traceback.print_exc() # Add traceback for better error debugging
             return jsonify({"error": "An unexpected error occurred"}), 500
 
-    def submit_name(self):
-        """Store user's name in session"""
-        try:
-            user_name = request.json.get("name", "").strip()
-            if not user_name:
-                return jsonify({"error": "Name is required"}), 400
-
-            session["user_name"] = user_name
-            return jsonify({"message": "Name saved successfully!", "name": user_name})
-        except Exception as e:
-            print(f"Error storing name: {e}")
-            return jsonify({"error": "An error occurred while storing the name"}), 500
+    # Remove submit_name method
 
     def generate_uml(self):
-        """Generate UML diagram from scenario"""
+        """Generate UML diagram from domain model description"""
         try:
-            scenario_text = request.json.get("scenarioText", "").strip()
-            if not scenario_text:
+            domain_model_description_text = request.json.get("domainModelDescriptionText", "").strip()
+            if not domain_model_description_text:
                 return jsonify({"error": "Domain Model Description is required"}), 400
 
             client = self.llm_service.client
-            plant_uml = gpt_v2_interface(scenario_text, client)
+            plant_uml = gpt_v2_interface(domain_model_description_text, client)
             return jsonify({"plantuml": plant_uml})
         except Exception as e:
             print(f"Error generating UML: {e}")
             return jsonify({"error": "An error occurred while generating the UML"}), 500
 
-    def get_current_scenario(self):
-        """Retrieve the current scenario"""
-        scenario = self.llm_service.get_current_scenario()
-        return jsonify({"scenario": scenario})
+    def get_current_domain_model_description(self):
+        """Retrieve the current domain model description"""
+        domain_model_description = self.llm_service.get_current_domain_model_description()
+        return jsonify({"domain_model_description": domain_model_description})

src/controller/project_controller.py

@@ -2,30 +2,10 @@
 from src.model.project_service import ProjectService
 
 class ProjectController:
-    """Controller for project management operations"""
+    """Controller for project management operations (simplified model)"""
 
     def __init__(self):
         self.project_service = ProjectService()
-        
-    def submit_to_database(self):
-        """Submit work results to the database"""
-        try:
-            data = request.json
-            project_name = data.get("project_name", "").strip()
-            file_name = data.get("file_name", "").strip()
-            username = data.get("username", "").strip()
-            scenario = data.get("scenario", "")
-            plant_uml = data.get("plant_uml", "")
-            chat_history = data.get("chat_history", [])
-            
-            result, status_code = self.project_service.submit_to_database(
-                project_name, file_name, username, scenario, plant_uml, chat_history
-            )
-            
-            return jsonify(result), status_code
-        except Exception as e:
-            print(f"Error in submit_to_database: {e}")
-            return jsonify({"error": "An unexpected error occurred."}), 500
 
     def get_projects(self):
         """Get list of projects from database"""
@@ -37,38 +17,52 @@ def get_projects(self):
             return jsonify({"error": "An unexpected error occurred."}), 500
 
     def create_project(self):
-        """Create a new project in the database"""
+        """Create a new project with auto-generated name"""
         try:
-            data = request.json
-            project_name = data.get("project_name", "").strip()
-            username = data.get("username", session.get("user_name", "Anonymous")).strip()
-            
-            result, status_code = self.project_service.create_project(project_name, username)
+            result, status_code = self.project_service.create_project()
             return jsonify(result), status_code
         except Exception as e:
             print(f"Error in create_project: {e}")
             return jsonify({"error": "An unexpected error occurred."}), 500
 
-    def create_file(self):
-        """Create a new file within a project"""
+    def rename_project(self):
+        """Rename an existing project"""
         try:
             data = request.json
-            project_name = data.get("project_name", "").strip()
-            file_name = data.get("file_name", "").strip()
+            old_project_name = data.get("old_project_name", "").strip()
+            new_project_name = data.get("new_project_name", "").strip()
 
-            result, status_code = self.project_service.create_file(project_name, file_name)
+            result, status_code = self.project_service.rename_project(old_project_name, new_project_name)
             return jsonify(result), status_code
         except Exception as e:
-            print(f"Error in create_file: {e}")
+            print(f"Error in rename_project: {e}")
             return jsonify({"error": "An unexpected error occurred."}), 500
 
-    def get_files(self):
-        """Get list of files for a project"""
+    def get_project_data(self):
+        """Get project data for the specified project"""
         try:
             project_name = request.args.get("project_name", "").strip()
 
-            result, status_code = self.project_service.get_files(project_name)
+            result, status_code = self.project_service.get_project_data(project_name)
+            return jsonify(result), status_code
+        except Exception as e:
+            print(f"Error in get_project_data: {e}")
+            return jsonify({"error": "An unexpected error occurred."}), 500
+    
+    def save_project_data(self):
+        """Save data for the specified project"""
+        try:
+            data = request.json
+            project_name = data.get("project_name", "").strip()
+            domain_model_description = data.get("domain_model_description")
+            plant_uml = data.get("plant_uml")
+            chat_history = data.get("chat_history")
+            
+            result, status_code = self.project_service.save_project_data(
+                project_name, domain_model_description, plant_uml, chat_history
+            )
+            
             return jsonify(result), status_code
         except Exception as e:
-            print(f"Error in get_files: {e}")
+            print(f"Error in save_project_data: {e}")
             return jsonify({"error": "An unexpected error occurred."}), 500

src/model/domain_model_description.py

@@ -0,0 +1,18 @@
+class DomainModelDescription:
+    """Data object for storing and managing domain model descriptions."""
+    
+    def __init__(self, text=None):
+        """Initialize a domain model description"""
+        self.text = text
+    
+    def set_text(self, text):
+        """Set the domain model description."""
+        self.text = text
+    
+    def add_text(self, text):
+        """Add a new domain model description (currently replaces existing one)."""
+        self.text = text
+    
+    def get_text(self):
+        """Get the domain model description."""
+        return self.text