Update app.py

app.py

@@ -2,6 +2,7 @@ import json
 import os
 import logging
 import shutil
+import asyncpg 
 from fastapi import FastAPI, File, Query,Form, Request, HTTPException, UploadFile
 from fastapi.responses import JSONResponse, RedirectResponse
 from fastapi.staticfiles import StaticFiles
@@ -10,6 +11,10 @@ from fastapi.middleware.cors import CORSMiddleware
 from dotenv import load_dotenv
 import mysql.connector
 from typing import List
+from pydantic import BaseModel
+import psycopg2
+
+
 
 # Load environment variables
 load_dotenv()
@@ -52,8 +57,63 @@ DB_USER = 'u852023448_redmindgpt'
 DB_PASSWORD = 'redmindGpt@123'
 DB_HOST = '217.21.88.10'
 DB_NAME = 'u852023448_redmindgpt'
+from pydantic import BaseModel
+class DatabaseConnection(BaseModel):
+    database_type: str
+    server: str
+    port: str
+    databaseName: str
+    username: str
+    password: str
+@app.post("/api/connect")
+async def connect_to_database(connection: DatabaseConnection):
+    try:
+        if connection.database_type == "postgres":
+            conn = psycopg2.connect(
+                host=connection.server,
+                port=connection.port,
+                database=connection.databaseName,
+                user=connection.username,
+                password=connection.password
+            )
+            query_schemas = "SELECT schema_name FROM information_schema.schemata"
+            query_tables = "SELECT table_name FROM information_schema.tables WHERE table_schema = %s"
+        elif connection.database_type == "mysql":
+            print(f"inside mysql",connection.server,connection.port,connection.databaseName,connection.username,connection.password)
+            conn = mysql.connector.connect(
+                host=connection.server,
+                port=connection.port,
+                database=connection.databaseName,
+                user=connection.username,
+                password=connection.password
+            )
+            query_schemas = "SELECT schema_name FROM information_schema.schemata"
+            query_tables = "SELECT table_name FROM information_schema.tables WHERE table_schema = %s"
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported database type")
+
+        cursor = conn.cursor()
+
+        # Fetch all schemas
+        cursor.execute(query_schemas)
+        schemas = cursor.fetchall()
+
+        # Fetch all tables within each schema
+        schema_tables = {}
+        for schema in schemas:
+            cursor.execute(query_tables, (schema[0],))
+            tables = cursor.fetchall()
+            schema_tables[schema[0]] = [table[0] for table in tables]
+
+        cursor.close()
+        conn.close()
+
+        return {"schemas": [schema[0] for schema in schemas], "schema_tables": schema_tables, "success": True}
 
-# Function to create a new database connection
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Function to create a new database connection for MySQL (Example)
 def get_db_connection():
     try:
         cnx = mysql.connector.connect(user=DB_USER, password=DB_PASSWORD, host=DB_HOST, database=DB_NAME)
@@ -207,6 +267,115 @@ async def get_companies():
         logging.error(f"Database error: {err}")
         raise HTTPException(status_code=500, detail="Internal Server Error")
    
