Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,427 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+# app.py - Empower Reports: Cambridge School Report System
+# Features: Admin + Teacher roles, CSV/Excel bulk upload, subject switching, averages, PDF reports, audit log, export, teacher self-update
+
 import streamlit as st
+import pandas as pd
+from sqlalchemy import create_engine, Column, Integer, String, Float, Text, ForeignKey, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import hashlib
+from datetime import datetime
+from reportlab.lib.pagesizes import letter
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.lib import colors
+import io
+from st_aggrid import AgGrid
+import yaml
+import os
+
+# -------------------------------
+# 1. DATABASE & MODELS
+# -------------------------------
+ENGINE = create_engine('sqlite:///empower.db')
+Base = declarative_base()
+Session = sessionmaker(bind=ENGINE)
+
+class User(Base):
+    __tablename__ = 'users'
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    email = Column(String, unique=True)  # Used as username
+    role = Column(String)  # 'admin', 'teacher', 'staff'
+    password_hash = Column(String)
+    subjects_taught = Column(String)
+    class_teacher_for = Column(String)
+
+class Student(Base):
+    __tablename__ = 'students'
+    id = Column(Integer, primary_key=True)
+    name = Column(String)
+    year = Column(Integer)
+    subjects = Column(String)  # e.g., "{'Math': 'Active', 'Science': 'Dropped'}"
+    subject_history = Column(Text)
+
+class Mark(Base):
+    __tablename__ = 'marks'
+    id = Column(Integer, primary_key=True)
+    student_id = Column(Integer, ForeignKey('students.id'))
+    subject = Column(String)
+    term = Column(Integer)
+    coursework = Column(Float)
+    midterm = Column(Float)
+    endterm = Column(Float)
+    average = Column(Float)
+    comment = Column(Text)
+    submitted_by = Column(Integer, ForeignKey('users.id'))
+    submitted_at = Column(String, default=lambda: datetime.now().isoformat())
+
+class AuditLog(Base):
+    __tablename__ = 'audit_logs'
+    id = Column(Integer, primary_key=True)
+    user_id = Column(Integer, ForeignKey('users.id'))
+    action = Column(String)
+    details = Column(Text)
+    timestamp = Column(DateTime, default=datetime.utcnow)
+
+Base.metadata.create_all(ENGINE)
+
+# -------------------------------
+# 2. AUTHENTICATION (Manual Login)
+# -------------------------------
+auth_config = {
+    'credentials': {
+        'usernames': {
+            'admin': {
+                'email': 'admin',
+                'name': 'Admin',
+                'password': hashlib.sha256('admin123'.encode()).hexdigest()
+            }
+        }
+    },
+    'cookie': {'name': 'empower_auth', 'key': 'empower_key', 'expiry_days': 30}
+}
+
+if 'authenticator' not in st.session_state:
+    with open('config.yaml', 'w') as f:
+        yaml.dump(auth_config, f)
+    import streamlit_authenticator as stauth
+    st.session_state.authenticator = stauth.Authenticate(
+        'config.yaml', 'empower_auth', 'localhost', 30
+    )
+
+# -------------------------------
+# 3. HELPER FUNCTIONS
+# -------------------------------
+def compute_average(cw, mt, et):
+    return round(cw * 0.3 + mt * 0.35 + et * 0.35, 2)
+
+def log_audit(session, user_id, action, details=""):
+    log = AuditLog(user_id=user_id, action=action, details=details)
+    session.add(log)
+    session.commit()
+
+# -------------------------------
+# 4. STREAMLIT APP
+# -------------------------------
+st.set_page_config(page_title="Empower Reports", layout="wide")
+st.markdown("<h1 style='text-align: center; color: #1e3a8a;'>Empower International Academy</h1>", unsafe_allow_html=True)
+
+# Login
+if 'logged_in' not in st.session_state:
+    st.session_state.logged_in = False
+    st.session_state.user_role = None
+    st.session_state.user_id = None
+
+name, authentication_status, username = st.session_state.authenticator.login('Login to Empower Reports', 'main')
+
+if authentication_status:
+    st.session_state.logged_in = True
+    session = Session()
+    user = session.query(User).filter_by(email=username).first()
+    st.session_state.user_role = user.role
+    st.session_state.user_id = user.id
+    session.close()
+    st.session_state.authenticator.logout('Logout', 'main')
+elif authentication_status is False:
+    st.error('Username/password is incorrect')
+    st.stop()
+elif authentication_status is None:
+    st.stop()
+
+# Sidebar
+st.sidebar.title(f"Welcome, {name}")
+if st.session_state.user_role == 'admin':
+    page = st.sidebar.selectbox("Menu", [
+        "Dashboard", "Manage Users", "Manage Students", "Data Export",
+        "Report Designer", "Generate Reports"
+    ])
+else:
+    page = st.sidebar.selectbox("Menu", [
+        "Dashboard", "Enter Marks", "My Classes", "Change Login Details"
+    ])
+
+# -------------------------------
+# 5. PAGES
+# -------------------------------
+
+# DASHBOARD
+if page == "Dashboard":
+    st.header("Dashboard")
+    session = Session()
+    st.metric("Total Students", session.query(Student).count())
+    st.metric("Total Teachers", session.query(User).filter_by(role='teacher').count())
+    
+    st.subheader("Recent Audit Logs")
+    logs = pd.read_sql("SELECT * FROM audit_logs ORDER BY timestamp DESC LIMIT 10", ENGINE)
+    if not logs.empty:
+        AgGrid(logs, height=250)
+    session.close()
+
+# ADMIN: MANAGE USERS
+elif page == "Manage Users" and st.session_state.user_role == 'admin':
+    st.header("Manage Teachers & Staff")
+    session = Session()
+
+    # Add Single User
+    with st.expander("Add New User", expanded=False):
+        with st.form("add_user_form"):
+            col1, col2 = st.columns(2)
+            with col1:
+                name = st.text_input("Full Name")
+                username = st.text_input("Username (for login)")
+                role = st.selectbox("Role", ["teacher", "staff"])
+            with col2:
+                subjects = st.text_input("Subjects Taught (comma-separated)")
+                class_for = st.text_input("Class Teacher For")
+                password = st.text_input("Password", type="password")
+                confirm = st.text_input("Confirm Password", type="password")
+            
+            if st.form_submit_button("Create Account"):
+                if password != confirm:
+                    st.error("Passwords do not match")
+                elif session.query(User).filter_by(email=username).first():
+                    st.error("Username already taken")
+                else:
+                    hash_pass = hashlib.sha256(password.encode()).hexdigest()
+                    new_user = User(
+                        name=name, email=username, role=role,
+                        password_hash=hash_pass,
+                        subjects_taught=subjects, class_teacher_for=class_for
+                    )
+                    session.add(new_user)
+                    session.commit()
+                    log_audit(session, st.session_state.user_id, "create_user", f"{name} (@{username})")
+                    st.success(f"Account created!\n\n**Username:** {username}\n**Password:** {password}\n\nGive this to the teacher.")
+    
+    # Bulk Upload
+    with st.expander("Bulk Upload Teachers (CSV/Excel)", expanded=False):
+        st.markdown("**Columns:** `name,username,role,subjects_taught,class_teacher_for,password`")
+        file = st.file_uploader("Upload file", type=["csv", "xlsx"], key="bulk_teachers")
+        if file:
+            try:
+                df = pd.read_excel(file) if file.name.endswith('.xlsx') else pd.read_csv(file)
+                required = {"name", "username", "role", "subjects_taught", "class_teacher_for", "password"}
+                if not required.issubset(df.columns):
+                    st.error(f"Missing columns: {', '.join(required - set(df.columns))}")
+                else:
+                    added = 0
+                    details = []
+                    for _, row in df.iterrows():
+                        u = str(row["username"]).strip()
+                        if session.query(User).filter_by(email=u).first():
+                            details.append(f"Skipped {u} (exists)")
+                            continue
+                        hash_pass = hashlib.sha256(str(row["password"]).encode()).hexdigest()
+                        new = User(
+                            name=row["name"], email=u, role=row["role"],
+                            password_hash=hash_pass,
+                            subjects_taught=row["subjects_taught"],
+                            class_teacher_for=row["class_teacher_for"]
+                        )
+                        session.add(new)
+                        added += 1
+                        details.append(f"Added {u}")
+                    session.commit()
+                    log_audit(session, st.session_state.user_id, "bulk_upload_teachers", "; ".join(details))
+                    st.success(f"{added} accounts created. Give login details manually.")
+            except Exception as e:
+                st.error(f"Error: {e}")
+
+    # List Users
+    users_df = pd.read_sql("SELECT id, name, email, role, subjects_taught, class_teacher_for FROM users WHERE role != 'admin'", ENGINE)
+    AgGrid(users_df, height=400, editable=False)
+    session.close()
+
+# ADMIN: MANAGE STUDENTS
+elif page == "Manage Students" and st.session_state.user_role == 'admin':
+    st.header("Manage Students")
+    session = Session()
+
+    # Add Single
+    with st.expander("Add Student"):
+        with st.form("add_student"):
+            name = st.text_input("Name")
+            year = st.selectbox("Year", range(8, 14))
+            subjects = st.text_area("Subjects", "{'Math': 'Active', 'English': 'Active'}")
+            if st.form_submit_button("Add"):
+                new = Student(name=name, year=year, subjects=subjects, subject_history=f"Initial: {subjects}")
+                session.add(new)
+                session.commit()
+                log_audit(session, st.session_state.user_id, "add_student", name)
+                st.success("Student added")
+
+    # Bulk Upload
+    with st.expander("Bulk Upload Students"):
+        file = st.file_uploader("CSV/Excel: name,year,subjects", type=["csv", "xlsx"], key="bulk_students")
+        if file:
+            df = pd.read_excel(file) if file.name.endswith('.xlsx') else pd.read_csv(file)
+            added = updated = 0
+            for _, row in df.iterrows():
+                s = session.query(Student).filter_by(name=row["name"]).first()
+                if s:
+                    s.year = row["year"]
+                    s.subjects = row["subjects"]
+                    s.subject_history += f"; {datetime.now()}: {row['subjects']}"
+                    updated += 1
+                else:
+                    new = Student(name=row["name"], year=row["year"], subjects=row["subjects"],
+                                  subject_history=f"Initial: {row['subjects']}")
+                    session.add(new)
+                    added += 1
+            session.commit()
+            log_audit(session, st.session_state.user_id, "bulk_upload_students", f"{added} added, {updated} updated")
+            st.success(f"{added} added, {updated} updated")
+
+    # Edit Subjects
+    students = pd.read_sql("SELECT * FROM students", ENGINE)
+    if not students.empty:
+        sel = st.selectbox("Edit Student", students['name'])
+        student = session.query(Student).filter_by(name=sel).first()
+        new_subj = st.text_area("Subjects", student.subjects)
+        if st.button("Update Subjects"):
+            student.subjects = new_subj
+            student.subject_history += f"; {datetime.now()}: {new_subj}"
+            session.commit()
+            st.success("Updated")
+
+    AgGrid(students, height=400)
+    session.close()
+
+# ADMIN: DATA EXPORT
+elif page == "Data Export" and st.session_state.user_role == 'admin':
+    st.header("Export Data")
+    if st.button("Download All Marks (CSV)"):
+        df = pd.read_sql("""
+            SELECT s.name as student, m.subject, m.term, m.coursework, m.midterm, m.endterm, 
+                   m.average, m.comment, u.name as teacher
+            FROM marks m
+            JOIN students s ON m.student_id = s.id
+            JOIN users u ON m.submitted_by = u.id
+        """, ENGINE)
+        csv = df.to_csv(index=False)
+        st.download_button("Download Marks", csv, "all_marks.csv", "text/csv")
+        log_audit(Session(), st.session_state.user_id, "export_marks", "Downloaded all marks")
+
+# ADMIN: REPORT DESIGNER
+elif page == "Report Designer" and st.session_state.user_role == 'admin':
+    st.header("Report Template")
+    template = st.text_area("JSON Template", '{"header": "Term Report", "grading": "A*:90+"}', height=200)
+    if st.button("Save Template"):
+        with open("report_template.json", "w") as f:
+            f.write(template)
+        st.success("Template saved")
+
+# ADMIN: GENERATE REPORTS
+elif page == "Generate Reports" and st.session_state.user_role == 'admin':
+    st.header("Generate Student Report")
+    session = Session()
+    students = pd.read_sql("SELECT name FROM students", ENGINE)
+    sel = st.selectbox("Student", students['name'])
+    if sel:
+        marks = pd.read_sql(f"SELECT * FROM marks WHERE student_id = (SELECT id FROM students WHERE name='{sel}')", ENGINE)
+        if not marks.empty:
+            AgGrid(marks.groupby(['term', 'subject'])['average'].mean().reset_index())
+        
+        if st.button("Generate PDF"):
+            buffer = io.BytesIO()
+            doc = SimpleDocTemplate(buffer, pagesize=letter)
+            story = []
+            styles = getSampleStyleSheet()
+            story.append(Paragraph(f"<b>{sel} - Term Report</b>", styles['Title']))
+            data = [['Term', 'Subject', 'Avg', 'Comment']] + marks[['term', 'subject', 'average', 'comment']].values.tolist()
+            table = Table(data)
+            table.setStyle(TableStyle([('BACKGROUND', (0,0), (-1,0), colors.grey), ('GRID', (0,0), (-1,-1), 1, colors.black)]))
+            story.append(table)
+            doc.build(story)
+            st.download_button("Download PDF", buffer.getvalue(), f"{sel}_report.pdf", "application/pdf")
+    session.close()
+
+# TEACHER: ENTER MARKS
+elif page == "Enter Marks" and st.session_state.user_role == 'teacher':
+    st.header("Enter Marks")
+    session = Session()
+    user = session.query(User).get(st.session_state.user_id)
+    my_subjects = [s.strip() for s in user.subjects_taught.split(',')] if user.subjects_taught else []
+    
+    # Single Entry
+    students = pd.read_sql("SELECT name FROM students", ENGINE)
+    sel_student = st.selectbox("Student", students['name'])
+    sel_subject = st.selectbox("Subject", my_subjects)
+    term = st.selectbox("Term", [1,2,3])
+    
+    with st.form("single_mark"):
+        cw = st.number_input("Coursework", 0.0, 100.0)
+        mt = st.number_input("Mid-term", 0.0, 100.0)
+        et = st.number_input("End-term", 0.0, 100.0)
+        comment = st.text_area("Comment")
+        if st.form_submit_button("Submit"):
+            student = session.query(Student).filter_by(name=sel_student).first()
+            if sel_subject not in str(student.subjects):
+                st.error("Subject not active")
+            else:
+                avg = compute_average(cw, mt, et)
+                new = Mark(student_id=student.id, subject=sel_subject, term=term,
+                           coursework=cw, midterm=mt, endterm=et, average=avg,
+                           comment=comment, submitted_by=st.session_state.user_id)
+                session.add(new)
+                session.commit()
+                st.success("Submitted")
+
+    # Bulk Upload
+    with st.expander("Bulk Upload Marks"):
+        file = st.file_uploader("CSV/Excel", type=["csv", "xlsx"], key="bulk_marks")
+        if file:
+            df = pd.read_excel(file) if file.name.endswith('.xlsx') else pd.read_csv(file)
+            saved = 0
+            for _, row in df.iterrows():
+                student = session.query(Student).filter_by(name=row["student_name"]).first()
+                if student and row["subject"] in my_subjects:
+                    avg = compute_average(row["coursework"], row["midterm"], row["endterm"])
+                    new = Mark(student_id=student.id, subject=row["subject"], term=row["term"],
+                               coursework=row["coursework"], midterm=row["midterm"], endterm=row["endterm"],
+                               average=avg, comment=row.get("comment", ""), submitted_by=st.session_state.user_id)
+                    session.add(new)
+                    saved += 1
+            session.commit()
+            st.success(f"{saved} marks saved")
+    session.close()
+
+# TEACHER: MY CLASSES
+elif page == "My Classes":
+    st.header("My Classes")
+    session = Session()
+    user = session.query(User).get(st.session_state.user_id)
+    st.write(f"Class Teacher: {user.class_teacher_for or 'None'}")
+    students = pd.read_sql("SELECT name, year FROM students", ENGINE)
+    AgGrid(students)
+    session.close()
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# TEACHER: CHANGE LOGIN
+elif page == "Change Login Details":
+    st.header("Change Username & Password")
+    session = Session()
+    user = session.query(User).get(st.session_state.user_id)
+    
+    with st.form("change_form"):
+        new_user = st.text_input("New Username", value=user.email)
+        curr_pass = st.text_input("Current Password", type="password")
+        new_pass = st.text_input("New Password", type="password")
+        confirm = st.text_input("Confirm New Password", type="password")
+        
+        if st.form_submit_button("Update"):
+            if hashlib.sha256(curr_pass.encode()).hexdigest() != user.password_hash:
+                st.error("Incorrect current password")
+            elif new_pass != confirm:
+                st.error("Passwords don't match")
+            elif session.query(User).filter(User.email == new_user, User.id != user.id).first():
+                st.error("Username taken")
+            else:
+                user.email = new_user
+                if new_pass:
+                    user.password_hash = hashlib.sha256(new_pass.encode()).hexdigest()
+                session.commit()
+                log_audit(session, st.session_state.user_id, "change_login", f"to {new_user}")
+                st.success("Updated! Logging out...")
+                st.experimental_rerun()
+    session.close()