Rename app.py to Files.Backup.AuthWorksapp.py

Files.Backup.AuthWorksapp.py

@@ -0,0 +1,162 @@
+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'
+REDIRECT_URI = 'https://huggingface.co/spaces/awacke1/MSGraphAPI'
+
+# Define product to scope mapping
+PRODUCT_SCOPES = {
+    "📧 Outlook": ['Mail.Read', 'Mail.Send', 'Calendars.ReadWrite'],
+    "📒 OneNote": ['Notes.Read', 'Notes.Create'],
+    "📊 Excel": ['Files.ReadWrite.All'],
+    "📄 Word": ['Files.ReadWrite.All'],
+    "🗃️ SharePoint": ['Sites.Read.All', 'Sites.ReadWrite.All'],
+    "📅 Teams": ['Team.ReadBasic.All', 'Channel.ReadBasic.All'],
+    "💬 Viva": ['Analytics.Read'],
+    "🚀 Power Platform": ['Flow.Read.All'],
+    "🧠 Copilot": ['Cognitive.Read'],
+    "🗂️ OneDrive": ['Files.ReadWrite.All'],
+    "💡 PowerPoint": ['Files.ReadWrite.All'],
+    "📚 Microsoft Bookings": ['Bookings.Read.All', 'Bookings.ReadWrite.All'],
+    "📓 Loop": ['Files.ReadWrite.All'],
+    "🗣️ Translator": ['Translation.Read'],
+    "📋 To Do & Planner": ['Tasks.ReadWrite'],
+    "🔗 Azure OpenAI Service": ['AzureAIServices.ReadWrite.All']
+}
+
+# Always include these base scopes
+BASE_SCOPES = ['User.Read', 'openid', 'profile', 'offline_access']
+
+# 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
+
+def get_msal_app(code_challenge=None):
+    return msal.PublicClientApplication(
+        client_id=APPLICATION_ID_KEY,
+        authority=AUTHORITY_URL
+    )
+
+# Function to get access token
+def get_access_token(code, code_verifier):
+    client_instance = get_msal_app()
+    
+    try:
+        result = client_instance.acquire_token_by_authorization_code(
+            code=code,
+            scopes=st.session_state.get('scopes', BASE_SCOPES),
+            redirect_uri=REDIRECT_URI,
+            code_verifier=code_verifier
+        )
+        
+        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
+
+# Main application function
+def main():
+    st.title("🦄 MS Graph API with AI & Cloud Integration for M365")
+
+    # Sidebar for product selection
+    st.sidebar.title("📝 M365 Products")
+    st.sidebar.write("Select products to integrate:")
+    
+    selected_products = {}
+    for product in PRODUCT_SCOPES.keys():
+        selected = st.sidebar.checkbox(product)
+        if selected:
+            selected_products[product] = True
+
+    # Dynamically build scopes based on selected products
+    scopes = BASE_SCOPES.copy()
+    for product in selected_products:
+        scopes.extend(PRODUCT_SCOPES[product])
+    scopes = list(set(scopes))  # Remove duplicates
+    st.session_state['scopes'] = scopes
+
+    # Authentication flow
+    if 'access_token' not in st.session_state:
+        if 'code_verifier' not in st.session_state:
+            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('=')
+        
+        client_instance = get_msal_app()
+        auth_url = client_instance.get_authorization_request_url(
+            scopes=scopes,
+            redirect_uri=REDIRECT_URI,
+            code_challenge=code_challenge,
+            code_challenge_method="S256"
+        )
+        st.write('👋 Please [click here]({}) to log in and authorize the app.'.format(auth_url))
+        
+        # Check for authorization code in query parameters
+        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, code_verifier)
+                st.session_state['access_token'] = access_token
+                st.success("Access token acquired successfully!")
+                st.rerun()
+            except Exception as e:
+                st.error(f"Error acquiring access token: {str(e)}")
+                st.stop()
+    else:
+        # User is authenticated, proceed with the app
+        access_token = st.session_state['access_token']
+        
+        # Greet the user
+        user_info = get_user_info(access_token)
+        if user_info:
+            st.sidebar.write(f"👋 Hello, {user_info.get('displayName', 'User')}!")
+        
+        # Handle selected products
+        if selected_products:
+            st.header("🧩 M365 Product Integrations")
+            for product in selected_products:
+                st.subheader(f"{product}")
+                handle_product_integration(access_token, product)
+        else:
+            st.write("No products selected. Please select products from the sidebar.")
+
+# Function to get user info
+def get_user_info(access_token):
+    headers = {'Authorization': f'Bearer {access_token}'}
+    response = requests.get('https://graph.microsoft.com/v1.0/me', headers=headers)
+    if response.status_code == 200:
+        return response.json()
+    else:
+        st.error('Failed to fetch user info.')
+        return None
+
+# Function to handle product integration
+def handle_product_integration(access_token, product):
+    # Implement the integration logic for each product here
+    # This is a placeholder - you'll need to implement the actual API calls
+    st.write(f"Integrating {product}...")
+    # Example: if product == "📧 Outlook": get_outlook_data(access_token)
+
+# Run the main function
+if __name__ == "__main__":
+    main()

app.py

