Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,378 @@
-import altair as alt
-import numpy as np
-import pandas as pd
+import io
+import os
+import shutil
+import zipfile
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from dotenv import load_dotenv
 import streamlit as st
 
-"""
-# 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])),
-    ))
+from reporter.generate import generate_selected, list_people
+
+load_dotenv()
+
+
+st.set_page_config(page_title="BDC Report Generator", layout="wide")
+
+
+def _require_login() -> None:
+    """Login semplice via variabili d'ambiente (file .env).
+
+    Variabili attese:
+    - AUTH_USER
+    - AUTH_PASSWORD
+
+    Se non configurate, l'app resta accessibile (utile in sviluppo).
+    """
+    user = os.getenv("AUTH_USER", "")
+    pwd = os.getenv("AUTH_PASSWORD", "")
+
+    if not user or not pwd:
+        return
+
+    if st.session_state.get("auth_ok"):
+        return
+
+    st.markdown("<br>" * 3, unsafe_allow_html=True)
+    _, col, _ = st.columns([1, 1.2, 1])
+    with col:
+        st.title("Bilancio Competenze")
+        u = st.text_input("Username", key="_login_u", placeholder="inserisci username")
+        p = st.text_input("Password", type="password", key="_login_p", placeholder="inserisci password")
+        st.markdown("<br>", unsafe_allow_html=True)
+        if st.button("Accedi", type="primary", use_container_width=True):
+            if u == user and p == pwd:
+                st.session_state.auth_ok = True
+                st.rerun()
+            else:
+                st.error("Credenziali non valide", icon="🔒")
+
+    st.stop()
+
+
+def _save_upload(upload, to_dir: Path) -> Optional[Path]:
+    if upload is None:
+        return None
+    p = to_dir / upload.name
+    p.write_bytes(upload.getbuffer())
+    return p
+
+
+def _zip_bytes(paths: List[Path]) -> bytes:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+        for p in paths:
+            if p.exists() and p.is_file():
+                z.write(p, arcname=p.name)
+    return buf.getvalue()
+
+
+_require_login()
+
+make_pdf = True
+
+work_root = Path("/tmp/bdc_app")
+work_root.mkdir(parents=True, exist_ok=True)
+
+
+def _ensure_tmp() -> Path:
+    if work_root.exists():
+        shutil.rmtree(work_root)
+    work_root.mkdir(parents=True, exist_ok=True)
+    return work_root
+
+
+def _load_people_lists(
+    c_auto_p: Optional[Path],
+    c_val_p: Optional[Path],
+    m_auto_p: Optional[Path],
+    m_val_p: Optional[Path],
+) -> Tuple[List[str], List[str]]:
+    collab_people: List[str] = []
+    manager_people: List[str] = []
+    if c_auto_p and c_val_p:
+        collab_people = list_people(c_auto_p, c_val_p)
+    if m_auto_p and m_val_p:
+        manager_people = list_people(m_auto_p, m_val_p)
+    return collab_people, manager_people
+
+
+# ── Sidebar ────────────────────────────────────────────────────────────────────
+with st.sidebar:
+    st.title("⚙️ Impostazioni")
+    sezioni = st.multiselect(
+        "Tipologia",
+        options=["Collaboratori", "Manager"],
+        default=["Collaboratori", "Manager"],
+    )
+
+    show_collab = "Collaboratori" in sezioni
+    show_manager = "Manager" in sezioni
+
+    if show_collab:
+        st.divider()
+        st.title("👥 Collaboratori")
+        tpl_collab = st.file_uploader("Modello Documento", type=["docx"], key="tpl_c")
+        c_auto = st.file_uploader("Autovalutazione", type=["xlsx"], key="c_auto")
+        c_val = st.file_uploader("Valutazione", type=["xlsx"], key="c_val")
+        if all([tpl_collab, c_auto, c_val]):
+            st.success("Files collaboratori inseriti", icon="✅")
+        else:
+            st.error("Inserire files collaboratori", icon="❌")
+    else:
+        tpl_collab = c_auto = c_val = None
+
+    if show_manager:
+        st.divider()
+        st.title("🏢 Manager")
+        tpl_manager = st.file_uploader("Modello Documento", type=["docx"], key="tpl_m")
+        m_auto = st.file_uploader("Autovalutazione", type=["xlsx"], key="m_auto")
+        m_val = st.file_uploader("Valutazione", type=["xlsx"], key="m_val")
+        if all([tpl_manager, m_auto, m_val]):
+            st.success("Files manager inseriti", icon="✅")
+        else:
+            st.error("Inserire files manager", icon="❌")
+    else:
+        tpl_manager = m_auto = m_val = None
+
+    collab_ready = all([tpl_collab, c_auto, c_val])
+    manager_ready = all([tpl_manager, m_auto, m_val])
+    can_prepare = collab_ready or manager_ready
+
+    st.divider()
+    if st.button("Genera Report", type="primary", disabled=not can_prepare, use_container_width=True):
+        tmp = _ensure_tmp()
+        tpl_c_p = _save_upload(tpl_collab, tmp) if collab_ready else None
+        tpl_m_p = _save_upload(tpl_manager, tmp) if manager_ready else None
+        c_auto_p = _save_upload(c_auto, tmp) if collab_ready else None
+        c_val_p = _save_upload(c_val, tmp) if collab_ready else None
+        m_auto_p = _save_upload(m_auto, tmp) if manager_ready else None
+        m_val_p = _save_upload(m_val, tmp) if manager_ready else None
+
+        collab_people, manager_people = _load_people_lists(c_auto_p, c_val_p, m_auto_p, m_val_p)
+
+        if not collab_people and not manager_people:
+            st.error("Non ho trovato nessun nome nei file. Controlla la colonna 'Nome e cognome'.")
+        else:
+            st.session_state._paths = {
+                "tpl_c": str(tpl_c_p) if tpl_c_p else "",
+                "tpl_m": str(tpl_m_p) if tpl_m_p else "",
+                "c_auto": str(c_auto_p) if c_auto_p else "",
+                "c_val": str(c_val_p) if c_val_p else "",
+                "m_auto": str(m_auto_p) if m_auto_p else "",
+                "m_val": str(m_val_p) if m_val_p else "",
+                "tmp": str(tmp),
+            }
+            st.session_state._collab_people = collab_people
+            st.session_state._manager_people = manager_people
+            st.session_state._phase = "select"
+            st.session_state._results_ready = False
+            st.rerun()
+
+
+# ── Main area ──────────────────────────────────────────────────────────────────
+st.title("📊 Bilancio Competenze")
+with st.expander("ℹ️ Funzionamento"):
+    st.markdown(
+        """
+        Questa app genera report individuali di **Bilancio delle Competenze** in Word e PDF.
+        ##### Istruzioni: 
+        1. Nella barra laterale seleziona le sezioni da attivare (**Collaboratori**, **Manager**, o entrambe)
+        2. Carica il template Word e i due file Excel (autovalutazione e valutazione) per ciascuna sezione
+        3. Clicca **Genera Report** — scegli le persone da includere e scarica i report
+        """
+    )
+st.divider()
+phase = st.session_state.get("_phase")
+
+
+# ── Fase: selezione persone ────────────────────────────────────────────────────
+if phase == "select":
+    collab_people: List[str] = st.session_state.get("_collab_people", [])
+    manager_people: List[str] = st.session_state.get("_manager_people", [])
+
+    col_c, col_m = st.columns(2)
+    sel_c: List[str] = []
+    sel_m: List[str] = []
+
+    with col_c:
+        st.subheader(f"👥 Collaboratori")
+        for n in collab_people:
+            if st.checkbox(n, value=True, key=f"c_{n}"):
+                sel_c.append(n)
+
+    with col_m:
+        st.subheader(f"🏢 Manager")
+        for n in manager_people:
+            if st.checkbox(n, value=True, key=f"m_{n}"):
+                sel_m.append(n)
+
+    tot = len(sel_c) + len(sel_m)
+    c1, c2= st.columns([1, 1])
+    with c1:
+        if st.button("Annulla", use_container_width=True):
+            st.session_state._phase = None
+            st.rerun()
+    with c2:
+        if st.button(f"Genera {tot} report", type="primary", disabled=tot == 0, use_container_width=True):
+            st.session_state._selected_c = sel_c
+            st.session_state._selected_m = sel_m
+            st.session_state._phase = "generate"
+            st.rerun()
+
+
+# ── Fase: generazione ─────────────────────────────────────────────────────────
+elif phase == "generate":
+    sel_c = st.session_state.get("_selected_c", [])
+    sel_m = st.session_state.get("_selected_m", [])
+    total = len(sel_c) + len(sel_m)
+
+    paths = st.session_state._paths
+
+    def _p(key: str) -> Optional[Path]:
+        v = paths.get(key, "")
+        return Path(v) if v else None
+
+    tpl_c_p, tpl_m_p = _p("tpl_c"), _p("tpl_m")
+    c_auto_p, c_val_p = _p("c_auto"), _p("c_val")
+    m_auto_p, m_val_p = _p("m_auto"), _p("m_val")
+    out_dir = Path(paths["tmp"]) / "output"
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    header = st.empty()
+    header.subheader(f"Generazione in corso… (0/{total})")
+    progress = st.progress(0)
+    log_area = st.empty()
+
+    all_produced = []
+    all_warnings: List[str] = []
+    done = 0
+    log_lines: List[str] = []
+
+    for name in sel_c:
+        log_lines.append(f"⏳ Collaboratore: **{name}**")
+        log_area.markdown("\n\n".join(log_lines))
+        r = generate_selected(
+            collab_auto=c_auto_p, collab_valut=c_val_p, collab_template=tpl_c_p,
+            manager_auto=None, manager_valut=None, manager_template=None,
+            selected_collaboratori=[name], selected_manager=[],
+            output_dir=out_dir, make_pdf=make_pdf,
+        )
+        all_produced.extend(r.produced)
+        all_warnings.extend(r.warnings)
+        done += 1
+        log_lines[-1] = f"✅ Collaboratore: **{name}**"
+        log_area.markdown("\n\n".join(log_lines))
+        progress.progress(done / total)
+        header.subheader(f"Generazione in corso… ({done}/{total})")
+
+    for name in sel_m:
+        log_lines.append(f"⏳ Manager: **{name}**")
+        log_area.markdown("\n\n".join(log_lines))
+        r = generate_selected(
+            collab_auto=None, collab_valut=None, collab_template=None,
+            manager_auto=m_auto_p, manager_valut=m_val_p, manager_template=tpl_m_p,
+            selected_collaboratori=[], selected_manager=[name],
+            output_dir=out_dir, make_pdf=make_pdf,
+        )
+        all_produced.extend(r.produced)
+        all_warnings.extend(r.warnings)
+        done += 1
+        log_lines[-1] = f"✅ Manager: **{name}**"
+        log_area.markdown("\n\n".join(log_lines))
+        progress.progress(done / total)
+        header.subheader(f"Generazione in corso… ({done}/{total})")
+
+    header.subheader(f"Completato — {total} report generati ✅")
+
+    st.session_state._results = [
+        {"person": a.person, "kind": a.kind,
+         "docx_path": a.docx_path, "pdf_path": a.pdf_path, "notes": a.notes}
+        for a in all_produced
+    ]
+    st.session_state._result_warnings = all_warnings
+    st.session_state._results_ready = True
+    st.session_state._phase = "results"
+    st.rerun()
+
+
+# ── Fase: risultati ────────────────────────────────────────────────────────────
+elif phase == "results":
+    results = st.session_state._results
+    warnings = st.session_state.get("_result_warnings", [])
+
+    if warnings:
+        st.warning("\n".join(warnings))
+
+    st.success(f"Generazione completata: {len(results)} report", icon="✅")
+
+    all_files: List[Path] = []
+    by_kind: Dict[str, list] = {}
+    for a in sorted(results, key=lambda x: (x["kind"], x["person"])):
+        by_kind.setdefault(a["kind"], []).append(a)
+
+    def _render_table(artifacts: list) -> None:
+        # Intestazione
+        h0, h1, h2 = st.columns([4, 1, 1])
+        h0.markdown("**Persona**")
+        h1.markdown("**Word**")
+        h2.markdown("**PDF**")
+        for a in artifacts:
+            c0, c1, c2 = st.columns([4, 1, 1])
+            label = a["person"]
+            if a["notes"]:
+                label += f"  \n*{a['notes']}*"
+            c0.markdown(label)
+
+            docx_path = Path(a["docx_path"])
+            all_files.append(docx_path)
+            c1.download_button(
+                "DOCX",
+                data=docx_path.read_bytes(),
+                file_name=docx_path.name,
+                mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                use_container_width=True,
+                key=f"docx_{a['kind']}_{a['person']}",
+            )
+
+            has_pdf = a["pdf_path"] and Path(a["pdf_path"]).exists()
+            if has_pdf:
+                pdf_path = Path(a["pdf_path"])
+                all_files.append(pdf_path)
+                c2.download_button(
+                    "PDF",
+                    data=pdf_path.read_bytes(),
+                    file_name=pdf_path.name,
+                    mime="application/pdf",
+                    use_container_width=True,
+                    key=f"pdf_{a['kind']}_{a['person']}",
+                    type="primary",
+                )
+
+    kinds = list(by_kind.keys())
+    if len(kinds) > 1:
+        tabs = st.tabs(kinds)
+        for tab, kind in zip(tabs, kinds):
+            with tab:
+                _render_table(by_kind[kind])
+    else:
+        st.subheader(kinds[0])
+        _render_table(by_kind[kinds[0]])
+
+    st.divider()
+    c1, c2= st.columns([1, 1])
+    with c1:
+        if st.button("Annulla", use_container_width=True):
+            st.session_state._phase = None
+            st.rerun()
+    with c2:             
+        st.download_button(
+            "Scarica Tutti i Files",
+            data=_zip_bytes(all_files),
+            file_name="BDC_report_output.zip",
+            mime="application/zip",
+            use_container_width=True,
+            key="zip_all",
+            type="primary",
+        )