Update app.py

app.py

@@ -1,126 +1,202 @@
 import streamlit as st
+import mysql.connector
+import bcrypt
+import re
+import datetime
+import pytz
 import pandas as pd
-import numpy as np
-from sklearn.model_selection import train_test_split
-from sklearn.ensemble import RandomForestRegressor
-from sklearn.preprocessing import StandardScaler
 import plotly.express as px
-import plotly.graph_objects as go
 
-# Load and preprocess data
-def load_data():
-    # For this example, we'll generate synthetic data
-    np.random.seed(42)
-    data = pd.DataFrame({
-        'employee_id': range(1000),
-        'age': np.random.randint(22, 65, 1000),
-        'experience': np.random.randint(0, 40, 1000),
-        'training_score': np.random.uniform(50, 100, 1000),
-        'project_completion': np.random.uniform(60, 100, 1000),
-        'performance_score': np.random.uniform(50, 100, 1000)
-    })
-    return data
+# MySQL Connection
+def get_database_connection():
+    connection = mysql.connector.connect(
+        host="gateway01.ap-southeast-1.prod.aws.tidbcloud.com",
+        port=4000,
+        user="37QUb7dvTn3P6E8.root",
+        password="MBAg14V0HaMdxwX0"
+    )
+    return connection
 
-# Train model
-def train_model(data):
-    X = data.drop(['employee_id', 'performance_score'], axis=1)
-    y = data['performance_score']
-    
-    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+# Initialize database and tables
+def init_database():
+    connection = get_database_connection()
+    cursor = connection.cursor(buffered=True)
+    
+    cursor.execute("CREATE DATABASE IF NOT EXISTS EmployeePerformance")
+    cursor.execute('USE EmployeePerformance')
+    
+    # Create User_data table
+    cursor.execute('''CREATE TABLE IF NOT EXISTS User_data (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        username VARCHAR(50) UNIQUE NOT NULL,
+        password VARCHAR(255) NOT NULL,
+        email VARCHAR(255) UNIQUE NOT NULL,
+        registered_date TIMESTAMP,
+        last_login TIMESTAMP
+    )''')
+    
+    # Create Employee_data table
+    cursor.execute('''CREATE TABLE IF NOT EXISTS Employee_data (
+        id INT AUTO_INCREMENT PRIMARY KEY,
+        employee_id VARCHAR(50) UNIQUE NOT NULL,
+        name VARCHAR(100) NOT NULL,
+        age INT,
+        last_performance_score FLOAT,
+        current_performance_score FLOAT,
+        future_advancement TEXT,
+        rank INT
+    )''')
+    
+    connection.commit()
+    cursor.close()
+    connection.close()
+
+# User authentication functions
+def username_exists(username):
+    connection = get_database_connection()
+    cursor = connection.cursor(buffered=True)
+    cursor.execute('USE EmployeePerformance')
+    cursor.execute("SELECT * FROM User_data WHERE username = %s", (username,))
+    result = cursor.fetchone() is not None
+    cursor.close()
+    connection.close()
+    return result
+
+def email_exists(email):
+    connection = get_database_connection()
+    cursor = connection.cursor(buffered=True)
+    cursor.execute('USE EmployeePerformance')
+    cursor.execute("SELECT * FROM User_data WHERE email = %s", (email,))
+    result = cursor.fetchone() is not None
+    cursor.close()
+    connection.close()
+    return result
+
+def is_valid_email(email):
+    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+    return re.match(pattern, email) is not None
+
+def create_user(username, password, email):
+    if username_exists(username):
+        return 'username_exists'
+    if email_exists(email):
+        return 'email_exists'
+    
+    connection = get_database_connection()
+    cursor = connection.cursor(buffered=True)
+    cursor.execute('USE EmployeePerformance')
+    
+    hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
+    registered_date = datetime.datetime.now(pytz.timezone('Asia/Kolkata'))
+    
+    cursor.execute(
+        "INSERT INTO User_data (username, password, email, registered_date) VALUES (%s, %s, %s, %s)",
+        (username, hashed_password, email, registered_date)
+    )
+    
+    connection.commit()
+    cursor.close()
+    connection.close()
+    return 'success'
+
+def verify_user(username, password):
+    connection = get_database_connection()
+    cursor = connection.cursor(buffered=True)
+    cursor.execute('USE EmployeePerformance')
+    
+    cursor.execute("SELECT password FROM User_data WHERE username = %s", (username,))
+    record = cursor.fetchone()
+    
+    if record and bcrypt.checkpw(password.encode('utf-8'), record[0].encode('utf-8')):
+        cursor.execute("UPDATE User_data SET last_login = %s WHERE username = %s", 
+                       (datetime.datetime.now(pytz.timezone('Asia/Kolkata')), username))
+        connection.commit()
+        cursor.close()
+        connection.close()
+        return True
+    
+    cursor.close()
+    connection.close()
+    return False
+
+# Employee data functions
+def get_employee_data():
+    connection = get_database_connection()
+    cursor = connection.cursor(buffered=True)
+    cursor.execute('USE EmployeePerformance')
+    
+    cursor.execute("SELECT * FROM Employee_data")
+    columns = [col[0] for col in cursor.description]
+    employees = [dict(zip(columns, row)) for row in cursor.fetchall()]
+    
+    cursor.close()
+    connection.close()
+    return employees
+
+# Streamlit app
+def main():
+    st.set_page_config(page_title="Employee Performance Dashboard", layout="wide")
     
-    scaler = StandardScaler()
-    X_train_scaled = scaler.fit_transform(X_train)
+    init_database()
     
