Upload chat with gemini api

.vscode/launch.json

@@ -12,6 +12,14 @@
             "console": "integratedTerminal",
             "justMyCode": true
         },
+        {
+            "name": "Python: app.py",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${workspaceFolder}/app.py",
+            "console": "integratedTerminal",
+            "justMyCode": true
+        },
         {
             "name": "Python: Attach to chat.py",
             "type": "debugpy",

app.py

@@ -1,10 +1,9 @@
-import torch
-from transformers import pipeline, AutoTokenizer
-from gradio import Blocks, Textbox, Button, Row, Column
+from gradio import Blocks, Chatbot, TextArea, Button, Row, Column, State
 import os
 import logging
+import traceback
 from dotenv import load_dotenv
-from src.chat import process_query
+from src.chat import generate_response
 from src.database.init_db import init_db
 from src.database.db_connection import get_db_engine
 
@@ -19,43 +18,140 @@ load_dotenv()
 def setup_database():
     """Initialize the database at application startup"""
     logger.info("Initializing database...")
-    if init_db():
-        logger.info("Database initialized successfully")
-    else:
-        logger.error("Failed to initialize database")
+    try:
+        if init_db():
+            logger.info("Database initialized successfully")
+            return True
+        else:
+            logger.error("Failed to initialize database")
+            return False
+    except Exception as e:
+        logger.error(f"Database initialization error: {str(e)}")
+        logger.debug(traceback.format_exc())
+        return False
+
+# Update chat.py to support conversation history
+def update_chat_for_multi_turn():
+    """
+    Helper function to handle conversation state for multi-turn chat.
+    This handles reconstruction of conversation context for the model.
+    """
+    # This is handled in the respond function below
+    pass
 
 # Gradio UI
 def create_ui():
     with Blocks() as app:
+        # Initialize conversation state
+        chat_history = State([])
         
         with Row():
-            with Column():
-                input_text = Textbox(label="Input", placeholder="Type your message here...")
-                submit_button = Button("Submit")
-                output_text = Textbox(label="Output", interactive=False)
+            with Column(scale=6):
+                # Replace Textbox with Chatbot for multi-turn conversation
+                chatbot = Chatbot(
+                    label="Business Interior Design Assistant",
+                    height=500,
+                    bubble_full_width=False,
+                    show_copy_button=True
+                )
+                
+                with Row():
+                    user_input = TextArea(
+                        placeholder="Type your message here...", 
+                        lines=2,
+                        label="Your Message",
+                        scale=5
+                    )
+                    submit_button = Button("Send", scale=1)
+                
+                # Add a clear chat button for better UX
+                clear_button = Button("Clear Conversation")
+        
+        def respond(message, history, chat_state):
+            """Process user input and update conversation with error handling"""
+            if not message.strip():
+                return history, chat_state, ""
+            
+            try:
+                # Generate response with conversation history context
+                try:
+                    # Check if we need to reset Gemini chat context
+                    # Currently Gemini chat manages its own state, but
+                    # we're keeping our own history for resilience
+                    response = generate_response(message)
+                    
+                    # Update the visible chat UI
+                    history.append((message, response))
+                    
+                except Exception as e:
+                    error_msg = f"I apologize, but I encountered an error: {str(e)}"
+                    logger.error(f"Error generating response: {str(e)}")
+                    logger.debug(traceback.format_exc())
+                    
+                    # Add error message to chat history
+                    history.append((message, error_msg))
+                
+                return history, chat_state, ""
+                
+            except Exception as e:
+                logger.error(f"Error in respond function: {str(e)}")
+                logger.debug(traceback.format_exc())
+                
+                error_msg = "I apologize, but something went wrong with our conversation system."
+                history.append((message, error_msg))
+                return history, chat_state, ""
+        
+        def clear_chat():
+            """Clear the conversation history"""
+            return [], []
         
-        def respond(input_text):
-            response = process_query(input_text)
-            return response
+        # Connect UI components to functions
+        submit_button.click(
+            respond, 
+            inputs=[user_input, chatbot, chat_history], 
+            outputs=[chatbot, chat_history, user_input],
+            api_name="chat"
+        )
         
-        submit_button.click(respond, inputs=input_text, outputs=output_text)
+        # Enable pressing Enter to send messages
+        user_input.submit(
+            respond, 
+            inputs=[user_input, chatbot, chat_history], 
+            outputs=[chatbot, chat_history, user_input]
+        )
+        
+        clear_button.click(
+            clear_chat,
+            outputs=[chatbot, chat_history]
+        )
     
     return app
 
 if __name__ == "__main__":
     # Ensure database is set up before starting the application
-    setup_database()
+    db_setup_success = setup_database()
     
     # Check if database connection is working
     engine = get_db_engine()
     if engine is None:
         logger.error("Failed to connect to database. Please check your connection settings.")
+        logger.warning("Application will continue with limited database functionality")
     else:
         logger.info("Successfully connected to database")
     
     # Launch the Gradio app
     app = create_ui()
-    app.launch(share=True)
+    
+    # Configure for different deployment environments
+    server_name = os.getenv("SERVER_NAME", "127.0.0.1")
+    server_port = int(os.getenv("PORT", 7860))
+    share = os.getenv("SHARE_APP", "true").lower() == "true"
+    
+    app.launch(
+        server_name=server_name,
+        server_port=server_port,
+        share=share
+    )
 
 
 

src/__init__.py

@@ -19,5 +19,5 @@ __version__ = '0.1.0'
 __author__ = 'Business Interior Team'
 
 # Import key modules for simplified access
-from src.core.function_definitions import calculate_office_space_function, get_product_recommendations_function
-from src.services.chat_service import calculate_office_space, get_product_recommendations
+from src.core.function_definitions import calculate_office_space, get_all_categories
+from src.services.chat_service import calculate_office_space, get_all_categories

src/chat.py

@@ -1,321 +1,337 @@
-# from google import genai
-# from google.genai import types
-# import os
-# from dotenv import load_dotenv
-# import json
-# from src.services.chat_service import (
-#     calculate_office_space as d_calculate_office_space,
-#     get_product_recommendations as d_get_product_recommendations,
-#     get_all_categories as d_get_all_categories,
-# )
+from google import genai
+from google.genai import types
+import os
+from dotenv import load_dotenv
+import json
+from src.core.function_definitions import (
+    calculate_office_space,
+    get_top_sales_products,
+    get_all_categories,
+    get_product_information_by_name,
+    find_products_by_price_range,
+)
+from src.services.chat_service import (
+    calculate_office_space as d_calculate_office_space,
+    get_all_categories as d_get_all_categories,
+    get_top_sales_products as d_get_top_sales_products,
+    get_product_information_by_name as d_get_product_information_by_name,
+    get_product_by_price_range as d_get_product_by_price_range,
+)
 
-# load_dotenv()
+load_dotenv()
 
-# calculate_office_space = {
-#     "name": "calculate_office_space",
-#     "description": "Calculate the total space required for a list of furniture items.",
-#     "parameters": {
-#         "type": "object",
-#         "properties": {
-#             "furniture_items": {
-#                 "type": "array",
-#                 "items": {
-#                     "type": "string",
-#                     "description": "List of furniture items to calculate space for (e.g., desk, chair).",
-#                 },
-#             },
-#         },
-#         "required": ["furniture_items"],
-#     },
-# }
-
-# get_product_recommendations = {
-#     "name": "get_product_recommendations",
-#     "description": "Get product recommendations based on the user's preferences.",
-#     "parameters": {
-#         "type": "object",
-#         "properties": {
-#             "product_type": {
-#                 "type": "string",
-#                 "description": "The type of product to recommend (e.g., chair, desk).",
-#             },
-#             "style": {
-#                 "type": "string",
-#                 "description": "The style of the product (e.g., modern, classic).",
-#             },
-#             "budget": {
-#                 "type": "number",
-#                 "description": "The budget for the product recommendations.",
-#             },
-#         },
-#         "required": ["product_type", "style"],
-#     },
-# }
+chat_tools = [
+    types.Tool(function_declarations=[calculate_office_space,
+    get_top_sales_products, get_all_categories, get_product_information_by_name, 
+    find_products_by_price_range],),
+]
 
-# get_all_categories = {
-#     "name": "get_all_categories",
-#     "description": "Get all available categories of products.",
-#     "parameters": {
-#         "type": "object",
-#         "properties": {},
-#         "required": [],
-#     },
-# }
+config = {
+    "tools": chat_tools,
+    "automatic_function_calling": {"disable": True},
+    "tool_config": {"function_calling_config": {"mode": "any"}},
+}
 
 
-# chat_tools = [
-#     types.Tool(function_declarations=[calculate_office_space, get_product_recommendations, get_all_categories])
-# ]
+# Config the client - Fix typo in environment variable name
+client = genai.Client(
+    api_key=os.getenv("GEMINI_API_KEY"),
+)
 
-# config = {
-#     "tools": chat_tools,
-#     "automatic_function_calling": {"disable": True},
-#     "tool_config": {"function_calling_config": {"mode": "any"}},
-# }
+chat = client.chats.create(
+    model="gemini-2.0-flash",
+    config=config,
+)
 
+def handle_function_call(function_name, arguments):
+    # Handle the function call here
+    if function_name == "calculate_office_space":
+        return d_calculate_office_space(arguments.get("furniture_items", []))
+    elif function_name == "get_top_sales_products":
+        return d_get_top_sales_products(    
+            arguments.get("category", ""),
+            arguments.get("limit", 5)
+        )
+    elif function_name == "get_all_categories":
+        return d_get_all_categories()
+    elif function_name == "get_product_information_by_name":
+        return d_get_product_information_by_name(
+            arguments.get("product_name", "")
+        )
+    elif function_name == "find_products_by_price_range":
+        return d_get_product_by_price_range(
+            arguments.get("category", None),
+            arguments.get("min_price", 0),
+            arguments.get("max_price", 0)
+        )
+    else:
+        raise ValueError(f"Unknown function: {function_name}")
 
-# # Config the client - Fix typo in environment variable name
-# client = genai.Client(
-#     api_key=os.getenv("GEMINI_API_KEY"),
-# )
+def detect_and_extract_function_call(response):
+    # Check if response has function call
+    if hasattr(response.candidates[0].content.parts[0], 'function_call'):
+        tool_call = response.candidates[0].content.parts[0].function_call
+        function_name = tool_call.name
+        arguments = tool_call.args
 
-# chat = client.chats.create(
-#     model="gemini-2.0-flash",
-#     config=config,
-# )
+        result = handle_function_call(function_name, arguments)
+        return tool_call, result
+    else:
+        # No function call detected, return the text response
+        return None, None
 
-# def handle_function_call(function_name, arguments):
-#     # Handle the function call here
-#     if function_name == "calculate_office_space":
-#         return d_calculate_office_space(arguments.get("furniture_items", []))
-#     elif function_name == "get_product_recommendations":
-#         return d_get_product_recommendations(
-#             arguments.get("product_type", ""),
-#             arguments.get("style", ""),
-#             arguments.get("budget", None),
-#         )
-#     elif function_name == "get_all_categories":
-#         return d_get_all_categories()
-#     else:
-#         raise ValueError(f"Unknown function: {function_name}")
+def generate_natural_language_response(tool_call, function_response_part):
+    contents = []
+    contents.append(types.Content(role="model", parts=[types.Part(function_call=tool_call)])) # Append the model's function call message
+    contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response
 
-# def detect_and_extract_function_call(response):
-#     # Check if response has function call
-#     if hasattr(response.candidates[0].content.parts[0], 'function_call'):
-#         tool_call = response.candidates[0].content.parts[0].function_call
-#         function_name = tool_call.name
-#         arguments = tool_call.args
+    final_response = client.models.generate_content(
+        model="gemini-2.0-flash",
+        contents=contents,
+    )
 
-#         result = handle_function_call(function_name, arguments)
-#         return tool_call, result
-#     else:
-#         # No function call detected, return the text response
-#         return None, None
+    print("Tool call:", tool_call)
 
-# def generate_natural_language_response(tool_call, function_response_part):
-#     # Convert the function response part to a natural language response
-#     print("Function response part:", function_response_part)
-#     print("Tool call:", tool_call)
-#     contents = []
-#     contents.append(types.Content(role="model", parts=[types.Part(function_call=tool_call)])) # Append the model's function call message
-#     contents.append(types.Content(role="user", parts=[function_response_part])) # Append the function response
+    return final_response.text
+    # Extract function name and arguments for context
+    # function_name = tool_call.name
+    # function_arguments = tool_call.args
+    
+    # # Create a system prompt to guide the model
+    # system_prompt = types.Content(
+    #     role="system",
+    #     parts=[types.Part(text="""
+    #         You are a helpful assistant for a business interior design company.
+    #         When presenting data from function calls:
+    #         - Format the information in a readable, conversational way
+    #         - Explain what the data means in the context of interior design
+    #         - Make helpful suggestions based on the results
+    #         - Use professional but friendly language
+    #         - If the data is a list, present it in a structured format
+    #         - Don't mention that you called a function, just present the information naturally
+    #     """)]
+    # )
+    
+    # # Create model's function call message
+    # function_call_content = types.Content(
+    #     role="model", 
+    #     parts=[types.Part(function_call=tool_call)]
+    # )
+    
+    # # Handle different result types for better presentation
+    # user_content = types.Content(
+    #     role="user", 
+    #     parts=[function_response_part]
+    # )
+    
+    # # Build the full conversation context
+    # contents = [
+    #     system_prompt,
+    #     function_call_content,
+    #     user_content
+    # ]
 
-#     final_response = client.models.generate_content(
-#         model="gemini-2.0-flash",
-#         contents=contents,
-#     )
+    # # Generate the natural language response
+    # final_response = client.models.generate_content(
+    #     model="gemini-2.0-flash",
+    #     contents=contents,
+    # )
 
-#     return final_response.text
+    # # Log debugging information 
+    # print(f"Function call: {function_name}({json.dumps(function_arguments, indent=2)})")
+    # print(f"Function result type: {type(function_result)}")
+    
+    # return final_response.text
 
-# def generate_response(input_text):
-#     try:
-#         # Call the chat model with the input text
-#         model_response = chat.send_message(input_text)
+def generate_response(input_text):
+    try:
+        # Call the chat model with the input text
+        model_response = chat.send_message(input_text)
         
-#         tool_call, function_result = detect_and_extract_function_call(model_response)
+        tool_call, function_result = detect_and_extract_function_call(model_response)
         
-#         # If no function call was detected, return the text response
-#         if tool_call is None:
-#             return model_response.text
+        # If no function call was detected, return the text response
+        if tool_call is None:
+            return model_response.text
         
-#         function_response_part = types.Part.from_function_response(
-#             name=tool_call.name,
-#             response={"result": function_result},
-#         )
+        function_response_part = types.Part.from_function_response(
+            name=tool_call.name,
+            response={"result": function_result},
+        )
         
-#         natural_response = generate_natural_language_response(tool_call, function_response_part)
-#         return natural_response
-#     except Exception as e:
-#         print(f"Error generating response: {e}")
-#         return f"I'm sorry, there was an error processing your request: {str(e)}"
+        natural_response = generate_natural_language_response(tool_call, function_response_part)
+        return natural_response
+    except Exception as e:
+        print(f"Error generating response: {e}")
+        return f"I'm sorry, there was an error processing your request: {str(e)}"
 
 
-import torch
-import json
-import re
-from transformers import pipeline
-from typing import List, Dict, Any, Optional
+# import torch
+# import json
+# import re
+# from transformers import pipeline
+# from typing import List, Dict, Any, Optional
 
-# Function definitions that will be available to the model
-FUNCTION_DEFINITIONS = [
-    {
-        "name": "get_product_information",
-        "description": "Get information about a specific interior product",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "product_id": {
-                    "type": "string",
-                    "description": "ID of the product to look up"
-                },
-                "details_required": {
-                    "type": "array",
-                    "items": {
-                        "type": "string",
-                        "enum": ["price", "dimensions", "materials", "availability", "color_options"]
-                    },
-                    "description": "What product details are needed"
-                }
-            },
-            "required": ["product_id"]
-        }
-    },
-    {
-        "name": "search_products",
-        "description": "Search for interior products based on criteria",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "category": {
-                    "type": "string",
-                    "description": "Product category (e.g., sofa, table, chair, lamp)"
-                },
-                "price_range": {
-                    "type": "object",
-                    "properties": {
-                        "min": {"type": "number"},
-                        "max": {"type": "number"}
-                    },
-                    "description": "Price range for the products"
-                },
-                "style": {
-                    "type": "string",
-                    "description": "Design style (e.g., modern, traditional, industrial)"
-                }
-            },
-            "required": ["category"]
-        }
-    }
-]
+# # Function definitions that will be available to the model
+# FUNCTION_DEFINITIONS = [
+#     {
+#         "name": "get_product_information",
+#         "description": "Get information about a specific interior product",
+#         "parameters": {
+#             "type": "object",
+#             "properties": {
+#                 "product_id": {
+#                     "type": "string",
+#                     "description": "ID of the product to look up"
+#                 },
+#                 "details_required": {
+#                     "type": "array",
+#                     "items": {
+#                         "type": "string",
+#                         "enum": ["price", "dimensions", "materials", "availability", "color_options"]
+#                     },
+#                     "description": "What product details are needed"
+#                 }
+#             },
+#             "required": ["product_id"]
+#         }
+#     },
+#     {
+#         "name": "search_products",
+#         "description": "Search for interior products based on criteria",
+#         "parameters": {
+#             "type": "object",
+#             "properties": {
+#                 "category": {
+#                     "type": "string",
+#                     "description": "Product category (e.g., sofa, table, chair, lamp)"
+#                 },
+#                 "price_range": {
+#                     "type": "object",
+#                     "properties": {
+#                         "min": {"type": "number"},
+#                         "max": {"type": "number"}
+#                     },
+#                     "description": "Price range for the products"
+#                 },
+#                 "style": {
+#                     "type": "string",
+#                     "description": "Design style (e.g., modern, traditional, industrial)"
+#                 }
+#             },
+#             "required": ["category"]
+#         }
+#     }
+# ]
 
