from html import escape from admin_app.view.view_models import ( AdminBotMonitoringPageView, AdminCollaboratorManagementPageView, AdminLoginPageView, AdminPanelHomeView, AdminPanelMetric, AdminPanelModuleCard, AdminPanelNavigationItem, AdminPanelQuickAction, AdminPanelRoadmapItem, AdminPanelSurfaceLink, AdminRentalReportsPageView, AdminSalesRevenueReportsPageView, AdminSystemConfigurationPageView, AdminToolIntakePageView, AdminToolIntakeParameterTypeOption, AdminToolReviewPageView, AdminToolReviewWorkflowStep, ) BOOTSTRAP_CSS_HREF = "https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" BOOTSTRAP_JS_HREF = "https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js" _BADGE_CLASS_MAP = { "success": "bg-success-subtle text-success-emphasis border border-success-subtle", "warning": "bg-warning-subtle text-warning-emphasis border border-warning-subtle", "info": "bg-info-subtle text-info-emphasis border border-info-subtle", "primary": "bg-primary-subtle text-primary-emphasis border border-primary-subtle", "secondary": "bg-secondary-subtle text-secondary-emphasis border border-secondary-subtle", "dark": "bg-dark-subtle text-dark-emphasis border border-dark-subtle", } def render_panel_home( view: AdminPanelHomeView, *, css_href: str, js_href: str, ) -> str: navigation_markup = _render_navigation(view.navigation) quick_actions_markup = _render_quick_actions(view.quick_actions) metrics_markup = _render_metrics(view.metrics) modules_markup = _render_modules(view.modules) surface_links_markup = _render_surface_links(view.surface_links) roadmap_markup = _render_roadmap(view.roadmap) panel_title = escape(view.panel_title) app_name = escape(view.app_name) panel_subtitle = escape(view.panel_subtitle) environment = escape(view.environment) version = escape(view.version) api_prefix = escape(view.api_prefix) service = escape(view.service) release_label = escape(view.release_label) return f""" {panel_title}
Area interna protegida Minimal Bootstrap

Dashboard do administrador

A home protegida organiza o trabalho do time interno por fluxo, com foco no que realmente importa depois do login.

{quick_actions_markup}
{metrics_markup}

Areas do sistema

Onde o time interno opera

A dashboard agora funciona como ponto de orientacao para entrar nas areas certas sem expor atalhos desnecessarios.

{modules_markup}

Acessos disponiveis

Entradas claras para as areas protegidas

{surface_links_markup}

Fluxo recomendado

Como navegar no painel

{roadmap_markup}
""" def render_login_page( view: AdminLoginPageView, *, css_href: str, js_href: str, ) -> str: security_markup = _render_text_list(view.security_highlights) notes_markup = _render_text_list(view.integration_notes) return f""" {escape(view.title)}
""" def _render_navigation(items: tuple[AdminPanelNavigationItem, ...]) -> str: links: list[str] = [] for item in items: badge_markup = "" if item.badge: badge_markup = ( f'{escape(item.badge)}' ) active_class = " active shadow-sm" if item.is_active else "" links.append( f"""
{escape(item.label)}
{escape(item.description)}
{badge_markup}
""".strip() ) return "\n".join(links) def _render_quick_actions(items: tuple[AdminPanelQuickAction, ...]) -> str: return "\n".join( f'{escape(item.label)}' for item in items ) def _render_metrics(items: tuple[AdminPanelMetric, ...]) -> str: cards: list[str] = [] for item in items: cards.append( f"""

{escape(item.label)}

{escape(item.value)}

{escape(item.description)}

""".strip() ) return "\n".join(cards) def _render_modules(items: tuple[AdminPanelModuleCard, ...]) -> str: cards: list[str] = [] for item in items: highlights = "".join( f'
  • {escape(highlight)}
    • ' for highlight in item.highlights ) cta_markup = 'Em preparacao' if item.href and item.cta_label and item.is_available: cta_markup = ( f'{escape(item.cta_label)}' ) badge_classes = _BADGE_CLASS_MAP.get(item.status_variant, _BADGE_CLASS_MAP["secondary"]) cards.append( f"""

    {escape(item.eyebrow)}

    {escape(item.title)}

    {escape(item.status_label)}

    {escape(item.description)}

      {highlights}
    {cta_markup}
    """.strip() ) return "\n".join(cards) def _render_surface_links(items: tuple[AdminPanelSurfaceLink, ...]) -> str: cards: list[str] = [] for item in items: cards.append( f"""
    {escape(item.method)}
    {escape(item.label)}
    {escape(item.description)}
    Abrir
    """.strip() ) return "\n".join(cards) def _render_roadmap(items: tuple[AdminPanelRoadmapItem, ...]) -> str: cards: list[str] = [] for item in items: cards.append( f"""
    Etapa {escape(item.step)}
    {escape(item.title)}
    {escape(item.description)}
    {escape(item.status_label)}
    """.strip() ) return "\n".join(cards) def _render_text_list(items: tuple[str, ...]) -> str: return "\n".join( f"
  • {escape(item)}
    • " for item in items ) def render_tool_review_page( view: AdminToolReviewPageView, *, css_href: str, js_href: str, ) -> str: workflow_markup = _render_tool_review_workflow(view.workflow) review_notes_markup = _render_text_list(view.review_notes) approval_notes_markup = _render_text_list(view.approval_notes) activation_notes_markup = _render_text_list(view.activation_notes) return f""" {escape(view.title)}
    Governanca de tools Revisao e ativacao

    Fluxo visual de aprovacao no painel

    Esta tela conecta a sessao web do painel aos snapshots administrativos de tools para que o time consiga revisar a fila, conferir contratos e acompanhar o catalogo ativo.

    Voltar ao overview

    Fila de revisao

    0

    Items aguardando leitura tecnica ou aprovacao humana.

    Publicacoes ativas

    0

    Catalogo publicado e pronto para abastecer o runtime de produto.

    Etapas do contrato

    {len(view.workflow)}

    Workflow compartilhado entre revisao, aprovacao e ativacao.

    Pipeline visual

    Etapas que a tela acompanha

    Os cards abaixo resumem o trajeto de uma tool desde a analise ate a ativacao no produto.

    {workflow_markup}

    Fila atual

    Revisao tecnica e aprovacao

    A fila abaixo e lida da superficie web do painel e respeita o papel da sessao autenticada.

    Bootstrap

    Nenhum item carregado ainda

    Clique em atualizar leitura para sincronizar a fila de revisao do painel.

    Checklist de aprovacao

    Playbook para a decisao humana

    Aprovacao e ativacao continuam controladas pelo papel administrativo e pela leitura do contrato compartilhado.

    Antes de aprovar

      {approval_notes_markup}

    Lifecycle disponivel

    Aguardando leitura do contrato compartilhado...

    Tipos de parametro

    Aguardando

    Detalhe da versao

    Revisao humana antes da ativacao

    Selecione uma versao da fila para validar o contrato, inspecionar o codigo completo gerado e registrar a decisao da diretoria.

    Nenhum item
    Selecione um item da fila

    O detalhe da versao aparece aqui junto com o resumo funcional e o gate humano atual.

    Contexto e parametros

    Nenhuma versao selecionada.

    Validacoes automaticas

    As validacoes da pipeline aparecem aqui.

    Historico da diretoria

    Nenhuma decisao humana registrada ainda.

    Proximos passos

    Os proximos passos da versao aparecem aqui.
    Use este campo para revisar a implementacao completa antes de validar, aprovar e ativar a nova tool.
    As notas da decisao ficam persistidas na trilha administrativa da versao.

    Catalogo ativo

    Ativacao e superficie publicada

    Quando a sessao tem permissao de publicacao, o painel tambem exibe o catalogo conhecido de tools ativas.

    Catalogo

    Catalogo ainda nao sincronizado

    A leitura da ativacao aparece aqui assim que a sessao web carregar as publicacoes disponiveis.

    """ def _render_tool_review_workflow(items: tuple[AdminToolReviewWorkflowStep, ...]) -> str: cards: list[str] = [] for item in items: badge_classes = _BADGE_CLASS_MAP.get(item.status_variant, _BADGE_CLASS_MAP["secondary"]) cards.append( f"""

    {escape(item.eyebrow)}

    {escape(item.title)}

    {escape(item.status_label)}

    {escape(item.description)}

    """.strip() ) return "\n".join(cards) def render_tool_intake_page( view: AdminToolIntakePageView, *, css_href: str, js_href: str, ) -> str: naming_rules_markup = _render_text_list(view.naming_rules) submission_notes_markup = _render_text_list(view.submission_notes) approval_notes_markup = _render_text_list(view.approval_notes) domain_cards_markup = "\n".join( f'''
    {escape(item.label)}
    {escape(item.description)}
    ''' for item in view.domain_options ) parameter_type_badges_markup = "\n".join( f'''{escape(item.label)}''' for item in view.parameter_type_options ) domain_select_options = "\n".join( f'''''' for item in view.domain_options ) parameter_select_options = _render_tool_parameter_options(view.parameter_type_options) return f''' {escape(view.title)}
    Nova tool Preview validado

    Cadastrar uma nova tool com contexto operacional

    A tela abaixo transforma o cadastro em um pre-draft validado, pronto para seguir ao fluxo de revisao humana antes de qualquer publicacao no produto.

    {parameter_type_badges_markup}

    Formulario principal

    Preencher os dados da nova tool

    O objetivo aqui e validar estrutura, objetivo operacional e parametros e salvar o draft administrativo antes da revisao.

    Parametros

    Estrutura de entrada da tool

    Adicione somente os parametros realmente necessarios para a decisao do bot.

    Ir para revisao

    Dominios sugeridos

    {domain_cards_markup}

    Orientacoes da fase atual

      {submission_notes_markup}

    Preview do draft

    Resultado da validacao

    Aguardando

    Nenhum pre-cadastro validado ainda

    Assim que o formulario for validado, o resumo do draft aparece aqui com avisos e proximos passos.

    ''' def _render_tool_parameter_options(items: tuple[AdminToolIntakeParameterTypeOption, ...]) -> str: return "\n".join( f'' for item in items ) def render_collaborator_management_page( view: AdminCollaboratorManagementPageView, *, css_href: str, js_href: str, ) -> str: onboarding_notes_markup = _render_text_list(view.onboarding_notes) governance_notes_markup = _render_text_list(view.governance_notes) return f''' {escape(view.title)}
    Gestao de equipe Sessao protegida

    Cadastro e status da equipe administrativa

    Esta area centraliza o onboarding de colaboradores e deixa o diretor com uma leitura simples de quem esta ativo no painel.

    Politica de senha

    {escape(view.password_policy_label)}

    Total de colaboradores

    0

    Contas administrativas de colaborador cadastradas no painel.

    Ativos

    0

    Colaboradores que podem entrar normalmente no admin.

    Inativos

    0

    Acessos pausados sem remover rastreabilidade da conta.

    Novo acesso

    Cadastrar colaborador

    Crie a conta inicial da equipe com nome, email e senha provisoria ja validada pela politica do admin.

    Politica atual: {escape(view.password_policy_label)}

    Equipe cadastrada

    Leitura atual da equipe interna

    A lista abaixo vem da superficie web do painel e permite ligar ou desligar acessos rapidamente.

    Nenhum colaborador carregado ainda

    Clique em atualizar lista para sincronizar o estado atual da equipe.

    ''' def _render_collaborator_cards(items: list[dict]) -> str: return "\n".join( f'''
    {escape(str(item.get("role") or "colaborador"))}

    {escape(str(item.get("display_name") or "Colaborador"))}

    {escape(str(item.get("email") or ""))}
    {'Ativo' if item.get("is_active") else 'Inativo'}
    Ultimo login: {escape(str(item.get("last_login_at") or "Ainda nao acessou"))}
    ID: {escape(str(item.get("id") or "-"))}
    ''' for item in items ) def render_system_configuration_page( view: AdminSystemConfigurationPageView, *, css_href: str, js_href: str, ) -> str: access_notes_markup = _render_text_list(view.access_notes) governance_notes_markup = _render_text_list(view.governance_notes) return f''' {escape(view.title)}
    Somente leitura Sessao protegida

    Configuracao funcional e regras do painel em uma unica tela

    Aqui voce acompanha o que esta disponivel para consulta agora, sem expor detalhes internos demais do ambiente.

    Configuracoes funcionais

    0

    Itens que o time pode acompanhar nesta etapa.

    Campos governados pelo bot

    0

    Ajustes do atendimento sob controle do admin.

    Perfis de runtime

    0

    Separacao entre atendimento e geracao de tools quando liberada.

    Fontes de configuracao

    0

    Base usada para montar os dados desta tela.

    Catalogo funcional

    Configuracoes funcionais do sistema

    Cada card resume o que a configuracao cobre e como ela impacta a operacao.

    Contrato compartilhado

    Catalogo ainda nao carregado

    Atualize a leitura para montar a superficie funcional desta etapa.

    Governanca do bot

    Campos sob governanca administrativa

    Os ajustes do atendimento aparecem aqui de forma agrupada e clara.

    Parent config keys
    Aguardando

    Governanca ainda nao carregada

    Os campos governados pelo bot aparecem aqui depois da primeira leitura.

    Runtime administrativo

    Informacoes essenciais do painel

    Mostra apenas o contexto util para a operacao.

    Runtime aguardando leitura

    Esta area e carregada conforme a permissao da sessao atual.

    Postura de seguranca

    Regras visiveis de senha e sessao

    Exibe somente o necessario para orientar o uso da sessao.

    Seguranca aguardando leitura

    A sessao atual precisa de permissao elevada para ver este snapshot.

    Separacao de runtime

    Modelos do atendimento versus geracao de tools

    Aqui fica clara a separacao entre atendimento e geracao de tools.

    Perfis de runtime aguardando leitura

    A superficie completa aparece quando a sessao pode consultar manage_settings.

    Fontes do snapshot

    De onde cada configuracao vem

    Resumo das bases usadas para montar esta tela.

    Fontes aguardando leitura

    As fontes completas entram quando a sessao pode consultar o overview tecnico.

    ''' def render_sales_revenue_reports_page( view: AdminSalesRevenueReportsPageView, *, css_href: str, js_href: str, ) -> str: access_notes_markup = _render_text_list(view.access_notes) reading_notes_markup = _render_text_list(view.reading_notes) return f''' {escape(view.title)}
    Leitura operacional Fase 4

    Vendas e arrecadacao na mesma visao do painel

    Aqui o time acompanha os principais blocos comerciais de forma simples e organizada.

    Relatorios de vendas

    0

    Estrutura inicial do dominio comercial.

    Relatorios de arrecadacao

    0

    Leitura inicial dos recebimentos de locacao.

    Bases de leitura

    0

    Bases consolidadas usadas para montar esta tela.

    Atualizacao

    --

    Ritmo atual da carga exibida no painel.

    Vendas

    O que acompanhar em vendas

    Volume de pedidos, ticket medio, cancelamentos e comparativos principais.

    Vendas aguardando leitura

    Clique em atualizar leitura para carregar o snapshot de vendas.

    Proximas melhorias

    Arrecadacao

    O que acompanhar em arrecadacao

    Pagamentos liquidados, valor arrecadado e conciliacao por contrato.

    Arrecadacao aguardando leitura

    Clique em atualizar leitura para carregar o snapshot de arrecadacao.

    Proximas melhorias
    ''' def render_rental_reports_page( view: AdminRentalReportsPageView, *, css_href: str, js_href: str, ) -> str: access_notes_markup = _render_text_list(view.access_notes) reading_notes_markup = _render_text_list(view.reading_notes) return f''' {escape(view.title)}
    Leitura operacional Fase 4

    Visao inicial de locacao para frota e contratos

    Acompanhe os principais blocos do dominio em uma leitura organizada do painel.

    Relatorios

    0

    Temas iniciais que o time ja consegue acompanhar.

    Bases de leitura

    0

    Bases consolidadas de frota e contratos.

    Atualizacao

    --

    Ritmo atual da carga exibida no painel.

    Area acompanhada

    --

    Dominio principal desta leitura.

    Overview de locacao

    Resumo inicial da operacao

    Os indicadores mostram rapidamente a situacao atual de frota e contratos.

    Locacao aguardando leitura

    Clique em atualizar leitura para montar o snapshot desta superficie.

    Proximas melhorias

    Relatorios desta etapa

    Relatorios disponiveis nesta etapa

    Disponibilidade de frota, lifecycle de contratos, devolucoes em atraso, ocupacao e receita prevista versus final.

    Catalogo aguardando leitura

    Os cards de relatorio aparecem aqui depois da primeira leitura do painel.

    ''' def render_bot_monitoring_page( view: AdminBotMonitoringPageView, *, css_href: str, js_href: str, ) -> str: access_notes_markup = _render_text_list(view.access_notes) reading_notes_markup = _render_text_list(view.reading_notes) return f''' {escape(view.title)}
    Observabilidade operacional Fase 4

    Fluxo do bot e saude do atendimento na mesma tela

    Acompanhe o basico da operacao e da telemetria sem entrar em detalhes de infraestrutura.

    Relatorios de fluxo

    0

    Status, roteamento, tools, fallback e falhas do turno.

    Relatorios de saude

    0

    Volume, latencia, distribuicao por dominio e saude do atendimento.

    Bases de leitura

    0

    Base consolidada usada pelas duas visoes.

    Atualizacao

    --

    Ritmo atual da carga exibida no painel.

    Fluxo do bot

    Triagem da operacao

    Veja status, roteamento, uso de tools, fallback, handoff e falhas do turno.

    Fluxo aguardando leitura

    Clique em atualizar leitura para carregar o snapshot operacional do bot.

    Proximas melhorias

    Telemetria conversacional

    Saude do atendimento

    Volume, latencia, distribuicao por dominio e sinais de saude da conversa.

    Telemetria aguardando leitura

    Clique em atualizar leitura para carregar o snapshot conversacional.

    Proximas melhorias
    '''