Update app.py

app.py

@@ -2,787 +2,132 @@ import os
 import streamlit as st
 import requests
 import msal
-import urllib.parse
-import base64
-import hashlib
 import secrets
 
-# 🤓 Load environment variables (Ensure these are set!)
-APPLICATION_ID_KEY = os.getenv('APPLICATION_ID_KEY')
-CLIENT_SECRET_KEY = os.getenv('CLIENT_SECRET_KEY')
-AUTHORITY_URL = 'https://login.microsoftonline.com/common'  # Use 'common' for multi-tenant apps
-#REDIRECT_URI = 'http://localhost:8501'  # 👈 Make sure this matches your app's redirect URI
-REDIRECT_URI = 'https://huggingface.co/spaces/awacke1/MSGraphAPI'  # 👈 Make sure this matches your app's redirect URI
-
-
-# 🎯 Define the scopes your app will need
-#SCOPES = ['User.Read', 'Calendars.ReadWrite', 'Mail.ReadWrite', 'Notes.ReadWrite.All', 'Files.ReadWrite.All']
-SCOPES = ['User.Read']
-
-# New function to generate PKCE code verifier and challenge
-def generate_pkce_codes():
-    code_verifier = secrets.token_urlsafe(128)[:128]
-    code_challenge = base64.urlsafe_b64encode(hashlib.sha256(code_verifier.encode()).digest()).decode().rstrip('=')
-    return code_verifier, code_challenge
+# Configuration
+APPLICATION_ID = os.getenv('APPLICATION_ID_KEY')
+CLIENT_SECRET = os.getenv('CLIENT_SECRET_KEY')
+AUTHORITY = 'https://login.microsoftonline.com/common'
+REDIRECT_URI = 'https://huggingface.co/spaces/awacke1/MSGraphAPI'
+SCOPES = ['User.Read', 'Calendars.ReadWrite', 'Mail.ReadWrite']
 
+# MSAL setup
 def get_msal_app():
     return msal.ConfidentialClientApplication(
-        client_id=APPLICATION_ID_KEY,
-        client_credential=CLIENT_SECRET_KEY,
-        authority=AUTHORITY_URL
-    )
-    
-def get_msal_app2():
-    return msal.PublicClientApplication(
-        client_id=APPLICATION_ID_KEY,
-        authority=AUTHORITY_URL
+        client_id=APPLICATION_ID,
+        client_credential=CLIENT_SECRET,
+        authority=AUTHORITY
     )
 