-def create_function_calling_prompt(user_query: str, functions: List[Dict[str, Any]]) -> str:
-    """Create a prompt for the model that includes function calling instructions"""
+# def create_function_calling_prompt(user_query: str, functions: List[Dict[str, Any]]) -> str:
+#     """Create a prompt for the model that includes function calling instructions"""
     
-    functions_str = json.dumps(functions, indent=2)
+#     functions_str = json.dumps(functions, indent=2)
     
-    prompt = f"""You are a helpful assistant for a business interior design company.
-    You have access to the following functions: {functions_str}
-    If the user's request can be fulfilled using one of these functions, generate a response in the following JSON format:
-    {{
-        "function_call": {{
-            "name": "function_name",
-            "parameters": {{
-                "param1": "value1",
-                "param2": "value2"
-            }}
-        }}
-    }}
+#     prompt = f"""You are a helpful assistant for a business interior design company.
+#     You have access to the following functions: {functions_str}
+#     If the user's request can be fulfilled using one of these functions, generate a response in the following JSON format:
+#     {{
+#         "function_call": {{
+#             "name": "function_name",
+#             "parameters": {{
+#                 "param1": "value1",
+#                 "param2": "value2"
+#             }}
+#         }}
+#     }}
 
-    If no function is needed, respond conversationally.
+#     If no function is needed, respond conversationally.
 
-    User: {user_query}
-    Assistant:"""
+#     User: {user_query}
+#     Assistant:"""
     
-    return prompt
+#     return prompt
 
-def extract_function_call(generated_text: str) -> Optional[Dict[str, Any]]:
-    """Extract the function call from the generated text"""
-    # Look for JSON-like patterns in the output
-    pattern = r'(\{[\s\S]*\})'
-    match = re.search(pattern, generated_text)
+# def extract_function_call(generated_text: str) -> Optional[Dict[str, Any]]:
+#     """Extract the function call from the generated text"""
+#     # Look for JSON-like patterns in the output
+#     pattern = r'(\{[\s\S]*\})'
+#     match = re.search(pattern, generated_text)
     
-    if match:
-        try:
-            # Try to parse as JSON
-            json_str = match.group(1)
-            result = json.loads(json_str)
-            if "function_call" in result:
-                return result["function_call"]
-        except json.JSONDecodeError:
-            pass
+#     if match:
+#         try:
+#             # Try to parse as JSON
+#             json_str = match.group(1)
+#             result = json.loads(json_str)
+#             if "function_call" in result:
+#                 return result["function_call"]
+#         except json.JSONDecodeError:
+#             pass
     
