alteracoes generalizadas

backend/app/api/pesquisa.py

@@ -47,6 +47,7 @@ def pesquisar_modelos(
     autor: str | None = Query(None),
     contem_app: str | None = Query(None),
     tipo_modelo: str | None = Query(None),
+    negociacao_modelo: str | None = Query(None),
     finalidade: str | None = Query(None),
     finalidade_colunas: str | None = Query(None),
     bairro: str | None = Query(None),
@@ -89,6 +90,7 @@ def pesquisar_modelos(
         autor=autor,
         contem_app=contem_app,
         tipo_modelo=tipo_modelo,
+        negociacao_modelo=negociacao_modelo,
         finalidade=finalidade,
         finalidade_colunas=_split_csv(finalidade_colunas),
         bairro=bairro,

backend/app/core/elaboracao/core.py

@@ -6,6 +6,7 @@ Contém: carregamento de dados, estatísticas, transformações, modelo OLS, dia
 
 import os
 import re
+from datetime import datetime
 import pandas as pd
 # Desabilita StringDtype para compatibilidade entre versões do pandas
 pd.set_option('future.infer_string', False)
@@ -203,8 +204,51 @@ def _normalizar_data_iso(valor):
     """Converte valores de data para ISO (YYYY-MM-DD), retornando None se inválido."""
     if valor is None:
         return None
+
+    if isinstance(valor, pd.Timestamp):
+        if pd.isna(valor):
+            return None
+        return valor.date().isoformat()
+
+    texto = str(valor).strip()
+    if not texto:
+        return None
+
+    match_iso = re.match(r"^(\d{4})-(\d{2})-(\d{2})(?:[T\s].*)?$", texto)
+    if match_iso:
+        try:
+            return datetime(
+                int(match_iso.group(1)),
+                int(match_iso.group(2)),
+                int(match_iso.group(3)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    match_iso_slash = re.match(r"^(\d{4})/(\d{2})/(\d{2})(?:[T\s].*)?$", texto)
+    if match_iso_slash:
+        try:
+            return datetime(
+                int(match_iso_slash.group(1)),
+                int(match_iso_slash.group(2)),
+                int(match_iso_slash.group(3)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    match_br = re.match(r"^(\d{2})/(\d{2})/(\d{4})(?:[T\s].*)?$", texto)
+    if match_br:
+        try:
+            return datetime(
+                int(match_br.group(3)),
+                int(match_br.group(2)),
+                int(match_br.group(1)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
     try:
-        dt = pd.to_datetime(valor, errors="coerce", dayfirst=True)
+        dt = pd.to_datetime(texto, errors="coerce", dayfirst=True)
     except Exception:
         return None
     if pd.isna(dt):

backend/app/core/visualizacao/app.py

@@ -10,6 +10,7 @@ from joblib import load
 import os
 import re
 import traceback
+from datetime import datetime
 
 
 # Importações para gráficos (trazidas de graficos.py)
@@ -1239,9 +1240,33 @@ def _formatar_badge_completo(pacote, nome_modelo=""):
 
     def _data_br(value):
         texto = str(value or "").strip()
-        match = re.match(r"^(\d{4})-(\d{2})-(\d{2})$", texto)
-        if match:
-            return f"{match.group(3)}/{match.group(2)}/{match.group(1)}"
+        if not texto:
+            return ""
+
+        match_iso = re.match(r"^(\d{4})-(\d{2})-(\d{2})(?:[T\s].*)?$", texto)
+        if match_iso:
+            try:
+                dt = datetime(int(match_iso.group(1)), int(match_iso.group(2)), int(match_iso.group(3)))
+                return dt.strftime("%d/%m/%Y")
+            except Exception:
+                return texto
+
+        match_iso_slash = re.match(r"^(\d{4})/(\d{2})/(\d{2})(?:[T\s].*)?$", texto)
+        if match_iso_slash:
+            try:
+                dt = datetime(int(match_iso_slash.group(1)), int(match_iso_slash.group(2)), int(match_iso_slash.group(3)))
+                return dt.strftime("%d/%m/%Y")
+            except Exception:
+                return texto
+
+        match_br = re.match(r"^(\d{2})/(\d{2})/(\d{4})(?:[T\s].*)?$", texto)
+        if match_br:
+            try:
+                dt = datetime(int(match_br.group(3)), int(match_br.group(2)), int(match_br.group(1)))
+                return dt.strftime("%d/%m/%Y")
+            except Exception:
+                return texto
+
         return texto
 
     model_name = str(nome_modelo or "").strip() or "-"

backend/app/services/elaboracao_service.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 import json
 import os
+import re
+from datetime import datetime
 from dataclasses import asdict
 from pathlib import Path
 from typing import Any
@@ -48,6 +50,77 @@ _AVALIADORES_PATH = Path(__file__).resolve().parent.parent / "core" / "elaboraca
 _AVALIADORES_CACHE: list[dict[str, Any]] | None = None
 
 
+def _parse_data_iso_segura(value: Any) -> str | None:
+    if value is None:
+        return None
+    if isinstance(value, pd.Timestamp):
+        if pd.isna(value):
+            return None
+        return value.date().isoformat()
+
+    text = str(value).strip()
+    if not text:
+        return None
+
+    iso_match = re.match(r"^(\d{4})-(\d{2})-(\d{2})(?:[T\s].*)?$", text)
+    if iso_match:
+        try:
+            return datetime(
+                int(iso_match.group(1)),
+                int(iso_match.group(2)),
+                int(iso_match.group(3)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    iso_slash_match = re.match(r"^(\d{4})/(\d{2})/(\d{2})(?:[T\s].*)?$", text)
+    if iso_slash_match:
+        try:
+            return datetime(
+                int(iso_slash_match.group(1)),
+                int(iso_slash_match.group(2)),
+                int(iso_slash_match.group(3)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    br_match = re.match(r"^(\d{2})/(\d{2})/(\d{4})(?:[T\s].*)?$", text)
+    if br_match:
+        try:
+            return datetime(
+                int(br_match.group(3)),
+                int(br_match.group(2)),
+                int(br_match.group(1)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    parsed = pd.to_datetime(text, errors="coerce", dayfirst=True)
+    if pd.isna(parsed):
+        return None
+    return parsed.date().isoformat()
+
+
+def _parse_serie_datas_texto_segura(serie_texto: pd.Series) -> pd.Series:
+    preenchidos = serie_texto.dropna().astype(str).str.strip()
+    if preenchidos.empty:
+        return pd.to_datetime(serie_texto, errors="coerce")
+
+    if preenchidos.str.match(r"^\d{4}-\d{2}-\d{2}(?:[T\s].*)?$").all():
+        base = serie_texto.astype(str).str.slice(0, 10)
+        return pd.to_datetime(base, format="%Y-%m-%d", errors="coerce")
+
+    if preenchidos.str.match(r"^\d{4}/\d{2}/\d{2}(?:[T\s].*)?$").all():
+        base = serie_texto.astype(str).str.slice(0, 10)
+        return pd.to_datetime(base, format="%Y/%m/%d", errors="coerce")
+
+    if preenchidos.str.match(r"^\d{2}/\d{2}/\d{4}(?:[T\s].*)?$").all():
+        base = serie_texto.astype(str).str.slice(0, 10)
+        return pd.to_datetime(base, format="%d/%m/%Y", errors="coerce")
+
+    return pd.to_datetime(serie_texto, errors="coerce", dayfirst=True)
+
+
 def list_avaliadores() -> list[dict[str, Any]]:
     global _AVALIADORES_CACHE
     if _AVALIADORES_CACHE is not None:
@@ -212,12 +285,12 @@ def _normalizar_periodo_dados_mercado(periodo: dict[str, Any] | None) -> dict[st
     if not isinstance(periodo, dict):
         return {"coluna_data": None, "data_inicial": None, "data_final": None}
     coluna_data = str(periodo.get("coluna_data") or "").strip() or None
-    inicio = pd.to_datetime(periodo.get("data_inicial"), errors="coerce", dayfirst=True)
-    fim = pd.to_datetime(periodo.get("data_final"), errors="coerce", dayfirst=True)
+    inicio = _parse_data_iso_segura(periodo.get("data_inicial"))
+    fim = _parse_data_iso_segura(periodo.get("data_final"))
     return {
         "coluna_data": coluna_data,
-        "data_inicial": None if pd.isna(inicio) else inicio.date().isoformat(),
-        "data_final": None if pd.isna(fim) else fim.date().isoformat(),
+        "data_inicial": inicio,
+        "data_final": fim,
     }
 
 
@@ -271,7 +344,7 @@ def _converter_coluna_para_datas(
             )
         datas = pd.to_datetime(serie_num, unit="D", origin="1899-12-30", errors="coerce")
     else:
-        datas = pd.to_datetime(serie_base, errors="coerce", dayfirst=True)
+        datas = _parse_serie_datas_texto_segura(serie_base)
 
     datas_validas = datas[mascara_preenchida].dropna()
     proporcao = len(datas_validas) / total_preenchido if total_preenchido else 0.0

backend/app/services/pesquisa_service.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import json
 import math
 import re
 import unicodedata
@@ -20,8 +19,6 @@ from app.core.elaboracao.core import _migrar_pacote_v1_para_v2
 from app.services import model_repository
 from app.services.serializers import sanitize_value
 
-ADMIN_CONFIG_PATH = Path(__file__).resolve().parent.parent / "core" / "pesquisa" / "pesquisa_admin_config.json"
-
 AREA_PRIVATIVA_ALIASES = ["APRIV", "APRIVEQ", "ATPRIV", "ACOPRIV", "AREAPRIV", "AREA_PRIVATIVA", "AREA PRIVATIVA"]
 AREA_TOTAL_ALIASES = ["ATTOTAL", "ATOTAL", "ATOT", "AREA_TOTAL", "AREA TOTAL", "AREA"]
 AREA_GERAL_ALIASES = AREA_PRIVATIVA_ALIASES + AREA_TOTAL_ALIASES + ["ACONST", "ALOC"]
@@ -153,6 +150,7 @@ class PesquisaFiltros:
     autor: str | None = None
     contem_app: str | None = None
     tipo_modelo: str | None = None
+    negociacao_modelo: str | None = None
     finalidade: str | None = None
     finalidade_colunas: list[str] | None = None
     bairro: str | None = None
@@ -193,6 +191,7 @@ _CACHE_LOCK = Lock()
 _CACHE: dict[str, dict[str, Any]] = {}
 _ADMIN_CONFIG_LOCK = Lock()
 _CACHE_SOURCE_SIGNATURE: str | None = None
+_ADMIN_FONTES_SESSION: dict[str, list[str]] = {}
 
 
 def _resolver_repositorio_modelos() -> model_repository.ModelRepositoryResolution:
@@ -233,13 +232,13 @@ def salvar_admin_config_pesquisa(campos: dict[str, list[str]] | None) -> dict[st
     todos = [_carregar_resumo_com_cache(caminho) for caminho in modelos]
     colunas_filtro = _montar_config_colunas_filtro(todos)
     admin_fontes = _normalizar_fontes_admin(campos or {}, colunas_filtro)
-    _persistir_fontes_admin(admin_fontes)
+    _salvar_fontes_admin_sessao(admin_fontes)
     return sanitize_value(
         {
             "colunas_filtro": colunas_filtro,
             "admin_fontes": admin_fontes,
             "total_modelos": len(todos),
-            "status": "Configuracao de busca salva com sucesso.",
+            "status": "Configuracao de busca aplicada para a sessao atual.",
             "fonte_modelos": resolved.as_payload(),
         }
     )
@@ -274,6 +273,7 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
                     "autor": filtros.autor,
                     "contem_app": filtros.contem_app,
                     "tipo_modelo": filtros.tipo_modelo,
+                    "negociacao_modelo": filtros.negociacao_modelo,
                     "finalidade": filtros.finalidade,
                     "finalidade_colunas": filtros.finalidade_colunas or [],
                     "bairro": filtros.bairro,
@@ -339,6 +339,7 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
                 "autor": filtros.autor,
                 "contem_app": filtros.contem_app,
                 "tipo_modelo": filtros.tipo_modelo,
+                "negociacao_modelo": filtros.negociacao_modelo,
                 "finalidade": filtros.finalidade,
                 "finalidade_colunas": filtros.finalidade_colunas or [],
                 "bairro": filtros.bairro,
@@ -651,7 +652,45 @@ def _faixa_data_do_pacote(pacote: dict[str, Any]) -> dict[str, Any] | None:
 def _data_iso_or_none(value: Any) -> str | None:
     if _is_empty(value):
         return None
-    parsed = pd.to_datetime(value, errors="coerce", dayfirst=True)
+
+    text = str(value).strip()
+    if not text:
+        return None
+
+    iso_match = re.match(r"^(\d{4})-(\d{2})-(\d{2})(?:[T\s].*)?$", text)
+    if iso_match:
+        try:
+            return datetime(
+                int(iso_match.group(1)),
+                int(iso_match.group(2)),
+                int(iso_match.group(3)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    iso_slash_match = re.match(r"^(\d{4})/(\d{2})/(\d{2})(?:[T\s].*)?$", text)
+    if iso_slash_match:
+        try:
+            return datetime(
+                int(iso_slash_match.group(1)),
+                int(iso_slash_match.group(2)),
+                int(iso_slash_match.group(3)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    br_match = re.match(r"^(\d{2})/(\d{2})/(\d{4})(?:[T\s].*)?$", text)
+    if br_match:
+        try:
+            return datetime(
+                int(br_match.group(3)),
+                int(br_match.group(2)),
+                int(br_match.group(1)),
+            ).date().isoformat()
+        except Exception:
+            return None
+
+    parsed = pd.to_datetime(text, errors="coerce", dayfirst=True)
     if pd.isna(parsed):
         return None
     return parsed.date().isoformat()
@@ -857,10 +896,17 @@ def _extrair_faixa_data_real_serie(serie: pd.Series) -> dict[str, Any] | None:
     if proporcao_ano_puro >= 0.8:
         return None
 
-    try:
-        serie_data = pd.to_datetime(bruto, errors="coerce", dayfirst=True, format="mixed").dropna()
-    except TypeError:
-        serie_data = pd.to_datetime(bruto, errors="coerce", dayfirst=True).dropna()
+    if bruto.str.match(r"^\d{4}-\d{2}-\d{2}(?:[T\s].*)?$").all():
+        serie_data = pd.to_datetime(bruto.str.slice(0, 10), errors="coerce", format="%Y-%m-%d").dropna()
+    elif bruto.str.match(r"^\d{4}/\d{2}/\d{2}(?:[T\s].*)?$").all():
+        serie_data = pd.to_datetime(bruto.str.slice(0, 10), errors="coerce", format="%Y/%m/%d").dropna()
+    elif bruto.str.match(r"^\d{2}/\d{2}/\d{4}(?:[T\s].*)?$").all():
+        serie_data = pd.to_datetime(bruto.str.slice(0, 10), errors="coerce", format="%d/%m/%Y").dropna()
+    else:
+        try:
+            serie_data = pd.to_datetime(bruto, errors="coerce", dayfirst=True, format="mixed").dropna()
+        except TypeError:
+            serie_data = pd.to_datetime(bruto, errors="coerce", dayfirst=True).dropna()
     total = len(bruto)
     minimo_amostras = min(3, total)
     if len(serie_data) < minimo_amostras:
@@ -1000,6 +1046,10 @@ def _aceita_filtros(modelo: dict[str, Any], filtros: PesquisaFiltros, fontes_adm
     if filtros.tipo_modelo and not _contains_any([_tipo_modelo_modelo(modelo)], filtros.tipo_modelo):
         return False
 
+    negociacao_modelo = _normalizar_negociacao_modelo(filtros.negociacao_modelo)
+    if negociacao_modelo and _negociacao_modelo_modelo(modelo) != negociacao_modelo:
+        return False
+
     if filtros.finalidade and not _aceita_texto_com_colunas(modelo, filtros.finalidade, "finalidade", fontes_admin.get("finalidade")):
         return False
 
@@ -1041,6 +1091,17 @@ def _normalizar_contem_app(value: str | None) -> bool | None:
     return None
 
 
+def _normalizar_negociacao_modelo(value: str | None) -> str | None:
+    chave = _normalize(value or "")
+    if not chave:
+        return None
+    if chave in {"aluguel", "locacao", "a"}:
+        return "aluguel"
+    if chave in {"venda", "v"}:
+        return "venda"
+    return None
+
+
 def _normalizar_otica(value: str | None) -> str:
     return "avaliando"
 
@@ -1063,13 +1124,23 @@ def _anexar_avaliando_info(
 
     finalidade_info = filtros.aval_finalidade
     if _is_provided(finalidade_info):
-        aceito = _aceita_texto_com_colunas(item, str(finalidade_info), "aval_finalidade", fontes_admin.get("aval_finalidade"))
-        registrar("finalidade", finalidade_info, aceito, "nao encontrada no modelo")
+        termos_finalidade = _split_terms(str(finalidade_info))
+        aceito = any(
+            _aceita_texto_com_colunas(item, termo, "aval_finalidade", fontes_admin.get("aval_finalidade"))
+            for termo in termos_finalidade
+        ) if termos_finalidade else False
+        detalhe = "nenhuma das finalidades informadas foi encontrada no modelo" if len(termos_finalidade) > 1 else "nao encontrada no modelo"
+        registrar("finalidade", finalidade_info, aceito, detalhe)
 
     bairro_info = filtros.aval_bairro
     if _is_provided(bairro_info):
-        aceito = _aceita_texto_com_colunas(item, str(bairro_info), "aval_bairro", fontes_admin.get("aval_bairro"))
-        registrar("bairro", bairro_info, aceito, "bairro fora da cobertura do modelo")
+        termos_bairro = _split_terms(str(bairro_info))
+        aceito = any(
+            _aceita_texto_com_colunas(item, termo, "aval_bairro", fontes_admin.get("aval_bairro"))
+            for termo in termos_bairro
+        ) if termos_bairro else False
+        detalhe = "nenhum dos bairros informados esta na cobertura do modelo" if len(termos_bairro) > 1 else "bairro fora da cobertura do modelo"
+        registrar("bairro", bairro_info, aceito, detalhe)
 
     endereco_info = filtros.aval_endereco
     if _is_provided(endereco_info):
@@ -1222,26 +1293,16 @@ def _montar_config_colunas_filtro(modelos: list[dict[str, Any]]) -> dict[str, An
 
 
 def _carregar_fontes_admin(colunas_filtro: dict[str, Any]) -> dict[str, list[str]]:
-    raw: dict[str, Any] = {}
     with _ADMIN_CONFIG_LOCK:
-        if ADMIN_CONFIG_PATH.exists():
-            try:
-                raw_file = json.loads(ADMIN_CONFIG_PATH.read_text(encoding="utf-8"))
-                if isinstance(raw_file, dict):
-                    raw = raw_file
-            except Exception:
-                raw = {}
+        raw = dict(_ADMIN_FONTES_SESSION or {})
     return _normalizar_fontes_admin(raw, colunas_filtro)
 
 
-def _persistir_fontes_admin(fontes_admin: dict[str, list[str]]) -> None:
-    ADMIN_CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+def _salvar_fontes_admin_sessao(fontes_admin: dict[str, list[str]]) -> None:
     payload = {campo: _dedupe_strings(valores) for campo, valores in (fontes_admin or {}).items()}
+    global _ADMIN_FONTES_SESSION
     with _ADMIN_CONFIG_LOCK:
-        ADMIN_CONFIG_PATH.write_text(
-            json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True),
-            encoding="utf-8",
-        )
+        _ADMIN_FONTES_SESSION = payload
 
 
 def _normalizar_fontes_admin(raw: dict[str, Any], colunas_filtro: dict[str, Any]) -> dict[str, list[str]]:
@@ -1697,6 +1758,16 @@ def _tipo_modelo_modelo(modelo: dict[str, Any]) -> str | None:
     return _inferir_tipo_por_nome(nome_referencia)
 
 
+def _negociacao_modelo_modelo(modelo: dict[str, Any]) -> str | None:
+    nome_referencia = _str_or_none(modelo.get("arquivo")) or _str_or_none(modelo.get("nome_modelo")) or ""
+    nome_upper = nome_referencia.upper()
+    if re.search(r"(^|_)A(_|$)", nome_upper):
+        return "aluguel"
+    if re.search(r"(^|_)V(_|$)", nome_upper):
+        return "venda"
+    return None
+
+
 def _extrair_termos_bairro(filtros: PesquisaFiltros) -> list[str]:
     termos: list[str] = []
     if filtros.bairro:

backend/app/services/visualizacao_service.py

@@ -136,7 +136,7 @@ def exibir_modelo(session: SessionState) -> dict[str, Any]:
     mask = tab_coef["Variável"].astype(str).str.lower().isin(["intercept", "const", "(intercept)"])
     if mask.any():
         tab_coef = pd.concat([tab_coef[mask], tab_coef[~mask]], ignore_index=True)
-    tab_coef = tab_coef.round(2)
+    tab_coef = tab_coef.round(4)
 
     tab_obs_calc = pacote["modelo"]["obs_calc"].reset_index().round(2)
 
@@ -169,7 +169,7 @@ def exibir_modelo(session: SessionState) -> dict[str, Any]:
         "escalas_html": escalas_html,
         "dados_transformados": dataframe_to_payload(df_xy, decimals=2),
         "resumo_html": resumo_html,
-        "coeficientes": dataframe_to_payload(tab_coef, decimals=2),
+        "coeficientes": dataframe_to_payload(tab_coef, decimals=4),
         "obs_calc": dataframe_to_payload(tab_obs_calc, decimals=2),
         "grafico_obs_calc": figure_to_payload(figs.get("obs_calc")),
         "grafico_residuos": figure_to_payload(figs.get("residuos")),

frontend/src/components/ElaboracaoTab.jsx

@@ -27,6 +27,7 @@ const GRAU_LABEL_CURTO = {
   2: 'Grau II',
   3: 'Grau III',
 }
+const OUTLIER_RECURSIVO_TOOLTIP = 'Aplicar com recursividade executa os mesmos filtros em ciclos sucessivos: nos bastidores, simula a exclusão dos índices encontrados, recalcula o ajuste do modelo e as métricas de outlier e reaplica os filtros, repetindo até não surgir nenhum índice novo. Para você, o resultado prático é que o campo "A excluir" é preenchido automaticamente com o conjunto total de índices encontrados nessa simulação recursiva.'
 
 function grauBadgeClass(value) {
   const grau = Number(value)
@@ -3696,7 +3697,9 @@ export default function ElaboracaoTab({ sessionId }) {
               </div>
               <div className="outlier-actions-row">
                 <button onClick={onApplyOutlierFilters} disabled={loading}>Aplicar filtros</button>
-                <button type="button" className="btn-filtro-recursivo" onClick={onApplyOutlierFiltersRecursive} disabled={loading}>Aplicar com recursividade</button>
+                <span className="btn-filtro-recursivo-wrap" data-tooltip={OUTLIER_RECURSIVO_TOOLTIP}>
+                  <button type="button" className="btn-filtro-recursivo" onClick={onApplyOutlierFiltersRecursive} disabled={loading}>Aplicar com recursividade</button>
+                </span>
                 <button type="button" className="btn-filtro-add" onClick={onAddFiltro} disabled={loading}>Adicionar filtro</button>
               </div>
             </div>
@@ -3707,7 +3710,12 @@ export default function ElaboracaoTab({ sessionId }) {
               <div className="outlier-inputs-grid">
                 <div className="outlier-input-card">
                   <label>A excluir</label>
-                  <input type="text" value={outliersTexto} onChange={(e) => setOutliersTexto(e.target.value)} placeholder="ex: 5, 12, 30" />
+                  <textarea
+                    rows={2}
+                    value={outliersTexto}
+                    onChange={(e) => setOutliersTexto(e.target.value)}
+                    placeholder="ex: 5, 12, 30"
+                  />
                 </div>
                 <div className="outlier-input-card">
                   <label>A reincluir</label>

frontend/src/components/PesquisaTab.jsx

@@ -7,6 +7,7 @@ import SectionBlock from './SectionBlock'
 const EMPTY_FILTERS = {
   contemApp: '',
   tipoModelo: '',
+  negociacaoModelo: '',
   dataMin: '',
   dataMax: '',
   avalFinalidade: '',
@@ -75,6 +76,37 @@ function normalizeTokenText(value) {
     .toUpperCase()
 }
 
+function normalizeSearchText(value) {
+  return String(value || '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .trim()
+}
+
+function splitMultiTerms(value) {
+  const text = String(value || '').trim()
+  const parts = text.includes('||')
+    ? text.split(/\s*\|\|\s*/)
+    : text.split(/[;|]/)
+  const raw = parts
+    .map((item) => String(item || '').trim())
+    .filter(Boolean)
+  const seen = new Set()
+  const unique = []
+  raw.forEach((item) => {
+    const key = normalizeSearchText(item)
+    if (!key || seen.has(key)) return
+    seen.add(key)
+    unique.push(item)
+  })
+  return unique
+}
+
+function joinMultiTerms(values) {
+  return (values || []).map((item) => String(item || '').trim()).filter(Boolean).join(' || ')
+}
+
 function inferTipoPorNomeModelo(...nomes) {
   const tokens = Object.keys(TIPO_SIGLAS).sort((a, b) => b.length - a.length)
   for (const nome of nomes) {
@@ -106,6 +138,7 @@ function buildApiFilters(filters) {
     otica: 'avaliando',
     contem_app: filters.contemApp,
     tipo_modelo: filters.tipoModelo,
+    negociacao_modelo: filters.negociacaoModelo,
     aval_finalidade: filters.avalFinalidade,
     aval_bairro: filters.avalBairro,
     data_min: filters.dataMin,
@@ -163,6 +196,245 @@ function DateFieldInput({ field, ...props }) {
   )
 }
 
+function ChipAutocompleteInput({
+  field,
+  value,
+  onChange,
+  placeholder,
+  suggestions = [],
+  panelTitle = 'Sugestoes',
+}) {
+  const rootRef = useRef(null)
+  const [query, setQuery] = useState('')
+  const [open, setOpen] = useState(false)
+  const [activeIndex, setActiveIndex] = useState(-1)
+  const selectedValues = useMemo(() => splitMultiTerms(value), [value])
+  const selectedKeys = useMemo(() => new Set(selectedValues.map((item) => normalizeSearchText(item))), [selectedValues])
+  const queryNormalized = normalizeSearchText(query)
+
+  useEffect(() => {
+    if (!value) setQuery('')
+  }, [value])
+
+  const filteredSuggestions = useMemo(() => {
+    const unique = []
+    const seen = new Set()
+
+    ;(suggestions || []).forEach((item) => {
+      const text = String(item || '').trim()
+      if (!text) return
+      const key = normalizeSearchText(text)
+      if (!key || seen.has(key) || selectedKeys.has(key)) return
+      seen.add(key)
+      unique.push(text)
+    })
+
+    if (!queryNormalized) return unique.slice(0, 120)
+    return unique
+      .filter((item) => normalizeSearchText(item).includes(queryNormalized))
+      .slice(0, 120)
+  }, [suggestions, queryNormalized, selectedKeys])
+
+  useEffect(() => {
+    if (!open) return undefined
+    function onDocumentMouseDown(event) {
+      if (!rootRef.current) return
+      if (!rootRef.current.contains(event.target)) {
+        setOpen(false)
+      }
+    }
+    document.addEventListener('mousedown', onDocumentMouseDown)
+    return () => document.removeEventListener('mousedown', onDocumentMouseDown)
+  }, [open])
+
+  useEffect(() => {
+    if (!open || !filteredSuggestions.length) {
+      setActiveIndex(-1)
+      return
+    }
+    setActiveIndex(-1)
+  }, [filteredSuggestions, open])
+
+  function emitValue(nextValue) {
+    onChange({
+      target: {
+        value: nextValue,
+        dataset: { field },
+        name: toInputName(field),
+      },
+    })
+  }
+
+  function setSelectedValues(nextSelected) {
+    emitValue(joinMultiTerms(nextSelected))
+  }
+
+  function addValue(nextValue) {
+    const text = String(nextValue || '').trim()
+    if (!text) return
+    const key = normalizeSearchText(text)
+    if (!key || selectedKeys.has(key)) {
+      setQuery('')
+      return
+    }
+    setSelectedValues([...selectedValues, text])
+    setQuery('')
+    setOpen(true)
+    setActiveIndex(-1)
+  }
+
+  function removeValue(nextValue) {
+    const target = String(nextValue || '').trim()
+    if (!target) return
+
+    const exactIndex = selectedValues.findIndex((item) => String(item || '').trim() === target)
+    if (exactIndex >= 0) {
+      const nextSelected = [...selectedValues]
+      nextSelected.splice(exactIndex, 1)
+      setSelectedValues(nextSelected)
+      return
+    }
+
+    const key = normalizeSearchText(target)
+    const normalizedIndex = selectedValues.findIndex((item) => normalizeSearchText(item) === key)
+    if (normalizedIndex < 0) return
+    const nextSelected = [...selectedValues]
+    nextSelected.splice(normalizedIndex, 1)
+    setSelectedValues(nextSelected)
+  }
+
+  function onInputChange(event) {
+    setQuery(event.target.value)
+    setOpen(true)
+    setActiveIndex(-1)
+  }
+
+  function onInputKeyDown(event) {
+    if (event.key === 'Escape') {
+      setOpen(false)
+      return
+    }
+
+    if (!filteredSuggestions.length) return
+
+    if (event.key === 'ArrowDown') {
+      event.preventDefault()
+      setOpen(true)
+      setActiveIndex((prev) => (prev < 0 ? 0 : (prev + 1) % filteredSuggestions.length))
+      return
+    }
+
+    if (event.key === 'ArrowUp') {
+      event.preventDefault()
+      setOpen(true)
+      setActiveIndex((prev) => {
+        if (prev < 0) return filteredSuggestions.length - 1
+        return (prev - 1 + filteredSuggestions.length) % filteredSuggestions.length
+      })
+      return
+    }
+
+    if (event.key === 'Enter' && open && activeIndex >= 0) {
+      event.preventDefault()
+      addValue(filteredSuggestions[activeIndex])
+      return
+    }
+
+    if (event.key === 'Enter') {
+      const next = String(query || '').trim()
+      if (next) {
+        event.preventDefault()
+        addValue(next)
+      }
+      return
+    }
+
+    if (event.key === ',' || event.key === ';' || event.key === '|') {
+      const next = String(query || '').trim()
+      if (next) {
+        event.preventDefault()
+        addValue(next)
+      }
+      return
+    }
+
+    if (event.key === 'Backspace' && !query && selectedValues.length) {
+      const nextSelected = selectedValues.slice(0, -1)
+      setSelectedValues(nextSelected)
+    }
+  }
+
+  return (
+    <div className={`chip-autocomplete${open ? ' is-open' : ''}`} ref={rootRef}>
+      {selectedValues.length ? (
+        <div className="chip-autocomplete-selected-wrap">
+          {selectedValues.map((item) => (
+            <span key={`${field}-selected-${item}`} className="chip-autocomplete-selected">
+              <span>{item}</span>
+              <button
+                type="button"
+                className="chip-autocomplete-selected-remove"
+                onMouseDown={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                  removeValue(item)
+                }}
+                onClick={(event) => {
+                  event.preventDefault()
+                  event.stopPropagation()
+                }}
+                aria-label={`Remover ${item}`}
+              >
+                ×
+              </button>
+            </span>
+          ))}
+        </div>
+      ) : null}
+
+      <TextFieldInput
+        field={field}
+        value={query}
+        onChange={onInputChange}
+        onFocus={() => {
+          setOpen(true)
+          setActiveIndex(-1)
+        }}
+        onKeyDown={onInputKeyDown}
+        placeholder={placeholder}
+      />
+
+      {open ? (
+        <div className="chip-autocomplete-panel" role="listbox">
+          <div className="chip-autocomplete-panel-head">{panelTitle}</div>
+          {filteredSuggestions.length ? (
+            <div className="chip-autocomplete-chip-wrap">
+              {filteredSuggestions.map((item, idx) => (
+                <button
+                  type="button"
+                  key={`${field}-chip-${item}-${idx}`}
+                  className={`chip-autocomplete-chip${idx === activeIndex ? ' is-active' : ''}`}
+                  onMouseDown={(event) => {
+                    event.preventDefault()
+                    event.stopPropagation()
+                    addValue(item)
+                  }}
+                >
+                  {item}
+                </button>
+              ))}
+            </div>
+          ) : (
+            <div className="chip-autocomplete-empty">
+              Nenhuma sugestao encontrada.
+            </div>
+          )}
+        </div>
+      ) : null}
+    </div>
+  )
+}
+
 export default function PesquisaTab() {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState('')
@@ -380,7 +652,7 @@ export default function PesquisaTab() {
             </select>
           </label>
           <label className="pesquisa-field">
-            Tipo do modelo
+            Finalidade Generica
             <select
               data-field="tipoModelo"
               name={toInputName('tipoModelo')}
@@ -395,25 +667,30 @@ export default function PesquisaTab() {
             </select>
           </label>
           <label className="pesquisa-field">
-            Finalidade do imovel
-            <TextFieldInput
-              list="pesquisa-finalidades"
+            Finalidade Cadastral
+            <ChipAutocompleteInput
               field="avalFinalidade"
               value={filters.avalFinalidade}
               onChange={onFieldChange}
-              placeholder="Ex: Apartamento"
+              placeholder="Digite e pressione Enter"
+              suggestions={sugestoes.finalidades || []}
+              panelTitle="Finalidades sugeridas"
             />
           </label>
 
           <label className="pesquisa-field">
-            Bairro do imovel
-            <TextFieldInput
-              list="pesquisa-bairros"
-              field="avalBairro"
-              value={filters.avalBairro}
+            Tipo do Modelo
+            <select
+              data-field="negociacaoModelo"
+              name={toInputName('negociacaoModelo')}
+              value={filters.negociacaoModelo}
               onChange={onFieldChange}
-              placeholder="Ex: Centro"
-            />
+              autoComplete="off"
+            >
+              <option value="">Indiferente</option>
+              <option value="aluguel">Aluguel</option>
+              <option value="venda">Venda</option>
+            </select>
           </label>
         </div>
 
@@ -431,28 +708,30 @@ export default function PesquisaTab() {
           </div>
 
           <div className="pesquisa-avaliando-stack pesquisa-avaliando-bottom-stack">
-            <label className="pesquisa-field">
-              Area do imovel
-              <NumberFieldInput field="avalArea" value={filters.avalArea} onChange={onFieldChange} placeholder="0" />
-            </label>
-            <label className="pesquisa-field">
-              RH do imovel
-              <NumberFieldInput field="avalRh" value={filters.avalRh} onChange={onFieldChange} placeholder="0" />
+            <div className="pesquisa-area-rh-grid">
+              <label className="pesquisa-field">
+                Area do imovel
+                <NumberFieldInput field="avalArea" value={filters.avalArea} onChange={onFieldChange} placeholder="0" />
+              </label>
+              <label className="pesquisa-field">
+                RH do imovel
+                <NumberFieldInput field="avalRh" value={filters.avalRh} onChange={onFieldChange} placeholder="0" />
+              </label>
+            </div>
+            <label className="pesquisa-field pesquisa-bairro-bottom-field">
+              Bairro do imovel
+              <ChipAutocompleteInput
+                field="avalBairro"
+                value={filters.avalBairro}
+                onChange={onFieldChange}
+                placeholder="Digite e pressione Enter"
+                suggestions={sugestoes.bairros || []}
+                panelTitle="Bairros sugeridos"
+              />
             </label>
           </div>
         </div>
 
-        <datalist id="pesquisa-finalidades">
-          {(sugestoes.finalidades || []).map((item) => (
-            <option key={`finalidade-${item}`} value={item} />
-          ))}
-        </datalist>
-        <datalist id="pesquisa-bairros">
-          {(sugestoes.bairros || []).map((item) => (
-            <option key={`bairro-${item}`} value={item} />
-          ))}
-        </datalist>
-
         <div className="row pesquisa-actions pesquisa-actions-primary">
           <button type="button" onClick={() => void buscarModelos()} disabled={loading}>
             {loading ? 'Pesquisando...' : 'Pesquisar'}

frontend/src/styles.css

@@ -911,6 +911,119 @@ button.pesquisa-otica-btn.active:hover {
   width: 100%;
 }
 
+.chip-autocomplete {
+  position: relative;
+}
+
+.chip-autocomplete-selected-wrap {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+  margin: 0 0 7px;
+}
+
+.chip-autocomplete-selected {
+  display: inline-flex;
+  align-items: center;
+  flex: 0 0 auto;
+  gap: 6px;
+  border: 1px solid #b7cee6;
+  border-radius: 999px;
+  background: #eaf3fc;
+  color: #2f4d69;
+  font-size: 0.77rem;
+  font-weight: 700;
+  line-height: 1.1;
+  padding: 4px 8px;
+}
+
+.chip-autocomplete-selected-remove {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  flex: 0 0 16px;
+  width: 16px;
+  height: 16px;
+  border: none;
+  background: transparent;
+  color: #365776;
+  font-size: 0.9rem;
+  font-weight: 700;
+  line-height: 1;
+  padding: 0;
+  margin: 0;
+  border-radius: 999px;
+  box-shadow: none;
+  transform: none;
+  cursor: pointer;
+}
+
+.chip-autocomplete-selected-remove:hover {
+  color: #20374f;
+  background: rgba(54, 87, 118, 0.09);
+  box-shadow: none;
+  transform: none;
+}
+
+.chip-autocomplete-panel {
+  position: absolute;
+  top: calc(100% + 6px);
+  left: 0;
+  right: 0;
+  z-index: 35;
+  border: 1px solid #c8d7e6;
+  border-radius: 12px;
+  background: #ffffff;
+  box-shadow: 0 8px 24px rgba(46, 77, 107, 0.14);
+  padding: 8px;
+  max-height: 190px;
+  overflow: auto;
+}
+
+.chip-autocomplete-panel-head {
+  font-size: 0.72rem;
+  font-weight: 700;
+  color: #4f667d;
+  margin: 1px 1px 7px;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+}
+
+.chip-autocomplete-chip-wrap {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
+.chip-autocomplete-chip {
+  border: 1px solid #c9d9ea;
+  border-radius: 999px;
+  background: #f5f9fd;
+  color: #37516b;
+  font-size: 0.78rem;
+  font-weight: 600;
+  line-height: 1.15;
+  padding: 5px 9px;
+  cursor: pointer;
+  max-width: 100%;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.chip-autocomplete-chip:hover,
+.chip-autocomplete-chip.is-active {
+  background: #dcecff;
+  border-color: #aac7e8;
+  color: #233b54;
+}
+
+.chip-autocomplete-empty {
+  font-size: 0.8rem;
+  color: #657f99;
+  padding: 2px 2px 5px;
+}
+
 .pesquisa-filtros-groups .pesquisa-field input,
 .pesquisa-filtros-groups .pesquisa-field select {
   width: min(100%, 255px);
@@ -997,6 +1110,13 @@ button.pesquisa-otica-btn.active:hover {
   align-items: start;
 }
 
+.pesquisa-area-rh-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px 14px;
+  align-items: start;
+}
+
 .pesquisa-avaliando-periodo-pair {
   margin: 0;
 }
@@ -1005,6 +1125,10 @@ button.pesquisa-otica-btn.active:hover {
   gap: 12px;
 }
 
+.pesquisa-bairro-bottom-field {
+  grid-column: 1 / -1;
+}
+
 .pesquisa-avaliando-bottom-grid .pesquisa-field-pair {
   grid-column: auto;
   margin: 0;
@@ -2864,7 +2988,7 @@ button.btn-upload-select {
 
 .outlier-inputs-grid {
   display: grid;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
+  grid-template-columns: minmax(0, 1fr);
   gap: 12px;
 }
 
@@ -2884,6 +3008,13 @@ button.btn-upload-select {
   width: 100%;
 }
 
+.outlier-input-card textarea {
+  width: 100%;
+  resize: vertical;
+  min-height: 58px;
+  max-height: 160px;
+}
+
 .btn-reiniciar-iteracao {
   --btn-bg-start: #ff8c00;
   --btn-bg-end: #e67e00;
@@ -2973,11 +3104,68 @@ button.btn-upload-select {
 }
 
 .outlier-actions-row button.btn-filtro-recursivo {
-  --btn-bg-start: #8f6bd9;
-  --btn-bg-end: #7552c3;
-  --btn-border: #6848b4;
-  --btn-shadow-soft: rgba(117, 82, 195, 0.2);
-  --btn-shadow-strong: rgba(117, 82, 195, 0.28);
+  --btn-bg-start: #59b97f;
+  --btn-bg-end: #3d9c63;
+  --btn-border: #338655;
+  --btn-shadow-soft: rgba(61, 156, 99, 0.2);
+  --btn-shadow-strong: rgba(61, 156, 99, 0.28);
+}
+
+.outlier-actions-row .btn-filtro-recursivo-wrap {
+  position: relative;
+  display: inline-flex;
+}
+
+.outlier-actions-row .btn-filtro-recursivo-wrap::after {
+  content: attr(data-tooltip);
+  position: absolute;
+  left: calc(100% + 10px);
+  bottom: calc(100% + 2px);
+  width: min(520px, 68vw);
+  max-width: 520px;
+  background: #f4fbf7;
+  border: 1px solid #bfe4cc;
+  border-radius: 10px;
+  color: #2f5f43;
+  font-size: 0.78rem;
+  line-height: 1.35;
+  font-weight: 600;
+  padding: 10px 12px;
+  box-shadow: 0 8px 20px rgba(47, 95, 67, 0.18);
+  opacity: 0;
+  transform: translateY(4px);
+  transition: opacity 0.14s ease, transform 0.14s ease;
+  pointer-events: none;
+  z-index: 30;
+}
+
+.outlier-actions-row .btn-filtro-recursivo-wrap::before {
+  content: '';
+  position: absolute;
+  left: calc(100% + 4px);
+  bottom: calc(100% + 12px);
+  width: 10px;
+  height: 10px;
+  background: #f4fbf7;
+  border-left: 1px solid #bfe4cc;
+  border-top: 1px solid #bfe4cc;
+  transform: rotate(225deg);
+  opacity: 0;
+  transition: opacity 0.14s ease, transform 0.14s ease;
+  pointer-events: none;
+  z-index: 29;
+}
+
+.outlier-actions-row .btn-filtro-recursivo-wrap:hover::after,
+.outlier-actions-row .btn-filtro-recursivo-wrap:focus-within::after {
+  opacity: 1;
+  transform: translateY(0);
+}
+
+.outlier-actions-row .btn-filtro-recursivo-wrap:hover::before,
+.outlier-actions-row .btn-filtro-recursivo-wrap:focus-within::before {
+  opacity: 1;
+  transform: rotate(225deg);
 }
 
 .resumo-outliers-box {
@@ -3758,6 +3946,10 @@ button.btn-download-subtle {
     grid-template-columns: 1fr;
   }
 
+  .pesquisa-area-rh-grid {
+    grid-template-columns: 1fr;
+  }
+
   .pesquisa-dynamic-filter-row,
   .pesquisa-range-values-row,
   .pesquisa-range-row,