+#to view the details
+@app.get("/api/getcompanydetails/{company_id}")
+async def get_company_details(company_id: int):
+    company = await get_company_from_db(company_id)
+    if not company:
+        raise HTTPException(status_code=404, detail="Company not found")
+    return company  
+      
+async def get_company_from_db(company_id: int):
+    try:
+        # Establish a connection to the database
+        cnx = get_db_connection()
+        if cnx is None:
+            raise HTTPException(status_code=500, detail="Failed to connect to the database")
+        cursor = cnx.cursor(dictionary=True)
+        query = "SELECT * FROM company_detail WHERE company_id = %s"
+        cursor.execute(query, (company_id,))
+        company = cursor.fetchone()
+        cursor.close()
+        cnx.close()
+        return company
+    except mysql.connector.Error as err:
+        logging.error(f"Error fetching company: {err}")
+        raise HTTPException(status_code=500, detail="Failed to fetch company")
+# to edit the details    
+@app.put("/api/putcompanydetails/{company_id}")
+async def update_company_details(company_id: int, 
+                                 company_name: str = Form(...),
+                                 company_code: str = Form(...),
+                                 domain: str = Form(...),
+                                 llm_tools: List[str] = Form(...)):
+    print(f"Received company_id",company_id)  # Debug statement
+    logging.info(f"Received request for company data")
+    company_data = {
+        'company_name': company_name,
+        'company_code': company_code,
+        'domain': domain,
+        'llm_tools': ','.join(llm_tools)
+    }
+    updated_company = await update_company_in_db(company_id, company_data)
+    if not updated_company:
+        raise HTTPException(status_code=500, detail="Failed to update company")
+    return updated_company
+
+async def update_company_in_db(company_id: int, company_data: dict):
+    try:
+        print(f"Received company_nid inside function",company_id)  # Debug statement
+        logging.info(f"Received request for company name")
+        cnx = get_db_connection()
+        if cnx is None:
+            raise HTTPException(status_code=500, detail="Failed to connect to the database")
+        cursor = cnx.cursor()
+        update_query = """
+        UPDATE redmind_gpt.company_detail cd
+        SET cd.company_name = %s, cd.company_code = %s, cd.domain = %s, cd.llm_tools = %s
+        WHERE cd.company_id = %s;
+        """
+        logging.info(f"Executing query: {update_query} with company_id: {company_id}")
+        params = (company_id,company_data)
+        logging.info(f"Query parameters: {params}")
+        print(f"Query parameters: {params}")
+
+    
+        cursor.execute(update_query, (
+            company_data['company_name'],
+            company_data['company_code'],
+            company_data['domain'],
+            company_data['llm_tools'],
+            company_id
+        ))
+
+        cnx.commit()
+        success = cursor.rowcount > 0
+        cursor.close()
+        cnx.close()
+        if not success:
+            return None
+        return company_data
+    except mysql.connector.Error as err:
+        logging.error(f"Error updating company: {err}")
+        raise HTTPException(status_code=500, detail="Failed to update company")
+
+
+def delete_company_from_db(company_id: int) -> bool:
+    print(f"Received company_name: {company_id}")  # Debug statement
+    logging.info(f"Received request for company name: {company_id}")
+    try:
+        # Establish a connection to the database
+        cnx = get_db_connection()
+        if cnx is None:
+            raise HTTPException(status_code=500, detail="Failed to connect to the database")
+        cursor = cnx.cursor()
+        delete_query = "DELETE FROM company_detail WHERE company_id = %s"
+        cursor.execute(delete_query, (company_id,))
+        cnx.commit()
+        success = cursor.rowcount > 0
+        cursor.close()
+        cnx.close()
+        return success
+    except mysql.connector.Error as err:
+        logging.error(f"Error deleting company: {err}")
+        raise HTTPException(status_code=500, detail="Failed to delete company")
+@app.delete("/api/delcompanydetails/{company_id}")
+async def delete_company(company_id: int):
+    deletion_success = delete_company_from_db(company_id)
+    if not deletion_success:
+        raise HTTPException(status_code=404, detail="Company not found or failed to delete")
+    return {"message": "Company deleted successfully"}
+
 @app.get("/knowledgebase")
 async def knowledgebase(request: Request):
     return templates.TemplateResponse("knowledgebase.html", {"request": request,"title":"KnowledgeBase"})