-    return None
+#     return None
 
-def execute_function(function_name: str, parameters: Dict[str, Any]) -> str:
-    """Execute the specified function with the given parameters"""
-    # In a real implementation, these functions would connect to your database or APIs
-    if function_name == "get_product_information":
-        # Simulate product information retrieval
-        product_id = parameters.get("product_id")
-        return f"Retrieved information for product {product_id}: Price: $1,299, Material: Leather, Availability: In stock"
+# def execute_function(function_name: str, parameters: Dict[str, Any]) -> str:
+#     """Execute the specified function with the given parameters"""
+#     # In a real implementation, these functions would connect to your database or APIs
+#     if function_name == "get_product_information":
+#         # Simulate product information retrieval
+#         product_id = parameters.get("product_id")
+#         return f"Retrieved information for product {product_id}: Price: $1,299, Material: Leather, Availability: In stock"
     
-    elif function_name == "search_products":
-        # Simulate product search
-        category = parameters.get("category")
-        return f"Found 5 {category} products matching your criteria. Would you like to see the results?"
+#     elif function_name == "search_products":
+#         # Simulate product search
+#         category = parameters.get("category")
+#         return f"Found 5 {category} products matching your criteria. Would you like to see the results?"
     
-    return "Function execution failed. Please try again."
+#     return "Function execution failed. Please try again."
 
-# Load the model
-model_id = "meta-llama/Llama-3.2-1B"
+# # Load the model
+# model_id = "meta-llama/Llama-3.2-1B"
 
-pipe = pipeline(
-    "text-generation", 
-    model=model_id, 
-    torch_dtype=torch.bfloat16, 
-    device_map="auto",
-    max_new_tokens=800,  # Increase token limit for detailed responses
-    do_sample=True,
-    temperature=0.2,     # Lower temperature for more deterministic outputs
-    top_p=0.95           # Control diversity while maintaining structure
-)
+# pipe = pipeline(
+#     "text-generation", 
+#     model=model_id, 
+#     torch_dtype=torch.bfloat16, 
+#     device_map="auto",
+#     max_new_tokens=800,  # Increase token limit for detailed responses
+#     do_sample=True,
+#     temperature=0.2,     # Lower temperature for more deterministic outputs
+#     top_p=0.95           # Control diversity while maintaining structure
+# )
 
-# Example usage
-def process_query(user_query: str) -> str:
-    # Create the prompt with function specifications
-    prompt = create_function_calling_prompt(user_query, FUNCTION_DEFINITIONS)
+# # Example usage
+# def process_query(user_query: str) -> str:
+#     # Create the prompt with function specifications
+#     prompt = create_function_calling_prompt(user_query, FUNCTION_DEFINITIONS)
     
-    print(f"Prompt: {prompt}")
+#     print(f"Prompt: {prompt}")
     
-    # Generate response from the model
-    result = pipe(prompt)
-    generated_text = result[0]['generated_text']
+#     # Generate response from the model
+#     result = pipe(prompt)
+#     generated_text = result[0]['generated_text']
     
-    # Try to extract a function call
-    function_call = extract_function_call(generated_text)
+#     # Try to extract a function call
+#     function_call = extract_function_call(generated_text)
     
-    if function_call:
-        # If a function call was detected, execute it
-        function_name = function_call.get("name")
-        parameters = function_call.get("parameters", {})
+#     if function_call:
+#         # If a function call was detected, execute it
+#         function_name = function_call.get("name")
+#         parameters = function_call.get("parameters", {})
         
-        print(f"Detected function call: {function_name}")
-        print(f"Parameters: {parameters}")
+#         print(f"Detected function call: {function_name}")
+#         print(f"Parameters: {parameters}")
         
-        # Execute the function and return result
-        return execute_function(function_name, parameters)
-    else:
-        # Return the normal conversational response
-        # Extract just the assistant's response
-        assistant_response = generated_text.split("Assistant:")[-1].strip()
-        return assistant_response
+#         # Execute the function and return result
+#         return execute_function(function_name, parameters)
+#     else:
+#         # Return the normal conversational response
+#         # Extract just the assistant's response
+#         assistant_response = generated_text.split("Assistant:")[-1].strip()
+#         return assistant_response
 
-# Test with some example queries
-queries = [
-    "I need information about product ID FUR-2345",
-]
+# # Test with some example queries
+# queries = [
+#     "I need information about product ID FUR-2345",
+# ]
 
-for query in queries:
-    print(f"\nUser: {query}")
-    response = process_query(query)
-    print(f"Response: {response}")
+# for query in queries:
+#     print(f"\nUser: {query}")
+#     response = process_query(query)
+#     print(f"Response: {response}")

src/core/function_definitions.py

@@ -1,43 +1,245 @@
 import json
 
-calculate_office_space_function = {
-    "name": "calculate_office_space_function",
-    "description": "Calculate the office space needed for a given number of employees.",
+calculate_office_space = {
+    "name": "calculate_office_space",
+    "description": "Calculate the office space needed for furniture items.",
     "parameters": {
         "type": "object",
         "properties": {
-            "number_of_employees": {
+            "furniture_items": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "item_name": {
+                            "type": "string",
+                            "description": "Name of the furniture item (e.g., desk, chair).",
+                        },
+                        "quantity": {
+                            "type": "integer",
+                            "description": "Number of items needed.",
+                        },
+                    },
+                    "required": ["item_name", "quantity"],
+                },
+                "description": "List of furniture items and their quantities.",
+            },
+        },
+        "required": ["furniture_items"],
+    },
+}
+
+get_top_sales_products = {
+    "name": "get_top_sales_products",
+    "description": "Get top-selling products based on sales data.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "category": {
+                "type": "string",
+                "description": "Category of products to filter by (e.g., 'furniture', 'decor').",
+            },
+            "limit": {
                 "type": "integer",
-                "description": "The number of employees in the office.",
+                "description": "Number of top-selling products to return.",
+            },
+        },
+        "required": ["category", "limit"],
+    },
+}
+
+get_all_categories = {
+    "name": "get_all_categories",
+    "description": "Get all available categories of products.",
+    "parameters": {
+        "type": "object",
+        "properties": {},
+        "required": [],
+    },
+}
+
+get_product_information_by_name = {
+    "name": "get_product_information_by_name",
+    "description": "Get product information by name.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "product_name": {
+                "type": "string",
+                "description": "Name of the product to retrieve information for.",
+            },
+        },
+        "required": ["product_name"],
+    },
+}
+
+get_product_recommendations = {
+    "name": "get_product_recommendations",
+    "description": "Get personalized product recommendations based on needs.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "office_size": {
+                "type": "integer",
+                "description": "Size of the office in square feet.",
+            },
+            "employee_count": {
+                "type": "integer",
+                "description": "Number of employees to accommodate.",
+            },
+            "style_preference": {
+                "type": "string",
+                "description": "Preferred style (e.g., 'modern', 'traditional', 'minimalist').",
+            },
+        },
+        "required": ["office_size", "employee_count"],
+    },
+}
+
+request_custom_quote = {
+    "name": "request_custom_quote",
+    "description": "Request a custom quote for bulk orders or custom furniture.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "product_details": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "product_name": {
+                            "type": "string",
+                            "description": "Name of the product.",
+                        },
+                        "quantity": {
+                            "type": "integer",
+                            "description": "Quantity needed.",
+                        },
+                        "customization": {
+                            "type": "string",
+                            "description": "Any customization requirements.",
+                        },
+                    },
+                    "required": ["product_name", "quantity"],
+                },
+                "description": "List of products for the quote.",
             },
-            "office_space_per_employee": {
+            "contact_information": {
+                "type": "object",
+                "properties": {
+                    "name": {
+                        "type": "string",
+                        "description": "Contact person's name.",
+                    },
+                    "email": {
+                        "type": "string",
+                        "description": "Contact email address.",
+                    },
+                    "phone": {
+                        "type": "string",
+                        "description": "Contact phone number.",
+                    },
+                },
+                "required": ["name", "email"],
+            },
+        },
+        "required": ["product_details", "contact_information"],
+    },
+}
+
+check_product_availability = {
+    "name": "check_product_availability",
+    "description": "Check if products are in stock and available for purchase.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "product_name": {
+                "type": "string",
+                "description": "Name of the product to check availability for.",
+            },
+            "quantity": {
+                "type": "integer",
+                "description": "Quantity needed.",
+            },
+        },
+        "required": ["product_name", "quantity"],
+    },
+}
+
+find_products_by_price_range = {
+    "name": "find_products_by_price_range",
+    "description": "Find products within a specific price range.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "category": {
+                "type": "string",
+                "description": "Category of products to search within.",
+            },
+            "min_price": {
+                "type": "number",
+                "description": "Minimum price (in dollars).",
+            },
+            "max_price": {
                 "type": "number",
-                "description": "The amount of office space allocated per employee in square feet.",
+                "description": "Maximum price (in dollars).",
             },
         },
-        "required": ["number_of_employees", "office_space_per_employee"],
+        "required": ["min_price", "max_price"],
     },
 }
 
