Create app.py

app.py

@@ -0,0 +1,941 @@
+# app.py
+import streamlit as st
+import pandas as pd
+import sqlite3
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+from datetime import datetime as dt, timedelta
+import calendar
+import plotly.graph_objects as go
+from PIL import Image
+import datetime
+from google.oauth2 import service_account
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from streamlit_calendar import calendar
+import pytz
+
+# ---------------------------------
+# Meeting room details
+# ---------------------------------
+meeting_rooms = [
+    "Meeting Room (Floor 1)",
+    "Meeting Room (Floor 2)",
+    "Meeting Room (Floor 3)"
+]
+
+# ---------------------------------
+# Reset points at the beginning of each month
+# ---------------------------------
+def reset_points(username):
+    current_month = dt.now().strftime("%Y-%m")
+    cursor.execute('SELECT last_reset FROM members WHERE username = ?', (username,))
+    last_reset = cursor.fetchone()
+    
+    if last_reset is None or last_reset[0] != current_month:
+        cursor.execute('UPDATE members SET points = 50, last_reset = ? WHERE username = ?', (current_month, username))
+        conn.commit()
+
+# ---------------------------------
+# CONFIGURATION (Set your values here)
+# ---------------------------------
+CREDENTIALS_FILE = "credentials.json"  
+CALENDAR_ID = "growork3@gmail.com"
+TIME_ZONE = "GMT+5"
+
+# Super Admin credentials
+SUPER_ADMIN_USERNAME = "superadmin"
+SUPER_ADMIN_PASSWORD = "superadmin123"
+
+# Admin credentials
+ADMIN_USERNAME = "admin"
+ADMIN_PASSWORD = "admin123"
+
+# Custom CSS to hide the sidebar on the login page
+hide_sidebar_css = """
+    <style>
+        section[data-testid="stSidebar"] {
+            display: none;
+        }
+    </style>
+"""
+
+st.set_page_config(page_title="GroWork", page_icon="Logo1.png")
+
+# Database connection
+conn = sqlite3.connect('growork.db', check_same_thread=False)
+cursor = conn.cursor()
+
+# ---------------------------------
+# GOOGLE CALENDAR API AUTHENTICATION
+# ---------------------------------
+def authenticate_google():
+    creds = service_account.Credentials.from_service_account_file(
+        CREDENTIALS_FILE, scopes=["https://www.googleapis.com/auth/calendar"]
+    )
+    return build("calendar", "v3", credentials=creds)
+
+calendar_service = authenticate_google()
+
+# ---------------------------------
+# FETCH BOOKINGS FROM GOOGLE CALENDAR
+# ---------------------------------
+def get_calendar_events():
+    try:
+        now = datetime.datetime.utcnow().isoformat() + "Z"
+        events_result = calendar_service.events().list(
+            calendarId=CALENDAR_ID, timeMin=now, maxResults=100, singleEvents=True, orderBy="startTime"
+        ).execute()
+        events = events_result.get("items", [])
+        bookings = []
+        for event in events:
+            start_time = event["start"].get("dateTime", event["start"].get("date"))
+            end_time = event["end"].get("dateTime", event["end"].get("date"))
+            summary = event.get("summary", "No Title")
+            event_id = event.get("id")
+            # Extract room from summary (format: "username (room)")
+            room = summary.split("(")[-1].rstrip(")") if "(" in summary else "Unknown Room"
+            bookings.append({"Start": start_time, "End": end_time, "Booked By": summary.split(" ")[0], "Event ID": event_id, "Room": room})
+        return pd.DataFrame(bookings)
+    except HttpError as error:
+        st.error(f"An error occurred: {error}")
+        return pd.DataFrame(columns=["Start", "End", "Booked By", "Event ID", "Room"])
+
+# ---------------------------------
+# FETCH MEMBER CREDENTIALS FROM DATABASE
+# ---------------------------------
+def fetch_member_credentials():
+    """
+    Fetch all member usernames and passwords from the database.
+    """
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT username, password, email_id FROM members")
+    members = cursor.fetchall()
+    conn.close()
+    
+    # Convert the result into a dictionary for easy lookup
+    member_credentials = {username: password for username, password, _ in members}
+    member_emails = {username: email for username, _, email in members}
+    
+    return member_credentials, member_emails
+
+# ---------------------------------
+# INITIALIZE DATABASE
+# ---------------------------------
+def initialize_db():
+    # Create the members table if it doesn't exist
+    cursor.execute('''CREATE TABLE IF NOT EXISTS members (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        full_name TEXT,
+                        cnic TEXT,
+                        company_name TEXT,
+                        contact_number TEXT,
+                        email_id TEXT,
+                        rooms_booked INTEGER,
+                        room_id_floor TEXT,
+                        username TEXT UNIQUE,
+                        password TEXT,
+                        points INTEGER DEFAULT 50,
+                        last_reset TEXT,
+                        date_of_occupancy TEXT,
+                        cost_per_seat REAL
+                    )''')
+
+    # Create the rooms table if it doesn't exist
+    cursor.execute('''CREATE TABLE IF NOT EXISTS rooms (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        room_id TEXT,
+                        floor TEXT,
+                        seats INTEGER)''')  # Add seats column
+
+    # Create the announcements table if it doesn't exist
+    cursor.execute("""
+        CREATE TABLE IF NOT EXISTS announcements (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            recipient TEXT,
+            message TEXT,
+            timestamp TEXT)""")
+
+    # Create the bookings table if it doesn't exist
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS bookings (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            room TEXT,
+            time_slot TEXT,
+            booking_date TEXT)''')
+
+    # Create the complaints table if it doesn't exist
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS complaints (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT,
+            room_id TEXT,
+            complaint TEXT,
+            timestamp TEXT
+        )''')
+
+    # Add the `last_reset` column to the members table if it doesn't exist
+    cursor.execute('PRAGMA table_info(members)')
+    columns = cursor.fetchall()
+    column_names = [column[1] for column in columns]
+    if 'last_reset' not in column_names:
+        cursor.execute('ALTER TABLE members ADD COLUMN last_reset TEXT')
+
+    # Add the `date_of_occupancy` column to the members table if it doesn't exist
+    if 'date_of_occupancy' not in column_names:
+        cursor.execute('ALTER TABLE members ADD COLUMN date_of_occupancy TEXT')
+
+    # Add the `cost_per_seat` column to the members table if it doesn't exist
+    if 'cost_per_seat' not in column_names:
+        cursor.execute('ALTER TABLE members ADD COLUMN cost_per_seat REAL')
+
+    # Add the `seats` column to the rooms table if it doesn't exist
+    cursor.execute('PRAGMA table_info(rooms)')
+    columns = cursor.fetchall()
+    column_names = [column[1] for column in columns]
+    if 'seats' not in column_names:
+        cursor.execute('ALTER TABLE rooms ADD COLUMN seats INTEGER')
+    
+    conn.commit()  # Commit the changes
+
+# ---------------------------------
+# SAVE MEMBER INFO
+# ---------------------------------
+def save_member_info(member_info):
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    cursor.execute("""
+        INSERT INTO members (full_name, cnic, company_name, contact_number, email_id, rooms_booked, room_id_floor, username, password, points, last_reset, date_of_occupancy, cost_per_seat)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 50, NULL, ?, ?)""", member_info)
+    conn.commit()  # Commit the changes
+    conn.close()  # Close the connection
+    st.success("Member added successfully!")
+
+# ---------------------------------
+# REMOVE MEMBER
+# ---------------------------------
+def remove_member(member_name):
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM members WHERE full_name = ?", (member_name,))
+    if cursor.rowcount > 0:
+        st.success(f"Member {member_name} removed successfully!")
+    else:
+        st.error("Member not found.")
+    conn.commit()
+    conn.close()
+
+# ---------------------------------
+# FETCH MEMBER DETAILS
+# ---------------------------------
+def fetch_member_details():
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    cursor.execute('''
+        SELECT full_name, company_name, contact_number, email_id, rooms_booked, room_id_floor, date_of_occupancy, cost_per_seat
+        FROM members
+    ''')
+    members = cursor.fetchall()
+    conn.close()
+    return members
+
+# ---------------------------------
+# CALCULATE CHARGES
+# ---------------------------------
+def calculate_charges(rooms_booked, cost_per_seat, date_of_occupancy):
+    if date_of_occupancy:
+        occupancy_date = dt.strptime(date_of_occupancy, "%Y-%m-%d")
+        days_occupied = (dt.now() - occupancy_date).days
+        return rooms_booked * cost_per_seat * days_occupied
+    return 0
+
+# ---------------------------------
+# SAVE ROOM INFO
+# ---------------------------------
+def save_room_info(room_info):
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    cursor.execute("INSERT INTO rooms (room_id, floor, seats) VALUES (?, ?, ?)", room_info)
+    conn.commit()
+    conn.close()
+    st.success("Room added successfully!")   
+
+# ---------------------------------
+# REMOVE ROOM
+# ---------------------------------
+def remove_room(room_id, floor):
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    cursor.execute("DELETE FROM rooms WHERE room_id = ? AND floor = ?", (room_id, floor))
+    if cursor.rowcount > 0:
+        st.success(f"Room {room_id} on Floor {floor} removed successfully!")
+    else:
+        st.error("Room not found.")
+    conn.commit()
+    conn.close()
+
+# ---------------------------------
+# SAVE ANNOUNCEMENT
+# ---------------------------------
+def save_announcement(recipient, message):
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    timestamp = dt.now().strftime("%Y-%m-%d %H:%M:%S")
+    cursor.execute("INSERT INTO announcements (recipient, message, timestamp) VALUES (?, ?, ?)",
+                   (recipient, message, timestamp))
+    conn.commit()
+    conn.close()
+
+# ---------------------------------
+# GET ANNOUNCEMENTS
+# ---------------------------------
+def get_announcements(username):
+    conn = sqlite3.connect("growork.db")
+    cursor = conn.cursor()
+    cursor.execute("SELECT message, timestamp FROM announcements WHERE recipient = ? OR recipient = 'all' ORDER BY timestamp DESC", (username,))
+    announcements = cursor.fetchall()
+    conn.close()
+    return announcements
+
+# ---------------------------------
+# SEND EMAIL
+# ---------------------------------
+def send_email(recipient_email, subject, message):
+    # Gmail account details
+    sender_email = "growork3@gmail.com"  # Your Gmail address
+    sender_password = "fswitclgutgyibni"  # Use the 16-character App Password
+
+    # Create the email
+    msg = MIMEMultipart()
+    msg["From"] = sender_email
+    msg["To"] = recipient_email
+    msg["Subject"] = subject
+    msg.attach(MIMEText(message, "plain"))
+
+    try:
+        # Use Gmail's SMTP server
+        server = smtplib.SMTP("smtp.gmail.com", 587)  # Gmail's SMTP server and port
+        server.starttls()  # Upgrade the connection to secure
+        server.login(sender_email, sender_password)  # Log in to your Gmail account
+        server.sendmail(sender_email, recipient_email, msg.as_string())  # Send the email
+        server.quit()  # Close the connection
+        print("Email sent successfully!")
+    except Exception as e:
+        print(f"Failed to send email: {str(e)}")
+
+
+# Initialize the database when the script runs
+initialize_db()
+
+
+# ---------------------------------
+# LOGIN PAGE
+# ---------------------------------
+def login_page():
+    # Inject custom CSS to hide the sidebar
+    st.markdown(hide_sidebar_css, unsafe_allow_html=True)
+    st.image("LongLogo.png", width=500)
+    col1, col2, col3 = st.columns([1, 2, 1])  # Creates three columns
+    with col2:  # Puts the image in the middle column
+        st.title("GroWork Login")
+    st.write("Welcome to GroWork! Please log in to continue.")
+
+    # Fetch member credentials from the database
+    member_credentials, member_emails = fetch_member_credentials()
+
+    # Login form
+    username = st.text_input("Username")
+    password = st.text_input("Password", type="password")
+    login_button = st.button("Login")
+
+    if login_button:
+        if username == SUPER_ADMIN_USERNAME and password == SUPER_ADMIN_PASSWORD:
+            st.session_state["role"] = "superadmin"
+            st.session_state["page"] = "superadmin"
+        elif username == ADMIN_USERNAME and password == ADMIN_PASSWORD:
+            st.session_state["role"] = "admin"
+            st.session_state["page"] = "admin"
+        elif username in member_credentials and member_credentials[username] == password:
+            st.session_state["role"] = "member"
+            st.session_state["page"] = "member"
+            st.session_state["username"] = username  # Store the member's username
+        else:
+            st.error("Invalid username or password")
+
+# ---------------------------------
+# SUPERADMIN PAGE
+# ---------------------------------
+def superadmin_page():
+    st.image("LongLogo.png", width=500)
+    st.title("Super Admin Dashboard")
+    
+    # Sidebar for navigation
+    st.sidebar.title("Navigation")
+    page = st.sidebar.radio("Go to", ["Add/Remove Members", "View Member Details", "Add/Remove Rooms", "Announcements", "See All Bookings", "Complaints"])
+
+    if page == "Add/Remove Members":
+        st.header("Add/Remove Members")
+        
+        # Fetch available rooms
+        conn = sqlite3.connect("growork.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT room_id, floor, seats FROM rooms")
+        rooms = cursor.fetchall()
+        conn.close()
+        
+        available_rooms = [f"{room[0]} ({room[1]})" for room in rooms]
+        
+        full_name = st.text_input("Full Name")
+        cnic = st.text_input("CNIC")
+        company_name = st.text_input("Company Name")
+        contact_number = st.text_input("Contact Number")
+        email_id = st.text_input("Email ID")
+        num_rooms = st.number_input("Number of Rooms Booked", min_value=0, step=1, value=0)
+        room_info = st.selectbox("Select Room", available_rooms)  # Dropdown for available rooms
+        username = st.text_input("Member Username")
+        password = st.text_input("Member Password", type="password")
+        date_of_occupancy = st.date_input("Date of Occupancy")
+        cost_per_seat = st.number_input("Cost per Seat (Rs.)", min_value=0.0, step=100.0, value=1000.0)
+    
+        if st.button("Add Member"):
+            if full_name and username and password:  # Ensure required fields are filled
+                member_info = [full_name, cnic, company_name, contact_number, email_id, num_rooms, room_info, username, password, date_of_occupancy.strftime("%Y-%m-%d"), cost_per_seat]
+                save_member_info(member_info)
+                
+                # Remove the allocated room from the available rooms list
+                room_id_floor = room_info.split(" (")[0]
+                conn = sqlite3.connect("growork.db")
+                cursor = conn.cursor()
+                cursor.execute("DELETE FROM rooms WHERE room_id = ?", (room_id_floor,))
+                conn.commit()
+                conn.close()
+                
+                st.success(f"Member {full_name} added successfully and room {room_info} allocated!")
+                st.session_state["refresh_member_details"] = True  # Trigger refresh
+            else:
+                st.error("Please fill in all required fields (Full Name, Username, and Password).")
+        
+        remove_member_name = st.text_input("Enter Member Name to Remove")
+        if st.button("Remove Member"):
+            remove_member(remove_member_name)
+            st.session_state["refresh_member_details"] = True  # Trigger refresh
+
+    elif page == "View Member Details":
+        st.header("View Member Details")
+        
+        # Fetch all members from the database
+        members = fetch_member_details()
+        
+        if members:
+            # Create a DataFrame to display the member details
+            member_details = []
+            for member in members:
+                full_name, company_name, contact_number, email_id, rooms_booked, room_id_floor, date_of_occupancy, cost_per_seat = member
+                
+                # Handle NULL values for rooms_booked and cost_per_seat
+                if rooms_booked is None:
+                    rooms_booked = 0  # Replace NULL with 0
+                if cost_per_seat is None:
+                    cost_per_seat = 0  # Replace NULL with 0
+                
+                # Calculate charges per seat
+                charges_per_seat = calculate_charges(rooms_booked, cost_per_seat, date_of_occupancy)
+                
+                member_details.append({
+                    "Name": full_name,
+                    "Company Name": company_name,
+                    "Contact Number": contact_number,
+                    "Email ID": email_id,
+                    "Rooms Booked": rooms_booked,
+                    "Room ID and Floor": room_id_floor,
+                    "Date of Occupancy": date_of_occupancy,
+                    "Cost per Seat (Rs.)": cost_per_seat,
+                    "Total Charges (Rs.)": charges_per_seat
+                })
+            
+            # Convert to DataFrame
+            df = pd.DataFrame(member_details)
+            
+            # Display the DataFrame
+            st.write("### Member Details")
+            st.dataframe(df)  # Use st.dataframe to display the DataFrame
+            
+            # Option to download the data as a CSV file
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download Member Details as CSV",
+                data=csv,
+                file_name="member_details.csv",
+                mime="text/csv",
+            )
+        else:
+            st.write("No members found in the database.")
+
+
+    elif page == "Add/Remove Rooms":
+        st.header("Add/Remove Rooms")
+        
+        # Add Room Form
+        room_id = st.text_input("Room ID")
+        floor = st.text_input("Floor")
+        seats = st.number_input("Number of Seats", min_value=1, step=1, value=1)
+        
+        if st.button("Add Room"):
+            room_info = [room_id, floor, seats]
+            save_room_info(room_info)
+            st.success(f"Room {room_id} on {floor} with {seats} seats added successfully!")
+        
+        # Remove Room Form
+        remove_room_id = st.text_input("Enter Room ID to Remove")
+        remove_floor = st.text_input("Enter Floor Number of the Room to Remove")
+        if st.button("Remove Room"):
+            remove_room(remove_room_id, remove_floor)
+        
+        # Display Available Rooms and Seats
+        st.header("Available Rooms and Seats")
+        conn = sqlite3.connect("growork.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT room_id, floor, seats FROM rooms")
+        rooms = cursor.fetchall()
+        conn.close()
+        
+        if rooms:
+            room_details = [{"Room ID": room[0], "Floor": room[1], "Seats": room[2]} for room in rooms]
+            df = pd.DataFrame(room_details)
+            st.write(df)  # Display the table of available rooms
+        else:
+            st.write("No rooms found.")  
+    
+    elif page == "See All Bookings":
+        st.header("All Bookings")
+        
+        # Fetch bookings from Google Calendar
+        with st.spinner("Fetching bookings..."):
+            df = get_calendar_events()
+
+        if not df.empty:
+            # Display the calendar view
+            st.write("### Calendar View of Bookings")
+            events = [{"title": f"Booked by {row['Booked By']} ({row['Room']})", "start": row["Start"], "end": row["End"], "color": "red"} for _, row in df.iterrows()]
+            calendar_options = {
+                "editable": False,
+                "defaultView": "month",
+                "timeZone": TIME_ZONE,
+            }
+            calendar(events=events, options=calendar_options)
+
+            # Display the bookings in a table
+            st.write("### Bookings Table")
+            st.write(df)
+        else:
+            st.write("No bookings found.")
+
+    elif page == "Announcements":
+        st.header("Make Announcements")
+        announcement = st.text_area("Announcement Text")
+        
+        # Fetch member usernames and emails from the database
+        member_credentials, member_emails = fetch_member_credentials()
+        
+        recipient_option = st.radio("Select Recipients", ["Single Member", "Multiple Members", "All Members"])
+        
+        if recipient_option == "Single Member":
+            recipient = st.selectbox("Select Member", list(member_credentials.keys()))
+        elif recipient_option == "Multiple Members":
+            recipient = st.multiselect("Select Members", list(member_credentials.keys()))
+        else:
+            recipient = "all"
+        
+        if st.button("Post Announcement"):
+            if announcement:
+                if recipient == "all":
+                    for email in member_emails.values():
+                        send_email(email, "New Announcement", announcement)
+                    save_announcement("all", announcement)
+                elif isinstance(recipient, list):
+                    for user in recipient:
+                        send_email(member_emails[user], "New Announcement", announcement)
+                        save_announcement(user, announcement)
+                else:
+                    send_email(member_emails[recipient], "New Announcement", announcement)
+                    save_announcement(recipient, announcement)
+                
+                st.success("Announcement posted and emailed successfully!")
+            else:
+                st.error("Please enter an announcement before posting.")
+    
+    elif page == "Complaints":
+        st.header("Complaints")
+        
+        # Fetch all complaints from the database
+        conn = sqlite3.connect("growork.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT username, room_id, complaint, timestamp FROM complaints ORDER BY timestamp DESC")
+        complaints = cursor.fetchall()
+        conn.close()
+        
+        if complaints:
+            # Create a DataFrame to display the complaints
+            complaint_details = []
+            for complaint in complaints:
+                username, room_id, complaint_text, timestamp = complaint
+                complaint_details.append({
+                    "Username": username,
+                    "Room ID": room_id,
+                    "Complaint": complaint_text,
+                    "Timestamp": timestamp
+                })
+            
+            # Convert to DataFrame
+            df = pd.DataFrame(complaint_details)
+            
+            # Display the DataFrame
+            st.write("### Complaints")
+            st.dataframe(df)  # Use st.dataframe to display the DataFrame
+            
+            # Option to download the data as a CSV file
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download Complaints as CSV",
+                data=csv,
+                file_name="complaints.csv",
+                mime="text/csv",
+            )
+        else:
+            st.write("No complaints found.")
+
+
+    # Logout button
+    if st.button("Logout"):
+        st.session_state.clear()  # Clear the session state
+        st.session_state["page"] = "login"  # Redirect to the login page
+        st.rerun()  # Rerun the app to reflect changes
+
+# ---------------------------------
+# ADMIN PAGE
+# ---------------------------------
+def admin_page():
+    st.image("LongLogo.png", width=500)
+    st.title("Admin Dashboard")
+    
+    # Sidebar for navigation
+    st.sidebar.title("Navigation")
+    page = st.sidebar.radio("Go to", ["Add/Remove Members", "See All Bookings", "Announcements", "Complaints"])
+
+    if page == "Add/Remove Members":
+        st.header("Add/Remove Members")
+        full_name = st.text_input("Full Name")
+        cnic = st.text_input("CNIC")
+        company_name = st.text_input("Company Name")
+        contact_number = st.text_input("Contact Number")
+        email_id = st.text_input("Email ID")
+        num_rooms = st.number_input("Number of Rooms Booked", min_value=1, step=1)
+        room_info = st.text_area("Room ID and Floor (e.g., 101-2nd Floor, 202-3rd Floor)")
+        username = st.text_input("Member Username")
+        password = st.text_input("Member Password", type="password")
+    
+        if st.button("Add Member"):
+            member_info = [full_name, cnic, company_name, contact_number, email_id, num_rooms, room_info, username, password]
+            save_member_info(member_info)
+            st.success(f"Member {full_name} added successfully!")
+        
+        remove_member_name = st.text_input("Enter Member Name to Remove")
+        if st.button("Remove Member"):
+            remove_member(remove_member_name)
+    
+    elif page == "See All Bookings":
+        st.header("All Bookings")
+        
+        # Fetch bookings from Google Calendar
+        with st.spinner("Fetching bookings..."):
+            df = get_calendar_events()
+
+        if not df.empty:
+            # Display the calendar view
+            st.write("### Calendar View of Bookings")
+            events = [{"title": f"Booked by {row['Booked By']} ({row['Room']})", "start": row["Start"], "end": row["End"], "color": "red"} for _, row in df.iterrows()]
+            calendar_options = {
+                "editable": False,
+                "defaultView": "month",
+                "timeZone": TIME_ZONE,
+            }
+            calendar(events=events, options=calendar_options)
+
+            # Display the bookings in a table
+            st.write("### Bookings Table")
+            st.write(df)
+        else:
+            st.write("No bookings found.")
+
+    elif page == "Announcements":
+        st.header("Make Announcements")
+        announcement = st.text_area("Announcement Text")
+        
+        # Fetch member usernames and emails from the database
+        member_credentials, member_emails = fetch_member_credentials()
+        
+        recipient_option = st.radio("Select Recipients", ["Single Member", "Multiple Members", "All Members"])
+        
+        if recipient_option == "Single Member":
+            recipient = st.selectbox("Select Member", list(member_credentials.keys()))
+        elif recipient_option == "Multiple Members":
+            recipient = st.multiselect("Select Members", list(member_credentials.keys()))
+        else:
+            recipient = "all"
+        
+        if st.button("Post Announcement"):
+            if announcement:
+                if recipient == "all":
+                    for email in member_emails.values():
+                        send_email(email, "New Announcement", announcement)
+                    save_announcement("all", announcement)
+                elif isinstance(recipient, list):
+                    for user in recipient:
+                        send_email(member_emails[user], "New Announcement", announcement)
+                        save_announcement(user, announcement)
+                else:
+                    send_email(member_emails[recipient], "New Announcement", announcement)
+                    save_announcement(recipient, announcement)
+                
+                st.success("Announcement posted and emailed successfully!")
+            else:
+                st.error("Please enter an announcement before posting.")
+
+    elif page == "Complaints":
+        st.header("Complaints")
+        
+        # Fetch all complaints from the database
+        conn = sqlite3.connect("growork.db")
+        cursor = conn.cursor()
+        cursor.execute("SELECT username, room_id, complaint, timestamp FROM complaints ORDER BY timestamp DESC")
+        complaints = cursor.fetchall()
+        conn.close()
+        
+        if complaints:
+            # Create a DataFrame to display the complaints
+            complaint_details = []
+            for complaint in complaints:
+                username, room_id, complaint_text, timestamp = complaint
+                complaint_details.append({
+                    "Username": username,
+                    "Room ID": room_id,
+                    "Complaint": complaint_text,
+                    "Timestamp": timestamp
+                })
+            
+            # Convert to DataFrame
+            df = pd.DataFrame(complaint_details)
+            
+            # Display the DataFrame
+            st.write("### Complaints")
+            st.dataframe(df)  # Use st.dataframe to display the DataFrame
+            
+            # Option to download the data as a CSV file
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="Download Complaints as CSV",
+                data=csv,
+                file_name="complaints.csv",
+                mime="text/csv",
+            )
+        else:
+            st.write("No complaints found.")
+
+
+    # Logout button
+    if st.button("Logout"):
+        st.session_state.clear()  # Clear the session state
+        st.session_state["page"] = "login"  # Redirect to the login page
+        st.rerun()  # Rerun the app to reflect changes
+
+# ---------------------------------
+# MEMBER PAGE
+# ---------------------------------
+def member_page(cursor):
+    st.image("LongLogo.png", width=500)
+    st.title("Member Dashboard")
+    
+    # Sidebar for navigation
+    st.sidebar.title("Navigation")
+    page = st.sidebar.radio("Go to", ["Meeting Room Reservation", "Complain Registration", "See Announcements"])
+
+    username = st.session_state["username"]
+    reset_points(username)
+    
+    # Room Reservation Page
+    if page == "Meeting Room Reservation":
+        st.header("Meeting Room Reservation")
+        
+        # Fetch member points
+        cursor.execute('SELECT points FROM members WHERE username = ?', (username,))
+        result = cursor.fetchone()
+        if result:
+            points = result[0]
+        else:
+            st.error("Member data not found. Please contact the admin.")
+            return
+        
+        # Fetch and display bookings
+        with st.spinner("Fetching bookings..."):
+            df = get_calendar_events()
+
+        # Ensure the DataFrame has the required columns
+        if df.empty:
+            df = pd.DataFrame(columns=["Start", "End", "Booked By", "Event ID", "Room"])
+
+        # Display interactive calendar
+        st.write("### Available & Booked Slots")
+        events = [{"title": f"Booked by {row['Booked By']} ({row['Room']})", "start": row["Start"], "end": row["End"], "color": "red"} for _, row in df.iterrows()]
+        calendar_options = {
+            "editable": False,
+            "defaultView": "month",
+            "timeZone": TIME_ZONE,
+        }
+        calendar(events=events, options=calendar_options)
+
+        # Booking Form
+        st.write("### Book a Room")
+        date = st.date_input("Select Date", min_value=datetime.date.today())
+        start_time = st.time_input("Start Time")
+        end_time = st.time_input("End Time")
+
+        # Filter out rooms that are already booked for the selected time slot
+        start_datetime = datetime.datetime.combine(date, start_time).astimezone(pytz.UTC).isoformat()
+        end_datetime = datetime.datetime.combine(date, end_time).astimezone(pytz.UTC).isoformat()
+
+        # Get the list of rooms already booked for the selected time slot
+        booked_rooms = df[(df["Start"] <= end_datetime) & (df["End"] >= start_datetime)]["Room"].tolist()
+
+        # Available rooms are those not in the booked_rooms list
+        available_rooms = [room for room in meeting_rooms if room not in booked_rooms]
+
+        # If no rooms are available, show a message
+        if not available_rooms:
+            st.warning("No rooms available for the selected time slot.")
+        else:
+            room = st.selectbox("Select Room", available_rooms)  # Allow room selection
+
+            if st.button("Book Now"):
+                if start_time >= end_time:
+                    st.error("End time must be after start time.")
+                else:
+                    event = {
+                        "summary": f"{username} ({room})",  # Include room in the event summary
+                        "start": {"dateTime": start_datetime, "timeZone": TIME_ZONE},
+                        "end": {"dateTime": end_datetime, "timeZone": TIME_ZONE},
+                    }
+                    try:
+                        calendar_service.events().insert(calendarId=CALENDAR_ID, body=event).execute()
+                        st.success(f"Room {room} booked successfully!")
+                        st.rerun()  # Refresh the page to show the updated calendar
+                    except HttpError as error:
+                        st.error(f"An error occurred: {error}")
+
+    elif page == "See Announcements":
+        st.header("Announcements")
+        announcements = get_announcements(st.session_state["username"])
+        if announcements:
+            for msg, timestamp in announcements:
+                st.write(f"{timestamp}: {msg}")
+        else:
+            st.write("No announcements yet.")
+
+    elif page == "Complain Registration":
+        st.header("Register a Complaint")
+        
+        subjects = [
+            "Noise Levels", "Temperature", "Cleanliness", "Distractions", "Lack of Privacy",
+            "Internet Connectivity", "Equipment Malfunction", "Limited Resources",
+            "Inadequate Furniture", "Parking Issues"
+        ]
+        
+        subject = st.selectbox("Select Subject", subjects)
+        complaint = st.text_area("Complaint Details")
+        
+        if st.button("Submit Complaint"):
+            if subject and complaint:
+                # Save the complaint to the database
+                conn = sqlite3.connect("growork.db")
+                cursor = conn.cursor()
+                timestamp = dt.now().strftime("%Y-%m-%d %H:%M:%S")
+                cursor.execute("""
+                    INSERT INTO complaints (username, room_id, complaint, timestamp)
+                    VALUES (?, ?, ?, ?)
+                """, (username, "N/A", f"{subject}: {complaint}", timestamp))
+                conn.commit()
+                conn.close()
+                
+                # Send an email notification (optional)
+                send_email("admin@growork.com", "New Complaint", f"Complaint from {username}: {subject}: {complaint}")
+                
+                st.success("Complaint submitted successfully!")
+            else:
+                st.warning("Please fill in all fields before submitting.")
+
+    # Logout button
+    if st.button("Logout"):
+        st.session_state.clear()  # Clear the session state
+        st.session_state["page"] = "login"  # Redirect to the login page
+        st.rerun()  # Rerun the app to reflect changes
+
+
+# ---------------------------------
+# MAIN APP LOGIC
+# ---------------------------------
+def main():
+    # Initialize session state
+    if "page" not in st.session_state:
+        st.session_state["page"] = "login"
+
+    # Initialize the database connection and cursor
+    conn = sqlite3.connect('growork.db', check_same_thread=False)
+    cursor = conn.cursor()
+
+    # Render the appropriate page based on session state
+    if st.session_state["page"] == "login":
+        login_page()
+    elif st.session_state["page"] == "superadmin":
+        superadmin_page()
+    elif st.session_state["page"] == "admin":
+        admin_page()
+    elif st.session_state["page"] == "member":
+        member_page(cursor)  # Pass the cursor to the member_page function
+
+    # Footer
+    st.markdown(
+    """
+    <div style="display: flex; justify-content: space-between; align-items: center; padding: 20px; border-top: 2px solid #ddd;">
+        <!-- Left Section: Contact Information -->
+        <div style="text-align: left;">
+            <b>📧 Email:</b> <a href="mailto:info@example.com">info@growork.pk</a>  
+            <br><b>📞 Phone:</b> <a href="tel:+92 304 4865868">+92 304 4865868</a>  
+            <br><b>📍 Location:</b> <a href="https://www.google.com/maps/place/GroWork+Coworking/data=!4m2!3m1!1s0x0:0x5068422a19bab54d?sa=X&ved=1t:2428&ictx=111" target="_blank">View on Google Maps</a>  
+        </div>
+        <div style="text-align: right;">
+            <b>Scan to visit our website:</b>  
+            <br>
+            <img src="https://api.qrserver.com/v1/create-qr-code/?size=150x150&data=https://yourwebsite.com" width="120">
+        </div>
+    </div>
+    """,
+    unsafe_allow_html=True
+    )
+
+    st.markdown(
+    """
+    <div style="text-align: center; padding: 10px;">
+        © 2025 <b>GroWork</b>. All rights reserved.
+    </div>
+    """,
+    unsafe_allow_html=True
+    )
+
+    # Close the database connection when done
+    conn.close()
+
+# Run the app
+if __name__ == "__main__":
+    main()