@@ -262,9 +431,9 @@ async def get_document(company_id: str = Query(...), company_name: str = Query(.
         cnx = get_db_connection()
         cursor = cnx.cursor()
         query = """
-            SELECT kb.company_id, kb.file_path, kb.document_name, kb.document_desc,kb.department,kb.version,kb.vectorDBflag,kb.last_updated
-            FROM u852023448_redmindgpt.knowledge_base kb
-            JOIN u852023448_redmindgpt.company_detail cd ON kb.company_id = cd.company_id 
+            SELECT kb.kid,kb.company_id, kb.file_path, kb.document_name, kb.document_desc,kb.department,kb.version,kb.vectorDBflag,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}")
@@ -279,15 +448,17 @@ async def get_document(company_id: str = Query(...), company_name: str = Query(.
         cnx.close()
         companies=[]
         for row in result:
+            
             companies.append({
-                "company_id": row[0],
-               # "file_path":row[1],
-                "document_name": row[2],
-                "document_desc": row[3],
-                "department": row[4],
-                "version": row[5],
-                "vectorDBflag":row[6],
-                "last_updated": row[7]                
+                "row_id":row[0],
+                "company_id": row[1],
+               #"file_path":row[2],
+                "document_name": row[3],
+                "document_desc": row[4],
+                "department": row[5],
+                "version": row[6],
+                "vectorDBflag":row[7],
+                "last_updated": row[8]                
             })
         if companies:
             return companies
@@ -298,6 +469,139 @@ async def get_document(company_id: str = Query(...), company_name: str = Query(.
         logging.error(f"Database error: {err}")
         raise HTTPException(status_code=500, detail="Internal Server Error")
     
+#to get data for view  in knowledgebase
+@app.get("/api/getknowledgebase/{company_id}")
+async def get_company_details(company_id: int):
+    company = await get_knowledge_from_db(company_id)
+    if not company:
+        raise HTTPException(status_code=404, detail="Company not found")
+    return company  
+      
+async def get_knowledge_from_db(company_id: int):
+    try:
+        # Establish a connection to the database
+        cnx = get_db_connection()
+        if cnx is None:
+            raise HTTPException(status_code=500, detail="Failed to connect to the database")
+        cursor = cnx.cursor(dictionary=True)
+        query = "SELECT * FROM knowledge_base WHERE kid = %s"
+        cursor.execute(query, (company_id,))
+        company = cursor.fetchone()
+        cursor.close()
+        cnx.close()
+        if company:
+            logging.debug(f"Extracted filename")
+            if company.get('file_path'):
+                company['file_path'] = os.path.basename(company['file_path'])
+                logging.debug(f"Extracted filename: {company['file_path']}")
+            return company
+        else:
+            raise HTTPException(status_code=404, detail="Company not found or file not found for the company")
+    except mysql.connector.Error as err:
+        logging.error(f"Error fetching company: {err}")
+        raise HTTPException(status_code=500, detail="Failed to fetch company")
+    
+# to edit the knowledgebase details    
+@app.put("/api/putknowledgebase/{kid}")
+async def update_company_details( 
+                                  kid: int,
+                                  company_id: str = Form(...),
+                                 # file_name: str = Form(...),
+                                  documentName: str = Form(...),
+                                  documentDescription: str = Form(...),
+                                  department: str = Form(...),
+                                  version: str = Form(...),
+                                  vectorDBFlag: str = Form(...),
+                                  lastUpdated: str = Form(...)):
+    logging.info(f"Received request for company data with ID: {kid}")
+    
+    # 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)
+
+    company_data = {
+        'company_id': company_id,
+        #'file_path': file_name,
+        'document_name': documentName,
+        'document_desc': documentDescription,
+        'department': department,
+        'version': version,
+        'vectorDBflag': vectorDBFlag,
+        'last_updated': lastUpdated
+    }
+
+    updated_company = await update_knowledge_in_db(kid, company_data)
+    if not updated_company:
+        raise HTTPException(status_code=500, detail="Failed to update company")
+    return updated_company
+async def update_knowledge_in_db(kid: int, company_data: dict):
+    try:
+        logging.info(f"Updating knowledge base for ID: {kid}")
+        cnx = get_db_connection()
+        if cnx is None:
+            raise HTTPException(status_code=500, detail="Failed to connect to the database")
+        
+        cursor = cnx.cursor()
+        update_query = """
+        UPDATE redmind_gpt.knowledge_base kb
+        SET kb.company_id,kb.document_name=%s, kb.document_desc=%s, kb.department=%s, kb.version=%s, kb.vectorDBflag=%s, kb.last_updated=%s
+        WHERE kb.kid = %s;
+        """
+        cursor.execute(update_query, (
+            company_data['company_id'],
+           # company_data['file_path'],
+            company_data['document_name'],
+            company_data['document_desc'],
+            company_data['department'],
+            company_data['version'],
+            company_data['vectorDBflag'],
+            company_data['last_updated'],
+            kid
+        ))
+
+        cnx.commit()
+        success = cursor.rowcount > 0
+        cursor.close()
+        cnx.close()
+        if not success:
+            return None
+        return company_data
+    except mysql.connector.Error as err:
+        logging.error(f"Error updating company: {err}")
+        raise HTTPException(status_code=500, detail="Failed to update company")
+
+
+def delete_knowledge_from_db(company_id: int) -> bool:
+    print(f"Received knowledge base company_id: {company_id}")  # Debug statement
+    logging.info(f"Received request for knowledgebase company id: {company_id}")
+    try:
+        # Establish a connection to the database
+        cnx = get_db_connection()
+        if cnx is None:
+            raise HTTPException(status_code=500, detail="Failed to connect to the database")
+        cursor = cnx.cursor()
+        delete_query = "DELETE FROM knowledge_base WHERE kid = %s"
+        cursor.execute(delete_query, (company_id,))
+        cnx.commit()
+        success = cursor.rowcount > 0
+        cursor.close()
+        cnx.close()
+        return success
+    except mysql.connector.Error as err:
+        logging.error(f"Error deleting company: {err}")
+        raise HTTPException(status_code=500, detail="Failed to delete company")
+    
+@app.delete("/api/delknowledgebase/{company_id}")
+async def delete_company(company_id: int):
+    deletion_success = delete_knowledge_from_db(company_id)
+    if not deletion_success:
+        raise HTTPException(status_code=404, detail="Company not found or failed to delete")
+    return {"message": "Company deleted successfully"}
+
+ 
 @app.get("/data_connectors")
 async def data_connectors(request: Request):
     return templates.TemplateResponse("data_connectors.html", {"request": request, "title": "Data Connectors"})