@@ -1,209 +0,0 @@
-import os
-import streamlit as st
-import requests
-import msal
-import secrets
-from urllib.parse import urlencode
-from datetime import datetime, timedelta
-
-# 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', 'Files.ReadWrite.All']
-
-# MSAL setup
-def get_msal_app():
-    return msal.ConfidentialClientApplication(
-        client_id=APPLICATION_ID,
-        client_credential=CLIENT_SECRET,
-        authority=AUTHORITY
-    )
-
-# Authentication functions
-def generate_auth_url():
-    msal_app = get_msal_app()
-    state = secrets.token_urlsafe(32)
-    auth_url = msal_app.get_authorization_request_url(
-        scopes=SCOPES,
-        redirect_uri=REDIRECT_URI,
-        state=state
-    )
-    new_query_params = st.query_params.to_dict()
-    new_query_params['auth_state'] = state
-    return f"{auth_url}&{urlencode(new_query_params)}"
-
-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')}")
-
-# API call function
-def make_api_call(endpoint, token, method='GET', data=None):
-    headers = {'Authorization': f'Bearer {token}', 'Content-Type': 'application/json'}
-    url = f'https://graph.microsoft.com/v1.0/{endpoint}'
-    
-    if method == 'GET':
-        response = requests.get(url, headers=headers)
-    elif method == 'POST':
-        response = requests.post(url, headers=headers, json=data)
-    else:
-        raise ValueError(f"Unsupported method: {method}")
-    
-    if response.status_code in [200, 201]:
-        return response.json()
-    else:
-        st.error(f"API call failed: {response.status_code} - {response.text}")
-        return None
-
-# Product integration functions
-def handle_outlook_integration(token):
-    st.subheader("📧 Outlook Integration")
-    emails = make_api_call('me/messages?$top=5', token)
-    if emails:
-        for email in emails['value']:
-            st.write(f"Subject: {email['subject']}")
-            st.write(f"From: {email['from']['emailAddress']['name']}")
-            st.write("---")
-
-def handle_onenote_integration(token):
-    st.subheader("📒 OneNote Integration")
-    notebooks = make_api_call('me/onenote/notebooks', token)
-    if notebooks:
-        for notebook in notebooks['value']:
-            st.write(f"Notebook: {notebook['displayName']}")
-
-def handle_calendar_integration(token):
-    st.subheader("📅 Calendar Integration")
-    events = make_api_call('me/events?$top=5', token)
-    if events:
-        for event in events['value']:
-            st.write(f"Event: {event['subject']}")
-            st.write(f"Start: {event['start']['dateTime']}")
-            st.write("---")
-
-def handle_onedrive_integration(token):
-    st.subheader("🗂️ OneDrive Integration")
-    files = make_api_call('me/drive/root/children', 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("---")
-
-# Main application
-def main():
-    st.title("🦄 MS Graph API with AI & Cloud Integration for M365")
-
-    # Debug information
-    st.sidebar.write("Debug Info:")
-    st.sidebar.write(f"Query Params: {st.query_params.to_dict()}")
-
-    if 'code' in st.query_params and 'state' in st.query_params:
-        received_state = st.query_params['state']
-        expected_state = st.query_params.get('auth_state')
-        
-        if received_state != expected_state:
-            st.error(f"Invalid state parameter. Expected {expected_state}, got {received_state}")
-            st.error("Please try logging in again.")
-            st.query_params.clear()
-            st.rerun()
-        
-        try:
-            token = get_token_from_code(st.query_params['code'])
-            st.session_state['token'] = token
-            st.query_params.clear()
-            st.success("Successfully authenticated!")
-            st.rerun()
-        except Exception as e:
-            st.error(f"Authentication failed: {str(e)}")
-            st.query_params.clear()
-            st.rerun()
-
-    if 'token' not in st.session_state:
-        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
-    token = st.session_state['token']['access_token']
-    st.sidebar.success("Authenticated successfully!")
-    
-    # Display user info
-    user_info = make_api_call('me', token)
-    if user_info:
-        st.sidebar.write(f"Welcome, {user_info.get('displayName', 'User')}!")
-
-    # App navigation
-    st.sidebar.title("Navigation")
-    app_mode = st.sidebar.selectbox("Choose the app mode",
-        ["Dashboard", "Product Integration", "Event Management"])
-
-    if app_mode == "Dashboard":
-        st.header("📊 Dashboard")
-        # Add dashboard widgets here
-
-    elif app_mode == "Product Integration":
-        st.header("🧩 Product Integration")
-        products = {
-            "📧 Outlook": handle_outlook_integration,
-            "📒 OneNote": handle_onenote_integration,
-            "📅 Calendar": handle_calendar_integration,
-            "🗂️ OneDrive": handle_onedrive_integration
-        }
-        
-        for product, handler in products.items():
-            if st.checkbox(f"Enable {product}"):
-                handler(token)
-
-    elif app_mode == "Event Management":
-        st.header("📅 Event Management")
-        event_action = st.radio("Choose an action", ["View Upcoming Events", "Add New Event"])
-
-        if event_action == "View Upcoming Events":
-            events = make_api_call('me/events?$top=10&$orderby=start/dateTime', token)
-            if events:
-                for event in events['value']:
-                    st.write(f"Event: {event['subject']}")
-                    st.write(f"Start: {event['start']['dateTime']}")
-                    st.write("---")
-
-        elif event_action == "Add New Event":
-            subject = st.text_input("Event Subject")
-            start_date = st.date_input("Start Date")
-            start_time = st.time_input("Start Time")
-            duration = st.number_input("Duration (hours)", min_value=0.5, max_value=8.0, step=0.5)
-            
-            if st.button("Add Event"):
-                start_datetime = datetime.combine(start_date, start_time)
-                end_datetime = start_datetime + timedelta(hours=duration)
-                
-                event_data = {
-                    "subject": subject,
-                    "start": {
-                        "dateTime": start_datetime.isoformat(),
-                        "timeZone": "UTC"
-                    },
-                    "end": {
-                        "dateTime": end_datetime.isoformat(),
-                        "timeZone": "UTC"
-                    }
-                }
-                
-                result = make_api_call('me/events', token, method='POST', data=event_data)
-                if result:
-                    st.success("Event added successfully!")
-                else:
-                    st.error("Failed to add event.")
-
-if __name__ == "__main__":
-    main()