-# Ensure that the code_verifier is correctly stored before redirect
-if 'code_verifier' not in st.session_state:
-    # Generate PKCE codes
-    code_verifier, code_challenge = generate_pkce_codes()
-    st.session_state['code_verifier'] = code_verifier
-else:
-    code_verifier = st.session_state['code_verifier']
-    code_challenge = base64.urlsafe_b64encode(hashlib.sha256(code_verifier.encode()).digest()).decode().rstrip('=')
-
-# Create the MSAL instance for acquiring tokens
-client_instance = get_msal_app()
-
-
-def get_access_token(code=None):
-    client_instance = get_msal_app()
-    
-    try:
-        if code:
-            # Initial token acquisition
-            result = client_instance.acquire_token_by_authorization_code(
-                code=code,
-                scopes=SCOPES,
-                redirect_uri=REDIRECT_URI
-            )
-        elif 'refresh_token' in st.session_state:
-            # Token refresh
-            result = client_instance.acquire_token_by_refresh_token(
-                refresh_token=st.session_state['refresh_token'],
-                scopes=SCOPES
-            )
-        else:
-            raise Exception("No authorization code or refresh token available")
-        
-        if 'access_token' in result:
-            st.session_state['access_token'] = result['access_token']
-            if 'refresh_token' in result:
-                st.session_state['refresh_token'] = result['refresh_token']
-            return result['access_token']
-        else:
-            error_description = result.get('error_description', 'No error description provided')
-            raise Exception(f"Error acquiring token: {error_description}")
-    except Exception as e:
-        st.error(f"Exception in get_access_token: {str(e)}")
-        raise
-        
-def get_access_token4(code):
-    client_instance = get_msal_app()
-    
-    try:
-        result = client_instance.acquire_token_by_authorization_code(
-            code=code,
-            scopes=SCOPES,
-            redirect_uri=REDIRECT_URI
-        )
-        
-        if 'access_token' in result:
-            return result['access_token']
-        else:
-            error_description = result.get('error_description', 'No error description provided')
-            raise Exception(f"Error acquiring token: {error_description}")
-    except Exception as e:
-        st.error(f"Exception in get_access_token: {str(e)}")
-        raise
-        
-def get_access_token3(code):
-    client_instance = get_msal_app()
-    
-    st.write("Debug: MSAL App Configuration:")
-    st.write(f"Client ID: {APPLICATION_ID_KEY[:5]}...")
-    st.write(f"Authority: {AUTHORITY_URL}")
-    st.write(f"Redirect URI: {REDIRECT_URI}")
-    
-    try:
-        # Without code_verifier (for testing)
-        result = client_instance.acquire_token_by_authorization_code(
-            code=code,
-            scopes=SCOPES,
-            redirect_uri=REDIRECT_URI
-        )
-        
-        if 'access_token' in result:
-            return result['access_token']
-        else:
-            error_description = result.get('error_description', 'No error description provided')
-            raise Exception(f"Error acquiring token: {error_description}")
-    except Exception as e:
-        st.error(f"Exception in get_access_token: {str(e)}")
-        raise
+# Authentication functions
+def generate_auth_url():
+    msal_app = get_msal_app()
+    state = secrets.token_urlsafe(32)
+    st.session_state['auth_state'] = state
+    return msal_app.get_authorization_request_url(
+        scopes=SCOPES,
+        redirect_uri=REDIRECT_URI,
+        state=state
+    )
 
+def get_token_from_code(code):
+    msal_app = get_msal_app()
+    result = msal_app.acquire_token_by_authorization_code(
+        code=code,
+        scopes=SCOPES,
+        redirect_uri=REDIRECT_URI
+    )
+    if 'access_token' in result:
+        return result
+    else:
+        raise Exception(f"Error acquiring token: {result.get('error_description')}")
+
+def get_token_from_cache():
+    if 'token_cache' in st.session_state:
+        msal_app = get_msal_app()
+        accounts = msal_app.get_accounts()
+        if accounts:
+            result = msal_app.acquire_token_silent(SCOPES, account=accounts[0])
+            if result:
+                return result
+    return None
+
+# API call function
+def make_api_call(endpoint, token):
+    headers = {'Authorization': f'Bearer {token}'}
+    response = requests.get(f'https://graph.microsoft.com/v1.0/{endpoint}', headers=headers)
+    if response.status_code == 200:
+        return response.json()
+    else:
+        st.error(f"API call failed: {response.status_code} - {response.text}")
+        return None
 
+# Main application
+def main():
+    st.title("🦄 MS Graph API Integration")
 
-# Now this function accepts both 'code' and 'code_verifier'
-def get_access_token2(code, code_verifier=None):
-    client_instance = get_msal_app()
-    
-    st.write("Debug: MSAL App Configuration:")
-    st.write(f"Client ID: {APPLICATION_ID_KEY[:5]}...")
-    st.write(f"Authority: {AUTHORITY_URL}")
-    st.write(f"Redirect URI: {REDIRECT_URI}")
+    # Check for authentication
+    token = get_token_from_cache()
     
