Upload app.py

app.py

@@ -0,0 +1,470 @@
+import streamlit as st
+import firebase_admin
+from firebase_admin import credentials, firestore
+import pandas as pd
+
+# Set Page Configuration (must be the first Streamlit command)
+st.set_page_config(
+    page_title="ERP Admin Panel",
+    page_icon="🛠️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize Firebase
+try:
+    cred = credentials.Certificate("serviceAccountKey.json")
+    firebase_admin.initialize_app(cred)
+except ValueError:
+    # If the app is already initialized, skip re-initialization
+    pass
+
+db = firestore.client()
+
+# Default User Authentication
+DEFAULT_USERS = {
+    "Admin": {"password": "Admin", "role": "Admin"},
+    "Manager": {"password": "Manager", "role": "Manager"},
+}
+
+def normalize_email(email):
+    """Normalize email by converting it to lowercase."""
+    return email.strip().lower()
+
+def initialize_default_users():
+    """
+    Initialize default users in Firestore if they don't already exist.
+    """
+    for email, user_data in DEFAULT_USERS.items():
+        normalized_email = normalize_email(email)
+        emp_doc = db.collection("Employees").document(normalized_email).get()
+        if not emp_doc.exists:
+            with st.spinner(f"⏳ Initializing default user: {email}"):
+                db.collection("Employees").document(normalized_email).set({
+                    "name": email.capitalize(),  # Use email as name for simplicity
+                    "email": normalized_email,
+                    "phone": "N/A",  # Default placeholder
+                    "designation": "Default User",
+                    "role": user_data["role"],
+                    "password": user_data["password"],
+                    "force_password_change": False  # No need to change default passwords
+                })
+            st.success(f"✅ Default user '{email}' initialized successfully.")
+
+def login_user(email, password):
+    # Normalize email
+    email = normalize_email(email)
+    
+    # Check if the user is a default user (Admin/Manager)
+    if email in DEFAULT_USERS and DEFAULT_USERS[email]["password"] == password:
+        return DEFAULT_USERS[email]["role"]
+    
+    # Check if the user exists in Firestore (employees)
+    emp_doc = db.collection("Employees").document(email).get()
+    if emp_doc.exists:
+        emp_data = emp_doc.to_dict()
+        if "password" in emp_data and emp_data["password"] == password:
+            return emp_data.get("role", "Employee")  # Default role is "Employee"
+    
+    # If no match is found, return None
+    st.error("❌ Invalid credentials. Please try again.")
+    return None
+
+# Sidebar Navigation with Icons
+st.sidebar.markdown("""
+    <style>
+    .sidebar .sidebar-content {
+        background-color: #e6f7ff; /* Light Blue Background */
+        border-radius: 15px;
+        box-shadow: 5px 5px 15px rgba(0, 0, 0, 0.2);
+    }
+    .sidebar .stButton button {
+        background-color: #007bff;
+        color: white;
+        border-radius: 10px;
+        padding: 10px;
+        font-size: 16px;
+        box-shadow: 3px 3px 8px rgba(0, 0, 0, 0.3);
+    }
+    .sidebar .stButton button:hover {
+        background-color: #0056b3;
+        transform: scale(1.05);
+        transition: all 0.3s ease;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+st.sidebar.title("🚀 Admin Panel 🛠️")
+
+# Initialize Default Users
+if "default_users_initialized" not in st.session_state:
+    initialize_default_users()
+    st.session_state.default_users_initialized = True
+
+# Login Section
+if "logged_in" not in st.session_state:
+    st.session_state.logged_in = False
+    st.session_state.user_role = None
+
+if not st.session_state.logged_in:
+    st.sidebar.subheader("🔑 Login")
+    email = st.sidebar.text_input("📧 Email", placeholder="Enter your email")
+    password = st.sidebar.text_input("🔒 Password", type="password", placeholder="Enter your password")
+    
+    if st.sidebar.button("🔓 Login"):
+        user_role = login_user(email, password)
+        if user_role:
+            # Check if the user needs to change their password
+            emp_doc = db.collection("Employees").document(normalize_email(email)).get()
+            if emp_doc.exists:
+                emp_data = emp_doc.to_dict()
+                if emp_data.get("force_password_change", False):
+                    st.session_state.force_password_change = True
+                    st.session_state.temp_email = normalize_email(email)
+                    st.experimental_rerun()
+            
+            # Update session state for successful login
+            st.session_state.logged_in = True
+            st.session_state.user_role = user_role
+            st.experimental_rerun()
+else:
+    if "force_password_change" in st.session_state and st.session_state.force_password_change:
+        st.header("⚠️ Change Password")
+        st.warning("🔒 You must change your password before proceeding.")
+        new_password = st.text_input("🔐 New Password", type="password", placeholder="Enter a new password")
+        confirm_password = st.text_input("🔒 Confirm Password", type="password", placeholder="Confirm your new password")
+        
+        if st.button("✅ Save Password"):
+            if not new_password or not confirm_password:
+                st.error("❌ Please fill in both fields.")
+            elif new_password != confirm_password:
+                st.error("❌ Passwords do not match.")
+            elif len(new_password) < 8 or not any(char.isdigit() for char in new_password) or not any(char.isupper() for char in new_password):
+                st.error("❌ Password must be at least 8 characters long, include a number, and an uppercase letter.")
+            else:
+                # Update password in Firestore
+                db.collection("Employees").document(st.session_state.temp_email).update({
+                    "password": new_password,
+                    "force_password_change": False
+                })
+                st.success("✅ Password changed successfully!")
+                st.session_state.force_password_change = False
+                st.session_state.logged_in = True
+                st.experimental_rerun()
+    else:
+        st.sidebar.subheader(f"👋 Welcome, {st.session_state.user_role}")
+        menu = {
+            "👥 Employee Management": "employee",
+            "🛡️ Role Management": "role",
+            "🔒 Access Control": "access",
+            "📊 Dashboards": "dashboard",
+            "📋 Reporting Templates": "report",
+            "🤖 Chatbot": "chatbot",
+            "🧠 Advanced Analytics": "analytics",
+        }
+        choice = st.sidebar.radio("📚 Menu", list(menu.keys()))
+
+        # Logout Button
+        if st.sidebar.button("🚪 Logout"):
+            st.session_state.logged_in = False
+            st.session_state.user_role = None
+            st.experimental_rerun()
+
+# Theme Selection
+st.sidebar.subheader("🎨 Appearance")
+theme = st.sidebar.selectbox("🌙 Choose Theme", ["☀️ Light", "🌙 Dark"])
+if theme == "☀️ Light":
+    st.markdown("""
+        <style>
+        .stApp {background-color: #e6f7ff; color: black;} /* Light Blue Background */
+        </style>
+    """, unsafe_allow_html=True)
+elif theme == "🌙 Dark":
+    st.markdown("""
+        <style>
+        .stApp {background-color: #1E1E1E; color: white;}
+        </style>
+    """, unsafe_allow_html=True)
+
+# Main Content
+if "logged_in" in st.session_state and st.session_state.logged_in:
+    # Role-Based Access Control
+    user_role = st.session_state.user_role
+    if user_role not in ["Admin", "Manager", "Engineer", "Accountant"]:
+        st.error("❌ Unauthorized access. Please contact the administrator.")
+        st.stop()
+
+    if menu[choice] == "employee":
+        if user_role not in ["Admin", "Manager"]:
+            st.error("❌ You do not have permission to access this module.")
+            st.stop()
+
+        st.header("👥 Employee Management")
+        
+        # Real-Time Updates for Employees
+        def fetch_employees():
+            employees_ref = db.collection("Employees").stream()
+            return [{"ID": emp.id, "Name": emp.to_dict()["name"], "Email": emp.to_dict()["email"], "Role": emp.to_dict()["role"]} for emp in employees_ref]
+
+        # Add Employee Form
+        with st.form("add_employee_form"):
+            st.subheader("📝 Add Employee")
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("👤 Name", placeholder="Enter full name", help="Full name of the employee")
+                email = st.text_input("📧 Email", placeholder="Enter email address", help="Official email address")
+            with col2:
+                phone = st.text_input("📞 Phone", placeholder="Enter phone number", help="Contact number")
+                designation = st.text_input("💼 Designation", placeholder="Enter job title", help="Job role or position")
+            
+            role = st.selectbox("🛡️ Role", ["Admin", "Manager", "Engineer", "Accountant"], help="Select the employee's role.")
+            temp_password = st.text_input("🔒 Temporary Password", type="password", placeholder="Set a temporary password", help="The employee will be forced to change this on first login.")
+            submitted = st.form_submit_button("✅ Save Employee")
+            
+            if submitted:
+                if not name or not email or not phone or not designation or not temp_password:
+                    st.error("❌ Please fill in all fields.")
+                elif len(temp_password) < 8 or not any(char.isdigit() for char in temp_password) or not any(char.isupper() for char in temp_password):
+                    st.error("❌ Temporary password must be at least 8 characters long, include a number, and an uppercase letter.")
+                else:
+                    # Normalize email before saving
+                    normalized_email = normalize_email(email)
+                    with st.spinner("⏳ Saving employee details..."):
+                        db.collection("Employees").document(normalized_email).set({  # Use normalized email as document ID
+                            "name": name,
+                            "email": normalized_email,
+                            "phone": phone,
+                            "designation": designation,
+                            "role": role,
+                            "password": temp_password,
+                            "force_password_change": True  # Enforce password change on first login
+                        })
+                    st.success("✅ Employee Added Successfully!")
+        
+        # Display Employees
+        st.subheader("📋 All Employees")
+        employees_data = fetch_employees()
+        df = pd.DataFrame(employees_data)
+        st.dataframe(df, use_container_width=True)
+        
+        # Modify or Remove Employee
+        if user_role == "Admin":
+            st.subheader("📝 Modify or Remove Employee")
+            selected_employee = st.selectbox("👥 Select Employee to Modify/Remove", [emp["Email"] for emp in employees_data])
+            
+            if selected_employee:
+                emp_doc = db.collection("Employees").document(selected_employee).get()
+                if emp_doc.exists:
+                    emp_data = emp_doc.to_dict()
+                    
+                    # Modify Employee Form
+                    with st.form("modify_employee_form"):
+                        st.subheader("📝 Modify Employee Details")
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            name = st.text_input("👤 Name", value=emp_data.get("name", ""), help="Full name of the employee")
+                            email = st.text_input("📧 Email", value=emp_data.get("email", ""), help="Official email address")
+                        with col2:
+                            phone = st.text_input("📞 Phone", value=emp_data.get("phone", ""), help="Contact number")
+                            designation = st.text_input("💼 Designation", value=emp_data.get("designation", ""), help="Job role or position")
+                        
+                        role = st.selectbox("🛡️ Role", ["Admin", "Manager", "Engineer", "Accountant"], index=["Admin", "Manager", "Engineer", "Accountant"].index(emp_data.get("role", "Employee")))
+                        submitted = st.form_submit_button("✅ Update Employee")
+                        
+                        if submitted:
+                            # Normalize email before saving
+                            normalized_email = normalize_email(email)
+                            with st.spinner("⏳ Updating employee details..."):
+                                db.collection("Employees").document(normalized_email).update({
+                                    "name": name,
+                                    "email": normalized_email,
+                                    "phone": phone,
+                                    "designation": designation,
+                                    "role": role
+                                })
+                            st.success("✅ Employee Updated Successfully!")
+                    
+                    # Remove Employee Button
+                    if st.button("🗑️ Remove Employee"):
+                        with st.spinner("⏳ Removing employee..."):
+                            db.collection("Employees").document(selected_employee).delete()
+                        st.success("✅ Employee Removed Successfully!")
+
+        # Export Data as CSV
+        if not df.empty:
+            csv = df.to_csv(index=False).encode('utf-8')
+            st.download_button(
+                label="📥 Download Employee Data as CSV",
+                data=csv,
+                file_name="employees.csv",
+                mime="text/csv"
+            )
+
+    elif menu[choice] == "role":
+        if user_role not in ["Admin"]:
+            st.error("❌ You do not have permission to access this module.")
+            st.stop()
+
+        st.header("🛡️ Role Management")
+        
+        # Add Role Form
+        with st.form("add_role_form"):
+            st.subheader("📝 Add Role")
+            role_name = st.text_input("📜 Role Name", placeholder="Enter role name", help="Name of the role")
+            col1, col2 = st.columns(2)
+            with col1:
+                project_management = st.checkbox("📊 Project Management Access", help="Grant access to project management tools")
+                finance_access = st.checkbox("💰 Finance Access", help="Grant access to financial tools")
+            with col2:
+                hr_access = st.checkbox("👥 HR Access", help="Grant access to HR tools")
+            
+            submitted = st.form_submit_button("✅ Save Role")
+            if submitted:
+                if not role_name:
+                    st.error("❌ Please enter a role name.")
+                else:
+                    with st.spinner("⏳ Saving role details..."):
+                        db.collection("Roles").add({
+                            "role_name": role_name,
+                            "permissions": {
+                                "Project Management": project_management,
+                                "Finance": finance_access,
+                                "HR": hr_access
+                            }
+                        })
+                    st.success(f"✅ Role '{role_name}' Added Successfully!")
+        
+        # Display Roles
+        st.subheader("📋 All Roles")
+        roles_ref = db.collection("Roles").stream()
+        role_data = [{"ID": role.id, "Role Name": role.to_dict()["role_name"], "Permissions": role.to_dict()["permissions"]} for role in roles_ref]
+        st.table(pd.DataFrame(role_data))
+
+    elif menu[choice] == "access":
+        st.header("🔒 Access Control")
+        st.write("Control access to modules based on roles here.")
+        # Example: Simulate role-based access control
+        user_role = st.selectbox("🛡️ Select User Role", ["Admin", "Manager", "Engineer", "Accountant"])
+        if user_role == "Admin":
+            st.info("✅ Full Access Granted.")
+        elif user_role == "Manager":
+            st.info("✅ Access to Project Management and Dashboards.")
+        else:
+            st.warning("⚠️ Limited Access.")
+
+    elif menu[choice] == "dashboard":
+        st.header("📊 Admin Dashboards")
+        
+        # Employee Count by Role
+        st.subheader("👥 Employees by Role")
+        roles_count = {}
+        employees_ref = db.collection("Employees").stream()
+        for emp in employees_ref:
+            role = emp.to_dict()["role"]
+            roles_count[role] = roles_count.get(role, 0) + 1
+        
+        roles = list(roles_count.keys())
+        counts = list(roles_count.values())
+        
+        # Bar Chart
+        st.bar_chart(pd.DataFrame({"Role": roles, "Count": counts}).set_index("Role"))
+        
+        # Pie Chart
+        st.subheader("📊 Role Distribution")
+        fig = px.pie(names=roles, values=counts, title="Role Distribution")
+        st.plotly_chart(fig)
+
+    elif menu[choice] == "report":
+        st.header("📋 Reporting Templates")
+        
+        # Add Template Form
+        with st.form("add_template_form"):
+            st.subheader("📝 Add Report Template")
+            template_name = st.text_input("📄 Template Name", placeholder="Enter template name", help="Name of the report template")
+            fields = st.text_area("📋 Fields (comma-separated)", "Project Name, Start Date, End Date", help="Enter fields separated by commas.")
+            
+            submitted = st.form_submit_button("✅ Save Template")
+            if submitted:
+                if not template_name or not fields:
+                    st.error("❌ Please fill in all fields.")
+                else:
+                    with st.spinner("⏳ Saving report template..."):
+                        db.collection("Reports").add({
+                            "template_name": template_name,
+                            "fields": fields.split(",")
+                        })
+                    st.success(f"✅ Template '{template_name}' Added Successfully!")
+        
+        # Display Templates
+        st.subheader("📋 All Templates")
+        templates_ref = db.collection("Reports").stream()
+        template_data = [{"ID": temp.id, "Template Name": temp.to_dict()["template_name"], "Fields": temp.to_dict()["fields"]} for temp in templates_ref]
+        st.table(pd.DataFrame(template_data))
+
+    elif menu[choice] == "chatbot":
+        st.header("🤖 Chatbot")
+        
+        # Load QA model
+        qa_pipeline = pipeline("question-answering")
+        
+        # Chatbot Interface
+        st.subheader("💬 Ask a Question")
+        question = st.text_input("❓ Your Question")
+        context = "The Admin module allows you to manage employees, roles, and access control. Use the sidebar to navigate."
+        
+        if st.button("🔍 Get Answer"):
+            try:
+                result = qa_pipeline(question=question, context=context)
+                st.write("💡 Answer:", result["answer"])
+            except Exception as e:
+                st.error(f"❌ An error occurred: {e}")
+
+    elif menu[choice] == "analytics":
+        st.header("🧠 Advanced Analytics")
+        
+        # Predictive Analytics: Role Recommendations
+        st.subheader("👥 Employee Role Recommendations")
+        employees_ref = db.collection("Employees").stream()
+        employee_data = [{"Name": emp.to_dict()["name"], "Role": emp.to_dict()["role"]} for emp in employees_ref]
+        df = pd.DataFrame(employee_data)
+        
+        if not df.empty:
+            # Encode roles for clustering
+            role_mapping = {role: idx for idx, role in enumerate(df["Role"].unique())}
+            df["Role_Encoded"] = df["Role"].map(role_mapping)
+            
+            # Perform K-Means Clustering
+            kmeans = KMeans(n_clusters=len(role_mapping), random_state=42)
+            df["Cluster"] = kmeans.fit_predict(df[["Role_Encoded"]])
+            
+            # Display Recommendations
+            st.write("👥 Clustered Employees:")
+            st.dataframe(df)
+            
+            # Predict Role for New Employee
+            st.subheader("🎯 Predict Role for New Employee")
+            new_employee_name = st.text_input("👤 New Employee Name")
+            if st.button("🔮 Predict Role"):
+                if not new_employee_name:
+                    st.error("❌ Please enter the employee's name.")
+                else:
+                    # Randomly assign a cluster (for demonstration purposes)
+                    predicted_cluster = np.random.randint(0, len(role_mapping))
+                    predicted_role = [role for role, idx in role_mapping.items() if idx == predicted_cluster][0]
+                    st.success(f"🎯 Recommended Role for {new_employee_name}: {predicted_role}")
+        
+        # Anomaly Detection
+        st.subheader("⚠️ Anomaly Detection in Employee Data")
+        if not df.empty:
+            # Use Isolation Forest for anomaly detection
+            iso_forest = IsolationForest(contamination=0.1, random_state=42)
+            df["Anomaly"] = iso_forest.fit_predict(df[["Role_Encoded"]])
+            anomalies = df[df["Anomaly"] == -1]
+            
+            st.write("⚠️ Detected Anomalies:")
+            st.dataframe(anomalies)
+
+# Notifications Feature
+st.sidebar.subheader("🔔 Notifications")
+st.sidebar.info("🎉 New feature: Advanced reporting tools added!")
+st.sidebar.warning("⏰ Reminder: Save your changes before navigating away.")