diversas atualizacoes na aba pesquisas

backend/app/api/pesquisa.py

@@ -3,7 +3,13 @@ from __future__ import annotations
 from fastapi import APIRouter, Query
 from pydantic import BaseModel
 
-from app.services.pesquisa_service import PesquisaFiltros, gerar_mapa_modelos, listar_modelos
+from app.services.pesquisa_service import (
+    PesquisaFiltros,
+    gerar_mapa_modelos,
+    listar_modelos,
+    obter_admin_config_pesquisa,
+    salvar_admin_config_pesquisa,
+)
 
 
 router = APIRouter(prefix="/api/pesquisa", tags=["pesquisa"])
@@ -19,12 +25,27 @@ class MapaModelosPayload(BaseModel):
     modelos_ids: list[str]
 
 
+class PesquisaAdminConfigPayload(BaseModel):
+    campos: dict[str, list[str]] = {}
+
+
+@router.get("/admin-config")
+def pesquisar_admin_config() -> dict:
+    return obter_admin_config_pesquisa()
+
+
+@router.post("/admin-config")
+def pesquisar_admin_config_salvar(payload: PesquisaAdminConfigPayload) -> dict:
+    return salvar_admin_config_pesquisa(payload.campos)
+
+
 @router.get("/modelos")
 def pesquisar_modelos(
     somente_contexto: bool = Query(False),
     otica: str = Query("modelo"),
     nome: str | None = Query(None),
     autor: str | None = Query(None),
+    contem_app: str | None = Query(None),
     finalidade: str | None = Query(None),
     finalidade_colunas: str | None = Query(None),
     bairro: str | None = Query(None),
@@ -65,6 +86,7 @@ def pesquisar_modelos(
         otica=otica,
         nome=nome,
         autor=autor,
+        contem_app=contem_app,
         finalidade=finalidade,
         finalidade_colunas=_split_csv(finalidade_colunas),
         bairro=bairro,

backend/app/services/pesquisa_service.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 import math
 import re
 import unicodedata
@@ -18,17 +19,20 @@ from app.core.elaboracao.core import _migrar_pacote_v1_para_v2
 from app.services.serializers import sanitize_value
 
 MODELOS_DIR = Path(__file__).resolve().parent.parent / "core" / "pesquisa" / "modelos_dai"
+ADMIN_CONFIG_PATH = Path(__file__).resolve().parent.parent / "core" / "pesquisa" / "pesquisa_admin_config.json"
 
-AREA_PRIVATIVA_ALIASES = ["APRIV", "ACOPRIV", "AREAPRIV", "AREA_PRIVATIVA", "AREA PRIVATIVA"]
-AREA_TOTAL_ALIASES = ["ATOTAL", "ATOT", "AREA_TOTAL", "AREA TOTAL", "AREA"]
-VALOR_UNITARIO_ALIASES = ["VU", "VUNIT", "VULOC", "VUAPRIV", "VALOR_UNITARIO", "VALOR UNITARIO"]
-VALOR_TOTAL_ALIASES = ["VLOC", "VTOT", "VALOR_TOTAL", "VALOR TOTAL"]
+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"]
+VALOR_UNITARIO_ALIASES = ["VU", "VUNIT", "VULOC", "VUAPRIV", "VUNIPRIV", "VUACONST", "VALOR_UNITARIO", "VALOR UNITARIO"]
+VALOR_TOTAL_ALIASES = ["VLOC", "VTOT", "VTOTAL", "VALOR_TOTAL", "VALOR TOTAL"]
 RH_ALIASES = ["RH", "FATOR_RH", "FATOR RH", "RENDA_HABITACIONAL"]
-DATA_ALIASES = ["DATA", "DT", "ANO", "DATA_AVALIACAO", "DATA AVALIACAO", "COMPETENCIA"]
+DATA_ALIASES = ["DATA", "DT", "RDATA", "AVALDT", "DT ENC", "DT EST", "DT REG", "DATA_AVALIACAO", "DATA AVALIACAO", "COMPETENCIA"]
 BAIRRO_ALIASES = ["BAIRRO", "BAIRROS", "NOME_BAIRRO", "BAIRRO_NOME", "NME BAI", "NME_BAI"]
 FINALIDADE_ALIASES = ["NME IMO-FINAL", "NME_IMO_FINAL", "NME IMO FINAL", "FINALIDADE", "TIPO_IMOVEL", "TIPO IMOVEL"]
 LAT_ALIASES = ["LAT", "LATITUDE", "SIAT_LATITUDE"]
 LON_ALIASES = ["LON", "LONG", "LONGITUDE", "SIAT_LONGITUDE"]
+APP_ALIASES = ["% APP", "%APP"]
 
 TIPO_POR_TOKEN = {
     "RECOND": "Residencia em condominio",
@@ -80,10 +84,13 @@ CAMPO_FAIXA_META_FONTES = {
 
 CAMPO_FAIXA_ALIASES_COLUNA = {
     "data": DATA_ALIASES,
-    "area": AREA_PRIVATIVA_ALIASES + AREA_TOTAL_ALIASES,
-    "rh": RH_ALIASES,
     "aval_data": DATA_ALIASES,
-    "aval_area": AREA_PRIVATIVA_ALIASES + AREA_TOTAL_ALIASES,
+}
+
+CAMPO_FAIXA_ALIASES_VARIAVEL = {
+    "area": AREA_GERAL_ALIASES,
+    "rh": RH_ALIASES,
+    "aval_area": AREA_GERAL_ALIASES,
     "aval_area_privativa": AREA_PRIVATIVA_ALIASES,
     "aval_area_total": AREA_TOTAL_ALIASES,
     "aval_rh": RH_ALIASES,
@@ -146,6 +153,7 @@ class PesquisaFiltros:
     otica: str = "modelo"
     nome: str | None = None
     autor: str | None = None
+    contem_app: str | None = None
     finalidade: str | None = None
     finalidade_colunas: list[str] | None = None
     bairro: str | None = None
@@ -184,6 +192,7 @@ class PesquisaFiltros:
 
 _CACHE_LOCK = Lock()
 _CACHE: dict[str, dict[str, Any]] = {}
+_ADMIN_CONFIG_LOCK = Lock()
 
 
 def ensure_modelos_dir() -> Path:
@@ -191,6 +200,38 @@ def ensure_modelos_dir() -> Path:
     return MODELOS_DIR
 
 
+def obter_admin_config_pesquisa() -> dict[str, Any]:
+    pasta = ensure_modelos_dir()
+    modelos = sorted(pasta.glob("*.dai"), key=lambda item: item.name.lower())
+    todos = [_carregar_resumo_com_cache(caminho) for caminho in modelos]
+    colunas_filtro = _montar_config_colunas_filtro(todos)
+    admin_fontes = _carregar_fontes_admin(colunas_filtro)
+    return sanitize_value(
+        {
+            "colunas_filtro": colunas_filtro,
+            "admin_fontes": admin_fontes,
+            "total_modelos": len(todos),
+        }
+    )
+
+
+def salvar_admin_config_pesquisa(campos: dict[str, list[str]] | None) -> dict[str, Any]:
+    pasta = ensure_modelos_dir()
+    modelos = sorted(pasta.glob("*.dai"), key=lambda item: item.name.lower())
+    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)
+    return sanitize_value(
+        {
+            "colunas_filtro": colunas_filtro,
+            "admin_fontes": admin_fontes,
+            "total_modelos": len(todos),
+            "status": "Configuracao de busca salva com sucesso.",
+        }
+    )
+
+
 def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_contexto: bool = False) -> dict[str, Any]:
     pasta = ensure_modelos_dir()
     modelos = sorted(pasta.glob("*.dai"), key=lambda item: item.name.lower())
@@ -199,8 +240,9 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
     filtros_exec = PesquisaFiltros(**{**filtros.__dict__, "otica": otica})
 
     todos = [_carregar_resumo_com_cache(caminho) for caminho in modelos]
-    sugestoes = _extrair_sugestoes(todos)
     colunas_filtro = _montar_config_colunas_filtro(todos)
+    admin_fontes = _carregar_fontes_admin(colunas_filtro)
+    sugestoes = _extrair_sugestoes(todos, admin_fontes)
 
     if somente_contexto:
         return sanitize_value(
@@ -211,9 +253,11 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
                 "total_filtrado": 0,
                 "total_geral": len(todos),
                 "modelos_dir": str(pasta),
+                "admin_fontes": admin_fontes,
                 "filtros_aplicados": {
                     "nome": filtros.nome,
                     "autor": filtros.autor,
+                    "contem_app": filtros.contem_app,
                     "finalidade": filtros.finalidade,
                     "finalidade_colunas": filtros.finalidade_colunas or [],
                     "bairro": filtros.bairro,
@@ -253,10 +297,10 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
             }
         )
 
-    filtrados = [item for item in todos if _aceita_filtros(item, filtros_exec)]
+    filtrados = [item for item in todos if _aceita_filtros(item, filtros_exec, admin_fontes)]
 
     if otica == "avaliando":
-        filtrados = [_anexar_avaliando_info(item, filtros_exec) for item in filtrados]
+        filtrados = [_anexar_avaliando_info(item, filtros_exec, admin_fontes) for item in filtrados]
         filtrados = [item for item in filtrados if item.get("avaliando", {}).get("aceito")]
 
     if limite and limite > 0:
@@ -272,9 +316,11 @@ def listar_modelos(filtros: PesquisaFiltros, limite: int | None = None, somente_
             "total_filtrado": len(filtrados),
             "total_geral": len(todos),
             "modelos_dir": str(pasta),
+            "admin_fontes": admin_fontes,
             "filtros_aplicados": {
                 "nome": filtros.nome,
                 "autor": filtros.autor,
+                "contem_app": filtros.contem_app,
                 "finalidade": filtros.finalidade,
                 "finalidade_colunas": filtros.finalidade_colunas or [],
                 "bairro": filtros.bairro,
@@ -464,6 +510,7 @@ def _construir_resumo_modelo(caminho_modelo: Path) -> dict[str, Any]:
         "endereco_referencia": None,
         "equacao": None,
         "r2": None,
+        "tem_app": False,
         "mapa_disponivel": False,
         "compatibilidade_campos": {chave: [] for chave in COMPATIBILIDADE_MAP},
         "faixas_por_campo": {chave: None for chave in RANGE_CAMPOS},
@@ -473,8 +520,10 @@ def _construir_resumo_modelo(caminho_modelo: Path) -> dict[str, Any]:
         "fonte": {
             "modelo": "dai",
         },
+        "_variaveis_modelo": [],
         "_texto_colunas_index": {},
         "_faixa_colunas_index": {},
+        "_faixa_variaveis_index": {},
     }
 
     try:
@@ -510,6 +559,9 @@ def _construir_resumo_modelo(caminho_modelo: Path) -> dict[str, Any]:
     if resumo["r2"] is None:
         resumo["r2"] = _r2_do_pacote(pacote)
 
+    resumo["_variaveis_modelo"] = _variaveis_do_modelo(pacote)
+    resumo["tem_app"] = _modelo_contem_variavel(resumo, APP_ALIASES)
+
     if resumo["total_dados"] is None and df_modelo is not None:
         resumo["total_dados"] = int(len(df_modelo))
 
@@ -530,14 +582,11 @@ def _construir_resumo_modelo(caminho_modelo: Path) -> dict[str, Any]:
 
     resumo["faixa_area"] = _merge_ranges(
         resumo["faixa_area"],
-        _extrair_faixa_por_alias(estat_df, AREA_PRIVATIVA_ALIASES + AREA_TOTAL_ALIASES),
+        _extrair_faixa_por_alias(estat_df, AREA_GERAL_ALIASES),
     )
     resumo["faixa_rh"] = _merge_ranges(resumo["faixa_rh"], _extrair_faixa_por_alias(estat_df, RH_ALIASES))
 
-    faixa_data_estat = _extrair_faixa_por_alias(estat_df, DATA_ALIASES)
-    if faixa_data_estat is None and df_modelo is not None:
-        faixa_data_estat = _extrair_faixa_data_dataframe(df_modelo)
-    resumo["faixa_data"] = _merge_ranges(resumo["faixa_data"], faixa_data_estat)
+    resumo["faixa_data"] = _merge_ranges(resumo["faixa_data"], _extrair_faixa_data_dataframe(df_modelo))
 
     colunas_catalogo = _coletar_colunas_para_catalogo(estat_df, df_modelo)
     resumo["compatibilidade_campos"] = _mapear_compatibilidade(colunas_catalogo)
@@ -545,6 +594,7 @@ def _construir_resumo_modelo(caminho_modelo: Path) -> dict[str, Any]:
     resumo["mapa_disponivel"] = _tem_colunas_mapa(df_modelo)
     resumo["_texto_colunas_index"] = _indexar_texto_colunas(df_modelo)
     resumo["_faixa_colunas_index"] = _indexar_faixas_colunas(df_modelo)
+    resumo["_faixa_variaveis_index"] = _indexar_faixas_variaveis(estat_df, resumo["_variaveis_modelo"])
 
     return resumo
 
@@ -569,6 +619,44 @@ def _r2_do_pacote(pacote: dict[str, Any]) -> float | None:
     return _to_float_or_none(gerais.get("r2"))
 
 
+def _variaveis_do_modelo(pacote: dict[str, Any]) -> list[str]:
+    variaveis: list[str] = []
+
+    modelo = pacote.get("modelo") if isinstance(pacote.get("modelo"), dict) else {}
+    coeficientes = modelo.get("coeficientes") if isinstance(modelo, dict) else None
+    if isinstance(coeficientes, pd.DataFrame):
+        variaveis.extend([str(item) for item in coeficientes.index.tolist()])
+    elif isinstance(coeficientes, pd.Series):
+        variaveis.extend([str(item) for item in coeficientes.index.tolist()])
+    elif isinstance(coeficientes, dict):
+        variaveis.extend([str(item) for item in coeficientes.keys()])
+
+    transformacoes = pacote.get("transformacoes") if isinstance(pacote.get("transformacoes"), dict) else {}
+    x_transformado = transformacoes.get("X")
+    y_transformado = transformacoes.get("y")
+    if isinstance(x_transformado, pd.DataFrame):
+        variaveis.extend([str(item) for item in x_transformado.columns.tolist()])
+    if isinstance(y_transformado, pd.Series):
+        nome_y = _str_or_none(y_transformado.name)
+        if nome_y:
+            variaveis.append(nome_y)
+
+    equacao = _equacao_do_pacote(pacote)
+    if isinstance(equacao, str) and "=" in equacao:
+        variaveis.append(equacao.split("=", 1)[0].strip())
+
+    limpas = [item for item in variaveis if _str_or_none(item) and _normalize(item) != "const"]
+    return _dedupe_strings(limpas)
+
+
+def _modelo_contem_variavel(modelo: dict[str, Any], aliases: list[str]) -> bool:
+    variaveis = list(modelo.get("_variaveis_modelo") or [])
+    indice_faixa = modelo.get("_faixa_variaveis_index") or {}
+    if isinstance(indice_faixa, dict):
+        variaveis.extend([str(chave) for chave in indice_faixa.keys()])
+    return any(_has_alias_exato(str(variavel), aliases) for variavel in variaveis)
+
+
 def _to_dataframe(value: Any) -> pd.DataFrame | None:
     if value is None:
         return None
@@ -686,19 +774,69 @@ def _extrair_finalidades(df: pd.DataFrame) -> list[str]:
 
 
 def _extrair_faixa_data_dataframe(df: pd.DataFrame) -> dict[str, Any] | None:
-    candidatos = [col for col in df.columns if _has_alias(str(col), DATA_ALIASES)]
-    for col in candidatos:
-        serie = pd.to_datetime(df[col], errors="coerce", dayfirst=True)
-        serie = serie.dropna()
-        if serie.empty:
-            continue
-        return {
-            "min": serie.min().date().isoformat(),
-            "max": serie.max().date().isoformat(),
-        }
+    for col in _colunas_data_reais(df):
+        faixa = _extrair_faixa_data_real_serie(df[col])
+        if faixa is not None:
+            return faixa
     return None
 
 
+def _colunas_data_reais(df: pd.DataFrame | None) -> list[str]:
+    if df is None or df.empty:
+        return []
+    candidatos = [str(col) for col in df.columns if _has_alias(str(col), DATA_ALIASES)]
+    return [col for col in candidatos if not _parece_coluna_apenas_ano(col)]
+
+
+def _parece_coluna_apenas_ano(nome_coluna: str) -> bool:
+    nome_norm = _normalize(nome_coluna)
+    if not nome_norm:
+        return False
+    tokens_ano = [
+        "ano",
+        "anodado",
+        "anoconstr",
+        "anobconstrucao",
+        "anocconstrucao",
+        "imoanomaior",
+        "pmianomaior",
+    ]
+    return any(token in nome_norm for token in tokens_ano)
+
+
+def _extrair_faixa_data_real_serie(serie: pd.Series) -> dict[str, Any] | None:
+    serie_limpa = serie.dropna()
+    if serie_limpa.empty:
+        return None
+
+    bruto = serie_limpa.astype(str).str.strip()
+    bruto = bruto[bruto != ""]
+    if bruto.empty:
+        return None
+
+    # Rejeita colunas que sejam basicamente ano puro (YYYY), pois nao suportam
+    # intervalo de datas reais (dia/mes/ano).
+    proporcao_ano_puro = float(bruto.str.fullmatch(r"\d{4}").mean())
+    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()
+    total = len(bruto)
+    minimo_amostras = min(3, total)
+    if len(serie_data) < minimo_amostras:
+        return None
+    if total > 0 and (len(serie_data) / total) < 0.6:
+        return None
+
+    return {
+        "min": serie_data.min().date().isoformat(),
+        "max": serie_data.max().date().isoformat(),
+    }
+
+
 def _extrair_faixa_por_alias(estat_df: pd.DataFrame | None, aliases: list[str]) -> dict[str, Any] | None:
     if estat_df is None or estat_df.empty:
         return None
@@ -810,14 +948,20 @@ def _tem_colunas_mapa(df: pd.DataFrame | None) -> bool:
     return tem_lat and tem_lon
 
 
-def _aceita_filtros(modelo: dict[str, Any], filtros: PesquisaFiltros) -> bool:
+def _aceita_filtros(modelo: dict[str, Any], filtros: PesquisaFiltros, fontes_admin: dict[str, list[str]] | None = None) -> bool:
+    fontes_admin = fontes_admin or {}
+
     if filtros.nome and not _contains_any([modelo.get("nome_modelo"), modelo.get("arquivo")], filtros.nome):
         return False
 
     if filtros.autor and not _contains_any([modelo.get("autor")], filtros.autor):
         return False
 
-    if filtros.finalidade and not _aceita_texto_com_colunas(modelo, filtros.finalidade, "finalidade", filtros.finalidade_colunas):
+    app_flag = _normalizar_contem_app(filtros.contem_app)
+    if app_flag is not None and _modelo_contem_variavel(modelo, APP_ALIASES) != app_flag:
+        return False
+
+    if filtros.finalidade and not _aceita_texto_com_colunas(modelo, filtros.finalidade, "finalidade", fontes_admin.get("finalidade")):
         return False
 
     if filtros.endereco and not _contains_any([modelo.get("endereco_referencia"), ", ".join(modelo.get("bairros") or [])], filtros.endereco):
@@ -826,26 +970,42 @@ def _aceita_filtros(modelo: dict[str, Any], filtros: PesquisaFiltros) -> bool:
     termos_bairro = _extrair_termos_bairro(filtros)
     if termos_bairro:
         for termo in termos_bairro:
-            if not _aceita_texto_com_colunas(modelo, termo, "bairros", filtros.bairros_colunas):
+            if not _aceita_texto_com_colunas(modelo, termo, "bairros", fontes_admin.get("bairros")):
                 return False
 
-    if not _aceita_range_com_colunas(modelo, "area", filtros.area_colunas, filtros.area_min, filtros.area_max):
+    if not _aceita_range_com_colunas(modelo, "area", fontes_admin.get("area"), filtros.area_min, filtros.area_max):
         return False
 
-    if not _aceita_range_com_colunas(modelo, "rh", filtros.rh_colunas, filtros.rh_min, filtros.rh_max):
+    if not _aceita_range_com_colunas(modelo, "rh", fontes_admin.get("rh"), filtros.rh_min, filtros.rh_max):
         return False
 
-    if not _aceita_range_com_colunas(modelo, "data", filtros.data_colunas, filtros.data_min, filtros.data_max):
+    if not _aceita_range_com_colunas(modelo, "data", fontes_admin.get("data"), filtros.data_min, filtros.data_max):
         return False
 
     return True
 
 
+def _normalizar_contem_app(value: str | None) -> bool | None:
+    chave = _normalize(value or "")
+    if not chave:
+        return None
+    if chave in {"sim", "true", "1", "com", "contem"}:
+        return True
+    if chave in {"nao", "false", "0", "sem"}:
+        return False
+    return None
+
+
 def _normalizar_otica(value: str | None) -> str:
     return "avaliando" if _normalize(value or "") == "avaliando" else "modelo"
 
 
-def _anexar_avaliando_info(modelo: dict[str, Any], filtros: PesquisaFiltros) -> dict[str, Any]:
+def _anexar_avaliando_info(
+    modelo: dict[str, Any],
+    filtros: PesquisaFiltros,
+    fontes_admin: dict[str, list[str]] | None = None,
+) -> dict[str, Any]:
+    fontes_admin = fontes_admin or {}
     item = dict(modelo)
     checks: list[dict[str, Any]] = []
     rejeicoes: list[str] = []
@@ -858,12 +1018,12 @@ def _anexar_avaliando_info(modelo: dict[str, Any], filtros: PesquisaFiltros) ->
 
     finalidade_info = filtros.aval_finalidade
     if _is_provided(finalidade_info):
-        aceito = _aceita_texto_com_colunas(item, str(finalidade_info), "aval_finalidade", filtros.aval_finalidade_colunas)
+        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")
 
     bairro_info = filtros.aval_bairro
     if _is_provided(bairro_info):
-        aceito = _aceita_texto_com_colunas(item, str(bairro_info), "aval_bairro", filtros.aval_bairro_colunas)
+        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")
 
     endereco_info = filtros.aval_endereco
@@ -872,55 +1032,55 @@ def _anexar_avaliando_info(modelo: dict[str, Any], filtros: PesquisaFiltros) ->
         aceito = _contains_any(candidatos, str(endereco_info))
         registrar("endereco", endereco_info, aceito, "sem correspondencia textual no modelo")
 
-    faixa_data_ref = _faixa_resumo_com_colunas(item, "aval_data", filtros.aval_data_colunas)
+    faixa_data_ref = _faixa_resumo_com_colunas(item, "aval_data", fontes_admin.get("aval_data"))
     registrar(
         "data",
         filtros.aval_data,
-        _aceita_valor_com_colunas(item, "aval_data", filtros.aval_data_colunas, filtros.aval_data),
+        _aceita_valor_com_colunas(item, "aval_data", fontes_admin.get("aval_data"), filtros.aval_data),
         f"fora da faixa {formatar_faixa(faixa_data_ref)}",
     )
-    faixa_rh_ref = _faixa_resumo_com_colunas(item, "aval_rh", filtros.aval_rh_colunas)
+    faixa_rh_ref = _faixa_resumo_com_colunas(item, "aval_rh", fontes_admin.get("aval_rh"))
     registrar(
         "rh",
         filtros.aval_rh,
-        _aceita_valor_com_colunas(item, "aval_rh", filtros.aval_rh_colunas, filtros.aval_rh),
+        _aceita_valor_com_colunas(item, "aval_rh", fontes_admin.get("aval_rh"), filtros.aval_rh),
         f"fora da faixa {formatar_faixa(faixa_rh_ref)}",
     )
-    faixa_area_ref = _faixa_resumo_com_colunas(item, "aval_area", filtros.aval_area_colunas)
+    faixa_area_ref = _faixa_resumo_com_colunas(item, "aval_area", fontes_admin.get("aval_area"))
     registrar(
         "area",
         filtros.aval_area,
-        _aceita_valor_com_colunas(item, "aval_area", filtros.aval_area_colunas, filtros.aval_area),
+        _aceita_valor_com_colunas(item, "aval_area", fontes_admin.get("aval_area"), filtros.aval_area),
         f"fora da faixa {formatar_faixa(faixa_area_ref)}",
     )
 
-    faixa_area_priv = _faixa_resumo_com_colunas(item, "aval_area_privativa", filtros.aval_area_privativa_colunas)
-    faixa_area_total = _faixa_resumo_com_colunas(item, "aval_area_total", filtros.aval_area_total_colunas)
-    faixa_valor_unit = _faixa_resumo_com_colunas(item, "aval_valor_unitario", filtros.aval_valor_unitario_colunas)
-    faixa_valor_tot = _faixa_resumo_com_colunas(item, "aval_valor_total", filtros.aval_valor_total_colunas)
+    faixa_area_priv = _faixa_resumo_com_colunas(item, "aval_area_privativa", fontes_admin.get("aval_area_privativa"))
+    faixa_area_total = _faixa_resumo_com_colunas(item, "aval_area_total", fontes_admin.get("aval_area_total"))
+    faixa_valor_unit = _faixa_resumo_com_colunas(item, "aval_valor_unitario", fontes_admin.get("aval_valor_unitario"))
+    faixa_valor_tot = _faixa_resumo_com_colunas(item, "aval_valor_total", fontes_admin.get("aval_valor_total"))
 
     registrar(
         "area_privativa",
         filtros.aval_area_privativa,
-        _aceita_valor_com_colunas(item, "aval_area_privativa", filtros.aval_area_privativa_colunas, filtros.aval_area_privativa),
+        _aceita_valor_com_colunas(item, "aval_area_privativa", fontes_admin.get("aval_area_privativa"), filtros.aval_area_privativa),
         f"fora da faixa {formatar_faixa(faixa_area_priv)}",
     )
     registrar(
         "area_total",
         filtros.aval_area_total,
-        _aceita_valor_com_colunas(item, "aval_area_total", filtros.aval_area_total_colunas, filtros.aval_area_total),
+        _aceita_valor_com_colunas(item, "aval_area_total", fontes_admin.get("aval_area_total"), filtros.aval_area_total),
         f"fora da faixa {formatar_faixa(faixa_area_total)}",
     )
     registrar(
         "valor_unitario",
         filtros.aval_valor_unitario,
-        _aceita_valor_com_colunas(item, "aval_valor_unitario", filtros.aval_valor_unitario_colunas, filtros.aval_valor_unitario),
+        _aceita_valor_com_colunas(item, "aval_valor_unitario", fontes_admin.get("aval_valor_unitario"), filtros.aval_valor_unitario),
         f"fora da faixa {formatar_faixa(faixa_valor_unit)}",
     )
     registrar(
         "valor_total",
         filtros.aval_valor_total,
-        _aceita_valor_com_colunas(item, "aval_valor_total", filtros.aval_valor_total_colunas, filtros.aval_valor_total),
+        _aceita_valor_com_colunas(item, "aval_valor_total", fontes_admin.get("aval_valor_total"), filtros.aval_valor_total),
         f"fora da faixa {formatar_faixa(faixa_valor_tot)}",
     )
 
@@ -936,20 +1096,34 @@ def _anexar_avaliando_info(modelo: dict[str, Any], filtros: PesquisaFiltros) ->
     return item
 
 
-def _extrair_sugestoes(modelos: list[dict[str, Any]], limite: int = 200) -> dict[str, list[str]]:
+def _extrair_sugestoes(
+    modelos: list[dict[str, Any]],
+    fontes_admin: dict[str, list[str]] | None = None,
+    limite: int = 200,
+) -> dict[str, list[str]]:
+    fontes_admin = fontes_admin or {}
     nomes: list[str] = []
     autores: list[str] = []
     finalidades: list[str] = []
     bairros: list[str] = []
     enderecos: list[str] = []
 
+    fontes_finalidade = _dedupe_strings((fontes_admin.get("finalidade") or []) + (fontes_admin.get("aval_finalidade") or []))
+    fontes_bairro = _dedupe_strings((fontes_admin.get("bairros") or []) + (fontes_admin.get("aval_bairro") or []))
+
     for modelo in modelos:
         nomes.append(str(modelo.get("nome_modelo") or ""))
         nomes.append(str(modelo.get("arquivo") or ""))
         autores.append(str(modelo.get("autor") or ""))
-        finalidades.append(str(modelo.get("finalidade") or ""))
-        finalidades.extend([str(item) for item in (modelo.get("finalidades") or [])])
-        bairros.extend([str(item) for item in (modelo.get("bairros") or [])])
+        if fontes_finalidade:
+            finalidades.extend(_valores_para_fontes(modelo, fontes_finalidade))
+        else:
+            finalidades.append(str(modelo.get("finalidade") or ""))
+            finalidades.extend([str(item) for item in (modelo.get("finalidades") or [])])
+        if fontes_bairro:
+            bairros.extend(_valores_para_fontes(modelo, fontes_bairro))
+        else:
+            bairros.extend([str(item) for item in (modelo.get("bairros") or [])])
         enderecos.append(str(modelo.get("endereco_referencia") or ""))
 
     return {
@@ -966,48 +1140,143 @@ def _modelo_publico(modelo: dict[str, Any]) -> dict[str, Any]:
 
 
 def _montar_config_colunas_filtro(modelos: list[dict[str, Any]]) -> dict[str, Any]:
-    todas_colunas_texto = set()
-    todas_colunas_faixa = set()
-    for modelo in modelos:
-        indice_texto = modelo.get("_texto_colunas_index") or {}
-        if isinstance(indice_texto, dict):
-            todas_colunas_texto.update([str(col) for col in indice_texto.keys()])
-        indice_faixa = modelo.get("_faixa_colunas_index") or {}
-        if isinstance(indice_faixa, dict):
-            todas_colunas_faixa.update([str(col) for col in indice_faixa.keys()])
-
-    colunas_texto_ordenadas = sorted(todas_colunas_texto, key=lambda item: item.lower())
-    colunas_faixa_ordenadas = sorted(todas_colunas_faixa, key=lambda item: item.lower())
     config: dict[str, Any] = {}
 
     campos = list(CAMPO_TEXTO_META_FONTES.keys()) + [campo for campo in CAMPO_FAIXA_META_FONTES.keys() if campo not in CAMPO_TEXTO_META_FONTES]
 
     for campo in campos:
-        if campo in CAMPO_TEXTO_META_FONTES:
-            meta_fontes = list(CAMPO_TEXTO_META_FONTES.get(campo, []))
-            aliases = CAMPO_TEXTO_ALIASES_COLUNA.get(campo, [])
-            colunas_ordenadas = colunas_texto_ordenadas
-        else:
-            meta_fontes = list(CAMPO_FAIXA_META_FONTES.get(campo, []))
-            aliases = CAMPO_FAIXA_ALIASES_COLUNA.get(campo, [])
-            colunas_ordenadas = colunas_faixa_ordenadas
-
-        disponiveis = [{"id": fonte, "label": FONTE_META_LABELS.get(fonte, fonte)} for fonte in meta_fontes]
-        disponiveis.extend([{"id": f"col:{col}", "label": col} for col in colunas_ordenadas])
-
-        padrao = list(meta_fontes)
-        for col in colunas_ordenadas:
-            if _has_alias(col, aliases):
-                padrao.append(f"col:{col}")
-
+        fontes_campo = set()
+        fontes_padrao = set()
+        for modelo in modelos:
+            if campo in CAMPO_TEXTO_META_FONTES:
+                fontes_campo.update(_fontes_texto_disponiveis(modelo, campo))
+                fontes_padrao.update(_fontes_texto_padrao(modelo, campo))
+            else:
+                fontes_campo.update(_fontes_faixa_disponiveis(modelo, campo))
+                fontes_padrao.update(_fontes_faixa_padrao(modelo, campo))
+
+        fontes = sorted(fontes_campo, key=lambda item: _rotulo_fonte(item).lower())
+        padrao = [item for item in sorted(fontes_padrao, key=lambda item: _rotulo_fonte(item).lower()) if item in set(fontes)]
+        if not padrao:
+            padrao = list(fontes)
         config[campo] = {
-            "disponiveis": disponiveis,
-            "padrao": _dedupe_strings(padrao),
+            "disponiveis": [{"id": fonte, "label": _rotulo_fonte(fonte)} for fonte in fontes],
+            "padrao": padrao,
         }
 
     return config
 
 
+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 = {}
+    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)
+    payload = {campo: _dedupe_strings(valores) for campo, valores in (fontes_admin or {}).items()}
+    with _ADMIN_CONFIG_LOCK:
+        ADMIN_CONFIG_PATH.write_text(
+            json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True),
+            encoding="utf-8",
+        )
+
+
+def _normalizar_fontes_admin(raw: dict[str, Any], colunas_filtro: dict[str, Any]) -> dict[str, list[str]]:
+    saida: dict[str, list[str]] = {}
+    for campo, config in (colunas_filtro or {}).items():
+        disponiveis = [str(item.get("id")) for item in (config.get("disponiveis") or []) if isinstance(item, dict) and item.get("id")]
+        padrao = [str(item) for item in (config.get("padrao") or []) if str(item).strip()]
+        escolhidas_raw = raw.get(campo) if isinstance(raw, dict) else None
+        escolhidas = [str(item) for item in (escolhidas_raw or []) if str(item).strip()]
+
+        set_disponiveis = set(disponiveis)
+        escolhidas_validas = [item for item in _dedupe_strings(escolhidas) if item in set_disponiveis]
+        if not escolhidas_validas:
+            escolhidas_validas = [item for item in _dedupe_strings(padrao) if item in set_disponiveis]
+        if not escolhidas_validas and disponiveis:
+            escolhidas_validas = [disponiveis[0]]
+
+        saida[campo] = escolhidas_validas
+    return saida
+
+
+def _rotulo_fonte(fonte: str) -> str:
+    if fonte.startswith("col:"):
+        return fonte[4:]
+    if fonte.startswith("var:"):
+        return f"Variavel: {fonte[4:]}"
+    return FONTE_META_LABELS.get(fonte, fonte)
+
+
+def _fontes_texto_disponiveis(modelo: dict[str, Any], campo: str) -> list[str]:
+    aliases = CAMPO_TEXTO_ALIASES_COLUNA.get(campo, [])
+    indice = modelo.get("_texto_colunas_index") or {}
+    if not isinstance(indice, dict):
+        return []
+
+    fontes: list[str] = []
+    for col in indice.keys():
+        col_text = str(col)
+        if _has_alias(col_text, aliases):
+            fontes.append(f"col:{col_text}")
+    return _dedupe_strings(fontes)
+
+
+def _fontes_texto_padrao(modelo: dict[str, Any], campo: str) -> list[str]:
+    return _fontes_texto_disponiveis(modelo, campo)
+
+
+def _fontes_faixa_disponiveis(modelo: dict[str, Any], campo: str) -> list[str]:
+    fontes: list[str] = []
+
+    aliases_coluna = CAMPO_FAIXA_ALIASES_COLUNA.get(campo, [])
+    indice_colunas = modelo.get("_faixa_colunas_index") or {}
+    if isinstance(indice_colunas, dict):
+        for col in indice_colunas.keys():
+            col_text = str(col)
+            if _has_alias(col_text, aliases_coluna):
+                fontes.append(f"col:{col_text}")
+
+    permite_variaveis = campo in CAMPO_FAIXA_ALIASES_VARIAVEL
+    indice_variaveis = modelo.get("_faixa_variaveis_index") or {}
+    if permite_variaveis and isinstance(indice_variaveis, dict):
+        for var in indice_variaveis.keys():
+            fontes.append(f"var:{str(var)}")
+
+    return _dedupe_strings(fontes)
+
+
+def _fontes_faixa_padrao(modelo: dict[str, Any], campo: str) -> list[str]:
+    fontes: list[str] = []
+
+    aliases_coluna = CAMPO_FAIXA_ALIASES_COLUNA.get(campo, [])
+    indice_colunas = modelo.get("_faixa_colunas_index") or {}
+    if isinstance(indice_colunas, dict):
+        for col in indice_colunas.keys():
+            col_text = str(col)
+            if _has_alias(col_text, aliases_coluna):
+                fontes.append(f"col:{col_text}")
+
+    aliases_variavel = CAMPO_FAIXA_ALIASES_VARIAVEL.get(campo, [])
+    indice_variaveis = modelo.get("_faixa_variaveis_index") or {}
+    if isinstance(indice_variaveis, dict):
+        for var in indice_variaveis.keys():
+            var_text = str(var)
+            if _has_alias_exato(var_text, aliases_variavel):
+                fontes.append(f"var:{var_text}")
+
+    return _dedupe_strings(fontes)
+
+
 def _dedupe_strings(values: list[str]) -> list[str]:
     out: list[str] = []
     seen = set()
@@ -1063,35 +1332,21 @@ def _faixas_para_campo(modelo: dict[str, Any], campo: str, fontes_selecionadas:
 
 
 def _resolver_fontes_campo(modelo: dict[str, Any], campo: str, fontes_selecionadas: list[str] | None) -> list[str]:
-    base = _dedupe_strings([str(item) for item in (fontes_selecionadas or [])])
-    if base:
-        return base
-
-    fontes = list(CAMPO_TEXTO_META_FONTES.get(campo, []))
-    aliases = CAMPO_TEXTO_ALIASES_COLUNA.get(campo, [])
-    indice = modelo.get("_texto_colunas_index") or {}
-    if isinstance(indice, dict):
-        for col in indice.keys():
-            col_text = str(col)
-            if _has_alias(col_text, aliases):
-                fontes.append(f"col:{col_text}")
-    return _dedupe_strings(fontes)
+    disponiveis = _fontes_texto_disponiveis(modelo, campo)
+    selecionadas = _dedupe_strings([str(item) for item in (fontes_selecionadas or [])])
+    if selecionadas:
+        set_disponiveis = set(disponiveis)
+        return [item for item in selecionadas if item in set_disponiveis]
+    return disponiveis
 
 
 def _resolver_fontes_faixa(modelo: dict[str, Any], campo: str, fontes_selecionadas: list[str] | None) -> list[str]:
-    base = _dedupe_strings([str(item) for item in (fontes_selecionadas or [])])
-    if base:
-        return base
-
-    fontes = list(CAMPO_FAIXA_META_FONTES.get(campo, []))
-    aliases = CAMPO_FAIXA_ALIASES_COLUNA.get(campo, [])
-    indice = modelo.get("_faixa_colunas_index") or {}
-    if isinstance(indice, dict):
-        for col in indice.keys():
-            col_text = str(col)
-            if _has_alias(col_text, aliases):
-                fontes.append(f"col:{col_text}")
-    return _dedupe_strings(fontes)
+    disponiveis = _fontes_faixa_disponiveis(modelo, campo)
+    selecionadas = _dedupe_strings([str(item) for item in (fontes_selecionadas or [])])
+    if selecionadas:
+        set_disponiveis = set(disponiveis)
+        return [item for item in selecionadas if item in set_disponiveis]
+    return disponiveis
 
 
 def _valores_para_fontes(modelo: dict[str, Any], fontes: list[str]) -> list[str]:
@@ -1137,6 +1392,9 @@ def _faixas_para_fontes(modelo: dict[str, Any], fontes: list[str]) -> list[dict[
     indice_colunas = modelo.get("_faixa_colunas_index") or {}
     if not isinstance(indice_colunas, dict):
         indice_colunas = {}
+    indice_variaveis = modelo.get("_faixa_variaveis_index") or {}
+    if not isinstance(indice_variaveis, dict):
+        indice_variaveis = {}
 
     for fonte in fontes:
         faixa: dict[str, Any] | None = None
@@ -1144,6 +1402,8 @@ def _faixas_para_fontes(modelo: dict[str, Any], fontes: list[str]) -> list[dict[
             faixa = _faixa_meta(modelo, fonte)
         elif fonte.startswith("col:"):
             faixa = indice_colunas.get(fonte[4:])
+        elif fonte.startswith("var:"):
+            faixa = indice_variaveis.get(fonte[4:])
         if not isinstance(faixa, dict):
             continue
         if _is_empty(faixa.get("min")) and _is_empty(faixa.get("max")):
@@ -1251,40 +1511,52 @@ def _indexar_faixas_colunas(df_modelo: pd.DataFrame | None) -> dict[str, dict[st
         return {}
 
     indice: dict[str, dict[str, Any]] = {}
-    colunas = [str(col) for col in df_modelo.columns[:MAX_COLUNAS_INDEXADAS]]
-    base = df_modelo[colunas].head(MAX_LINHAS_INDEXACAO)
+    colunas = _colunas_data_reais(df_modelo)[:MAX_COLUNAS_INDEXADAS]
+    if not colunas:
+        return indice
 
+    base = df_modelo[colunas].head(MAX_LINHAS_INDEXACAO)
     for coluna in colunas:
-        faixa = _extrair_faixa_serie(base[coluna])
+        faixa = _extrair_faixa_data_real_serie(base[coluna])
         if faixa is not None:
             indice[coluna] = faixa
 
     return indice
 
 
-def _extrair_faixa_serie(serie: pd.Series) -> dict[str, Any] | None:
-    serie_limpa = serie.dropna()
-    if serie_limpa.empty:
-        return None
+def _indexar_faixas_variaveis(estat_df: pd.DataFrame | None, variaveis_modelo: list[str] | None) -> dict[str, dict[str, Any]]:
+    if estat_df is None or estat_df.empty:
+        return {}
 
-    total = len(serie_limpa)
-    minimo_amostras = min(3, total)
+    trabalho = estat_df.copy()
+    if "Variável" in trabalho.columns:
+        trabalho = trabalho.set_index("Variável")
+    if trabalho.empty:
+        return {}
 
-    serie_num = pd.to_numeric(serie_limpa, errors="coerce").dropna()
-    if len(serie_num) >= minimo_amostras and (len(serie_num) / total) >= 0.6:
-        return {
-            "min": sanitize_value(serie_num.min()),
-            "max": sanitize_value(serie_num.max()),
-        }
+    min_col = _buscar_coluna(trabalho.columns, ["minimo", "mínimo", "min"])
+    max_col = _buscar_coluna(trabalho.columns, ["maximo", "máximo", "max"])
+    if min_col is None or max_col is None:
+        return {}
+
+    variaveis_norm = {_normalize(item) for item in (variaveis_modelo or []) if _str_or_none(item)}
+    indice: dict[str, dict[str, Any]] = {}
+
+    for variavel, linha in trabalho.iterrows():
+        nome = str(variavel)
+        if variaveis_norm and _normalize(nome) not in variaveis_norm:
+            continue
 
-    serie_data = pd.to_datetime(serie_limpa, errors="coerce", dayfirst=True).dropna()
-    if len(serie_data) >= minimo_amostras and (len(serie_data) / total) >= 0.6:
-        return {
-            "min": serie_data.min().date().isoformat(),
-            "max": serie_data.max().date().isoformat(),
+        min_val = sanitize_value(linha.get(min_col))
+        max_val = sanitize_value(linha.get(max_col))
+        if _is_empty(min_val) and _is_empty(max_val):
+            continue
+        indice[nome] = {
+            "min": None if _is_empty(min_val) else min_val,
+            "max": None if _is_empty(max_val) else max_val,
         }
 
-    return None
+    return indice
 
 
 def _lista_textos_unicos(valores: list[str], limite: int) -> list[str]:
@@ -1486,6 +1758,13 @@ def _has_alias(nome: str, aliases: list[str]) -> bool:
     return False
 
 
+def _has_alias_exato(nome: str, aliases: list[str]) -> bool:
+    nome_norm = _normalize(nome)
+    if not nome_norm:
+        return False
+    return any(_normalize(alias) == nome_norm for alias in aliases)
+
+
 def _normalize(value: str) -> str:
     ascii_text = unicodedata.normalize("NFKD", str(value)).encode("ascii", "ignore").decode("ascii")
     ascii_text = ascii_text.lower().strip()

frontend/src/api.js

@@ -59,6 +59,9 @@ export function downloadBlob(blob, fileName) {
 export const api = {
   createSession: () => postJson('/api/sessions', {}),
 
+  pesquisaAdminConfig: () => getJson('/api/pesquisa/admin-config'),
+  pesquisaAdminConfigSalvar: (campos = {}) => postJson('/api/pesquisa/admin-config', { campos }),
+
   pesquisarModelos(filtros = {}) {
     const params = new URLSearchParams()
     Object.entries(filtros).forEach(([key, value]) => {

frontend/src/components/PesquisaAdminConfigPanel.jsx

@@ -0,0 +1,238 @@
+import React, { useEffect, useMemo, useState } from 'react'
+import { api } from '../api'
+
+const CAMPOS_GRUPOS = [
+  {
+    titulo: 'Otica do modelo',
+    campos: ['finalidade', 'bairros', 'data', 'area', 'rh'],
+  },
+  {
+    titulo: 'Otica do avaliando',
+    campos: [
+      'aval_finalidade',
+      'aval_bairro',
+      'aval_data',
+      'aval_area',
+      'aval_rh',
+    ],
+  },
+]
+
+const CAMPO_LABELS = {
+  finalidade: 'Finalidade',
+  bairros: 'Bairro',
+  data: 'Data',
+  area: 'Area',
+  rh: 'RH',
+  aval_finalidade: 'Finalidade (avaliando)',
+  aval_bairro: 'Bairro (avaliando)',
+  aval_data: 'Data (avaliando)',
+  aval_area: 'Area (avaliando)',
+  aval_rh: 'RH (avaliando)',
+}
+
+function normalizeColunasConfig(rawConfig = {}) {
+  const out = {}
+  Object.entries(rawConfig || {}).forEach(([campo, config]) => {
+    const disponiveis = []
+    const vistos = new Set()
+    ;(Array.isArray(config?.disponiveis) ? config.disponiveis : []).forEach((item) => {
+      const id = typeof item === 'string' ? item : item?.id
+      const label = typeof item === 'string' ? item : item?.label || item?.id
+      const idText = String(id || '').trim()
+      if (!idText || vistos.has(idText)) return
+      vistos.add(idText)
+      disponiveis.push({ id: idText, label: String(label || idText) })
+    })
+    const padrao = []
+    ;(Array.isArray(config?.padrao) ? config.padrao : []).forEach((item) => {
+      const idText = String(item || '').trim()
+      if (!idText || !vistos.has(idText) || padrao.includes(idText)) return
+      padrao.push(idText)
+    })
+    out[campo] = { disponiveis, padrao }
+  })
+  return out
+}
+
+function normalizeSelecionadas(raw = {}, configNormalizada = {}) {
+  const out = {}
+  Object.keys(configNormalizada || {}).forEach((campo) => {
+    const disponiveis = new Set((configNormalizada[campo]?.disponiveis || []).map((item) => item.id))
+    const preferidas = Array.isArray(raw?.[campo]) ? raw[campo] : []
+    const validas = preferidas.map((item) => String(item || '').trim()).filter((item) => item && disponiveis.has(item))
+    if (validas.length) {
+      out[campo] = Array.from(new Set(validas))
+      return
+    }
+    const padrao = (configNormalizada[campo]?.padrao || []).filter((item) => disponiveis.has(item))
+    out[campo] = Array.from(new Set(padrao))
+  })
+  return out
+}
+
+function serializarCampos(campos = {}) {
+  const normalizado = {}
+  Object.keys(campos || {}).sort().forEach((campo) => {
+    normalizado[campo] = [...(campos[campo] || [])]
+  })
+  return JSON.stringify(normalizado)
+}
+
+export default function PesquisaAdminConfigPanel({ onSaved }) {
+  const [loading, setLoading] = useState(false)
+  const [saving, setSaving] = useState(false)
+  const [error, setError] = useState('')
+  const [status, setStatus] = useState('')
+  const [colunasConfig, setColunasConfig] = useState({})
+  const [selecionadas, setSelecionadas] = useState({})
+  const [baseline, setBaseline] = useState('{}')
+
+  const dirty = useMemo(() => serializarCampos(selecionadas) !== baseline, [selecionadas, baseline])
+
+  async function carregar() {
+    setLoading(true)
+    setError('')
+    setStatus('')
+    try {
+      const response = await api.pesquisaAdminConfig()
+      const configNormalizada = normalizeColunasConfig(response.colunas_filtro || {})
+      const selecionadasNormalizadas = normalizeSelecionadas(response.admin_fontes || {}, configNormalizada)
+      const base = serializarCampos(selecionadasNormalizadas)
+      setColunasConfig(configNormalizada)
+      setSelecionadas(selecionadasNormalizadas)
+      setBaseline(base)
+    } catch (err) {
+      setError(err.message)
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  useEffect(() => {
+    void carregar()
+  }, [])
+
+  function findLabel(campo, id) {
+    const match = (colunasConfig[campo]?.disponiveis || []).find((item) => item.id === id)
+    return match?.label || id
+  }
+
+  function onAdd(campo, value) {
+    const id = String(value || '').trim()
+    if (!id) return
+    setSelecionadas((current) => {
+      const atual = current[campo] || []
+      if (atual.includes(id)) return current
+      return { ...current, [campo]: [...atual, id] }
+    })
+  }
+
+  function onRemove(campo, id) {
+    setSelecionadas((current) => ({
+      ...current,
+      [campo]: (current[campo] || []).filter((item) => item !== id),
+    }))
+  }
+
+  function onRestaurarPadrao(campo) {
+    const padrao = colunasConfig[campo]?.padrao || []
+    setSelecionadas((current) => ({ ...current, [campo]: [...padrao] }))
+  }
+
+  async function onSalvar() {
+    setSaving(true)
+    setError('')
+    setStatus('')
+    try {
+      const response = await api.pesquisaAdminConfigSalvar(selecionadas)
+      const configNormalizada = normalizeColunasConfig(response.colunas_filtro || {})
+      const selecionadasNormalizadas = normalizeSelecionadas(response.admin_fontes || {}, configNormalizada)
+      const base = serializarCampos(selecionadasNormalizadas)
+      setColunasConfig(configNormalizada)
+      setSelecionadas(selecionadasNormalizadas)
+      setBaseline(base)
+      setStatus(response.status || 'Configuracao salva.')
+      if (onSaved) onSaved()
+    } catch (err) {
+      setError(err.message)
+    } finally {
+      setSaving(false)
+    }
+  }
+
+  function renderCampo(campo) {
+    const configCampo = colunasConfig[campo] || { disponiveis: [], padrao: [] }
+    const selecionadasCampo = selecionadas[campo] || []
+    const selectedSet = new Set(selecionadasCampo)
+    const opcoesAdicionar = (configCampo.disponiveis || []).filter((item) => !selectedSet.has(item.id))
+
+    return (
+      <div key={campo} className="pesquisa-admin-field">
+        <div className="pesquisa-admin-field-head">
+          <strong>{CAMPO_LABELS[campo] || campo}</strong>
+          <button type="button" className="btn-pesquisa-expand" onClick={() => onRestaurarPadrao(campo)}>
+            Restaurar padrao
+          </button>
+        </div>
+
+        <div className="pesquisa-dynamic-filter-row pesquisa-admin-row">
+          <div className="pesquisa-colunas-box">
+            <div className="pesquisa-colunas-chip-list">
+              {selecionadasCampo.map((id) => (
+                <span key={`${campo}-${id}`} className="pesquisa-coluna-chip">
+                  <span>{findLabel(campo, id)}</span>
+                  <button type="button" className="pesquisa-coluna-remove" onClick={() => onRemove(campo, id)} aria-label={`Remover fonte ${findLabel(campo, id)}`}>
+                    x
+                  </button>
+                </span>
+              ))}
+              {!selecionadasCampo.length ? <span className="pesquisa-colunas-empty">Nenhuma fonte selecionada.</span> : null}
+            </div>
+          </div>
+
+          <select
+            className="pesquisa-colunas-add"
+            defaultValue=""
+            onChange={(event) => {
+              const selected = String(event.target.value || '').trim()
+              if (!selected) return
+              onAdd(campo, selected)
+              event.target.value = ''
+            }}
+          >
+            <option value="">Adicionar fonte...</option>
+            {opcoesAdicionar.map((item) => (
+              <option key={`${campo}-opt-${item.id}`} value={item.id}>{item.label}</option>
+            ))}
+          </select>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className="pesquisa-admin-panel">
+      <div className="row pesquisa-actions pesquisa-actions-primary">
+        <button type="button" onClick={() => void onSalvar()} disabled={saving || loading || !dirty}>
+          {saving ? 'Salvando...' : 'Salvar configuracao'}
+        </button>
+        <button type="button" onClick={() => void carregar()} disabled={saving || loading}>
+          Recarregar
+        </button>
+      </div>
+
+      {status ? <div className="status-line">{status}</div> : null}
+      {error ? <div className="error-line inline-error">{error}</div> : null}
+
+      {CAMPOS_GRUPOS.map((grupo) => (
+        <section key={grupo.titulo} className="pesquisa-filtro-grupo">
+          <h5>{grupo.titulo}</h5>
+          <div className="pesquisa-admin-fields">
+            {grupo.campos.map((campo) => renderCampo(campo))}
+          </div>
+        </section>
+      ))}
+    </div>
+  )
+}

frontend/src/components/PesquisaTab.jsx

@@ -1,12 +1,14 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react'
 import { api } from '../api'
 import MapFrame from './MapFrame'
+import PesquisaAdminConfigPanel from './PesquisaAdminConfigPanel'
 import SectionBlock from './SectionBlock'
 
 const EMPTY_FILTERS = {
   otica: 'modelo',
   nome: '',
   autor: '',
+  contemApp: '',
   finalidade: '',
   bairros: '',
   dataMin: '',
@@ -19,11 +21,7 @@ const EMPTY_FILTERS = {
   avalBairro: '',
   avalData: '',
   avalArea: '',
-  avalAreaPrivativa: '',
-  avalAreaTotal: '',
   avalRh: '',
-  avalValorUnitario: '',
-  avalValorTotal: '',
 }
 
 const RESULT_INITIAL = {
@@ -181,28 +179,16 @@ function reconciliarColunasSelecionadas(atual, configNormalizada, camposEditados
   return next
 }
 
-function buildApiFilters(filters, colunasFiltro = COLUNAS_FILTRO_INITIAL) {
+function buildApiFilters(filters) {
   if (filters.otica === 'avaliando') {
     return {
       otica: filters.otica,
+      contem_app: filters.contemApp,
       aval_finalidade: filters.avalFinalidade,
-      aval_finalidade_colunas: (colunasFiltro.aval_finalidade || []).join(','),
       aval_bairro: filters.avalBairro,
-      aval_bairro_colunas: (colunasFiltro.aval_bairro || []).join(','),
       aval_data: filters.avalData,
-      aval_data_colunas: (colunasFiltro.aval_data || []).join(','),
       aval_area: filters.avalArea,
-      aval_area_colunas: (colunasFiltro.aval_area || []).join(','),
-      aval_area_privativa: filters.avalAreaPrivativa,
-      aval_area_privativa_colunas: (colunasFiltro.aval_area_privativa || []).join(','),
-      aval_area_total: filters.avalAreaTotal,
-      aval_area_total_colunas: (colunasFiltro.aval_area_total || []).join(','),
       aval_rh: filters.avalRh,
-      aval_rh_colunas: (colunasFiltro.aval_rh || []).join(','),
-      aval_valor_unitario: filters.avalValorUnitario,
-      aval_valor_unitario_colunas: (colunasFiltro.aval_valor_unitario || []).join(','),
-      aval_valor_total: filters.avalValorTotal,
-      aval_valor_total_colunas: (colunasFiltro.aval_valor_total || []).join(','),
     }
   }
 
@@ -210,18 +196,14 @@ function buildApiFilters(filters, colunasFiltro = COLUNAS_FILTRO_INITIAL) {
     otica: filters.otica,
     nome: filters.nome,
     autor: filters.autor,
+    contem_app: filters.contemApp,
     finalidade: filters.finalidade,
-    finalidade_colunas: (colunasFiltro.finalidade || []).join(','),
     bairros: filters.bairros,
-    bairros_colunas: (colunasFiltro.bairros || []).join(','),
     data_min: filters.dataMin,
-    data_colunas: (colunasFiltro.data || []).join(','),
     data_max: filters.dataMax,
     area_min: filters.areaMin,
-    area_colunas: (colunasFiltro.area || []).join(','),
     area_max: filters.areaMax,
     rh_min: filters.rhMin,
-    rh_colunas: (colunasFiltro.rh || []).join(','),
     rh_max: filters.rhMax,
   }
 }
@@ -409,21 +391,11 @@ function DynamicRangeFilterField({
   )
 }
 
-function FiltroGroup({ title, children }) {
-  return (
-    <section className="pesquisa-filtro-grupo">
-      <h5>{title}</h5>
-      <div className="pesquisa-filtros-grid">
-        {children}
-      </div>
-    </section>
-  )
-}
-
 export default function PesquisaTab() {
   const [loading, setLoading] = useState(false)
   const [error, setError] = useState('')
   const [pesquisaInicializada, setPesquisaInicializada] = useState(false)
+  const [mostrarAdminConfig, setMostrarAdminConfig] = useState(false)
 
   const [filters, setFilters] = useState(EMPTY_FILTERS)
   const [result, setResult] = useState(RESULT_INITIAL)
@@ -619,9 +591,35 @@ export default function PesquisaTab() {
     }
   }
 
+  async function onAdminConfigSalva() {
+    if (pesquisaInicializada) {
+      await buscarModelos()
+      return
+    }
+    await carregarContextoInicial()
+  }
+
   return (
     <div className="tab-content">
-      <SectionBlock step="1" title="Filtros de Pesquisa" subtitle="Use a otica do modelo ou do avaliando. Todos os filtros sao cumulativos.">
+      <SectionBlock
+        step="1"
+        title="Filtros de Pesquisa"
+        subtitle="Use a otica do modelo ou do avaliando. Todos os filtros sao cumulativos."
+        aside={(
+          <button
+            type="button"
+            className={`pesquisa-admin-toggle${mostrarAdminConfig ? ' active' : ''}`}
+            onClick={() => setMostrarAdminConfig((current) => !current)}
+          >
+            <span className="pesquisa-admin-toggle-icon" aria-hidden="true">⚙</span>
+            <span>Configure as fontes dos campos</span>
+          </button>
+        )}
+      >
+        {mostrarAdminConfig ? (
+          <PesquisaAdminConfigPanel onSaved={() => void onAdminConfigSalva()} />
+        ) : null}
+
         <div className="pesquisa-otica-switch" role="tablist" aria-label="Otica de pesquisa">
           <button
             type="button"
@@ -649,261 +647,149 @@ export default function PesquisaTab() {
           </button>
         </div>
 
+        <div className="pesquisa-fields-grid pesquisa-fields-grid-single">
+          <label className="pesquisa-field">
+            Contem variavel APP (% APP)
+            <select
+              data-field="contemApp"
+              name={toInputName('contemApp')}
+              value={filters.contemApp}
+              onChange={onFieldChange}
+              autoComplete="off"
+            >
+              <option value="">Indiferente</option>
+              <option value="sim">Sim</option>
+              <option value="nao">Nao</option>
+            </select>
+          </label>
+        </div>
+
         {usandoOticaAvaliando ? (
-          <div id="pesquisa-panel-avaliando" role="tabpanel" aria-labelledby="pesquisa-otica-avaliando" className="pesquisa-filtros-groups">
-            <FiltroGroup title="Finalidade">
-              <DynamicFilterField
-                label="Finalidade do imovel"
-                campoValor="avalFinalidade"
-                campoColunas="aval_finalidade"
-                configCampo={colunasConfig.aval_finalidade}
-                selecionadas={colunasFiltro.aval_finalidade}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
+          <div
+            id="pesquisa-panel-avaliando"
+            role="tabpanel"
+            aria-labelledby="pesquisa-otica-avaliando"
+            className="pesquisa-fields-grid pesquisa-avaliando-grid"
+          >
+            <label className="pesquisa-field">
+              Finalidade do imovel
+              <TextFieldInput
+                list="pesquisa-finalidades"
+                field="avalFinalidade"
                 value={filters.avalFinalidade}
                 onChange={onFieldChange}
-                list="pesquisa-finalidades"
                 placeholder="Ex: Apartamento"
               />
-            </FiltroGroup>
-
-            <FiltroGroup title="Bairro">
-              <DynamicFilterField
-                label="Bairro do imovel"
-                campoValor="avalBairro"
-                campoColunas="aval_bairro"
-                configCampo={colunasConfig.aval_bairro}
-                selecionadas={colunasFiltro.aval_bairro}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
+            </label>
+
+            <label className="pesquisa-field">
+              Bairro do imovel
+              <TextFieldInput
+                list="pesquisa-bairros"
+                field="avalBairro"
                 value={filters.avalBairro}
                 onChange={onFieldChange}
-                list="pesquisa-bairros"
                 placeholder="Ex: Centro"
               />
-            </FiltroGroup>
-
-            <FiltroGroup title="Datas">
-              <DynamicFilterField
-                label="Data de referencia"
-                campoValor="avalData"
-                campoColunas="aval_data"
-                configCampo={colunasConfig.aval_data}
-                selecionadas={colunasFiltro.aval_data}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.avalData}
-                onChange={onFieldChange}
-                placeholder="2025-02-27"
-              />
-            </FiltroGroup>
-
-            <FiltroGroup title="Areas">
-              <DynamicFilterField
-                label="Area (generica)"
-                campoValor="avalArea"
-                campoColunas="aval_area"
-                configCampo={colunasConfig.aval_area}
-                selecionadas={colunasFiltro.aval_area}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.avalArea}
-                onChange={onFieldChange}
-                placeholder="0"
-                inputKind="number"
-              />
-              <DynamicFilterField
-                label="Area privativa"
-                campoValor="avalAreaPrivativa"
-                campoColunas="aval_area_privativa"
-                configCampo={colunasConfig.aval_area_privativa}
-                selecionadas={colunasFiltro.aval_area_privativa}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.avalAreaPrivativa}
-                onChange={onFieldChange}
-                placeholder="0"
-                inputKind="number"
-              />
-              <DynamicFilterField
-                label="Area total"
-                campoValor="avalAreaTotal"
-                campoColunas="aval_area_total"
-                configCampo={colunasConfig.aval_area_total}
-                selecionadas={colunasFiltro.aval_area_total}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.avalAreaTotal}
-                onChange={onFieldChange}
-                placeholder="0"
-                inputKind="number"
-              />
-            </FiltroGroup>
-
-            <FiltroGroup title="RH">
-              <DynamicFilterField
-                label="RH do imovel"
-                campoValor="avalRh"
-                campoColunas="aval_rh"
-                configCampo={colunasConfig.aval_rh}
-                selecionadas={colunasFiltro.aval_rh}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.avalRh}
-                onChange={onFieldChange}
-                placeholder="0"
-                inputKind="number"
-              />
-            </FiltroGroup>
-
-            <FiltroGroup title="Valores">
-              <DynamicFilterField
-                label="Valor unitario"
-                campoValor="avalValorUnitario"
-                campoColunas="aval_valor_unitario"
-                configCampo={colunasConfig.aval_valor_unitario}
-                selecionadas={colunasFiltro.aval_valor_unitario}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.avalValorUnitario}
-                onChange={onFieldChange}
-                placeholder="0"
-                inputKind="number"
-              />
-              <DynamicFilterField
-                label="Valor total"
-                campoValor="avalValorTotal"
-                campoColunas="aval_valor_total"
-                configCampo={colunasConfig.aval_valor_total}
-                selecionadas={colunasFiltro.aval_valor_total}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.avalValorTotal}
-                onChange={onFieldChange}
-                placeholder="0"
-                inputKind="number"
-              />
-            </FiltroGroup>
-          </div>
-        ) : (
-          <div id="pesquisa-panel-modelo" role="tabpanel" aria-labelledby="pesquisa-otica-modelo" className="pesquisa-filtros-groups pesquisa-filtros-groups-stack">
-            <FiltroGroup title="Modelo">
+            </label>
+
+            <div className="pesquisa-avaliando-inline">
               <label className="pesquisa-field">
-                Nome do modelo
-                <TextFieldInput
-                  list="pesquisa-nomes-modelo"
-                  field="nome"
-                  value={filters.nome}
-                  onChange={onFieldChange}
-                  placeholder="Ex: MOD_A_SALA_Z1"
-                />
+                Data do imovel
+                <TextFieldInput field="avalData" value={filters.avalData} onChange={onFieldChange} placeholder="2025-02-27" />
               </label>
               <label className="pesquisa-field">
-                Autor
-                <TextFieldInput
-                  list="pesquisa-autores"
-                  field="autor"
-                  value={filters.autor}
-                  onChange={onFieldChange}
-                  placeholder="Nome do avaliador"
-                />
+                Area do imovel
+                <NumberFieldInput field="avalArea" value={filters.avalArea} onChange={onFieldChange} placeholder="0" />
               </label>
-            </FiltroGroup>
-
-            <FiltroGroup title="Finalidade">
-              <DynamicFilterField
-                label=""
-                campoValor="finalidade"
-                campoColunas="finalidade"
-                configCampo={colunasConfig.finalidade}
-                selecionadas={colunasFiltro.finalidade}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.finalidade}
-                onChange={onFieldChange}
-                list="pesquisa-finalidades"
-                placeholder="Apartamento, sala, deposito..."
-              />
-            </FiltroGroup>
-
-            <FiltroGroup title="Bairro">
-              <DynamicFilterField
-                label=""
-                campoValor="bairros"
-                campoColunas="bairros"
-                configCampo={colunasConfig.bairros}
-                selecionadas={colunasFiltro.bairros}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                value={filters.bairros}
+              <label className="pesquisa-field">
+                RH do imovel
+                <NumberFieldInput field="avalRh" value={filters.avalRh} onChange={onFieldChange} placeholder="0" />
+              </label>
+            </div>
+          </div>
+        ) : (
+          <div id="pesquisa-panel-modelo" role="tabpanel" aria-labelledby="pesquisa-otica-modelo" className="pesquisa-fields-grid">
+            <label className="pesquisa-field">
+              Nome do modelo
+              <TextFieldInput
+                list="pesquisa-nomes-modelo"
+                field="nome"
+                value={filters.nome}
                 onChange={onFieldChange}
-                list="pesquisa-bairros"
-                placeholder="Centro, Moinhos de Vento"
+                placeholder="Ex: MOD_A_SALA_Z1"
               />
-            </FiltroGroup>
-
-            <FiltroGroup title="Datas">
-              <DynamicRangeFilterField
-                label=""
-                campoColunas="data"
-                configCampo={colunasConfig.data}
-                selecionadas={colunasFiltro.data}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                minLabel="Data minima"
-                minField="dataMin"
-                minValue={filters.dataMin}
-                maxLabel="Data maxima"
-                maxField="dataMax"
-                maxValue={filters.dataMax}
+            </label>
+            <label className="pesquisa-field">
+              Autor
+              <TextFieldInput
+                list="pesquisa-autores"
+                field="autor"
+                value={filters.autor}
                 onChange={onFieldChange}
-                minPlaceholder="2022 ou 2022-01-01"
-                maxPlaceholder="2025 ou 2025-12-31"
-                inputKind="text"
+                placeholder="Nome do avaliador"
               />
-            </FiltroGroup>
-
-            <FiltroGroup title="Areas">
-              <DynamicRangeFilterField
-                label=""
-                campoColunas="area"
-                configCampo={colunasConfig.area}
-                selecionadas={colunasFiltro.area}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                minLabel="Area minima"
-                minField="areaMin"
-                minValue={filters.areaMin}
-                maxLabel="Area maxima"
-                maxField="areaMax"
-                maxValue={filters.areaMax}
+            </label>
+
+            <label className="pesquisa-field">
+              Finalidade
+              <TextFieldInput
+                list="pesquisa-finalidades"
+                field="finalidade"
+                value={filters.finalidade}
                 onChange={onFieldChange}
-                minPlaceholder="0"
-                maxPlaceholder="0"
-                inputKind="number"
+                placeholder="Apartamento, sala, deposito..."
               />
-            </FiltroGroup>
-
-            <FiltroGroup title="RH">
-              <DynamicRangeFilterField
-                label=""
-                campoColunas="rh"
-                configCampo={colunasConfig.rh}
-                selecionadas={colunasFiltro.rh}
-                onAddColuna={onAddColunaFiltro}
-                onRemoveColuna={onRemoveColunaFiltro}
-                minLabel="RH minimo"
-                minField="rhMin"
-                minValue={filters.rhMin}
-                maxLabel="RH maximo"
-                maxField="rhMax"
-                maxValue={filters.rhMax}
+            </label>
+
+            <label className="pesquisa-field">
+              Bairro
+              <TextFieldInput
+                list="pesquisa-bairros"
+                field="bairros"
+                value={filters.bairros}
                 onChange={onFieldChange}
-                minPlaceholder="0"
-                maxPlaceholder="1"
-                inputKind="number"
+                placeholder="Centro, Moinhos de Vento"
               />
-            </FiltroGroup>
+            </label>
+
+            <div className="pesquisa-inline-trio">
+              <div className="pesquisa-field-pair pesquisa-field-pair-inline">
+                <span className="pesquisa-field-pair-title">Data</span>
+                <label className="pesquisa-field">
+                  Minima
+                  <TextFieldInput field="dataMin" value={filters.dataMin} onChange={onFieldChange} placeholder="2022-01-01" />
+                </label>
+                <label className="pesquisa-field">
+                  Maxima
+                  <TextFieldInput field="dataMax" value={filters.dataMax} onChange={onFieldChange} placeholder="2025-12-31" />
+                </label>
+              </div>
+
+              <div className="pesquisa-field-pair pesquisa-field-pair-inline">
+                <span className="pesquisa-field-pair-title">Area</span>
+                <label className="pesquisa-field">
+                  Minima
+                  <NumberFieldInput field="areaMin" value={filters.areaMin} onChange={onFieldChange} placeholder="0" />
+                </label>
+                <label className="pesquisa-field">
+                  Maxima
+                  <NumberFieldInput field="areaMax" value={filters.areaMax} onChange={onFieldChange} placeholder="0" />
+                </label>
+              </div>
+
+              <div className="pesquisa-field-pair pesquisa-field-pair-inline">
+                <span className="pesquisa-field-pair-title">RH</span>
+                <label className="pesquisa-field">
+                  Minimo
+                  <NumberFieldInput field="rhMin" value={filters.rhMin} onChange={onFieldChange} placeholder="0" />
+                </label>
+                <label className="pesquisa-field">
+                  Maximo
+                  <NumberFieldInput field="rhMax" value={filters.rhMax} onChange={onFieldChange} placeholder="1" />
+                </label>
+              </div>
+            </div>
           </div>
         )}
 

frontend/src/styles.css

@@ -310,6 +310,39 @@ textarea {
   margin-left: auto;
 }
 
+.pesquisa-admin-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  border: 1px solid #c7d8e8;
+  border-radius: 10px;
+  background: linear-gradient(180deg, #f7fbff 0%, #eef5fb 100%);
+  color: #3e5a74;
+  font-weight: 700;
+  padding: 8px 11px;
+  box-shadow: none;
+}
+
+.pesquisa-admin-toggle .pesquisa-admin-toggle-icon {
+  font-size: 0.95rem;
+  line-height: 1;
+}
+
+.pesquisa-admin-toggle.active {
+  border-color: #cf6f00;
+  background: linear-gradient(180deg, #ff9a26 0%, #e67900 100%);
+  color: #ffffff;
+}
+
+.pesquisa-admin-toggle:hover {
+  transform: none;
+  box-shadow: none;
+}
+
+.pesquisa-admin-panel {
+  margin-bottom: 16px;
+}
+
 .section-body {
   padding: 18px;
   min-width: 0;
@@ -395,7 +428,7 @@ textarea {
 .pesquisa-filtros-groups {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 22px;
+  gap: 18px;
   margin-bottom: 12px;
 }
 
@@ -438,8 +471,8 @@ textarea {
 
 .pesquisa-filtros-grid {
   display: grid;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 14px;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px;
   margin-bottom: 0;
 }
 
@@ -504,6 +537,94 @@ button.pesquisa-otica-btn.active:hover {
   width: 100%;
 }
 
+.pesquisa-filtros-groups .pesquisa-field input,
+.pesquisa-filtros-groups .pesquisa-field select {
+  width: min(100%, 255px);
+}
+
+.pesquisa-fields-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px 14px;
+  margin-bottom: 14px;
+  align-items: start;
+}
+
+.pesquisa-fields-grid-single {
+  grid-template-columns: minmax(240px, 420px);
+}
+
+.pesquisa-fields-grid .pesquisa-field input,
+.pesquisa-fields-grid .pesquisa-field select {
+  width: 100%;
+}
+
+.pesquisa-field-pair {
+  grid-column: 1 / -1;
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px 12px;
+  padding: 11px 12px;
+  border: 1px solid #d2deea;
+  border-radius: 12px;
+  background: linear-gradient(180deg, #ffffff 0%, #f9fcff 100%);
+}
+
+.pesquisa-field-pair-triple {
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  grid-column: 1 / -1;
+}
+
+.pesquisa-field-pair-title {
+  grid-column: 1 / -1;
+  font-size: 0.75rem;
+  font-weight: 700;
+  color: #3a5874;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+}
+
+.pesquisa-inline-trio {
+  grid-column: 1 / -1;
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px;
+  align-items: stretch;
+}
+
+.pesquisa-field-pair-inline {
+  grid-column: auto;
+  padding: 10px 11px;
+  height: 100%;
+}
+
+.pesquisa-field-pair-inline .pesquisa-field input,
+.pesquisa-field-pair-inline .pesquisa-field select {
+  max-width: none;
+}
+
+.pesquisa-avaliando-grid {
+  align-items: end;
+}
+
+.pesquisa-avaliando-inline {
+  grid-column: 1 / -1;
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px 14px;
+}
+
+.pesquisa-fields-grid .pesquisa-field {
+  min-width: 0;
+}
+
+.pesquisa-fields-grid .pesquisa-field input,
+.pesquisa-fields-grid .pesquisa-field select,
+.pesquisa-field-pair .pesquisa-field input,
+.pesquisa-field-pair .pesquisa-field select {
+  min-height: 34px;
+}
+
 .pesquisa-field input::placeholder {
   color: #b7c4d2;
   opacity: 1;
@@ -520,6 +641,27 @@ button.pesquisa-otica-btn.active:hover {
   grid-template-columns: minmax(0, 1.8fr) minmax(190px, 1fr);
 }
 
+.pesquisa-admin-fields {
+  display: grid;
+  gap: 14px;
+}
+
+.pesquisa-admin-field {
+  display: grid;
+  gap: 8px;
+}
+
+.pesquisa-admin-field-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+}
+
+.pesquisa-admin-row {
+  grid-template-columns: minmax(0, 1.8fr) minmax(220px, 1fr);
+}
+
 .pesquisa-colunas-box {
   min-height: 38px;
   border: 1px solid #cfdbe7;
@@ -2564,12 +2706,27 @@ button.btn-upload-select {
 
   .pesquisa-filtros-groups,
   .pesquisa-filtros-grid,
+  .pesquisa-fields-grid,
   .pesquisa-card-grid,
   .pesquisa-compare-grid,
   .pesquisa-compat-row {
     grid-template-columns: 1fr;
   }
 
+  .pesquisa-field-pair,
+  .pesquisa-field-pair.pesquisa-field-pair-triple {
+    grid-template-columns: 1fr;
+    grid-column: 1 / -1;
+  }
+
+  .pesquisa-inline-trio {
+    grid-template-columns: 1fr;
+  }
+
+  .pesquisa-avaliando-inline {
+    grid-template-columns: 1fr;
+  }
+
   .pesquisa-dynamic-filter-row,
   .pesquisa-range-values-row,
   .pesquisa-range-row,