-    try:
-        # Use the 'code_verifier' only if provided (for PKCE flow)
-        result = client_instance.acquire_token_by_authorization_code(
-            code=code,
-            scopes=SCOPES,
-            redirect_uri=REDIRECT_URI,
-            code_verifier=code_verifier  # Ensure this is passed only if PKCE is used
-        )
-        
-        if 'access_token' in result:
-            return result['access_token']
-        else:
-            error_description = result.get('error_description', 'No error description provided')
-            raise Exception(f"Error acquiring token: {error_description}")
-    except Exception as e:
-        st.error(f"Exception in get_access_token: {str(e)}")
-        raise
-        
-def clear_query_params():
-    # Get the current URL without query parameters
-    base_url = st.get_page_config().base_url_path
-    st.write(f'<meta http-equiv="refresh" content="0; url={base_url}">', unsafe_allow_html=True)
-    st.stop()
-
-def process_query_params():
-    query_params = st.query_params
-
-    if 'error' in query_params:
-        error = query_params.get('error')
-        error_description = query_params.get('error_description', 'No description provided')
-        st.error(f"Authentication Error: {error}")
-        st.error(f"Error Description: {urllib.parse.unquote(error_description)}")
-        st.session_state.clear()
-        st.rerun()
-
-    if 'code' in query_params and 'state' in query_params:
-        received_state = query_params.get('state')
-        if received_state != st.session_state.get('auth_state'):
+    if 'code' in st.query_params:
+        state = st.query_params.get('state')
+        if state != st.session_state.get('auth_state'):
             st.error("Invalid state parameter. Please try logging in again.")
             st.session_state.clear()
             st.rerun()
-
-        code = query_params.get('code')
+        
         try:
-            token = get_access_token(code)
-            st.session_state['access_token'] = token
+            token = get_token_from_code(st.query_params['code'])
+            st.session_state['token_cache'] = token
             st.success("Successfully authenticated!")
-            # Clear the URL parameters
-            st.experimental_set_query_params()
             st.rerun()
         except Exception as e:
-            st.error(f"Error acquiring access token: {str(e)}")
+            st.error(f"Authentication failed: {str(e)}")
             st.session_state.clear()
-            st.rerun()
-    
-def process_query_params3():
-    query_params = st.query_params
-    st.write("Debug: All query parameters:", query_params)
-
-    if 'error' in query_params:
-        error = query_params.get('error')
-        error_description = query_params.get('error_description', 'No description provided')
-        st.error(f"Authentication Error: {error}")
-        st.error(f"Error Description: {urllib.parse.unquote(error_description)}")
-        st.stop()
-
-    if 'code' in query_params:
-        code = query_params.get('code')
-        st.write('🔑 Authorization Code Obtained:', code[:10] + '...')
-        
-        try:
-            access_token = get_access_token(code)
-            st.session_state['access_token'] = access_token
-            st.success("Access token acquired successfully!")
-            # Redirect to clear query params
-            st.rerun()
-        except Exception as e:
-            st.error(f"Error acquiring access token: {str(e)}")
-            st.stop()
-
-    # Handle other query parameters as needed
-    if 'q' in query_params or 'query' in query_params:
-        query = query_params.get('q') or query_params.get('query')
-        if query:
-            # Process the query
-            pass
-
-    if 'action' in query_params:
-        action = query_params.get('action')
-        if action == 'show_message':
-            st.success("Showing a message because 'action=show_message' was found in the URL.")
-        elif action == 'clear':
-            # Instead of clearing query params, we'll redirect
-            st.rerun()
-        
-def process_query_params2():
-    # ⚙️q= Run ArXiv search from query parameters
-    try:
-        query_params = st.query_params
-        st.write("Debug: All query parameters:", query_params)
-
-        if 'error' in query_params:
-            error = query_params.get('error')
-            error_description = query_params.get('error_description', 'No description provided')
-            st.error(f"Authentication Error: {error}")
-            st.error(f"Error Description: {urllib.parse.unquote(error_description)}")
-            st.stop()
-
-        if 'code' in query_params:
-            code = query_params.get('code')
-            st.write('🔑 Authorization Code Obtained:', code[:10] + '...')
-            
-            try:
-                code_verifier = st.session_state.get('code_verifier')
-                if not code_verifier:
-                    st.error("Code verifier not found in session state.")
-                    st.stop()
-                
-                #access_token = get_access_token(code, code_verifier)
-                access_token = get_access_token(code)
-
-                
-                st.session_state['access_token'] = access_token
-                st.success("Access token acquired successfully!")
-                # Clear the code from the URL
-                st.experimental_set_query_params()
-                st.rerun()
-            except Exception as e:
-                st.error(f"Error acquiring access token: {str(e)}")
-                st.stop()
-        else:
-            st.warning("No authorization code found in the query parameters.")
-
-        
-        query = (query_params.get('q') or query_params.get('query') or [''])
-        if len(query) > 1: 
-            #result = search_arxiv(query)
-            #result2 = search_glossary(result) 
-    
-            filesearch = PromptPrefix + query
-            st.markdown(filesearch)
-            process_text(filesearch)
-    except:
-        st.markdown(' ')
-    
-    if 'action' in st.query_params:
-        action = st.query_params()['action'][0]  # Get the first (or only) 'action' parameter
-        if action == 'show_message':
-            st.success("Showing a message because 'action=show_message' was found in the URL.")
-        elif action == 'clear':
-            clear_query_params()
-            #st.rerun()
-    
-    if 'query' in st.query_params:
-        query = st.query_params['query'][0]  # Get the query parameter
-        # Display content or image based on the query
-        display_content_or_image(query)
-
-def get_user_info(access_token):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    response = requests.get('https://graph.microsoft.com/v1.0/me', headers=headers)
-    if response.status_code == 200:
-        return response.json()
-    else:
-        raise Exception(f"Failed to fetch user info: {response.status_code} - {response.text}")
-
-def generate_state():
-    state = secrets.token_urlsafe(32)
-    st.session_state['auth_state'] = state
-    return state
 
