Update app.py

app.py

@@ -1,24 +1,32 @@
+import json
 import os
 import logging
-from fastapi import FastAPI, File, UploadFile, HTTPException, APIRouter, Form, Request
-from pydantic import BaseModel
-from services.file_upload_service import FileHandler
-from services.chat_service import ChatAgentService
+import shutil
+from fastapi import FastAPI, File, Query,Form, Request, HTTPException, UploadFile
+from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
 from fastapi.middleware.cors import CORSMiddleware
 from dotenv import load_dotenv
-
 import mysql.connector
+from typing import List
 
-# Create the FastAPI app
-app = FastAPI(title="RedmindGen", description="Chat with your Data", version="1.0.0")
-
-# Load environment variables from .env file
+# Load environment variables
 load_dotenv()
 
-# Get the path to the vector database
-vector_db_path_documents = os.getenv('VECTOR_DB_PATH_DOCUMENTS')
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("redmindgen.log"),
+        logging.StreamHandler()  # This ensures logging to console
+    ]
+)
+logging.info("Application startup")
+
+# Create the FastAPI app
+app = FastAPI(title="RedmindGen", description="Chat with your Data", version="1.0.0")
 
 # Mount static files
 app.mount("/static", StaticFiles(directory="static"), name="static")
@@ -26,170 +34,303 @@ app.mount("/static", StaticFiles(directory="static"), name="static")
 # Jinja2 templates
 templates = Jinja2Templates(directory="templates")
 
