update app p.4

app.py

@@ -4,16 +4,36 @@ from PIL import Image
 from googleapiclient.discovery import build
 from googleapiclient.http import MediaFileUpload
 from google.oauth2.credentials import Credentials
+from neo4j import GraphDatabase
 from chainguard.blockchain_logger import BlockchainLogger
 
-# Initialize Blockchain Logger
+# Blockchain Logger
 blockchain_logger = BlockchainLogger()
 
-# Directory for local storage of uploaded files
-UPLOAD_DIR = "uploads"
-os.makedirs(UPLOAD_DIR, exist_ok=True)
+# Neo4j Handler
+class Neo4jHandler:
+    def __init__(self, uri, user, password):
+        self.driver = GraphDatabase.driver(uri, auth=(user, password))
 
-# Load Google Drive API credentials
+    def close(self):
+        self.driver.close()
+
+    def log_transaction(self, file_name, drive_id, blockchain_hash):
+        """Log transactions to Neo4j."""
+        with self.driver.session() as session:
+            session.write_transaction(self._create_transaction_node, file_name, drive_id, blockchain_hash)
+
+    @staticmethod
+    def _create_transaction_node(tx, file_name, drive_id, blockchain_hash):
+        tx.run(
+            """
+            MERGE (t:Transaction {file_name: $file_name, drive_id: $drive_id, blockchain_hash: $blockchain_hash})
+            RETURN t
+            """,
+            file_name=file_name, drive_id=drive_id, blockchain_hash=blockchain_hash
+        )
+
+# Google Drive Integration
 def get_drive_service():
     creds = Credentials.from_authorized_user_file("credentials.json", scopes=["https://www.googleapis.com/auth/drive.file"])
     return build('drive', 'v3', credentials=creds)
@@ -21,70 +41,77 @@ def get_drive_service():
 drive_service = get_drive_service()
 
 def upload_to_google_drive(file_path, folder_id):
-    """Uploads a file to Google Drive in the specified folder."""
-    file_metadata = {
-        'name': os.path.basename(file_path),
-        'parents': [folder_id]
-    }
+    """Uploads a file to Google Drive."""
+    file_metadata = {'name': os.path.basename(file_path), 'parents': [folder_id]}
     media = MediaFileUpload(file_path, resumable=True)
     file = drive_service.files().create(body=file_metadata, media_body=media, fields='id').execute()
     return file.get('id')
 
+# Metadata Logging
 def log_metadata(file_name, tags, album):
-    """Log photo metadata to Chagu blockchain."""
-    metadata = {
-        "file_name": file_name,
-        "tags": tags,
-        "album": album
-    }
+    """Log metadata to Chagu blockchain."""
+    metadata = {"file_name": file_name, "tags": tags, "album": album}
     block_details = blockchain_logger.log_data(metadata)
     return block_details
 
-# Streamlit App Layout
-st.title("Memora: Photo & Video Uploader")
-st.subheader("Securely upload and organize your memories")
+# Streamlit Layout
+st.title("Memora: Secure File Upload with Blockchain & Neo4j")
+st.subheader("Securely upload, organize, and query your files")
 
 # File Upload
-uploaded_files = st.file_uploader(
-    "Upload your photos or videos", accept_multiple_files=True, type=['jpg', 'jpeg', 'png', 'mp4', 'avi']
-)
+uploaded_files = st.file_uploader("Upload your files", accept_multiple_files=True, type=['jpg', 'jpeg', 'png', 'mp4', 'avi'])
 
 if uploaded_files:
-    folder_id = st.text_input("Enter your Google Drive Folder ID", "")
+    # Neo4j Setup
+    neo4j_handler = Neo4jHandler(
+        uri="neo4j+s://0ca71b10.databases.neo4j.io",
+        user="neo4j",
+        password="HwGDOxyGS1-79nLeTiX5bx5ohoFSpvHCmTv8IRgt-lY"
+    )
+
+    folder_id = st.text_input("Enter Google Drive Folder ID", "")
     for uploaded_file in uploaded_files:
         # Save file locally
-        file_path = os.path.join(UPLOAD_DIR, uploaded_file.name)
+        file_path = os.path.join("uploads", uploaded_file.name)
+        os.makedirs("uploads", exist_ok=True)
         with open(file_path, "wb") as f:
             f.write(uploaded_file.getbuffer())
-        st.success(f"File {uploaded_file.name} saved locally in {UPLOAD_DIR}.")
+        st.success(f"File saved locally: {file_path}")
 
-        # Display uploaded file
-        st.write(f"File Name: {uploaded_file.name}")
+        # Display file details
         if uploaded_file.type.startswith('image'):
             image = Image.open(uploaded_file)
             st.image(image, caption=uploaded_file.name, use_column_width=True)
 
         # Metadata Input
-        album = st.text_input(f"Album for {uploaded_file.name}", value="Default Album")
-        tags = st.text_input(f"Tags for {uploaded_file.name} (comma-separated)", value="")
+        album = st.text_input(f"Album for {uploaded_file.name}", "Default Album")
+        tags = st.text_input(f"Tags for {uploaded_file.name} (comma-separated)", "")
 
-        # Log Metadata
         if st.button(f"Log Metadata for {uploaded_file.name}"):
             metadata = log_metadata(uploaded_file.name, tags.split(','), album)
-            st.write(f"Metadata logged successfully! Block Details: {metadata}")
+            st.write(f"Metadata logged successfully! Blockchain Details: {metadata}")
 
         # Upload to Google Drive
         if folder_id and st.button(f"Upload {uploaded_file.name} to Google Drive"):
             try:
-                drive_file_id = upload_to_google_drive(file_path, folder_id)
-                st.success(f"File {uploaded_file.name} uploaded to Google Drive with File ID: {drive_file_id}")
+                drive_id = upload_to_google_drive(file_path, folder_id)
+                blockchain_hash = metadata.get('block_hash', 'N/A')
+                neo4j_handler.log_transaction(uploaded_file.name, drive_id, blockchain_hash)
+                st.success(f"File uploaded to Google Drive: File ID {drive_id}")
             except Exception as e:
                 st.error(f"Failed to upload {uploaded_file.name} to Google Drive: {str(e)}")
 
+    neo4j_handler.close()
+
 # Blockchain Integrity Validation
 if st.button("Validate Blockchain Integrity"):
     is_valid = blockchain_logger.is_blockchain_valid()
-    if is_valid:
-        st.success("Blockchain Integrity: Valid ✅")
-    else:
-        st.error("Blockchain Integrity: Invalid ❌")
+    st.write("Blockchain Integrity:", "Valid ✅" if is_valid else "Invalid ❌")
+
+# Query System
+st.subheader("Query Files")
+query = st.text_input("Enter your query (e.g., 'Good comedy')")
+if st.button("Search"):
+    # Simulating query processing
+    result = {"response": f"Mock result for '{query}'"}
+    st.write(f"Query Result: {result['response']}")