Update app.py

app.py

@@ -1,49 +1,40 @@
-# CosmicApp.py
 import streamlit as st
-from azure.cosmos import CosmosClient, exceptions
+from azure.cosmos import CosmosClient, PartitionKey, exceptions
 import os
 import pandas as pd
-import json
-from datetime import datetime
+import traceback
+import requests
 import shutil
+import zipfile
 from github import Github
 from git import Repo
+from datetime import datetime
 import base64
-from dotenv import load_dotenv
+import json
 
-# Load environment variables
-load_dotenv()
+st.set_page_config(layout="wide")
 
 # Cosmos DB configuration
-ENDPOINT = os.getenv("ENDPOINT")
-PRIMARY_KEY = os.getenv("PRIMARY_KEY")
+ENDPOINT = "https://acae-afd.documents.azure.com:443/"
+SUBSCRIPTION_ID = "003fba60-5b3f-48f4-ab36-3ed11bc40816"
+DATABASE_NAME = os.environ.get("COSMOS_DATABASE_NAME")
+CONTAINER_NAME = os.environ.get("COSMOS_CONTAINER_NAME")
 Key = os.environ.get("Key")
 
 # GitHub configuration
-GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
-
-# 🌟 Helper Functions Galore 🌟
-
 def download_github_repo(url, local_path):
-    """
-    🌀 Clone a GitHub repo faster than a swirling vortex!
-    """
     if os.path.exists(local_path):
         shutil.rmtree(local_path)
     Repo.clone_from(url, local_path)
 
-def create_repo(github_token, repo_name):
-    """
-    🐣 Hatch a new GitHub repo like a pro!
-    """
-    g = Github(github_token)
+def create_zip_file(source_dir, output_filename):
+    shutil.make_archive(output_filename, 'zip', source_dir)
+
+def create_repo(g, repo_name):
     user = g.get_user()
     return user.create_repo(repo_name)
 
 def push_to_github(local_path, repo, github_token):
-    """
-    🚀 Push your changes to GitHub at warp speed!
-    """
     repo_url = f"https://{github_token}@github.com/{repo.full_name}.git"
     local_repo = Repo(local_path)
     
@@ -53,100 +44,84 @@ def push_to_github(local_path, repo, github_token):
     else:
         origin = local_repo.create_remote('origin', repo_url)
     
+    if not local_repo.heads:
+        local_repo.git.checkout('-b', 'main')
+        current_branch = 'main'
+    else:
+        current_branch = local_repo.active_branch.name
+    
     local_repo.git.add(A=True)
+    
     if local_repo.is_dirty():
         local_repo.git.commit('-m', 'Initial commit')
     
-    origin.push(refspec=f"{local_repo.active_branch.name}:{local_repo.active_branch.name}")
+    origin.push(refspec=f'{current_branch}:{current_branch}')
 
 def get_base64_download_link(file_path, file_name):
-    """
-    🔗 Get a base64 download link for instant gratification!
-    """
     with open(file_path, "rb") as file:
         contents = file.read()
     base64_encoded = base64.b64encode(contents).decode()