-def initiate_auth_flow():
-    client_instance = get_msal_app()
-    auth_url = client_instance.get_authorization_request_url(
-        scopes=SCOPES,
-        redirect_uri=REDIRECT_URI,
-        state=generate_state()
-    )
-    st.write('👋 Please [click here]({}) to log in and authorize the app.'.format(auth_url))
-
-def is_token_valid(token):
     if not token:
-        return False
-    try:
-        # Make a simple API call to check if the token is still valid
-        headers = {'Authorization': f'Bearer {token}'}
-        response = requests.get('https://graph.microsoft.com/v1.0/me', headers=headers)
-        return response.status_code == 200
-    except:
-        return False
-
-# 🏃‍♂️ Main application function
-def main():
-    st.title("🦄 MS Graph API with AI & Cloud Integration with M365")
-
-    process_query_params()
-
-    
-    # Check if we have a valid access token
-    if 'access_token' not in st.session_state or not is_token_valid(st.session_state.get('access_token')):
-        # If not, initiate the login process
-        initiate_auth_flow()
-        st.stop()
-
-    # If we have a valid token, proceed with the app
-    access_token = st.session_state['access_token']
-
-    
-    #added
-    if 'access_token' not in st.session_state:
-        client_instance = get_msal_app()
-        authorization_url = client_instance.get_authorization_request_url(
-            scopes=SCOPES,
-            redirect_uri=REDIRECT_URI
-        )
-        st.write('👋 Please [click here]({}) to log in and authorize the app.'.format(authorization_url))
-        st.stop()
-        
-    try:
-        # Attempt to use the access token
-        user_info = get_user_info(st.session_state['access_token'])
-    except Exception as e:
-        if "token has expired" in str(e).lower():
-            # Token expired, attempt to refresh
-            try:
-                new_token = get_access_token()  # This will use the refresh token if available
-                st.session_state['access_token'] = new_token
-                user_info = get_user_info(new_token)
-            except Exception as refresh_error:
-                st.error("Failed to refresh token. Please log in again.")
-                st.session_state.clear()
-                st.rerun()
-        
-    if 'access_token' not in st.session_state:
-        query_params = st.query_params
-        if 'code' in query_params:
-            code = query_params.get('code')
-            st.write('🔑 Authorization Code Obtained:', code[:10] + '...')
-            
-            try:
-                access_token = get_access_token(code)
-                st.session_state['access_token'] = access_token
-                st.success("Access token acquired successfully!")
-                # Instead of clearing query params, we'll redirect to remove them
-                st.rerun()
-            except Exception as e:
-                if "AADSTS70000" in str(e) and "code has expired" in str(e):
-                    st.error("The authorization code has expired. Please log in again.")
-                    st.session_state.pop('access_token', None)
-                    # Redirect to clear query params
-                    st.rerun()
-                else:
-                    st.error(f"Error acquiring access token: {str(e)}")
-                    st.stop()
-        else:
-            client_instance = get_msal_app()
-            authorization_url = client_instance.get_authorization_request_url(
-                scopes=SCOPES,
-                redirect_uri=REDIRECT_URI
-            )
-            st.write('👋 Please [click here]({}) to log in and authorize the app.'.format(authorization_url))
-            st.stop()
-    else:
-        # Rest of your code for authenticated users
-        pass
-
-
-    # 🚀 Sidebar navigation
-    st.sidebar.title("Navigation")
-    menu = st.sidebar.radio("Go to", [
-        "1️⃣ Dashboard",
-        "🏠 Landing Page",
-        "📅 Upcoming Events",
-        "📆 Schedule",
-        "📝 Agenda",
-        "🔍 Event Details",
-        "➕ Add Event",
-        "🔎 Filter By"
-    ])
-    
-    # 📝 M365 Products with MS Graph Integration & AI Features
-    st.sidebar.title("📝 M365 Products")
-    st.sidebar.write("Toggle integration for each product:")
-    
-    # 🎛️ Product Integration Toggles
-    products = {
-        "📧 Outlook": {
-            "ai_capabilities": "Copilot for enhanced email writing, calendar management, and scheduling.",
-            "graph_api": "Access to mail, calendar, contacts, and events."
-        },
-        "📒 OneNote": {
-            "ai_capabilities": "Content suggestion, note organization, and OCR for extracting text from images.",
-            "graph_api": "Manage notebooks, sections, and pages."
-        },
-        "📊 Excel": {
-            "ai_capabilities": "Copilot for advanced data analysis, data insights, and formula generation.",
-            "graph_api": "Create and manage worksheets, tables, charts, and workbooks."
-        },
-        "📄 Word": {
-            "ai_capabilities": "Copilot for document drafting, summarization, and grammar improvements.",
-            "graph_api": "Document content access, templates, and file management."
-        },
-        "🗃️ SharePoint": {
-            "ai_capabilities": "Intelligent search, document tagging, and metadata extraction.",
-            "graph_api": "Access to sites, lists, files, and document libraries."
-        },
-        "📅 Teams": {
-            "ai_capabilities": "Copilot for meeting summaries, transcription, and chat suggestions.",
-            "graph_api": "Manage chats, teams, channels, and meetings."
-        },
-        "💬 Viva": {
-            "ai_capabilities": "Personalized learning insights, well-being insights, and productivity suggestions.",
-            "graph_api": "Access to user analytics and learning modules."
-        },
-        "🚀 Power Platform": {
-            "ai_capabilities": "Automation with AI Builder, data insights, and custom AI models.",
-            "graph_api": "Automation workflows, app creation, and data visualization."
-        },
-        "🧠 Copilot": {
-            "ai_capabilities": "Embedded across Word, Excel, Outlook, Teams, and more for AI-driven productivity.",
-            "graph_api": "Underpins Copilot's access to data and integrations."
-        },
-        "🗂️ OneDrive": {
-            "ai_capabilities": "Intelligent file organization and search.",
-            "graph_api": "File and folder access, sharing, and metadata."
-        },
-        "💡 PowerPoint": {
-            "ai_capabilities": "Design suggestions, presentation summarization, and speaker coaching.",
-            "graph_api": "Presentation creation, slide management, and templates."
-        },
-        "📚 Microsoft Bookings": {
-            "ai_capabilities": "Automated scheduling and reminders.",
-            "graph_api": "Booking calendars, services, and appointment details."
-        },
-        "📓 Loop": {
-            "ai_capabilities": "Real-time collaboration and content suggestions.",
-            "graph_api": "Access to shared workspaces and collaborative pages."
-        },
-        "🗣️ Translator": {
-            "ai_capabilities": "Real-time language translation and text-to-speech.",
-            "graph_api": "Integrated into communication and translation services."
-        },
-        "📋 To Do & Planner": {
-            "ai_capabilities": "Task prioritization and smart reminders.",
-            "graph_api": "Task creation, management, and synchronization."
-        },
-        "🔗 Azure OpenAI Service": {
-            "ai_capabilities": "Access to GPT models for custom AI implementations.",
-            "graph_api": "Used indirectly for building custom AI models into workflows."
-        }
-    }
-    
-    # 🗳️ Create toggles for each product
-    selected_products = {}
-    for product, info in products.items():
-        selected = st.sidebar.checkbox(product)
-        if selected:
-            st.sidebar.write(f"**AI Capabilities:** {info['ai_capabilities']}")
-            st.sidebar.write(f"**Graph API:** {info['graph_api']}")
-            selected_products[product] = True
-    
-    # 🔑 Authentication
-    if 'access_token' not in st.session_state:
-        # 🕵️‍♂️ Check for authorization code in query parameters
-        query_params = st.query_params
-        query = (query_params.get('code'))
-        #if len(query) > 1: 
-        
-        #st.write('Parsing query ' + query_params )
-        if 'code' in query_params:
-            #code = query_params['code'][0]
-            code = query_params.get('code')
-            
-            st.write('🔑Access Code Obtained from MS Graph Redirect🔑!:' + code)
-            
-            st.write('🔑 Acquiring access token from redirect URL for code parameter.')
-            access_token = get_access_token(code)
-            
-            st.session_state['access_token'] = access_token  # 🔑 Save it for later
-            
-            st.rerun()  # Reload the app to clear the code from URL
-        else:
-            # 📢 Prompt user to log in
-            client_instance = get_msal_app()
-            authorization_url = client_instance.get_authorization_request_url(
-                scopes=SCOPES,
-                redirect_uri=REDIRECT_URI
-            )
-            st.write('👋 Please [click here]({}) to log in and authorize the app.'.format(authorization_url))
-            st.stop()
-
-                
-    else:
-        # 🥳 User is authenticated, proceed with the app
-        access_token = st.session_state['access_token']
-        headers = {'Authorization': 'Bearer ' + access_token}
-        
-        # 🤗 Greet the user
-        response = requests.get('https://graph.microsoft.com/v1.0/me', headers=headers)
-        if response.status_code == 200:
-            user_info = response.json()
-            st.sidebar.write(f"👋 Hello, {user_info['displayName']}!")
-        else:
-            st.error('Failed to fetch user info.')
-            st.write(response.text)
-        
-        # 🎛️ Handle menu options
-        if menu == "1️⃣ Dashboard with Widgets":
-            st.header("1️⃣ Dashboard with Widgets")
-            st.write("Widgets will be displayed here. 🎛️")
-            # Add your widgets here
-        
-        elif menu == "🏠 Landing Page":
-            st.header("🏠 Landing Page")
-            st.write("Welcome to the app! 🥳")
-            # Add landing page content here
-        
-        elif menu == "📅 Upcoming Events":
-            st.header("📅 Upcoming Events")
-            events = get_upcoming_events(access_token)
-            for event in events:
-                st.write(f"📆 {event['subject']} on {event['start']['dateTime']}")
-            # Display upcoming events
-        
-        elif menu == "📆 Schedule":
-            st.header("📆 Schedule")
-            schedule = get_schedule(access_token)
-            st.write(schedule)
-            # Display schedule
-        
-        elif menu == "📝 Agenda":
-            st.header("📝 Agenda")
-            st.write("Your agenda for today. 📋")
-            # Display agenda
-        
-        elif menu == "🔍 Event Details":
-            st.header("🔍 Event Details")
-            event_id = st.text_input("Enter Event ID")
-            if event_id:
-                event_details = get_event_details(access_token, event_id)
-                st.write(event_details)
-            # Display event details based on ID
-        
-        elif menu == "➕ Add Event":
-            st.header("➕ Add Event")
-            event_subject = st.text_input("Event Subject")
-            event_start = st.date_input("Event Start Date")
-            event_start_time = st.time_input("Event Start Time")
-            event_end = st.date_input("Event End Date")
-            event_end_time = st.time_input("Event End Time")
-            if st.button("Add Event"):
-                event_details = {
-                    "subject": event_subject,
-                    "start": {
-                        "dateTime": f"{event_start}T{event_start_time}",
-                        "timeZone": "UTC"
-                    },
-                    "end": {
-                        "dateTime": f"{event_end}T{event_end_time}",
-                        "timeZone": "UTC"
-                    }
-                }
-                add_event(access_token, event_details)
-                st.success("Event added successfully! 🎉")
-            # Form to add new event
-        
-        elif menu == "🔎 Filter By":
-            st.header("🔎 Filter Events")
-            filter_criteria = st.text_input("Enter filter criteria")
-            if filter_criteria:
-                filtered_events = filter_events(access_token, filter_criteria)
-                for event in filtered_events:
-                    st.write(f"📅 {event['subject']} on {event['start']['dateTime']}")
-            # Filter events based on criteria
-        
-        # 🧩 Handle selected products
-        if selected_products:
-            st.header("🧩 M365 Product Integrations")
-            for product in selected_products:
-                st.subheader(f"{product}")
-                # Call the function corresponding to the product
-                handle_product_integration(access_token, product)
-        else:
-            st.write("No products selected.")
-        pass
-
-# 🧩 Function to handle product integration
-def handle_product_integration(access_token, product):
-    if product == "📧 Outlook":
-        st.write("Accessing Outlook data...")
-        # Implement Outlook integration
-        inbox_messages = get_outlook_messages(access_token)
-        st.write("Inbox Messages:")
-        for msg in inbox_messages:
-            st.write(f"✉️ {msg['subject']}")
-    elif product == "📒 OneNote":
-        st.write("Accessing OneNote data...")
-        # Implement OneNote integration
-        notebooks = get_onenote_notebooks(access_token)
-        st.write("Notebooks:")
-        for notebook in notebooks:
-            st.write(f"📔 {notebook['displayName']}")
-    elif product == "📊 Excel":
-        st.write("Accessing Excel data...")
-        # Implement Excel integration
-        st.write("Excel integration is a placeholder.")
-    elif product == "📄 Word":
-        st.write("Accessing Word documents...")
-        # Implement Word integration
-        st.write("Word integration is a placeholder.")
-    elif product == "🗃️ SharePoint":
-        st.write("Accessing SharePoint sites...")
-        # Implement SharePoint integration
-        sites = get_sharepoint_sites(access_token)
-        st.write("Sites:")
-        for site in sites:
-            st.write(f"🌐 {site['displayName']}")
-    elif product == "📅 Teams":
-        st.write("Accessing Teams data...")
-        # Implement Teams integration
-        teams = get_user_teams(access_token)
-        st.write("Teams:")
-        for team in teams:
-            st.write(f"👥 {team['displayName']}")
-    # Add additional product integrations as needed
-    else:
-        st.write(f"No integration implemented for {product}.")
-
-def get_outlook_messages():
-    messages = make_api_call('me/messages?$top=5')
-    if messages:
-        return messages.get('value', [])
-    return []
-
-    
-# 📨 Function to get Outlook messages
-def get_outlook_messages2(access_token):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    response = requests.get('https://graph.microsoft.com/v1.0/me/messages?$top=5', headers=headers)
-    if response.status_code == 200:
-        messages = response.json().get('value', [])
-        return messages
-    else:
-        st.error('Failed to fetch messages.')
-        st.write(response.text)
-        return []
-
-# 📔 Function to get OneNote notebooks
-def get_onenote_notebooks(access_token):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    response = requests.get('https://graph.microsoft.com/v1.0/me/onenote/notebooks', headers=headers)
-    if response.status_code == 200:
-        notebooks = response.json().get('value', [])
-        return notebooks
-    else:
-        st.error('Failed to fetch notebooks.')
-        st.write(response.text)
-        return []
-
-# 🌐 Function to get SharePoint sites
-def get_sharepoint_sites(access_token):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    response = requests.get('https://graph.microsoft.com/v1.0/sites?search=*', headers=headers)
-    if response.status_code == 200:
-        sites = response.json().get('value', [])
-        return sites
-    else:
-        st.error('Failed to fetch sites.')
-        st.write(response.text)
-        return []
-
-# 👥 Function to get user's Teams
-def get_user_teams(access_token):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    response = requests.get('https://graph.microsoft.com/v1.0/me/joinedTeams', headers=headers)
-    if response.status_code == 200:
-        teams = response.json().get('value', [])
-        return teams
-    else:
-        st.error('Failed to fetch teams.')
-        st.write(response.text)
-        return []
-
-def get_upcoming_events():
-    events = make_api_call('me/events?$orderby=start/dateTime&$top=10')
-    if events:
-        return events.get('value', [])
-    return []
-
-
-# 📅 Function to get upcoming events
-def get_upcoming_events2(access_token):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    response = requests.get('https://graph.microsoft.com/v1.0/me/events?$orderby=start/dateTime&$top=10', headers=headers)
-    if response.status_code == 200:
-        events = response.json().get('value', [])
-        return events
-    else:
-        st.error('Failed to fetch upcoming events.')
-        st.write(response.text)
-        return []
-
-# 📆 Function to get schedule (Placeholder)
-def get_schedule(access_token):
-    # Implement API call to get schedule
-    return "📆 Your schedule goes here."
-
-# ➕ Function to add a new event
-def add_event(access_token, event_details):
-    headers = {
-        'Authorization': 'Bearer ' + access_token,
-        'Content-Type': 'application/json'
-    }
-    response = requests.post('https://graph.microsoft.com/v1.0/me/events', headers=headers, json=event_details)
-    if response.status_code == 201:
-        st.success('Event created successfully! 🎉')
-    else:
-        st.error('Failed to create event.')
-        st.write(response.text)
-
-# 🔍 Function to get event details
-def get_event_details(access_token, event_id):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    response = requests.get(f'https://graph.microsoft.com/v1.0/me/events/{event_id}', headers=headers)
-    if response.status_code == 200:
-        event = response.json()
-        return event
-    else:
-        st.error('Failed to fetch event details.')
-        st.write(response.text)
-        return {}
+        auth_url = generate_auth_url()
+        st.write("Please log in to continue:")
+        st.markdown(f"[Login with Microsoft]({auth_url})")
+        return
+
+    # User is authenticated, show the main app
+    st.sidebar.success("Authenticated successfully!")
+    
+    # Display user info
+    user_info = make_api_call('me', token['access_token'])
+    if user_info:
+        st.sidebar.write(f"Welcome, {user_info.get('displayName', 'User')}!")
+
+    # App functionality
+    option = st.sidebar.selectbox(
+        "Choose a function",
+        ["View Emails", "View Calendar", "View OneDrive Files"]
+    )
 