-#log handling
-LOG_PATH = os.getenv('LOG_PATH')
-LOG_FILENAME = "redmindgen.log"
-full_log_path = os.path.join(LOG_PATH, LOG_FILENAME)
-# Configure logging
-logging.basicConfig(filename="test.log", level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logging.info("File upload start")
-
 # Configure CORS
 origins = [
-    "http://localhost:8000",  # Adjust this to the origins you want to allow
-    "http://127.0.0.1:8000",  # Example: Frontend running on a different port
+    "http://localhost:8000",
+    "http://127.0.0.1:8000",
     "http://167.71.75.10:8003/"
 ]
 
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=origins,  # Allows specified origins (use ["*"] for all origins)
+    allow_origins=origins,
     allow_credentials=True,
-    allow_methods=["*"],  # Allows all methods
-    allow_headers=["*"],  # Allows all headers
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 @app.get("/")
 async def read_root(request: Request):
-    """
-    Root endpoint that returns the index.html template.
-    """
     return templates.TemplateResponse("index.html", {"request": request})
 
 def verify_user(username: str, password: str):
-    """
-    Function to verify user credentials by checking the username and password in the database.
-    Returns "success" if the user is logged in, otherwise returns "failure".
-    """
-    # Connect to MySQL database
-    cnx = mysql.connector.connect(user='u852023448_redmindgpt', password='redmindGpt@123',
+    try:
+            # Connect to MySQL database
+        cnx = mysql.connector.connect(user='u852023448_redmindgpt', password='redmindGpt@123',
                                   host='217.21.88.10',
                                   database='u852023448_redmindgpt')
 
-    # Create a cursor object
-    cursor = cnx.cursor()
-
-    # Execute the query
-    query = "SELECT * FROM user_detail WHERE username = %s AND password = %s"
-    values = (username, password)  # Replace with actual values from the front end
-    cursor.execute(query, values)
-
-    # Fetch the result
-    result = cursor.fetchone()
-
-    # Check if the result is not None
-    if result is not None:
-        # User is logged in
-        return "success"
-    else:
-        # User is not logged in
+        #cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        query = "SELECT * FROM user_detail WHERE username = %s AND password = %s"
+        values = (username, password)
+        cursor.execute(query, values)
+        result = cursor.fetchone()
+        cursor.close()
+        cnx.close()
+        if result is not None:
+            logging.info(f"User {username} logged in successfully")
+            return "success"
+        else:
+            logging.info(f"User {username} login failed")
+            return "failure"
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
         return "failure"
 
-    # Close the cursor and connection
-    cursor.close()
-    cnx.close()
-
 @app.post("/validate-user")
 async def validate_user(request: Request, username: str = Form(...), password: str = Form(...)):
-    """
-    Endpoint to validate user credentials.
-    If the credentials are valid, it returns the dashboard.html template.
-    Otherwise, it returns the index.html template.
-    """
     status = verify_user(username, password)
     if status == 'success':
         return templates.TemplateResponse("dashboard.html", {"request": request, "username": username})
     else:
         return templates.TemplateResponse("index.html", {"request": request})
 
-@app.get("/knowledgebase")
-async def knowledgebase(request: Request):
-    """
-    Endpoint for the knowledgebase page.
-    Returns the knowledgebase.html template.
-    """
-    return templates.TemplateResponse("knowledgebase.html", {"request": request})
+@app.post("/submit_company_profile")
+async def submit_company_profile(request: Request,
+                                 company_name: str = Form(...),
+                                 company_code: str = Form(...),
+                                 domain: str = Form(...),
+                                 llm_tools: List[str] = Form(...)):
+    logging.info("Received form submission for company profile")
+    logging.info(f"Form data - company_name: {company_name}, company_code: {company_code}, domain: {domain}, llm_tools: {llm_tools}")
+
+    try:
+            # Connect to MySQL database
+        cnx = mysql.connector.connect(user='u852023448_redmindgpt', password='redmindGpt@123',
+                                  host='217.21.88.10',
+                                  database='u852023448_redmindgpt')
+
+        #cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        query = "INSERT INTO company_detail (company_name, company_code, domain, llm_tools) VALUES (%s, %s, %s, %s)"
+        values = (company_name, company_code, domain, ",".join(llm_tools))
+        logging.info(f"Executing query: {query} with values: {values}")
+        cursor.execute(query, values)
+        cnx.commit()
+        logging.info(f"Query executed successfully, {cursor.rowcount} row(s) affected")
+        cursor.close()
+        cnx.close()
+        logging.info(f"Company profile for {company_name} inserted successfully")
+        RedirectResponse(url="/company_profile?message=Data saved successfully", status_code=302)
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
-@app.get("/chatbot")
-async def chatbot(request: Request):
-    """
-    Endpoint for the knowledgebase page.
-    Returns the knowledgebase.html template.
-    """
-    return templates.TemplateResponse("chatpage.html", {"request": request})
+
+@app.get("/api/companies")
+async def get_companies():
+    try:
+        cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        query = "SELECT company_name FROM company_detail "
+        cursor.execute(query)
+        companies = cursor.fetchall()
+        cursor.close()
+        cnx.close() 
+        return {"companies": [{"name": company[0]} for company in companies]}
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
 
 @app.get("/company_profile")
 async def company_profile(request: Request):
-    """
-    Endpoint for the company profile page.
-    Returns the company_profile.html template.
-    """
     return templates.TemplateResponse("company_profile.html", {"request": request})
+@app.get("/api/company_id")
+async def get_company_id(company_name: str):
+    print(f"Received company_name: {company_name}")  # Debug statement
+    logging.info(f"Received request for company name: {company_name}")
+    try:
+        cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        query = "SELECT company_id FROM company_detail WHERE company_name = %s"
+        cursor.execute(query, (company_name,))
+        result = cursor.fetchone()
+        cursor.close()
+        cnx.close()
+        
+        if result:
+            return {"company_id": result[0]}
+        else:
+            logging.error(f"Company not found for name: {company_name}")
+            raise HTTPException(status_code=404, detail="Company not found")
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+   
+@app.get("/knowledgebase")
+async def knowledgebase(request: Request):
+    return templates.TemplateResponse("knowledgebase.html", {"request": request})
+@app.post("/upload_document")
+async def upload_document(
+    request: Request,
+    company_id:str=Form(...),
+    uploadFile: UploadFile = File(...),
+    documentName: str = Form(...),
+    documentDescription: str = Form(...),
+    department: str = Form(...),
+    version: str = Form(...),
+    lastUpdated: str = Form(...)
+):
+    try:
+        # Save the uploaded file
+        upload_folder = "uploads/"
+        os.makedirs(upload_folder, exist_ok=True)
+        file_path = os.path.join(upload_folder, uploadFile.filename)
+        
+        with open(file_path, "wb") as buffer:
+            shutil.copyfileobj(uploadFile.file, buffer)
+        
+        # Save the details to the database
+        cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        query = """
+            INSERT INTO knowledge_base (company_id,file_path, document_name, document_desc, department, version, last_updated)
+            VALUES (%s,%s, %s, %s, %s, %s, %s)
+        """
+        values = (company_id,file_path, documentName, documentDescription, department, version, lastUpdated)
+        cursor.execute(query, values)
+        cnx.commit()
+        cursor.close()
+        cnx.close()
+        
+        logging.info(f"Document {documentName} uploaded successfully")
+        return RedirectResponse(url="/", status_code=302)
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+    
+@app.get("/api/document_upload")
+async def get_document(company_id: str = Query(...), company_name: str = Query(...)):
+    print(f"Received companyId and name: {company_id},{company_name}")  # Log rec
+    #async def get_data_connectors(company_id: str, company_name: str):
+    logging.info(f"Received request for company_id  and company_id: {company_id},{company_name}")
+    try:
+        cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        query = """
+            SELECT kb.company_id, kb.file_path, kb.document_name, kb.document_desc,kb.department,kb.version,kb.last_updated
+            FROM redmind_gpt.knowledge_base kb
+            JOIN redmind_gpt.company_detail cd ON kb.company_id = cd.company_id 
+            WHERE kb.company_id = %s and cd.company_name=%s
+        """
+        logging.info(f"Executing query: {query} with company_id: {company_id}")
+        params = (company_id,company_name)
+        logging.info(f"Query parameters: {params}")
+        print(f"Query parameters: {params}")
+
+        cursor.execute(query, params)  # Pa
+        result = cursor.fetchone()
+        logging.info(f"Query result: {result}")
+        cursor.close
+        cnx.close()
+        
+        if result:
+            logging.info(f"Document  found for company_id: {company_id}")
+            return {
+                "company_id": result[0],
+               # "file_path":result[1],
+                "document_name": result[2],
+                "document_desc": result[3],
+                "department": result[4],
+                "version": result[5],
+                "last_updated": result[6]                
+            }
+        else:
+            logging.warning(f"No document found for company_id: {company_id}")
+            raise HTTPException(status_code=404, detail="Data document not found")
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+    
 @app.get("/data_connectors")
 async def data_connectors(request: Request):
-    """
-    Endpoint for the company profile page.
-    Returns the company_profile.html template.
-    """
     return templates.TemplateResponse("data_connectors.html", {"request": request})
+@app.post("/save_data_connectors")
+async def save_data_connectors( request: Request,
+                                company_id: int = Form(...),
+                                database: List[str] = Form(...),
+                                server: str = Form(...),
+                                port: str = Form(...),
+                                databaseName: List[str] = Form(...),
+                                username: str=Form(...),
+                                password: str=Form(...),
+                                tables: List[str] = Form(...)):
+    logging.info(f"Received form submission for database_connectors")
+    try:
+        cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        #databasetype_json=json.dumps(database)
+        query = "INSERT INTO data_connectors(company_id,databasetype, serverip, port, database_name,username,password,dbtablename) VALUES (%s,%s, %s, %s, %s,%s,%s,%s)"
+        values = (company_id, ",".join(database), server, port, ",".join(databaseName),username,password, ",".join(tables))
+        logging.info(f"Executing query: {query} with values: {values}")
+        cursor.execute(query, values)
+        cnx.commit()
+        logging.info(f"Query executed successfully, {cursor.rowcount} row(s) affected")
+        cursor.close()
+        cnx.close()
+        logging.info(f"Data_connectors for {database} inserted successfully")
+        return RedirectResponse(url="/data_connectors", status_code=302)
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+    
+@app.get("/api/check_data_connectors")
+async def get_data_connectors(company_id: str = Query(...), company_name: str = Query(...)):
+    print(f"Received companyId and name: {company_id},{company_name}")  # Log rec
+    #async def get_data_connectors(company_id: str, company_name: str):
+    logging.info(f"Received request for company_id  and company_id: {company_id},{company_name}")
+    try:
+        cnx = mysql.connector.connect(user='root', password='', host='localhost', database='redmind_gpt')
+        cursor = cnx.cursor()
+        query = """
+            SELECT dc.company_id, dc.databasetype, dc.serverip, dc.port,dc.database_name, dc.username, dc.password ,dc.dbtablename
+            FROM redmind_gpt.data_connectors dc
+            JOIN redmind_gpt.company_detail cd ON dc.company_id = cd.company_id 
+            WHERE dc.company_id = %s and cd.company_name=%s
+        """
+        logging.info(f"Executing query: {query} with company_id: {company_id}")
+        params = (company_id,company_name)
+        logging.info(f"Query parameters: {params}")
+        print(f"Query parameters: {params}")
+
+        cursor.execute(query, params)  # Pa
+        result = cursor.fetchone()
+        logging.info(f"Query result: {result}")
+        cursor.close()
+        cnx.close()
+        
+        if result:
+            logging.info(f"Data found for company_id: {company_id}")
+            return {
+                "company_id": result[0],
+                "databasetype":result[1],
+                "serverip": result[2],
+                "port": result[3],
+                "database_name": result[4],
+                "username": result[5],
+                "password": result[6],
+                "dbtablename": result[7]
+            }
+        else:
+            logging.warning(f"No data found for company_id: {company_id}")
+            raise HTTPException(status_code=404, detail="Data connector not found")
+    except mysql.connector.Error as err:
+        logging.error(f"Database error: {err}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+    
+
+
 @app.get("/API_connectors")
 async def API_connectors(request: Request):
-    """
-    Endpoint for the company profile page.
-    Returns the company_profile.html template.
-    """
     return templates.TemplateResponse("API_connectors.html", {"request": request})
+@app.get("/prompt_template")
+async def prompt_template(request: Request):
+    return templates.TemplateResponse("prompt_template.html", {"request": request})
+@app.get("/chatbot")
+async def chatbot(request: Request):
+    return templates.TemplateResponse("chatbot.html", {"request": request})
 
-@app.post("/upload_file/")
-async def upload_file(
-    file: UploadFile = File(..., description="Upload a file"),
-    document_name: str = Form(..., description="The name of the document."),
-    document_description: str = Form(..., description="A brief description of the document."),
-    department: str = Form(..., description="The department associated with the document."),
-    version: str = Form(..., description="The version of the document."),
-    last_updated: str = Form(..., description="The date when the document was last updated.")
-    ):
-
-    """
-    Endpoint to handle file uploads.
-    It validates the file type and calls the FileHandler to handle the file upload.
-    Returns the result of the file upload."""
-    print("upload_file called")
-    allowed_extensions = {'txt', 'pdf', 'docx', 'csv', 'xlsx'}
-    if file.filename.split('.')[-1].lower() not in allowed_extensions:
-       raise HTTPException(status_code=400,
-                          detail="Unsupported file type. Supported types: TXT, PDF, DOCX, CSV, XLSX.")
-
-    try:
-        
-        file_handler = FileHandler(vector_db_path=vector_db_path_documents)
-        print(vector_db_path_documents)
-        result = await file_handler.handle_file_upload(file, document_name, document_description, department, version,
-                                                       last_updated)
-        print("result")
-        return result
-    except Exception as e:
-        logging.error(f"Error handling file uploads: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-    
-@app.post("/chat_with_agent")
-async def chat_with_agent(request: Request, user_question: str = Form(...)):
-    """
-    Endpoint to chat with the chat agent.
-    It calls the ChatAgentService to get the answer to the user's question.
-    Returns the answer.
-    """
-    print(user_question)
-    
-    chat_service = ChatAgentService()
-    try:
-        print("chat_with_agent called")
-        answer = chat_service.answer_question(user_question)
-        print("answer returned")
-        return answer
-    except Exception as e:
-        logging.error(f"Error in chat api: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))