added write access check

backend/score.py

@@ -296,7 +296,9 @@ async def chat_bot(uri=Form(),model=Form(None),userName=Form(), password=Form(),
             graph = Neo4jGraph( url=uri,username=userName,password=password,database=database,sanitize = True, refresh_schema=True)
         else:
             graph = create_graph_database_connection(uri, userName, password, database)
-        result = await asyncio.to_thread(QA_RAG,graph=graph,model=model,question=question,document_names=document_names,session_id=session_id,mode=mode)
+            graph_DB_dataAccess = graphDBdataAccess(graph)
+            write_access = graph_DB_dataAccess.check_account_access(database=database)
+        result = await asyncio.to_thread(QA_RAG,graph=graph,model=model,question=question,document_names=document_names,session_id=session_id,mode=mode,write_access)
 
         total_call_time = time.time() - qa_rag_start_time
         logging.info(f"Total Response time is  {total_call_time:.2f} seconds")
@@ -382,7 +384,7 @@ async def clear_chat_bot(uri=Form(),userName=Form(), password=Form(), database=F
 async def connect(uri=Form(), userName=Form(), password=Form(), database=Form()):
     try:
         graph = create_graph_database_connection(uri, userName, password, database)
-        result = await asyncio.to_thread(connection_check_and_get_vector_dimensions, graph)
+        result = await asyncio.to_thread(connection_check_and_get_vector_dimensions, graph, database)
         json_obj = {'api_name':'connect','db_url':uri,'status':result, 'count':1, 'logging_time': formatted_time(datetime.now(timezone.utc))}
         logger.log_struct(json_obj, "INFO")
         return create_api_response('Success',data=result)

backend/src/QA_integration.py

@@ -34,7 +34,7 @@
 from src.llm import get_llm
 from src.shared.common_fn import load_embedding_model
 from src.shared.constants import *
-
+from src.graphDB_dataAccess import graphDBdataAccess
 load_dotenv() 
 
 EMBEDDING_MODEL = os.getenv('EMBEDDING_MODEL')
@@ -560,13 +560,13 @@ def process_graph_response(model, graph, question, messages, history):
             "user": "chatbot"
         }
 
-def create_neo4j_chat_message_history(graph, session_id, local=False):
+def create_neo4j_chat_message_history(graph, session_id, write_access=True):
     """
     Creates and returns a Neo4jChatMessageHistory instance.
 
     """
     try:
-        if not local: 
+        if write_access: 
             history = Neo4jChatMessageHistory(
                 graph=graph,
                 session_id=session_id
@@ -594,10 +594,10 @@ def get_chat_mode_settings(mode,settings_map=CHAT_MODE_CONFIG_MAP):
 
     return chat_mode_settings
 
-def QA_RAG(graph, model, question, document_names, session_id, mode):
+def QA_RAG(graph,model, question, document_names, session_id, mode, write_access=True):
     logging.info(f"Chat Mode: {mode}")
 
-    history = create_neo4j_chat_message_history(graph, session_id)
+    history = create_neo4j_chat_message_history(graph, session_id, write_access)
     messages = history.messages
 
     user_question = HumanMessage(content=question)

backend/src/graphDB_dataAccess.py

@@ -141,6 +141,32 @@ def update_KNN_graph(self):
         else:
             logging.info("Vector index does not exist, So KNN graph not update")
 
+    def check_account_access(self, database):
+        query = """
+        SHOW USER PRIVILEGES 
+        YIELD * 
+        WHERE graph = $database AND action IN ['read', 'write'] 
+        RETURN COUNT(*) AS readAccessCount
+        """
+        try:
+            logging.info(f"Checking access for database: {database}")
+
+            result = self.graph.query(query, params={"database": database})
+            read_access_count = result[0]["readAccessCount"] if result else 0
+
+            logging.info(f"Read access count: {read_access_count}")
+
+            if read_access_count > 0:
+                logging.info("The account has read access.")
+                return False
+            else:
+                logging.info("The account has write access.")
+                return True
+
+        except Exception as e:
+            logging.error(f"Error checking account access: {e}")
+            return False
+
     def check_gds_version(self):
         try:
             gds_procedure_count = """
@@ -162,7 +188,7 @@ def check_gds_version(self):
             logging.error(f"An error occurred while checking GDS version: {e}")
             return False
 
-    def connection_check_and_get_vector_dimensions(self):
+    def connection_check_and_get_vector_dimensions(self,database):
         """
         Get the vector index dimension from database and application configuration and DB connection status
 
@@ -189,18 +215,19 @@ def connection_check_and_get_vector_dimensions(self):
         logging.info(f'embedding model:{embeddings} and dimesion:{application_dimension}')
 
         gds_status = self.check_gds_version()
+        write_access = self.check_account_access(database=database)
 
         if self.graph:
             if len(db_vector_dimension) > 0:
-                return {'db_vector_dimension': db_vector_dimension[0]['vector_dimensions'], 'application_dimension':application_dimension, 'message':"Connection Successful","gds_status":gds_status}
+                return {'db_vector_dimension': db_vector_dimension[0]['vector_dimensions'], 'application_dimension':application_dimension, 'message':"Connection Successful","gds_status":gds_status,"write_access":write_access}
             else:
                 if len(db_vector_dimension) == 0 and len(result_chunks) == 0:
                     logging.info("Chunks and vector index does not exists in database")
-                    return {'db_vector_dimension': 0, 'application_dimension':application_dimension, 'message':"Connection Successful","chunks_exists":False,"gds_status":gds_status}
+                    return {'db_vector_dimension': 0, 'application_dimension':application_dimension, 'message':"Connection Successful","chunks_exists":False,"gds_status":gds_status,"write_access":write_access}
                 elif len(db_vector_dimension) == 0 and result_chunks[0]['hasEmbedding']==0 and result_chunks[0]['chunks'] > 0:
-                    return {'db_vector_dimension': 0, 'application_dimension':application_dimension, 'message':"Connection Successful","chunks_exists":True,"gds_status":gds_status}
+                    return {'db_vector_dimension': 0, 'application_dimension':application_dimension, 'message':"Connection Successful","chunks_exists":True,"gds_status":gds_status,"write_access":write_access}
                 else:
-                    return {'message':"Connection Successful","gds_status":gds_status}
+                    return {'message':"Connection Successful","gds_status": gds_status,"write_access":write_access}
 
     def execute_query(self, query, param=None):
         return self.graph.query(query, param)

backend/src/main.py

@@ -502,7 +502,7 @@ def update_graph(graph):
   graph_DB_dataAccess.update_KNN_graph()
 
 
-def connection_check_and_get_vector_dimensions(graph):
+def connection_check_and_get_vector_dimensions(graph,database):
   """
   Args:
     uri: URI of the graph to extract
@@ -513,7 +513,7 @@ def connection_check_and_get_vector_dimensions(graph):
    Returns a status of connection from NEO4j is success or failure
  """
   graph_DB_dataAccess = graphDBdataAccess(graph)
-  return graph_DB_dataAccess.connection_check_and_get_vector_dimensions()
+  return graph_DB_dataAccess.connection_check_and_get_vector_dimensions(database)
 
 def merge_chunks_local(file_name, total_chunks, chunk_dir, merged_dir):