-    return f'<a href="data:application/zip;base64,{base64_encoded}" download="{file_name}">🛸 Download {file_name} 🛸</a>'
-
-def fetch_db_structure(client):
-    """
-    📂 Fetch the cosmic database structure—no telescope needed!
-    """
-    structure = {}
-    for database in client.list_databases():
-        db_name = database['id']
-        structure[db_name] = []
-        db_client = client.get_database_client(db_name)
-        for container in db_client.list_containers():
-            structure[db_name].append(container['id'])
-    return structure
-
-def fetch_items(client, db_name, container_name):
-    """
-    🛰️ Fetch items from a container—beep boop!
-    """
-    container = client.get_database_client(db_name).get_container_client(container_name)
-    items = list(container.read_all_items())
-    return items
-
-def create_item(client, db_name, container_name):
-    """
-    🌱 Create a new cosmic item—let it grow!
-    """
-    st.subheader("🌱 Create New Item")
-    item_id = st.text_input("🆔 Item ID")
-    item_data = st.text_area("📝 Item Data (in JSON format)")
-    
-    if st.button("💾 Save New Item"):
-        try:
-            container = client.get_database_client(db_name).get_container_client(container_name)
-            json_data = json.loads(item_data)
-            json_data['id'] = item_id
-            container.create_item(body=json_data)
-            st.success("🎉 New item created successfully!")
-            st.json(json_data)
-            st.rerun()
-        except Exception as e:
-            st.error(f"🚨 Error creating item: {str(e)}")
-
-def edit_item(client, db_name, container_name, item_id):
-    """
-    ✏️ Edit an existing item—because change is the only constant!
-    """
-    container = client.get_database_client(db_name).get_container_client(container_name)
-    item = container.read_item(item=item_id, partition_key=item_id)
-    
-    st.subheader(f"✏️ Editing Item: {item_id}")
-    edited_item = st.text_area("📝 Edit Item Data (in JSON format)", value=json.dumps(item, indent=2))
-    
-    if st.button("💾 Save Changes"):
-        try:
-            json_data = json.loads(edited_item)
-            container.upsert_item(body=json_data)
-            st.success("✨ Item updated successfully!")
-            st.json(json_data)
-            st.rerun()
-        except Exception as e:
-            st.error(f"🚨 Error updating item: {str(e)}")
-
-def delete_item(client, db_name, container_name, item_id):
-    """
-    🗑️ Delete an item—because sometimes less is more!
-    """
-    st.subheader(f"🗑️ Delete Item: {item_id}")
-    if st.button("⚠️ Confirm Delete"):
-        try:
-            container = client.get_database_client(db_name).get_container_client(container_name)
-            container.delete_item(item=item_id, partition_key=item_id)
-            st.success(f"🔥 Item {item_id} deleted successfully!")
-            st.rerun()
-        except Exception as e:
-            st.error(f"🚨 Error deleting item: {str(e)}")
+    return f'<a href="data:application/zip;base64,{base64_encoded}" download="{file_name}">Download {file_name}</a>'
 
+# Cosmos DB functions
+def insert_record(record):
+    try:
+        response = container.create_item(body=record)
+        return True, response
+    except exceptions.CosmosHttpResponseError as e:
+        return False, f"HTTP error occurred: {str(e)}. Status code: {e.status_code}"
+    except Exception as e:
+        return False, f"An unexpected error occurred: {str(e)}"
+
+def call_stored_procedure(record):
+    try:
+        response = container.scripts.execute_stored_procedure(
+            sproc="processPrompt",
+            params=[record],
+            partition_key=record['id']
+        )
+        return True, response
+    except exceptions.CosmosHttpResponseError as e:
+        error_message = f"HTTP error occurred: {str(e)}. Status code: {e.status_code}"
+        return False, error_message
+    except Exception as e:
+        error_message = f"An unexpected error occurred: {str(e)}"
+        return False, error_message
+
+def fetch_all_records():
+    try:
+        query = "SELECT * FROM c"
+        items = list(container.query_items(query=query, enable_cross_partition_query=True))
+        return pd.DataFrame(items)
+    except exceptions.CosmosHttpResponseError as e:
+        st.error(f"HTTP error occurred while fetching records: {str(e)}. Status code: {e.status_code}")
+        return pd.DataFrame()
+    except Exception as e:
+        st.error(f"An unexpected error occurred while fetching records: {str(e)}")
+        return pd.DataFrame()
+
+def update_record(updated_record):
+    try:
+        container.upsert_item(body=updated_record)
+        return True, f"Record with id {updated_record['id']} successfully updated."
+    except exceptions.CosmosHttpResponseError as e:
+        return False, f"HTTP error occurred: {str(e)}. Status code: {e.status_code}"
+    except Exception as e:
+        return False, f"An unexpected error occurred: {traceback.format_exc()}"
+
+def delete_record(name, id):
+    try:
+        container.delete_item(item=id, partition_key=id)
+        return True, f"Successfully deleted record with name: {name} and id: {id}"
+    except exceptions.CosmosResourceNotFoundError:
+        return False, f"Record with id {id} not found. It may have been already deleted."
+    except exceptions.CosmosHttpResponseError as e:
+        return False, f"HTTP error occurred: {str(e)}. Status code: {e.status_code}"
+    except Exception as e:
+        return False, f"An unexpected error occurred: {traceback.format_exc()}"
+
+# New function to archive all databases and containers
 def archive_all_data(client):
-    """
-    📦 Archive all your data—pack it up, pack it in!
-    """
     try:
         base_dir = "./cosmos_archive"
         if os.path.exists(base_dir):
@@ -175,457 +150,208 @@ def archive_all_data(client):
         
         return get_base64_download_link(f"{archive_name}.zip", f"{archive_name}.zip")
     except Exception as e:
-        st.error(f"🚨 An error occurred while archiving data: {str(e)}")
-
-def download_all_code():
-    """
-    💾 Download all the code—because sharing is caring!
-    """
+        return f"An error occurred while archiving data: {str(e)}"
+
+# Streamlit app
+st.title("🌟 Cosmos DB and GitHub Integration")
+
+# Initialize session state
+if 'logged_in' not in st.session_state:
+    st.session_state.logged_in = False
+if 'selected_records' not in st.session_state:
+    st.session_state.selected_records = []
+
+# Login section
+if not st.session_state.logged_in:
+    st.subheader("🔐 Login")
+    input_key = Key
+    if st.button("🚀 Login"):
+        if input_key:
+            st.session_state.primary_key = input_key
+            st.session_state.logged_in = True
+            st.rerun()
+        else:
+            st.error("Invalid key. Please check your environment variables.")
+else:
+    # Initialize Cosmos DB client
     try:
-        base_dir = "."
-        exclude_dirs = ['.git', '__pycache__', 'cosmos_archive']
-        exclude_files = ['.env', '.gitignore', 'cosmos_archive.zip']
-
-        zip_filename = f"CosmosDBAICode_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
-        shutil.make_archive(zip_filename[:-4], 'zip', base_dir)
-        return get_base64_download_link(zip_filename, zip_filename)
+        client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
+        database = client.get_database_client(DATABASE_NAME)
+        container = database.get_container_client(CONTAINER_NAME)
+    except exceptions.CosmosHttpResponseError as e:
+        st.error(f"Failed to connect to Cosmos DB. HTTP error: {str(e)}. Status code: {e.status_code}")
+        st.stop()
     except Exception as e:
-        st.error(f"🚨 An error occurred while creating the code archive: {str(e)}")
-
-def render_sidebar(client, structure):
-    """
-    🎛️ Render the cosmic sidebar—control your destiny!
-    """
-    st.sidebar.title("🌌 Cosmic Control Panel")
-
-    # 🚦 Navigation
-    app_mode = st.sidebar.radio("🚀 Choose Your Adventure", ["App Mode 🌟", "Tutorial Mode 📖"])
-
-    if app_mode == "App Mode 🌟":
-        # 🗄️ Database and Container selection
-        selected_db = st.sidebar.selectbox("🗄️ Select Database", list(structure.keys()))
-        selected_container = st.sidebar.selectbox("📦 Select Container", structure[selected_db])
-        
-        # 📝 Fetch items for the selected container
-        items = fetch_items(client, selected_db, selected_container)
-        
-        # 📄 Item selection
-        item_ids = [item['id'] for item in items]
-        selected_item = st.sidebar.selectbox("📄 Select Item", ["Create New Item"] + item_ids)
-        
-        # 🎬 Action buttons
-        if selected_item != "Create New Item":
-            if st.sidebar.button("✏️ Edit Item"):
-                st.session_state.action = "edit"
-                st.session_state.selected_item = selected_item
-            if st.sidebar.button("🗑️ Delete Item"):
-                st.session_state.action = "delete"
-                st.session_state.selected_item = selected_item
-        else:
-            if st.sidebar.button("🌱 Create New Item"):
-                st.session_state.action = "create"
-        
-        # 🐙 GitHub Operations
-        st.sidebar.subheader("🐙 GitHub Operations")
-        source_repo = st.sidebar.text_input("🔗 Source Repo URL")
-        new_repo_name = st.sidebar.text_input("🆕 New Repo Name", value=f"Clone-{datetime.now().strftime('%Y%m%d_%H%M%S')}")
-        
-        if st.sidebar.button("📥 Clone Repository"):
-            clone_github_repo(source_repo, new_repo_name)
-        
-        if st.sidebar.button("📤 Push to New Repository"):
-            push_to_new_repo(source_repo, new_repo_name)
-        
-        # 📦 Archive data button
-        if st.sidebar.button("📦 Archive All Data"):
-            download_link = archive_all_data(client)
-            st.sidebar.markdown(download_link, unsafe_allow_html=True)
-        
-        # 💾 Download All Code button
-        if st.sidebar.button("💾 Download All Code"):
-            download_link = download_all_code()
-            st.sidebar.markdown(download_link, unsafe_allow_html=True)
-        
-        # 🚪 Logout button
-        if st.sidebar.button("🚪 Logout"):
-            st.session_state.logged_in = False
-            st.session_state.action = None
-            st.session_state.selected_item = None
-            st.rerun()
-        
-        return selected_db, selected_container, selected_item, app_mode
-    else:
-        # For tutorial mode
-        return None, None, None, app_mode
-
-def clone_github_repo(source_repo, new_repo_name):
-    """
-    📥 Clone a GitHub repo—it's like magic!
-    """
-    if GITHUB_TOKEN and source_repo:
-        try:
-            local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-            download_github_repo(source_repo, local_path)
-            zip_filename = f"{new_repo_name}.zip"
-            shutil.make_archive(zip_filename[:-4], 'zip', local_path)
-            st.sidebar.markdown(get_base64_download_link(zip_filename, zip_filename), unsafe_allow_html=True)
-            st.sidebar.success("🎉 Repository cloned successfully!")
-        except Exception as e:
-            st.sidebar.error(f"🚨 An error occurred: {str(e)}")
-        finally:
-            if os.path.exists(local_path):
-                shutil.rmtree(local_path)
-            if os.path.exists(zip_filename):
-                os.remove(zip_filename)
-    else:
-        st.sidebar.error("🚨 Please ensure GitHub token is set and source repository URL is provided.")
-
-def push_to_new_repo(source_repo, new_repo_name):
-    """
-    📤 Push to a new GitHub repo—reach for the stars!
-    """
-    if GITHUB_TOKEN and source_repo:
-        try:
-            new_repo = create_repo(GITHUB_TOKEN, new_repo_name)
-            local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
-            download_github_repo(source_repo, local_path)
-            push_to_github(local_path, new_repo, GITHUB_TOKEN)
-            st.sidebar.success(f"🚀 Repository pushed successfully to {new_repo.html_url}")
-        except Exception as e:
-            st.sidebar.error(f"🚨 An error occurred: {str(e)}")
-        finally:
-            if os.path.exists(local_path):
-                shutil.rmtree(local_path)
-    else:
-        st.sidebar.error("🚨 Please ensure GitHub token is set and source repository URL is provided.")
-
-def main():
-    """
-    🛸 Main function—where all the magic happens!
-    """
-    st.set_page_config(layout="wide")
-    st.title("🚀 Cosmos DB & GitHub Integration App with Streamlit 🎉")
-
-    # Initialize session state
-    if 'logged_in' not in st.session_state:
-        st.session_state.logged_in = False
-    if 'action' not in st.session_state:
-        st.session_state.action = None
-    if 'selected_item' not in st.session_state:
-        st.session_state.selected_item = None
-
-    # Login section
-    if not st.session_state.logged_in:
-        st.subheader("🔐 Login to Your Cosmic Account")
-        if st.button("🚀 Launch"):
-            if Key:
-                
-                st.session_state.primary_key = Key
-                st.session_state.logged_in = True
-                st.rerun()
-            else:
-                st.error("🚨 Invalid key. Please check your environment variables.")
-    else:
-        # Initialize Cosmos DB client
-        try:
-            client = CosmosClient(ENDPOINT, credential=st.session_state.primary_key)
-            # Fetch database structure
-            structure = fetch_db_structure(client)
-            # Render sidebar and get selections
-            selected_db, selected_container, selected_item, app_mode = render_sidebar(client, structure)
-            
-            if app_mode == "App Mode 🌟":
-                # Main area
-                if st.session_state.action == "create":
-                    create_item(client, selected_db, selected_container)
-                elif st.session_state.action == "edit":
-                    edit_item(client, selected_db, selected_container, st.session_state.selected_item)
-                elif st.session_state.action == "delete":
-                    delete_item(client, selected_db, selected_container, st.session_state.selected_item)
-                else:
-                    st.write("🌟 Select an action from the sidebar to get started.")
-            elif app_mode == "Tutorial Mode 📖":
-                display_tutorial()
-        except exceptions.CosmosHttpResponseError as e:
-            st.error(f"🚨 Failed to connect to Cosmos DB: {str(e)}")
-        except Exception as e:
-            st.error(f"🚨 An unexpected error occurred: {str(e)}")
-
-def display_tutorial():
-    """
-    📖 Display the in-app tutorial—knowledge is power!
-    """
-    st.header("📖 Welcome to the Cosmic Tutorial!")
-
-    st.markdown("""
-    ### 🚀 Introduction
-    
-    **Greetings, Earthling!** 👽 Ready to embark on a cosmic journey through the universe of Azure Cosmos DB and GitHub? Buckle up! This tutorial is not just informative—it's a blast! 🎆
-    
-    **What You'll Learn:**
-    
-    - 🌌 Connecting to **Azure Cosmos DB** using Python—no rocket science degree required!
-    - 🛠️ Performing **CRUD operations** on Cosmos DB containers—because you can!
-    - 🐙 Integrating **GitHub functionalities** within the app—unleash the octopus!
-    - 🎨 Building an interactive UI with **Streamlit**—your canvas awaits!
-    
-    ---
-    
-    ### 🌟 Prerequisites
-    
-    Before we launch into space, make sure you've got:
-
-    - 🛰️ An **Azure Cosmos DB** account—your mission control.
-    - 🐙 A **GitHub** account with a personal access token—tentacles not included.
-    - 🐍 **Python 3.7+** installed—because snakes are cool.
-    - 🧠 Basic knowledge of Python and Streamlit—you've got this!
-    
-    ---
+        st.error(f"An unexpected error occurred while connecting to Cosmos DB: {str(e)}")
+        st.stop()
+
+    # GitHub section
+    st.subheader("🐙 GitHub Operations")
+    github_token = os.environ.get("GITHUB")  # Read GitHub token from environment variable
+    source_repo = st.text_input("Source GitHub Repository URL", value="https://github.com/AaronCWacker/AIExamples-8-24-Streamlit")
+    new_repo_name = st.text_input("New Repository Name (for cloning)", value=f"AIExample-Clone-{datetime.now().strftime('%Y%m%d_%H%M%S')}")
     
-    ### 🛠️ Setting Up the Environment
-    
-    **1. Clone the Repository**
-
-    Open your terminal and run:
-
-    """)
-    st.code("""
-    git clone https://github.com/yourusername/cosmosdb-streamlit-app.git
-    cd cosmosdb-streamlit-app
-    """, language='bash')
-
-    st.markdown("""
-    **2. Create a Virtual Environment**
-
-    Let's keep things tidy:
-
-    """)
-    st.code("""
-    python -m venv venv
-    # On Windows
-    venv\\Scripts\\activate
-    # On macOS/Linux
-    source venv/bin/activate
-    """, language='bash')
-
-    st.markdown("""
-    **3. Install Dependencies**
-
-    Time to get those packages:
-
-    """)
-    st.code("""
-    pip install -r requirements.txt
-    """, language='bash')
-
-    st.markdown("""
-    **4. Set Up Environment Variables**
-
-    Create a `.env` file and add:
-
-    """)
-    st.code("""
-    ENDPOINT=https://your-cosmos-db-account.documents.azure.com:443/
-    PRIMARY_KEY=your_cosmos_db_primary_key
-    GITHUB_TOKEN=your_github_personal_access_token
-    """, language='text')
-
-    st.warning("⚠️ **Note:** Keep your `.env` file secret—just like your secret stash of cookies! 🍪")
-
-    st.markdown("---")
-
-    st.markdown("""
-    ### 🔧 Application Architecture
-
-    **Components:**
-
-    - 🗄️ **Cosmos DB Operations**: Functions to connect and interact with Azure Cosmos DB.
-    - 🐙 **GitHub Integration**: Clone, create, and push repositories like a boss.
-    - 🎨 **Streamlit Interface**: The front-end that brings it all together.
-    
-    **Data Flow:**
-
-    1. 🎛️ **User Interaction**: Users make choices in the app.
-    2. 🗄️ **Database Operations**: App performs actions on Cosmos DB.
-    3. 🐙 **GitHub Actions**: Clone and push repositories.
-    4. 📦 **Archiving Data**: Archive and download database contents.
-    
-    ---
-    
-    ### 🧩 Implementing the Application
-
-    **Importing Libraries**
-
-    """)
-    st.code("""
-    import streamlit as st
-    from azure.cosmos import CosmosClient, exceptions
-    import os
-    import json
-    from datetime import datetime
-    import shutil
-    from github import Github
-    from git import Repo
-    import base64
-    from dotenv import load_dotenv
-
-    load_dotenv()
-    """, language='python')
-
-    st.markdown("""
-    **Configuring Cosmos DB and GitHub**
-
-    """)
-    st.code("""
-    # Cosmos DB configuration
-    ENDPOINT = os.getenv("ENDPOINT")
-    PRIMARY_KEY = os.getenv("PRIMARY_KEY")
-
-    # GitHub configuration
-    GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
-    """, language='python')
-
-    st.markdown("""
-    **Helper Functions**
-
-    Here's where the magic happens! ✨
-
-    *GitHub Operations*
-
-    """)
-    st.code("""
-    def download_github_repo(url, local_path):
-        # Function implementation
-
-    def create_repo(github_token, repo_name):
-        # Function implementation
-
-    def push_to_github(local_path, repo, github_token):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    *Base64 Download Link*
-
-    """)
-    st.code("""
-    def get_base64_download_link(file_path, file_name):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    **Cosmos DB Operations**
-
-    *Fetching Database Structure*
-
-    """)
-    st.code("""
-    def fetch_db_structure(client):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    *CRUD Operations*
-
-    **Create Item**
-
-    """)
-    st.code("""
-    def create_item(client, db_name, container_name):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    **Edit Item**
-
-    """)
-    st.code("""
-    def edit_item(client, db_name, container_name, item_id):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    **Delete Item**
-
-    """)
-    st.code("""
-    def delete_item(client, db_name, container_name, item_id):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    **Archiving Data**
-
-    """)
-    st.code("""
-    def archive_all_data(client):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    **Streamlit Interface**
-
-    *Rendering the Sidebar*
-
-    """)
-    st.code("""
-    def render_sidebar(client, structure):
-        # Function implementation
-    """, language='python')
-
-    st.markdown("""
-    *Main Function*
-
-    """)
-    st.code("""
-    def main():
-        # Function implementation
-
-    if __name__ == "__main__":
-        main()
-    """, language='python')
-
-    st.markdown("---")
-
-    st.markdown("""
-    ### 🚀 Running the Application
-
-    **Start the Streamlit App**
-
-    """)
-    st.code("""
-    streamlit run CosmicApp.py
-    """, language='bash')
-
-    st.markdown("""
-    **Login**
+    col1, col2 = st.columns(2)
+    with col1:
+        if st.button("📥 Clone Repository"):
+            if github_token and source_repo:
+                try:
+                    local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                    download_github_repo(source_repo, local_path)
+                    zip_filename = f"{new_repo_name}.zip"
+                    create_zip_file(local_path, zip_filename[:-4])
+                    st.markdown(get_base64_download_link(zip_filename, zip_filename), unsafe_allow_html=True)
+                    st.success("Repository cloned successfully!")
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")
+                finally:
+                    if os.path.exists(local_path):
+                        shutil.rmtree(local_path)
+                    if os.path.exists(zip_filename):
+                        os.remove(zip_filename)
+            else:
+                st.error("Please ensure GitHub token is set in environment variables and source repository URL is provided.")
+
+    with col2:
+        if st.button("📤 Push to New Repository"):
+            if github_token and source_repo:
+                try:
+                    g = Github(github_token)
+                    new_repo = create_repo(g, new_repo_name)
+                    local_path = f"./temp_repo_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+                    download_github_repo(source_repo, local_path)
+                    push_to_github(local_path, new_repo, github_token)
+                    st.success(f"Repository pushed successfully to {new_repo.html_url}")
+                except Exception as e:
+                    st.error(f"An error occurred: {str(e)}")
+                finally:
+                    if os.path.exists(local_path):
+                        shutil.rmtree(local_path)
+            else:
+                st.error("Please ensure GitHub token is set in environment variables and source repository URL is provided.")
 
-    - Open your browser and go to `http://localhost:8501`.
-    - Click **Launch** to enter the app.
-    
-    **Using the App**
-
-    - **Database Selection**: Choose your database and container from the sidebar.
-    - **Item Operations**:
-      - 🌱 **Create New Item**
-      - ✏️ **Edit Item**
-      - 🗑️ **Delete Item**
-    - **GitHub Operations**:
-      - 📥 **Clone Repository**
-      - 📤 **Push to New Repository**
-    - **Archive Data**: Click **📦 Archive All Data** to download a ZIP file.
-    - **Download Code**: Click **💾 Download All Code** to get the app's source code.
-
-    ---
+    # Cosmos DB Operations
+    st.subheader("☁️ Cosmos DB Operations")
     
-    ### 🌠 Conclusion
+    # Archive all data
+    if st.button("📦 Archive All Cosmos DB Data"):
+        download_link = archive_all_data(client)
+        st.markdown(download_link, unsafe_allow_html=True)
 
-    You've reached the end of our cosmic tutorial! 🚀 We hope you had a stellar time learning and exploring the universe of Cosmos DB and GitHub integration.
+    # Fetch and display all records
+    st.subheader("📊 All Records")
+    df = fetch_all_records()
 
-    **Keep Reaching for the Stars!** 🌟
+    if df.empty:
+        st.write("No records found in the database.")
+    else:
+        st.write("Records:")
+        for index, row in df.iterrows():
+            col1, col2, col3 = st.columns([5, 1, 1])
+
+            with col1:
+                st.write(f"ID: {row['id']}, Name: {row['name']}, Document: {row['document']}, "
+                         f"Evaluation Text: {row['evaluationText']}, Evaluation Score: {row['evaluationScore']}")
+
+            with col2:
+                key = f"select_{row['id']}"
+                if st.button(f"👉 Select", key=key):
+                    st.session_state.selected_record = row.to_dict()
+
+            with col3:
+                if st.button(f"🗑️ Delete", key=f"delete_{row['id']}"):
+                    success, message = delete_record(row['name'], row['id'])
+                    if success:
+                        st.success(message)
+                        st.rerun()
+                    else:
+                        st.error(message)
+
+    # Display selected record for editing
+    if 'selected_record' in st.session_state and st.session_state.selected_record:
+        selected_record = st.session_state.selected_record
+
+        st.subheader(f"Editing Record - ID: {selected_record['id']}")
+
+        updated_name = st.text_input("Name", value=selected_record['name'])
+        updated_document = st.text_area("Document", value=selected_record['document'])
+        updated_evaluation_text = st.text_area("Evaluation Text", value=selected_record['evaluationText'])
+        updated_evaluation_score = st.text_input("Evaluation Score", value=str(selected_record['evaluationScore']))
+
+        if st.button("💾 Save Changes"):
+            updated_record = {
+                "id": selected_record['id'],
+                "name": updated_name,
+                "document": updated_document,
+                "evaluationText": updated_evaluation_text,
+                "evaluationScore": updated_evaluation_score
+            }
+
+            success, message = update_record(updated_record)
+            if success:
+                st.success(message)
+                st.session_state.selected_record = updated_record
+            else:
+                st.error(message)
+
+    # Input fields for new record
+    st.subheader("📝 Enter New Record Details")
+    new_id = st.text_input("ID")
+    new_name = st.text_input("Name")
+    new_document = st.text_area("Document")
+    new_evaluation_text = st.text_area("Evaluation Text")
+    new_evaluation_score = st.text_input("Evaluation Score")
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        if st.button("💾 Insert Record"):
+            record = {
+                "id": new_id,
+                "name": new_name,
+                "document": new_document,
+                "evaluationText": new_evaluation_text,
+                "evaluationScore": new_evaluation_score
+            }
+
+            success, response = insert_record(record)
+            if success:
+                st.success("✅ Record inserted successfully!")
+                st.json(response)
+            else:
+                st.error(f"❌ Failed to insert record: {response}")
+            st.rerun()
 
-    ---
-    """)
+    with col2:
+        if st.button("🔧 Call Procedure"):
+            record = {
+                "id": new_id,
+                "name": new_name,
+                "document": new_document,
+                "evaluationText": new_evaluation_text,
+                "evaluationScore": new_evaluation_score
+            }
+
+            success, response = call_stored_procedure(record)
+            if success:
+                st.success("✅ Stored procedure executed successfully!")
+                st.json(response)
+            else:
+                st.error(f"❌ Failed to execute stored procedure: {response}")
 
-if __name__ == "__main__":
-    main()
+    # Logout button
+    if st.button("🚪 Logout"):
+        st.session_state.logged_in = False
+        st.session_state.selected_records.clear()
+        st.session_state.selected_record = None
+        st.rerun()
+
+    # Display connection info
+    st.sidebar.subheader("🔗 Connection Information")
+    st.sidebar.text(f"Endpoint: {ENDPOINT}")
+    st.sidebar.text(f"Subscription ID: {SUBSCRIPTION_ID}")
+    st.sidebar.text(f"Database: {DATABASE_NAME}")
+    st.sidebar.text(f"Container: {CONTAINER_NAME}")
+
+#if __name__ == "__main__":
+#    st.write("Application is running")