-# 🔎 Function to filter events
-def filter_events(access_token, filter_criteria):
-    headers = {'Authorization': 'Bearer ' + access_token}
-    # Implement filtering logic based on criteria
-    response = requests.get(f"https://graph.microsoft.com/v1.0/me/events?$filter=startswith(subject,'{filter_criteria}')", headers=headers)
-    if response.status_code == 200:
-        events = response.json().get('value', [])
-        return events
-    else:
-        st.error('Failed to filter events.')
-        st.write(response.text)
-        return []
+    if option == "View Emails":
+        emails = make_api_call('me/messages?$top=10', token['access_token'])
+        if emails:
+            for email in emails['value']:
+                st.write(f"Subject: {email['subject']}")
+                st.write(f"From: {email['from']['emailAddress']['name']}")
+                st.write("---")
+
+    elif option == "View Calendar":
+        events = make_api_call('me/events?$top=10', token['access_token'])
+        if events:
+            for event in events['value']:
+                st.write(f"Event: {event['subject']}")
+                st.write(f"Start: {event['start']['dateTime']}")
+                st.write("---")
+
+    elif option == "View OneDrive Files":
+        files = make_api_call('me/drive/root/children', token['access_token'])
+        if files:
+            for file in files['value']:
+                st.write(f"File: {file['name']}")
+                st.write(f"Type: {file['file']['mimeType'] if 'file' in file else 'Folder'}")
+                st.write("---")
 
-# 🚀 Run the main function
 if __name__ == "__main__":
-    main()
+    main()