-    model = RandomForestRegressor(n_estimators=100, random_state=42)
-    model.fit(X_train_scaled, y_train)
+    if 'logged_in' not in st.session_state:
+        st.session_state.logged_in = False
     
-    return model, scaler
+    if not st.session_state.logged_in:
+        login_page()
+    else:
+        home_page()
 
-# Streamlit app
-def main():
-    st.title('Employee Performance Analysis Dashboard')
-    
-    data = load_data()
-    model, scaler = train_model(data)
-    
-    st.sidebar.header('Employee Details')
-    
-    # Input for employee ID
-    employee_id = st.sidebar.number_input('Employee ID', min_value=1, max_value=1000, value=1)
-    
-    # Get employee data
-    employee = data[data['employee_id'] == employee_id].iloc[0]
-    
-    # Display current employee details
-    st.sidebar.subheader('Current Details')
-    st.sidebar.write(f"Age: {employee['age']}")
-    st.sidebar.write(f"Experience: {employee['experience']} years")
-    st.sidebar.write(f"Training Score: {employee['training_score']:.2f}")
-    st.sidebar.write(f"Project Completion: {employee['project_completion']:.2f}%")
-    
-    # Input fields for updating employee details
-    st.sidebar.subheader('Update Details')
-    age = st.sidebar.number_input('Age', min_value=22, max_value=65, value=int(employee['age']))
-    experience = st.sidebar.number_input('Years of Experience', min_value=0, max_value=40, value=int(employee['experience']))
-    training_score = st.sidebar.slider('Training Score', 50.0, 100.0, float(employee['training_score']))
-    project_completion = st.sidebar.slider('Project Completion Rate', 60.0, 100.0, float(employee['project_completion']))
-    
-    # Create a dataframe with user input
-    user_input = pd.DataFrame({
-        'age': [age],
-        'experience': [experience],
-        'training_score': [training_score],
-        'project_completion': [project_completion]
-    })
-    
-    # Scale the input
-    user_input_scaled = scaler.transform(user_input)
-    
-    # Make prediction
-    prediction = model.predict(user_input_scaled)
-    
-    # Display results
-    col1, col2 = st.columns(2)
-    
-    with col1:
-        st.subheader('Predicted Performance Score')
-        fig = go.Figure(go.Indicator(
-            mode = "gauge+number",
-            value = prediction[0],
-            domain = {'x': [0, 1], 'y': [0, 1]},
-            title = {'text': "Performance"},
-            gauge = {'axis': {'range': [None, 100]},
-                     'steps' : [
-                         {'range': [0, 60], 'color': "lightgray"},
-                         {'range': [60, 80], 'color': "gray"},
-                         {'range': [80, 100], 'color': "darkgray"}],
-                     'threshold': {'line': {'color': "red", 'width': 4}, 'thickness': 0.75, 'value': 90}}))
-        st.plotly_chart(fig)
+def login_page():
+    st.title("Login")
+    
+    username = st.text_input("Username")
+    password = st.text_input("Password", type="password")
+    
+    if st.button("Login"):
+        if verify_user(username, password):
+            st.session_state.logged_in = True
+            st.session_state.username = username
+            st.experimental_rerun()
+        else:
+            st.error("Invalid username or password")
 
-    with col2:
-        st.subheader('Feature Importance')
-        importances = model.feature_importances_
-        feature_importance = pd.DataFrame({'feature': user_input.columns, 'importance': importances})
-        feature_importance = feature_importance.sort_values('importance', ascending=False)
-        fig = px.bar(feature_importance, x='importance', y='feature', orientation='h')
-        st.plotly_chart(fig)
-    
-    # Performance Interpretation
-    st.subheader('Performance Interpretation')
-    if prediction[0] >= 90:
-        st.write("Excellent performance! This employee is exceeding expectations.")
-    elif prediction[0] >= 75:
-        st.write("Good performance. The employee is meeting expectations.")
-    elif prediction[0] >= 60:
-        st.write("Average performance. There's room for improvement.")
-    else:
-        st.write("Performance needs improvement. Consider additional training or support.")
-    
-    # Historical Performance
-    st.subheader('Historical Performance')
-    historical_data = data[data['employee_id'] == employee_id]
-    fig = px.line(historical_data, x='employee_id', y='performance_score', title='Performance Over Time')
+def home_page():
+    st.title("Employee Performance Dashboard")
+    st.write(f"Welcome, {st.session_state.username}!")
+    
+    employees = get_employee_data()
+    
+    if not employees:
+        st.warning("No employee data available.")
+        return
+    
+    # Display employee information
+    for employee in employees:
+        st.subheader(f"Employee: {employee['name']}")
+        col1, col2, col3 = st.columns(3)
+        col1.metric("Employee ID", employee['employee_id'])
+        col2.metric("Age", employee['age'])
+        col3.metric("Rank", employee['rank'])
+        
+        col4, col5 = st.columns(2)
+        col4.metric("Last Performance Score", f"{employee['last_performance_score']:.2f}")
+        col5.metric("Current Performance Score", f"{employee['current_performance_score']:.2f}")
+        
+        st.write("Future Advancement:", employee['future_advancement'])
+        st.markdown("---")
+    
+    # Performance visualization
+    st.subheader("Performance Overview")
+    df = pd.DataFrame(employees)
+    fig = px.scatter(df, x="age", y="current_performance_score", size="rank", 
+                     hover_data=["name", "employee_id"], color="current_performance_score",
+                     labels={"current_performance_score": "Current Performance Score"})
     st.plotly_chart(fig)
+    
+    if st.button("Logout"):
+        st.session_state.logged_in = False
+        st.experimental_rerun()
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()