Update app.py

app.py

@@ -639,6 +639,102 @@ def main():
         if st.session_state.get("__auth_diag__"):
             _render_auth_diag_panel()
 
+            # ============================
+            # 🔬 Diagnóstico profundo do banco (somente Admin + painel ativo)
+            # ============================
+            from sqlalchemy import inspect  # import local para evitar custo desnecessário
+            with st.sidebar.expander("🧪 Diagnóstico Profundo do Banco", expanded=False):
+                db = _get_db_session()
+                try:
+                    eng = db.bind
+                    st.caption(f"Engine URL: {eng.url}")
+
+                    # 1) SELECT 1
+                    try:
+                        db.execute(text("SELECT 1"))
+                        st.success("SELECT 1 OK")
+                    except Exception as e:
+                        st.error(f"SELECT 1 falhou: {e}")
+
+                    # 2) Tabelas registradas
+                    insp = inspect(eng)
+                    tables = insp.get_table_names()
+                    st.write("Tabelas:", tables)
+
+                    # 3) Detectar tabela de usuários
+                    user_tables_candidates = ["usuarios", "usuario", "Usuario", "users", "auth_user"]
+                    target_table = next((t for t in user_tables_candidates if t in tables), None)
+                    if not target_table:
+                        st.warning("Tabela de usuários não encontrada. Verifique nomes e migrations.")
+                    else:
+                        st.write(f"Usando tabela: **{target_table}**")
+
+                        # 4) Colunas
+                        cols = [c["name"] for c in insp.get_columns(target_table)]
+                        st.write("Colunas:", cols)
+
+                        # 5) Contagem
+                        try:
+                            cnt = db.execute(text(f"SELECT COUNT(*) FROM {target_table}")).fetchone()[0]
+                            st.write("Quantidade de registros:", cnt)
+                        except Exception as e:
+                            st.error(f"COUNT(*) falhou: {e}")
+
+                        # 6) Amostra de usuários (sem senhas)
+                        try:
+                            # tenta nomes comuns de colunas
+                            sel_cols = [c for c in ["usuario", "email", "perfil", "nome"] if c in cols]
+                            sel_expr = ", ".join(sel_cols) if sel_cols else "*"
+                            amostra = db.execute(text(f"SELECT {sel_expr} FROM {target_table} LIMIT 5"))
+                            rows = [dict(r._mapping) for r in amostra]
+                            st.write("Amostra:", rows)
+                        except Exception as e:
+                            st.error(f"Amostra falhou: {e}")
+
+                        # 7) Teste de bcrypt (não grava nada)
+                        import bcrypt
+                        st.markdown("---")
+                        st.caption("Teste de verificação bcrypt (não grava nada)")
+                        test_user = st.text_input("Usuário para testar hash", "", key="__bcrypt_user__")
+                        test_pass = st.text_input("Senha para testar hash", "", type="password", key="__bcrypt_pass__")
+
+                        if st.button("Testar bcrypt com este usuário", key="__btn_bcrypt_test__"):
+                            try:
+                                # detectar nome da coluna de senha
+                                pass_cols = [c for c in ["senha_hash", "password_hash", "senha", "hash"] if c in cols]
+                                user_cols = [c for c in ["usuario", "username", "login"] if c in cols]
+                                if not pass_cols or not user_cols:
+                                    st.error("Não encontrei colunas de senha/usuário na tabela.")
+                                else:
+                                    c_pass = pass_cols[0]
+                                    c_user = user_cols[0]
+                                    res = db.execute(
+                                        text(f"SELECT {c_user} AS u, {c_pass} AS h FROM {target_table} WHERE {c_user} = :u LIMIT 1"),
+                                        {"u": test_user.strip()}
+                                    ).fetchone()
+                                    if not res:
+                                        st.error("Usuário não encontrado na tabela.")
+                                    else:
+                                        senha_hash = res._mapping.get("h")
+                                        if not senha_hash:
+                                            st.error(f"Coluna '{c_pass}' vazia/nula — login normal não vai entrar.")
+                                        else:
+                                            try:
+                                                ok = bcrypt.checkpw(test_pass.encode("utf-8"), str(senha_hash).encode("utf-8"))
+                                                st.success(f"bcrypt.checkpw = {ok}")
+                                                if not ok:
+                                                    st.info("Se a senha no banco não for bcrypt, gere um hash e atualize o registro.")
+                                            except Exception as e:
+                                                st.error(f"Falha no bcrypt: {e}")
+                                                st.info("Um hash válido geralmente começa com '$2a$' ou '$2b$' e tem 60 caracteres.")
+                            except Exception as e:
+                                st.error(f"Erro no teste: {e}")
+                finally:
+                    try:
+                        db.close()
+                    except Exception:
+                        pass
+
     # 🔄 Botão de Recarregar (mantém a sessão ativa) + ⏱️ Controle do intervalo
     st.sidebar.markdown("---")
     col_reload, col_interval = st.sidebar.columns([1, 1])