-get_product_recommendations_function = {
-    "name": "get_product_recommendations_function",
-    "description": "Get product recommendations based on the user's preferences.",
+
+find_products_by_dimension = {
+    "name": "find_products_by_dimension",
+    "description": "Find furniture that fits specific spatial requirements.",
     "parameters": {
         "type": "object",
         "properties": {
             "product_type": {
                 "type": "string",
-                "description": "The type of product to recommend (e.g., chair, desk).",
+                "description": "Type of product (e.g., 'desk', 'bookshelf').",
             },
-            "style": {
-                "type": "string",
-                "description": "The style of the product (e.g., modern, classic).",
+            "max_width": {
+                "type": "number",
+                "description": "Maximum width in inches.",
+            },
+            "max_depth": {
+                "type": "number",
+                "description": "Maximum depth in inches.",
             },
-            "budget": {
+            "max_height": {
                 "type": "number",
-                "description": "The budget for the product recommendations.",
+                "description": "Maximum height in inches.",
+            },
+        },
+        "required": ["product_type"],
+    },
+}
+
+get_product_reviews = {
+    "name": "get_product_reviews",
+    "description": "Get customer reviews for a specific product.",
+    "parameters": {
+        "type": "object",
+        "properties": {
+            "product_id": {
+                "type": "string",
+                "description": "ID of the product to get reviews for.",
+            },
+            "limit": {
+                "type": "integer",
+                "description": "Maximum number of reviews to return.",
+            },
+            "min_rating": {
+                "type": "integer",
+                "description": "Minimum rating (1-5) to filter by.",
             },
         },
-        "required": ["product_type", "style"],
+        "required": ["product_id"],
     },
 }
+
+
+
+__all__ = ["calculate_office_space", "get_product_recommendations", "get_all_categories", "get_top_sales_products", "get_product_information_by_name"]

src/database/db_connection.py

@@ -55,7 +55,7 @@ def get_db_engine():
             
             # The direct pyodbc connection approach for macOS
             # Use DSN-less connection which is more reliable on macOS with Azure SQL
-            conn_str = f'DRIVER={{ODBC Driver 18 for SQL Server}};SERVER={server};DATABASE=DearHome;UID={username};PWD={quoted_password}'
+            conn_str = f'DRIVER={{ODBC Driver 18 for SQL Server}};SERVER={server};DATABASE=INTERIOR_SHOPPING;UID={username};PWD={quoted_password};Encrypt=yes;TrustServerCertificate=yes;Connection Timeout=30;'
             
             # Create connection string for SQLAlchemy
             connection_url = f"mssql+pyodbc:///?odbc_connect={urllib.parse.quote_plus(conn_str)}"

src/database/generate_models.py

@@ -0,0 +1,61 @@
+import os
+import sys
+from dotenv import load_dotenv
+import urllib.parse
+
+# Load environment variables
+load_dotenv()
+
+# Get connection parameters from environment variables
+server = os.getenv("SQL_SERVER")
+database = os.getenv("SQL_DATABASE")
+username = os.getenv("SQL_USERNAME")
+password = os.getenv("SQL_PASSWORD")
+
+if not all([server, database, username, password]):
+    print("Error: SQL connection parameters not found in environment variables")
+    sys.exit(1)
+
+# Clean the server name (remove 'tcp:' prefix if present)
+if server.startswith('tcp:'):
+    server = server[4:]
+
+# URL encode the password to handle special characters
+quoted_password = urllib.parse.quote_plus(password)
+
+# Create the connection string based on the driver availability
+try:
+    import pyodbc
+    print("Using pyodbc driver for connection")
+    
+    # Create ODBC connection string
+    conn_str = f'DRIVER={{ODBC Driver 18 for SQL Server}};SERVER={server};DATABASE={database};UID={username};PWD={quoted_password}'
+    connection_url = f"mssql+pyodbc:///?odbc_connect={urllib.parse.quote_plus(conn_str)}"
+except ImportError:
+    try:
+        import pymssql
+        print("Using pymssql driver for connection")
+        
+        # Parse server and port if needed
+        if ',' in server:
+            server_parts = server.split(',')
+            host = server_parts[0]
+            port = int(server_parts[1]) if len(server_parts) > 1 else 1433
+        else:
+            host = server
+            port = 1433
+            
+        connection_url = f"mssql+pymssql://{username}:{password}@{host}:{port}/{database}"
+    except ImportError:
+        print("Error: Neither pyodbc nor pymssql is installed")
+        sys.exit(1)
+
+# Print the command to run (without password)
+safe_connection_url = connection_url.replace(quoted_password, "********")
+print(f"Running sqlacodegen with connection: {safe_connection_url}")
+
+# Execute sqlacodegen
+command = f"sqlacodegen --outfile=src/database/models.py '{connection_url}'"
+print("Generating models...")
+os.system(command)
+print("Models generated successfully in src/database/models.py")

src/database/models.py

@@ -1,96 +1,589 @@
-from sqlalchemy import Column, Integer, String, Text, DateTime, ForeignKey, Boolean, Float
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import relationship
+from typing import List, Optional
+
+from sqlalchemy import BigInteger, Boolean, Column, DECIMAL, Date, ForeignKeyConstraint, Identity, Index, Integer, PrimaryKeyConstraint, Table, Unicode, Uuid, text
+from sqlalchemy.dialects.mssql import DATETIME2, DATETIMEOFFSET
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship
 import datetime
+import decimal
 import uuid
-from sqlalchemy.dialects.mssql import UNIQUEIDENTIFIER
 
-# Create the base class for SQLAlchemy ORM models
-Base = declarative_base()
+class Base(DeclarativeBase):
+    pass
+
+
+class AspNetRoles(Base):
+    __tablename__ = 'AspNetRoles'
+    __table_args__ = (
+        PrimaryKeyConstraint('Id', name='PK_AspNetRoles'),
+        Index('RoleNameIndex', 'NormalizedName', unique=True)
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[Optional[str]] = mapped_column(Unicode(256, 'SQL_Latin1_General_CP1_CI_AS'))
+    NormalizedName: Mapped[Optional[str]] = mapped_column(Unicode(256, 'SQL_Latin1_General_CP1_CI_AS'))
+    ConcurrencyStamp: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
 
-class User(Base):
-    """User model representing application users."""
+    AspNetUsers: Mapped[List['AspNetUsers']] = relationship('AspNetUsers', secondary='AspNetUserRoles', back_populates='AspNetRoles_')
+    AspNetRoleClaims: Mapped[List['AspNetRoleClaims']] = relationship('AspNetRoleClaims', back_populates='AspNetRoles_')
+
+
+class AspNetUsers(Base):
     __tablename__ = 'AspNetUsers'
-    
-    id = Column(UNIQUEIDENTIFIER, primary_key=True, default=uuid.uuid4)
-    username = Column(String(256), nullable=False, unique=True, name="UserName")
-    email = Column(String(256), nullable=False, unique=True, name="Email")
-    password_hash = Column(String(256), nullable=False, name="PasswordHash")
-    first_name = Column(String(256), name="FirstName")
-    last_name = Column(String(256), name="LastName")
-    created_at = Column(DateTime, default=datetime.datetime.utcnow, name="CreatedAt")
-    updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow, name="UpdatedAt")
-    is_active = Column(Boolean, default=True, name="IsActive")
-    normalized_user_name = Column(String(256), name="NormalizedUserName")
-    normalized_email = Column(String(256), name="NormalizedEmail")
-    email_confirmed = Column(Boolean, default=False, name="EmailConfirmed")
-    security_stamp = Column(String(256), name="SecurityStamp")
-    concurrency_stamp = Column(String(256), name="ConcurrencyStamp")
-    phone_number = Column(String(256), name="PhoneNumber")
-    phone_number_confirmed = Column(Boolean, default=False, name="PhoneNumberConfirmed")
-    two_factor_enabled = Column(Boolean, default=False, name="TwoFactorEnabled")
-    lockout_end = Column(DateTime, name="LockoutEnd")
-    lockout_enabled = Column(Boolean, default=False, name="LockoutEnabled")
-    access_failed_count = Column(Integer, default=0, name="AccessFailedCount")
-    
-    # Relationships
-    chats = relationship("Chat", back_populates="user")
-    
-    def __repr__(self):
-        return f"<User(id={self.id}, username={self.username})>"
-
-
-class Chat(Base):
-    """Chat model representing a conversation session."""
-    __tablename__ = 'chats'
-    
-    id = Column(UNIQUEIDENTIFIER, primary_key=True, default=uuid.uuid4)
-    user_id = Column(UNIQUEIDENTIFIER, ForeignKey('AspNetUsers.id'), nullable=False)
-    title = Column(String(255), nullable=False, default="New Chat")
-    created_at = Column(DateTime, default=datetime.datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
-    is_active = Column(Boolean, default=True)
-    
-    # Relationships
-    user = relationship("User", back_populates="chats")
-    messages = relationship("Message", back_populates="chat", cascade="all, delete-orphan")
-    
-    def __repr__(self):
-        return f"<Chat(id={self.id}, title={self.title})>"
-
-
-class Message(Base):
-    """Message model representing individual messages in a chat."""
-    __tablename__ = 'messages'
-    
-    id = Column(UNIQUEIDENTIFIER, primary_key=True, default=uuid.uuid4)
-    chat_id = Column(UNIQUEIDENTIFIER, ForeignKey('chats.id'), nullable=False)
-    content = Column(Text, nullable=False)
-    role = Column(String(50), nullable=False)  # 'user', 'assistant', 'system', etc.
-    created_at = Column(DateTime, default=datetime.datetime.utcnow)
-    updated_at = Column(DateTime, default=datetime.datetime.utcnow, onupdate=datetime.datetime.utcnow)
-    
-    # Relationships
-    chat = relationship("Chat", back_populates="messages")
-    
-    def __repr__(self):
-        return f"<Message(id={self.id}, role={self.role})>"
-
-
-class FunctionCall(Base):
-    """Function call model for tracking function executions."""
-    __tablename__ = 'function_calls'
-    
-    id = Column(UNIQUEIDENTIFIER, primary_key=True, default=uuid.uuid4)
-    message_id = Column(UNIQUEIDENTIFIER, ForeignKey('messages.id'), nullable=False)
-    function_name = Column(String(255), nullable=False)
-    parameters = Column(Text, nullable=True)  # JSON string
-    result = Column(Text, nullable=True)  # JSON string
-    execution_time = Column(Float, nullable=True)  # in seconds
-    created_at = Column(DateTime, default=datetime.datetime.utcnow)
-    
-    # Relationships
-    message = relationship("Message")
-    
-    def __repr__(self):
-        return f"<FunctionCall(id={self.id}, function_name={self.function_name})>"
+    __table_args__ = (
+        PrimaryKeyConstraint('Id', name='PK_AspNetUsers'),
+        Index('EmailIndex', 'NormalizedEmail'),
+        Index('UserNameIndex', 'NormalizedUserName', unique=True)
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(100, 'SQL_Latin1_General_CP1_CI_AS'))
+    IsActive: Mapped[bool] = mapped_column(Boolean, server_default=text('(CONVERT([bit],(1)))'))
+    CustomerPoints: Mapped[int] = mapped_column(Integer, server_default=text('((0))'))
+    CustomerLevel: Mapped[int] = mapped_column(Integer, server_default=text('((0))'))
+    UserName: Mapped[str] = mapped_column(Unicode(50, 'SQL_Latin1_General_CP1_CI_AS'))
+    Email: Mapped[str] = mapped_column(Unicode(100, 'SQL_Latin1_General_CP1_CI_AS'))
+    EmailConfirmed: Mapped[bool] = mapped_column(Boolean)
+    PasswordHash: Mapped[str] = mapped_column(Unicode(100, 'SQL_Latin1_General_CP1_CI_AS'))
+    PhoneNumber: Mapped[str] = mapped_column(Unicode(15, 'SQL_Latin1_General_CP1_CI_AS'))
+    PhoneNumberConfirmed: Mapped[bool] = mapped_column(Boolean)
+    TwoFactorEnabled: Mapped[bool] = mapped_column(Boolean)
+    LockoutEnabled: Mapped[bool] = mapped_column(Boolean)
+    AccessFailedCount: Mapped[int] = mapped_column(Integer)
+    ImageUrl: Mapped[Optional[str]] = mapped_column(Unicode(200, 'SQL_Latin1_General_CP1_CI_AS'))
+    DateOfBirth: Mapped[Optional[datetime.date]] = mapped_column(Date)
+    NormalizedUserName: Mapped[Optional[str]] = mapped_column(Unicode(256, 'SQL_Latin1_General_CP1_CI_AS'))
+    NormalizedEmail: Mapped[Optional[str]] = mapped_column(Unicode(256, 'SQL_Latin1_General_CP1_CI_AS'))
+    SecurityStamp: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    ConcurrencyStamp: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    LockoutEnd: Mapped[Optional[datetime.datetime]] = mapped_column(DATETIMEOFFSET)
+
+    AspNetRoles_: Mapped[List['AspNetRoles']] = relationship('AspNetRoles', secondary='AspNetUserRoles', back_populates='AspNetUsers')
+    Addresses: Mapped[List['Addresses']] = relationship('Addresses', back_populates='AspNetUsers_')
+    AspNetUserClaims: Mapped[List['AspNetUserClaims']] = relationship('AspNetUserClaims', back_populates='AspNetUsers_')
+    AspNetUserLogins: Mapped[List['AspNetUserLogins']] = relationship('AspNetUserLogins', back_populates='AspNetUsers_')
+    AspNetUserTokens: Mapped[List['AspNetUserTokens']] = relationship('AspNetUserTokens', back_populates='AspNetUsers_')
+    Payments: Mapped[List['Payments']] = relationship('Payments', back_populates='AspNetUsers_')
+    Orders: Mapped[List['Orders']] = relationship('Orders', back_populates='AspNetUsers_')
+    Reviews: Mapped[List['Reviews']] = relationship('Reviews', back_populates='AspNetUsers_')
+
+
+class Attributes(Base):
+    __tablename__ = 'Attributes'
+    __table_args__ = (
+        PrimaryKeyConstraint('Id', name='PK_Attributes'),
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Type: Mapped[int] = mapped_column(Integer)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    CategoryAttributes: Mapped[List['CategoryAttributes']] = relationship('CategoryAttributes', back_populates='Attributes_')
+    AttributeValues: Mapped[List['AttributeValues']] = relationship('AttributeValues', back_populates='Attributes_')
+
+
+class Categories(Base):
+    __tablename__ = 'Categories'
+    __table_args__ = (
+        ForeignKeyConstraint(['ParentCategoryId'], ['Categories.Id'], name='FK_Categories_Categories_ParentCategoryId'),
+        PrimaryKeyConstraint('Id', name='PK_Categories'),
+        Index('IX_Categories_ParentCategoryId', 'ParentCategoryId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(100, 'SQL_Latin1_General_CP1_CI_AS'))
+    Slug: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    Description: Mapped[Optional[str]] = mapped_column(Unicode(500, 'SQL_Latin1_General_CP1_CI_AS'))
+    ImageUrl: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    ParentCategoryId: Mapped[Optional[uuid.UUID]] = mapped_column(Uuid)
+
+    Categories: Mapped[Optional['Categories']] = relationship('Categories', remote_side=[Id], back_populates='Categories_reverse')
+    Categories_reverse: Mapped[List['Categories']] = relationship('Categories', remote_side=[ParentCategoryId], back_populates='Categories')
+    CategoryAttributes: Mapped[List['CategoryAttributes']] = relationship('CategoryAttributes', back_populates='Categories_')
+    Products: Mapped[List['Products']] = relationship('Products', back_populates='Categories_')
+
+
+class Combos(Base):
+    __tablename__ = 'Combos'
+    __table_args__ = (
+        PrimaryKeyConstraint('Id', name='PK_Combos'),
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Description: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    DiscountPercentage: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    IsActive: Mapped[bool] = mapped_column(Boolean)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    ProductCombos: Mapped[List['ProductCombos']] = relationship('ProductCombos', back_populates='Combos_')
+
+
+class Placements(Base):
+    __tablename__ = 'Placements'
+    __table_args__ = (
+        PrimaryKeyConstraint('Id', name='PK_Placements'),
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    Description: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    Products: Mapped[List['Products']] = relationship('Products', back_populates='Placements_')
+
+
+class Promotions(Base):
+    __tablename__ = 'Promotions'
+    __table_args__ = (
+        PrimaryKeyConstraint('Id', name='PK_Promotions'),
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Code: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    DiscountPercentage: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    StartDate: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    EndDate: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    IsActive: Mapped[bool] = mapped_column(Boolean)
+    Ussage: Mapped[int] = mapped_column(Integer)
+    CustomerLevel: Mapped[int] = mapped_column(Integer)
+    Type: Mapped[int] = mapped_column(Integer)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    Description: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    ProductIds: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    Products: Mapped[List['Products']] = relationship('Products', secondary='ProductPromotion', back_populates='Promotions_')
+    Orders: Mapped[List['Orders']] = relationship('Orders', back_populates='Promotions_')
+
+
+class VerificationCodes(Base):
+    __tablename__ = 'VerificationCodes'
+    __table_args__ = (
+        PrimaryKeyConstraint('Id', name='PK_VerificationCodes'),
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Code: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Email: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    ExpirationDate: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+
+class EFMigrationsHistory(Base):
+    __tablename__ = '__EFMigrationsHistory'
+    __table_args__ = (
+        PrimaryKeyConstraint('MigrationId', name='PK___EFMigrationsHistory'),
+    )
+
+    MigrationId: Mapped[str] = mapped_column(Unicode(150, 'SQL_Latin1_General_CP1_CI_AS'), primary_key=True)
+    ProductVersion: Mapped[str] = mapped_column(Unicode(32, 'SQL_Latin1_General_CP1_CI_AS'))
+
+
+class Addresses(Base):
+    __tablename__ = 'Addresses'
+    __table_args__ = (
+        ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], ondelete='CASCADE', name='FK_Addresses_AspNetUsers_UserId'),
+        PrimaryKeyConstraint('Id', name='PK_Addresses'),
+        Index('IX_Addresses_UserId', 'UserId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    IsDefault: Mapped[bool] = mapped_column(Boolean)
+    UserId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    Street: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    District: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    City: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    PostalCode: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Country: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Ward: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    AspNetUsers_: Mapped['AspNetUsers'] = relationship('AspNetUsers', back_populates='Addresses')
+    Orders: Mapped[List['Orders']] = relationship('Orders', back_populates='Addresses_')
+
+
+class AspNetRoleClaims(Base):
+    __tablename__ = 'AspNetRoleClaims'
+    __table_args__ = (
+        ForeignKeyConstraint(['RoleId'], ['AspNetRoles.Id'], ondelete='CASCADE', name='FK_AspNetRoleClaims_AspNetRoles_RoleId'),
+        PrimaryKeyConstraint('Id', name='PK_AspNetRoleClaims'),
+        Index('IX_AspNetRoleClaims_RoleId', 'RoleId')
+    )
+
+    Id: Mapped[int] = mapped_column(Integer, Identity(start=1, increment=1), primary_key=True)
+    RoleId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    ClaimType: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    ClaimValue: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    AspNetRoles_: Mapped['AspNetRoles'] = relationship('AspNetRoles', back_populates='AspNetRoleClaims')
+
+
+class AspNetUserClaims(Base):
+    __tablename__ = 'AspNetUserClaims'
+    __table_args__ = (
+        ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], ondelete='CASCADE', name='FK_AspNetUserClaims_AspNetUsers_UserId'),
+        PrimaryKeyConstraint('Id', name='PK_AspNetUserClaims'),
+        Index('IX_AspNetUserClaims_UserId', 'UserId')
+    )
+
+    Id: Mapped[int] = mapped_column(Integer, Identity(start=1, increment=1), primary_key=True)
+    UserId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    ClaimType: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    ClaimValue: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    AspNetUsers_: Mapped['AspNetUsers'] = relationship('AspNetUsers', back_populates='AspNetUserClaims')
+
+
+class AspNetUserLogins(Base):
+    __tablename__ = 'AspNetUserLogins'
+    __table_args__ = (
+        ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], ondelete='CASCADE', name='FK_AspNetUserLogins_AspNetUsers_UserId'),
+        PrimaryKeyConstraint('LoginProvider', 'ProviderKey', name='PK_AspNetUserLogins'),
+        Index('IX_AspNetUserLogins_UserId', 'UserId')
+    )
+
+    LoginProvider: Mapped[str] = mapped_column(Unicode(450, 'SQL_Latin1_General_CP1_CI_AS'), primary_key=True)
+    ProviderKey: Mapped[str] = mapped_column(Unicode(450, 'SQL_Latin1_General_CP1_CI_AS'), primary_key=True)
+    UserId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    ProviderDisplayName: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    AspNetUsers_: Mapped['AspNetUsers'] = relationship('AspNetUsers', back_populates='AspNetUserLogins')
+
+
+t_AspNetUserRoles = Table(
+    'AspNetUserRoles', Base.metadata,
+    Column('UserId', Uuid, primary_key=True, nullable=False),
+    Column('RoleId', Uuid, primary_key=True, nullable=False),
+    ForeignKeyConstraint(['RoleId'], ['AspNetRoles.Id'], ondelete='CASCADE', name='FK_AspNetUserRoles_AspNetRoles_RoleId'),
+    ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], ondelete='CASCADE', name='FK_AspNetUserRoles_AspNetUsers_UserId'),
+    PrimaryKeyConstraint('UserId', 'RoleId', name='PK_AspNetUserRoles'),
+    Index('IX_AspNetUserRoles_RoleId', 'RoleId')
+)
+
+
+class AspNetUserTokens(Base):
+    __tablename__ = 'AspNetUserTokens'
+    __table_args__ = (
+        ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], ondelete='CASCADE', name='FK_AspNetUserTokens_AspNetUsers_UserId'),
+        PrimaryKeyConstraint('UserId', 'LoginProvider', 'Name', name='PK_AspNetUserTokens')
+    )
+
+    UserId: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    LoginProvider: Mapped[str] = mapped_column(Unicode(450, 'SQL_Latin1_General_CP1_CI_AS'), primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(450, 'SQL_Latin1_General_CP1_CI_AS'), primary_key=True)
+    Value: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    AspNetUsers_: Mapped['AspNetUsers'] = relationship('AspNetUsers', back_populates='AspNetUserTokens')
+
+
+class CategoryAttributes(Base):
+    __tablename__ = 'CategoryAttributes'
+    __table_args__ = (
+        ForeignKeyConstraint(['AttributeId'], ['Attributes.Id'], ondelete='CASCADE', name='FK_CategoryAttributes_Attributes_AttributeId'),
+        ForeignKeyConstraint(['CategoryId'], ['Categories.Id'], ondelete='CASCADE', name='FK_CategoryAttributes_Categories_CategoryId'),
+        PrimaryKeyConstraint('Id', name='PK_CategoryAttributes'),
+        Index('IX_CategoryAttributes_AttributeId', 'AttributeId'),
+        Index('IX_CategoryAttributes_CategoryId', 'CategoryId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    CategoryId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    AttributeId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    Attributes_: Mapped['Attributes'] = relationship('Attributes', back_populates='CategoryAttributes')
+    Categories_: Mapped['Categories'] = relationship('Categories', back_populates='CategoryAttributes')
+
+
+class Payments(Base):
+    __tablename__ = 'Payments'
+    __table_args__ = (
+        ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], ondelete='CASCADE', name='FK_Payments_AspNetUsers_UserId'),
+        PrimaryKeyConstraint('Id', name='PK_Payments'),
+        Index('IX_Payments_UserId', 'UserId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    CardHolderName: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    CardNumber: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    CardType: Mapped[str] = mapped_column(Unicode(20, 'SQL_Latin1_General_CP1_CI_AS'))
+    ExpirationDate: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Method: Mapped[str] = mapped_column(Unicode(20, 'SQL_Latin1_General_CP1_CI_AS'))
+    IsDefault: Mapped[bool] = mapped_column(Boolean, server_default=text('(CONVERT([bit],(0)))'))
+    UserId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    AspNetUsers_: Mapped['AspNetUsers'] = relationship('AspNetUsers', back_populates='Payments')
+    Orders: Mapped[List['Orders']] = relationship('Orders', back_populates='Payments_')
+
+
+class Products(Base):
+    __tablename__ = 'Products'
+    __table_args__ = (
+        ForeignKeyConstraint(['CategoryId'], ['Categories.Id'], ondelete='CASCADE', name='FK_Products_Categories_CategoryId'),
+        ForeignKeyConstraint(['PlacementId'], ['Placements.Id'], ondelete='CASCADE', name='FK_Products_Placements_PlacementId'),
+        PrimaryKeyConstraint('Id', name='PK_Products'),
+        Index('IX_Products_CategoryId', 'CategoryId'),
+        Index('IX_Products_PlacementId', 'PlacementId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Name: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    Price: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    Description: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    IsActive: Mapped[bool] = mapped_column(Boolean)
+    CategoryId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    PlacementId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    Status: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    ImageUrl: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+
+    Categories_: Mapped['Categories'] = relationship('Categories', back_populates='Products')
+    Placements_: Mapped['Placements'] = relationship('Placements', back_populates='Products')
+    Promotions_: Mapped[List['Promotions']] = relationship('Promotions', secondary='ProductPromotion', back_populates='Products')
+    AttributeValues: Mapped[List['AttributeValues']] = relationship('AttributeValues', back_populates='Products_')
+    ProductCombos: Mapped[List['ProductCombos']] = relationship('ProductCombos', back_populates='Products_')
+    Variants: Mapped[List['Variants']] = relationship('Variants', back_populates='Products_')
+
+
+class AttributeValues(Base):
+    __tablename__ = 'AttributeValues'
+    __table_args__ = (
+        ForeignKeyConstraint(['AttributeId'], ['Attributes.Id'], ondelete='CASCADE', name='FK_AttributeValues_Attributes_AttributeId'),
+        ForeignKeyConstraint(['ProductId'], ['Products.Id'], name='FK_AttributeValues_Products_ProductId'),
+        PrimaryKeyConstraint('Id', name='PK_AttributeValues'),
+        Index('IX_AttributeValues_AttributeId', 'AttributeId'),
+        Index('IX_AttributeValues_ProductId', 'ProductId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Value: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    AttributeId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    ProductId: Mapped[Optional[uuid.UUID]] = mapped_column(Uuid)
+
+    Attributes_: Mapped['Attributes'] = relationship('Attributes', back_populates='AttributeValues')
+    Products_: Mapped[Optional['Products']] = relationship('Products', back_populates='AttributeValues')
+    VariantAttributes: Mapped[List['VariantAttributes']] = relationship('VariantAttributes', back_populates='AttributeValues_')
+
+
+class Orders(Base):
+    __tablename__ = 'Orders'
+    __table_args__ = (
+        ForeignKeyConstraint(['AddressId'], ['Addresses.Id'], name='FK_Orders_Addresses_AddressId'),
+        ForeignKeyConstraint(['PaymentId'], ['Payments.Id'], name='FK_Orders_Payments_PaymentId'),
+        ForeignKeyConstraint(['PromotionId'], ['Promotions.Id'], name='FK_Orders_Promotions_PromotionId'),
+        ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], name='FK_Orders_AspNetUsers_UserId'),
+        PrimaryKeyConstraint('Id', name='PK_Orders'),
+        Index('IX_Orders_AddressId', 'AddressId'),
+        Index('IX_Orders_PaymentId', 'PaymentId'),
+        Index('IX_Orders_PromotionId', 'PromotionId'),
+        Index('IX_Orders_UserId', 'UserId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    UserId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    AddressId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    Status: Mapped[int] = mapped_column(Integer)
+    TotalPrice: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    Discount: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    FinalPrice: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    OrderDate: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    PaymentMethod: Mapped[int] = mapped_column(Integer)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    PromotionId: Mapped[Optional[uuid.UUID]] = mapped_column(Uuid)
+    Note: Mapped[Optional[str]] = mapped_column(Unicode(500, 'SQL_Latin1_General_CP1_CI_AS'))
+    PaymentId: Mapped[Optional[uuid.UUID]] = mapped_column(Uuid)
+    ShippingCode: Mapped[Optional[str]] = mapped_column(Unicode(50, 'SQL_Latin1_General_CP1_CI_AS'))
+    ShippingRate: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    PaymentLinkId: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    PaymentLinkUrl: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    PaymentOrderCode: Mapped[Optional[int]] = mapped_column(BigInteger)
+
+    Addresses_: Mapped['Addresses'] = relationship('Addresses', back_populates='Orders')
+    Payments_: Mapped[Optional['Payments']] = relationship('Payments', back_populates='Orders')
+    Promotions_: Mapped[Optional['Promotions']] = relationship('Promotions', back_populates='Orders')
+    AspNetUsers_: Mapped['AspNetUsers'] = relationship('AspNetUsers', back_populates='Orders')
+    OrderDetails: Mapped[List['OrderDetails']] = relationship('OrderDetails', back_populates='Orders_')
+
+
+class ProductCombos(Base):
+    __tablename__ = 'ProductCombos'
+    __table_args__ = (
+        ForeignKeyConstraint(['ComboId'], ['Combos.Id'], ondelete='CASCADE', name='FK_ProductCombos_Combos_ComboId'),
+        ForeignKeyConstraint(['ProductId'], ['Products.Id'], ondelete='CASCADE', name='FK_ProductCombos_Products_ProductId'),
+        PrimaryKeyConstraint('Id', name='PK_ProductCombos'),
+        Index('IX_ProductCombos_ComboId', 'ComboId'),
+        Index('IX_ProductCombos_ProductId', 'ProductId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    ProductId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    ComboId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    Combos_: Mapped['Combos'] = relationship('Combos', back_populates='ProductCombos')
+    Products_: Mapped['Products'] = relationship('Products', back_populates='ProductCombos')
+
+
+t_ProductPromotion = Table(
+    'ProductPromotion', Base.metadata,
+    Column('ProductsId', Uuid, primary_key=True, nullable=False),
+    Column('PromotionsId', Uuid, primary_key=True, nullable=False),
+    ForeignKeyConstraint(['ProductsId'], ['Products.Id'], ondelete='CASCADE', name='FK_ProductPromotion_Products_ProductsId'),
+    ForeignKeyConstraint(['PromotionsId'], ['Promotions.Id'], ondelete='CASCADE', name='FK_ProductPromotion_Promotions_PromotionsId'),
+    PrimaryKeyConstraint('ProductsId', 'PromotionsId', name='PK_ProductPromotion'),
+    Index('IX_ProductPromotion_PromotionsId', 'PromotionsId')
+)
+
+
+class Variants(Base):
+    __tablename__ = 'Variants'
+    __table_args__ = (
+        ForeignKeyConstraint(['ProductId'], ['Products.Id'], name='FK_Variants_Products_ProductId'),
+        PrimaryKeyConstraint('Id', name='PK_Variants'),
+        Index('IX_Variants_ProductId', 'ProductId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    ImageUrls: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    PriceAdjustment: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    Stock: Mapped[int] = mapped_column(Integer)
+    IsActive: Mapped[bool] = mapped_column(Boolean)
+    Sku: Mapped[str] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    ProductId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    Products_: Mapped['Products'] = relationship('Products', back_populates='Variants')
+    GoodReceivedNotes: Mapped[List['GoodReceivedNotes']] = relationship('GoodReceivedNotes', back_populates='Variants_')
+    OrderDetails: Mapped[List['OrderDetails']] = relationship('OrderDetails', back_populates='Variants_')
+    VariantAttributes: Mapped[List['VariantAttributes']] = relationship('VariantAttributes', back_populates='Variants_')
+    GoodReceivedItems: Mapped[List['GoodReceivedItems']] = relationship('GoodReceivedItems', back_populates='Variants_')
+
+
+class GoodReceivedNotes(Base):
+    __tablename__ = 'GoodReceivedNotes'
+    __table_args__ = (
+        ForeignKeyConstraint(['VariantId'], ['Variants.Id'], name='FK_GoodReceivedNotes_Variants_VariantId'),
+        PrimaryKeyConstraint('Id', name='PK_GoodReceivedNotes'),
+        Index('IX_GoodReceivedNotes_VariantId', 'VariantId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    ReceivedDate: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    Quantity: Mapped[int] = mapped_column(Integer)
+    TotalCost: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    ShippingCost: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    Status: Mapped[int] = mapped_column(Integer)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    Note: Mapped[Optional[str]] = mapped_column(Unicode(collation='SQL_Latin1_General_CP1_CI_AS'))
+    VariantId: Mapped[Optional[uuid.UUID]] = mapped_column(Uuid)
+
+    Variants_: Mapped[Optional['Variants']] = relationship('Variants', back_populates='GoodReceivedNotes')
+    GoodReceivedItems: Mapped[List['GoodReceivedItems']] = relationship('GoodReceivedItems', back_populates='GoodReceivedNotes_')
+
+
+class OrderDetails(Base):
+    __tablename__ = 'OrderDetails'
+    __table_args__ = (
+        ForeignKeyConstraint(['OrderId'], ['Orders.Id'], name='FK_OrderDetails_Orders_OrderId'),
+        ForeignKeyConstraint(['VariantId'], ['Variants.Id'], name='FK_OrderDetails_Variants_VariantId'),
+        PrimaryKeyConstraint('Id', name='PK_OrderDetails'),
+        Index('IX_OrderDetails_OrderId', 'OrderId'),
+        Index('IX_OrderDetails_VariantId', 'VariantId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    OrderId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    VariantId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    Quantity: Mapped[int] = mapped_column(Integer, server_default=text('((1))'))
+    UnitPrice: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2), server_default=text('((0.0))'))
+    TotalPrice: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2), server_default=text('((0.0))'))
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    Orders_: Mapped['Orders'] = relationship('Orders', back_populates='OrderDetails')
+    Variants_: Mapped['Variants'] = relationship('Variants', back_populates='OrderDetails')
+    Reviews: Mapped[List['Reviews']] = relationship('Reviews', back_populates='OrderDetails_')
+
+
+class VariantAttributes(Base):
+    __tablename__ = 'VariantAttributes'
+    __table_args__ = (
+        ForeignKeyConstraint(['AttributeValueId'], ['AttributeValues.Id'], name='FK_VariantAttributes_AttributeValues_AttributeValueId'),
+        ForeignKeyConstraint(['VariantId'], ['Variants.Id'], ondelete='CASCADE', name='FK_VariantAttributes_Variants_VariantId'),
+        PrimaryKeyConstraint('Id', name='PK_VariantAttributes'),
+        Index('IX_VariantAttributes_AttributeValueId', 'AttributeValueId'),
+        Index('IX_VariantAttributes_VariantId', 'VariantId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    VariantId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    AttributeValueId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    AttributeValues_: Mapped['AttributeValues'] = relationship('AttributeValues', back_populates='VariantAttributes')
+    Variants_: Mapped['Variants'] = relationship('Variants', back_populates='VariantAttributes')
+
+
+class GoodReceivedItems(Base):
+    __tablename__ = 'GoodReceivedItems'
+    __table_args__ = (
+        ForeignKeyConstraint(['GoodReceivedNoteId'], ['GoodReceivedNotes.Id'], ondelete='CASCADE', name='FK_GoodReceivedItems_GoodReceivedNotes_GoodReceivedNoteId'),
+        ForeignKeyConstraint(['VariantId'], ['Variants.Id'], ondelete='CASCADE', name='FK_GoodReceivedItems_Variants_VariantId'),
+        PrimaryKeyConstraint('Id', name='PK_GoodReceivedItems'),
+        Index('IX_GoodReceivedItems_GoodReceivedNoteId', 'GoodReceivedNoteId'),
+        Index('IX_GoodReceivedItems_VariantId', 'VariantId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    VariantId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    GoodReceivedNoteId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    Quantity: Mapped[int] = mapped_column(Integer)
+    UnitCost: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    TotalCost: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+
+    GoodReceivedNotes_: Mapped['GoodReceivedNotes'] = relationship('GoodReceivedNotes', back_populates='GoodReceivedItems')
+    Variants_: Mapped['Variants'] = relationship('Variants', back_populates='GoodReceivedItems')
+
+
+class Reviews(Base):
+    __tablename__ = 'Reviews'
+    __table_args__ = (
+        ForeignKeyConstraint(['OrderDetailId'], ['OrderDetails.Id'], ondelete='CASCADE', name='FK_Reviews_OrderDetails_OrderDetailId'),
+        ForeignKeyConstraint(['UserId'], ['AspNetUsers.Id'], name='FK_Reviews_AspNetUsers_UserId'),
+        PrimaryKeyConstraint('Id', name='PK_Reviews'),
+        Index('IX_Reviews_OrderDetailId', 'OrderDetailId'),
+        Index('IX_Reviews_UserId', 'UserId')
+    )
+
+    Id: Mapped[uuid.UUID] = mapped_column(Uuid, primary_key=True)
+    Rating: Mapped[decimal.Decimal] = mapped_column(DECIMAL(18, 2))
+    ReviewText: Mapped[str] = mapped_column(Unicode(1000, 'SQL_Latin1_General_CP1_CI_AS'), server_default=text("(N'')"))
+    OrderDetailId: Mapped[uuid.UUID] = mapped_column(Uuid)
+    CreatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UpdatedAt: Mapped[datetime.datetime] = mapped_column(DATETIME2)
+    UserId: Mapped[Optional[uuid.UUID]] = mapped_column(Uuid)
+
+    OrderDetails_: Mapped['OrderDetails'] = relationship('OrderDetails', back_populates='Reviews')
+    AspNetUsers_: Mapped[Optional['AspNetUsers']] = relationship('AspNetUsers', back_populates='Reviews')

src/database/querries.py

@@ -1,9 +1,10 @@
+from sqlalchemy import func
 from sqlalchemy.orm import Session
 from sqlalchemy.exc import SQLAlchemyError
 import logging
 import uuid
 from src.database.db_connection import create_session
-from src.database.models import User, Chat, Message, FunctionCall
+from src.database.models import AspNetUsers, Products, Categories, Variants, OrderDetails, Orders, Placements, Attributes, AttributeValues, VariantAttributes
 
 # Set up logging
 logger = logging.getLogger(__name__)
@@ -47,7 +48,7 @@ def get_all_categories(session=None):
     try:
         # Using SQLAlchemy to query distinct product names
         from sqlalchemy import text
-        result = session.execute(text("SELECT DISTINCT name FROM Categories"))
+        result = session.execute(text("SELECT DISTINCT Name FROM Categories"))
         categories = [row[0] for row in result.fetchall()]
         
         return {
@@ -104,18 +105,7 @@ def get_all_products(session=None):
         if close_session:
             session.close()
 
-# User-related queries
-def get_user_by_id(user_id, session=None):
-    """
-    Get a user by their ID.
-    
-    Args:
-        user_id (str or UUID): The ID of the user to retrieve.
-        session (Session, optional): SQLAlchemy session.
-        
-    Returns:
-        dict: A dictionary containing the user or error information
-    """
+def get_product_by_price_range(category = None, min_price = None, max_price = None, session=None):
     close_session = False
     
     if session is None:
@@ -124,105 +114,50 @@ def get_user_by_id(user_id, session=None):
             return session_result
         session = session_result["session"]
         close_session = True
-    
+
     try:
-        # Ensure user_id is a valid UUID
-        if isinstance(user_id, str):
-            user_id = parse_uuid(user_id)
-            if not user_id:
-                return {
-                    "success": False,
-                    "error": "Invalid user ID format"
-                }
-        
-        user = session.query(User).filter(User.id == user_id).first()
-        
-        if user:
-            return {
-                "success": True,
-                "user": user
-            }
-        else:
-            return {
-                "success": False,
-                "error": f"User with ID {user_id} not found"
-            }
-    except SQLAlchemyError as e:
-        logger.error(f"Error fetching user: {str(e)}")
-        return {
-            "success": False,
-            "error": f"Error fetching user: {str(e)}"
-        }
-    finally:
-        if close_session:
-            session.close()
+        # Using SQLAlchemy to query products by price range and category
+        if min_price is None:
+            min_price = 0
+        if max_price is None:
+            max_price = float('inf')
 
-# Chat-related queries
-def get_chats_by_user_id(user_id, limit=10, offset=0, session=None):
-    """
-    Get a list of chats for a specific user.
-    
-    Args:
-        user_id (str or UUID): The ID of the user.
-        limit (int): The maximum number of chats to retrieve.
-        offset (int): The offset for pagination.
-        session (Session, optional): SQLAlchemy session.
+        query = session.query(Products).filter(
+            Products.Price >= min_price,
+            Products.Price <= max_price
+        )
         
-    Returns:
-        dict: A dictionary containing the chats or error information
-    """
-    close_session = False
-    
-    if session is None:
-        session_result = create_session()
-        if not session_result.get("success"):
-            return session_result
-        session = session_result["session"]
-        close_session = True
-    
-    try:
-        # Ensure user_id is a valid UUID
-        if isinstance(user_id, str):
-            user_id = parse_uuid(user_id)
-            if not user_id:
-                return {
-                    "success": False,
-                    "error": "Invalid user ID format"
-                }
+        if category:
+            query = query.filter(Products.CategoryId == category)
         
-        chats = session.query(Chat).filter(
-            Chat.user_id == user_id,
-            Chat.is_active == True
-        ).order_by(Chat.updated_at.desc()).offset(offset).limit(limit).all()
+        result = query.all()     
+
+        products = []
+        for row in result:
+            product_dict = {
+                "product": {
+                    "name": row.Name,
+                    "description": row.Description,
+                    "price": float(row.Price),
+                },
+            }
+            products.append(product_dict)
         
         return {
             "success": True,
-            "chats": chats
+            "results": products
         }
     except SQLAlchemyError as e:
-        logger.error(f"Error fetching chats: {str(e)}")
+        logger.error(f"Error fetching products by price range: {str(e)}")
         return {
             "success": False,
-            "error": f"Error fetching chats: {str(e)}"
+            "error": f"Error fetching products by price range: {str(e)}"
         }
     finally:
         if close_session:
             session.close()
 
-# Message-related queries
-def get_messages_by_chat_id(chat_id, limit=50, offset=0, session=None):
-    """
-    Get messages for a specific chat.
-    
-    Args:
-        chat_id (str or UUID): The ID of the chat.
-        limit (int): The maximum number of messages to retrieve.
-        offset (int): The offset for pagination.
-        session (Session, optional): SQLAlchemy session.
-        
-    Returns:
-        dict: A dictionary containing the messages or error information
-    """
+def get_product_information_by_name(product_name, session=None):
     close_session = False
     
     if session is None:
@@ -231,47 +166,78 @@ def get_messages_by_chat_id(chat_id, limit=50, offset=0, session=None):
             return session_result
         session = session_result["session"]
         close_session = True
-    
+
     try:
-        # Ensure chat_id is a valid UUID
-        if isinstance(chat_id, str):
-            chat_id = parse_uuid(chat_id)
-            if not chat_id:
-                return {
-                    "success": False,
-                    "error": "Invalid chat ID format"
-                }
+        # Using SQLAlchemy to query product information by name
+        query = session.query(
+            Products, 
+            Categories, 
+            Placements, 
+            Variants, 
+            VariantAttributes, 
+            AttributeValues, 
+            Attributes
+        ).join(
+            Categories, Products.CategoryId == Categories.Id
+        ).join(
+            Placements, Products.PlacementId == Placements.Id
+        ).join(
+            Variants, Products.Id == Variants.ProductId
+        ).join(
+            VariantAttributes, Variants.Id == VariantAttributes.VariantId
+        ).join(
+            AttributeValues, VariantAttributes.AttributeValueId == AttributeValues.Id
+        ).join(
+            Attributes, AttributeValues.AttributeId == Attributes.Id
+        ).filter(
+            Products.Name == product_name
+        )
+        
+        result = query.all()
         
-        messages = session.query(Message).filter(
-            Message.chat_id == chat_id
-        ).order_by(Message.created_at).offset(offset).limit(limit).all()
+        # Transform the result into a dictionary format
+        products = []
+        for row in result:
+            product_dict = {
+                "product": {
+                    "name": row.Products.Name,
+                    "description": row.Products.Description,
+                    "price": float(row.Products.Price),
+                    "category": row.Categories.Name,
+                    "placement": row.Placements.Name,
+                },
+                "attribute": {
+                    "name": row.Attributes.Name,
+                    "value": row.AttributeValues.Value
+                }
+            }
+            products.append(product_dict)
         
         return {
             "success": True,
-            "messages": messages
+            "results": products
         }
     except SQLAlchemyError as e:
-        logger.error(f"Error fetching messages: {str(e)}")
+        logger.error(f"Error fetching product information: {str(e)}")
         return {
             "success": False,
-            "error": f"Error fetching messages: {str(e)}"
+            "error": f"Error fetching product information: {str(e)}"
         }
     finally:
         if close_session:
             session.close()
 
-# Create a new chat
-def create_chat(user_id, title="New Chat", session=None):
+# User-related queries
+def get_user_by_id(user_id, session=None):
     """
-    Create a new chat for a user.
+    Get a user by their ID.
     
     Args:
-        user_id (str or UUID): The ID of the user.
-        title (str): The title of the chat.
+        user_id (str or UUID): The ID of the user to retrieve.
         session (Session, optional): SQLAlchemy session.
         
     Returns:
-        dict: A dictionary containing the new chat or error information
+        dict: A dictionary containing the user or error information
     """
     close_session = False
     
@@ -292,39 +258,39 @@ def create_chat(user_id, title="New Chat", session=None):
                     "error": "Invalid user ID format"
                 }
         
-        # Create a new chat
-        new_chat = Chat(user_id=user_id, title=title)
-        session.add(new_chat)
-        session.commit()
+        user = session.query(AspNetUsers).filter(AspNetUsers.id == user_id).first()
         
-        return {
-            "success": True,
-            "chat": new_chat
-        }
+        if user:
+            return {
+                "success": True,
+                "user": user
+            }
+        else:
+            return {
+                "success": False,
+                "error": f"User with ID {user_id} not found"
+            }
     except SQLAlchemyError as e:
-        session.rollback()
-        logger.error(f"Error creating chat: {str(e)}")
+        logger.error(f"Error fetching user: {str(e)}")
         return {
             "success": False,
-            "error": f"Error creating chat: {str(e)}"
+            "error": f"Error fetching user: {str(e)}"
         }
     finally:
         if close_session:
             session.close()
 
-# Add a message to a chat
-def add_message(chat_id, content, role, session=None):
+def get_top_sale_products(category, limit=10, session=None):
     """
-    Add a new message to a chat.
+    Get top-selling products based on sales data.
     
     Args:
-        chat_id (str or UUID): The ID of the chat.
-        content (str): The content of the message.
-        role (str): The role of the message (user, assistant, etc.).
+        category (str): The category of products to filter by.
+        limit (int): The maximum number of top-selling products to return.
         session (Session, optional): SQLAlchemy session.
         
     Returns:
-        dict: A dictionary containing the new message or error information
+        dict: A dictionary containing the top-selling products or error information
     """
     close_session = False
     
@@ -336,37 +302,49 @@ def add_message(chat_id, content, role, session=None):
         close_session = True
     
     try:
-        # Ensure chat_id is a valid UUID
-        if isinstance(chat_id, str):
-            chat_id = parse_uuid(chat_id)
-            if not chat_id:
-                return {
-                    "success": False,
-                    "error": "Invalid chat ID format"
-                }
-        
-        # Create a new message
-        new_message = Message(chat_id=chat_id, content=content, role=role)
-        session.add(new_message)
-        
-        # Update the chat's updated_at timestamp
-        chat = session.query(Chat).filter(Chat.id == chat_id).first()
-        if chat:
-            chat.updated_at = new_message.created_at
-        
-        session.commit()
+        # Using SQLAlchemy to query top-selling products
+        result = session.execute(Categories.__table__.join(
+            Products, Categories.Id == Products.CategoryId
+        ).join(
+            Variants, Products.Id== Variants.ProductId
+        ).join(
+            OrderDetails, Variants.Id == OrderDetails.VariantId
+        ).join(
+            Orders, OrderDetails.OrderId == Orders.Id
+        ).
+        filter(
+            Categories.Name == category
+        ).group_by(
+            Products.Id
+        ).order_by(
+            func.sum(OrderDetails.Quantity).desc()
+        ).limit(limit))
+
+        print(f"Query executed: {result}")
+
+        top_sales_products = [dict(row._mapping) for row in result.fetchall()]  
+
+        print(f"Top-selling products in category '{category}': {top_sales_products}")
         
         return {
             "success": True,
-            "message": new_message
+            "top_sales_products": top_sales_products
         }
     except SQLAlchemyError as e:
-        session.rollback()
-        logger.error(f"Error adding message: {str(e)}")
+        logger.error(f"Error fetching top-selling products: {str(e)}")
         return {
             "success": False,
-            "error": f"Error adding message: {str(e)}"
+            "error": f"Error fetching top-selling products: {str(e)}"
         }
     finally:
         if close_session:
-            session.close()
+            session.close()
+        
+        top_products = [dict(row._mapping) for row in result.fetchall()]
+        
+        return {
+            "success": True,
+            "top_products": top_products
+        }
+
+      

src/services/chat_service.py

@@ -16,51 +16,27 @@ def calculate_office_space(furniture_items):
     }
      
     total_space = 0
-    unknown_item = []
+    unknown_items = []
     for item in furniture_items:
-        if item in space_requirements:
-            total_space += space_requirements[item]
+        item_name = item.get("item_name", "").lower()
+        quantity = item.get("quantity", 0)
+        if item_name in space_requirements:
+            total_space += space_requirements[item_name] * quantity
         else:
-            unknown_item.append(item)
+            unknown_items.append(item_name)
 
     result = {
         "total_space": total_space,
-        "unknown_items": unknown_item
+        "unknown_items": unknown_items
     }
 
     return result
 
-def get_product_recommendations(product_type, style, budget = 0):
-    catalog = {
-        "chair": {
-            "modern": [
-                {"name": "Ergonomic Mesh Chair", "price": 299, "description": "Adjustable modern mesh chair with lumbar support"},
-                {"name": "Sleek Executive Chair", "price": 499, "description": "Premium modern chair with memory foam padding"}
-            ],
-            "classic": [
-                {"name": "Leather Executive Chair", "price": 399, "description": "Traditional leather chair with brass accents"},
-                {"name": "Wooden Armchair", "price": 299, "description": "Solid wood chair with cushioned seat"}
-            ]
-        },
-        "desk": {
-            "modern": [
-                {"name": "Glass Computer Desk", "price": 349, "description": "Minimalist glass desk with metal frame"},
-                {"name": "Adjustable Standing Desk", "price": 649, "description": "Electric height-adjustable modern desk"}
-            ],
-            "classic": [
-                {"name": "Executive Wooden Desk", "price": 799, "description": "Mahogany desk with classic design"},
-                {"name": "Traditional Writing Desk", "price": 459, "description": "Solid wood desk with drawers"}
-            ]
-        }
-    }
-
-    if product_type.lower() in catalog:
-        products = catalog[product_type][style]
-
-    if budget is not None:
-        products = [product for product in products if product["price"] <= budget]
-
-    return products
+def get_top_sales_products(category, limit):
+    # Import the database function at the function level to avoid circular imports
+    from src.database.querries import get_top_sale_products
+    top_sales = get_top_sale_products(category, limit)
+    return top_sales
 
 def get_all_categories():
     # Import the database function at the function level to avoid circular imports
@@ -68,3 +44,14 @@ def get_all_categories():
     all_categories = db_get_all_categories()
     return all_categories
 
+def get_product_information_by_name(product_name):
+    # Import the database function at the function level to avoid circular imports
+    from src.database.querries import get_product_information_by_name as db_get_product_information_by_name
+    product_info = db_get_product_information_by_name(product_name)
+    return product_info
+
+def get_product_by_price_range(category, min_price, max_price):
+    # Import the database function at the function level to avoid circular imports
+    from src.database.querries import get_product_by_price_range as db_get_product_by_price_range
+    products = db_get_product_by_price_range(category, min_price, max_price)
+    return products