Tutoriais

Automatizando alertas de limpeza de caixa de água em ambientes corporativos: guia prático

Aprenda a criar alertas automáticos para limpeza de caixas d'água corporativas usando scripts, APIs e agendamento inteligente. Evite riscos sanitários e multas.

Você chegou no escritório na segunda-feira e descobriu que a caixa d’água do prédio não era limpa há 14 meses. A vigilância sanitária notificou a empresa, o síndico cobra providências e a equipe de facilities não tinha nenhum alerta configurado. Como evitar que esse cenário se repita sem depender de planilhas manuais ou memória de terceiros?

A resposta está em transformar uma obrigação legal recorrente em um processo automatizado, rastreável e integrado às ferramentas que sua equipe já usa. Neste guia, você vai construir um sistema completo de alertas — do mapeamento de ativos à notificação multicanal — usando Python, agendamento nativo do Linux e integrações modernas.

Mapeamento de ativos e definição de regras

Antes de escrever uma linha de código, faça o inventário físico. Percorra o prédio, fotografe cada reservatório, anote capacidade (litros), material (fibra, polietileno, concreto), localização (cobertura, subsolo, casa de máquinas) e data da última higienização comprovada. Registre tudo em uma planilha CSV ou diretamente no banco de dados da aplicação.

A periodicidade segue a NBR 12209 e portarias estaduais: geralmente seis meses para reservatórios de água potável. Porém, edifícios com consumo elevado, água de poço ou histórico de contaminação devem adotar intervalos menores. Crie uma coluna periodicidade_dias por ativo — 180, 120 ou 90 — e outra proxima_limpeza calculada automaticamente.

Estrutura de dados e modelo mínimo

Um modelo relacional simples resolve o problema. Tabela reservatorios com campos: id, nome, localizacao, capacidade_litros, material, ultima_limpeza (DATE), periodicidade_dias (INT), proxima_limpeza (DATE), responsavel_id (FK), ativo (BOOLEAN). Tabela alertas registra cada disparo: id, reservatorio_id, data_disparo, canal (email, slack, teams, itsm), status (enviado, falha, lido), payload_json.

from sqlalchemy import Column, Integer, String, Date, Boolean, ForeignKey, DateTime, Text
from sqlalchemy.orm import relationship
from database import Base
from datetime import datetime

class Reservatorio(Base):
    __tablename__ = 'reservatorios'
    id = Column(Integer, primary_key=True)
    nome = Column(String(100), nullable=False)
    localizacao = Column(String(200))
    capacidade_litros = Column(Integer)
    material = Column(String(50))
    ultima_limpeza = Column(Date)
    periodicidade_dias = Column(Integer, default=180)
    proxima_limpeza = Column(Date)
    responsavel_id = Column(Integer, ForeignKey('usuarios.id'))
    ativo = Column(Boolean, default=True)
    responsavel = relationship('Usuario', back_populates='reservatorios')
    alertas = relationship('Alerta', back_populates='reservatorio')

class Alerta(Base):
    __tablename__ = 'alertas'
    id = Column(Integer, primary_key=True)
    reservatorio_id = Column(Integer, ForeignKey('reservatorios.id'))
    data_disparo = Column(DateTime, default=datetime.utcnow)
    canal = Column(String(20))
    status = Column(String(20))
    payload_json = Column(Text)
    reservatorio = relationship('Reservatorio', back_populates='alertas')

Cálculo inteligente de datas com dias úteis

Não basta somar 180 dias corridos. Feriados municipais (aniversário da cidade), estaduais e nacionais devem ser excluídos. A biblioteca workalendar cobre o calendário brasileiro por estado e município.

from workalendar.america.brazil import Brazil, BrazilSaoPauloCity
from datetime import date, timedelta

def calcular_proxima_limpeza(ultima: date, periodicidade_dias: int, uf: str = 'SP', cidade: str = 'Sao Paulo') -> date:
    """Retorna a data da próxima limpeza considerando dias úteis."""
    cal = BrazilSaoPauloCity() if cidade == 'Sao Paulo' else Brazil()
    dias_adicionados = 0
    data_atual = ultima
    while dias_adicionados < periodicidade_dias:
        data_atual += timedelta(days=1)
        if cal.is_working_day(data_atual):
            dias_adicionados += 1
    return data_atual

def dias_uteis_ate(alvo: date, uf: str = 'SP', cidade: str = 'Sao Paulo') -> int:
    """Conta dias úteis de hoje até a data alvo."""
    cal = BrazilSaoPauloCity() if cidade == 'Sao Paulo' else Brazil()
    hoje = date.today()
    count = 0
    while hoje < alvo:
        hoje += timedelta(days=1)
        if cal.is_working_day(hoje):
            count += 1
    return count

Motor de verificação diária e disparo multicanal

O coração do sistema roda uma vez por dia via cron ou systemd timer. O script consulta todos os reservatórios ativos, calcula quantos dias úteis faltam para proxima_limpeza e dispara alertas nos limiares configurados: 30, 15, 7 e 1 dia útil antes. Cada canal tem seu adaptador.

import smtplib
import requests
import json
from email.mime.text import MIMEText
from datetime import date
from models import Reservatorio, Alerta, Session
from calculo_dias import dias_uteis_ate

LIMIARES = [30, 15, 7, 1]  # dias úteis antes

def enviar_email(destino, assunto, corpo):
    msg = MIMEText(corpo, 'html')
    msg['Subject'] = assunto
    msg['From'] = 'facilities@empresa.com'
    msg['To'] = destino
    with smtplib.SMTP('smtp.empresa.com', 587) as server:
        server.starttls()
        server.login('user', 'senha')
        server.send_message(msg)

def enviar_slack(webhook_url, texto):
    requests.post(webhook_url, json={'text': texto}, timeout=10)

def enviar_teams(webhook_url, titulo, corpo):
    payload = {'@type': 'MessageCard', '@context': 'http://schema.org/extensions',
               'themeColor': '0076D7', 'summary': titulo,
               'sections': [{'activityTitle': titulo, 'text': corpo}]}
    requests.post(webhook_url, json=payload, timeout=10)

def criar_chamado_itsm(reservatorio, dias_restantes):
    """Exemplo para Jira Cloud via REST API."""
    url = 'https://empresa.atlassian.net/rest/api/3/issue'
    auth = ('email@empresa.com', 'api_token')
    headers = {'Accept': 'application/json', 'Content-Type': 'application/json'}
    payload = {
        'fields': {
            'project': {'key': 'FAC'},
            'summary': f'Limpeza caixa d\'água: {reservatorio.nome} - {dias_restantes} dias úteis',
            'description': f'Reservatório: {reservatorio.nome}\nLocal: {reservatorio.localizacao}\nCapacidade: {reservatorio.capacidade_litros} L\nÚltima limpeza: {reservatorio.ultima_limpeza}\nPróxima prevista: {reservatorio.proxima_limpeza}\nResponsável: {reservatorio.responsavel.nome}',
            'issuetype': {'name': 'Task'},
            'assignee': {'emailAddress': reservatorio.responsavel.email}
        }
    }
    requests.post(url, json=payload, headers=headers, auth=auth, timeout=15)

def registrar_alerta(session, reservatorio_id, canal, status, payload):
    alerta = Alerta(reservatorio_id=reservatorio_id, canal=canal, status=status,
                    payload_json=json.dumps(payload, default=str))
    session.add(alerta)
    session.commit()

def main():
    session = Session()
    reservatorios = session.query(Reservatorio).filter_by(ativo=True).all()
    for r in reservatorios:
        dias = dias_uteis_ate(r.proxima_limpeza)
        if dias in LIMIARES:
            payload = {'reservatorio': r.nome, 'dias_uteis_restantes': dias,
                       'proxima_limpeza': str(r.proxima_limpeza)}
            try:
                enviar_email(r.responsavel.email,
                             f'Alerta: limpeza de caixa d\'água em {dias} dias úteis',
                             f'O reservatório {r.nome} precisa de limpeza até {r.proxima_limpeza}.')
                registrar_alerta(session, r.id, 'email', 'enviado', payload)
            except Exception as e:
                registrar_alerta(session, r.id, 'email', 'falha', {'erro': str(e)})
            try:
                enviar_slack('https://hooks.slack.com/services/XXX/YYY/ZZZ',
                             f':water_drop: Limpeza de *{r.nome}* em {dias} dias úteis ({r.proxima_limpeza})')
                registrar_alerta(session, r.id, 'slack', 'enviado', payload)
            except Exception as e:
                registrar_alerta(session, r.id, 'slack', 'falha', {'erro': str(e)})
            try:
                enviar_teams('https://outlook.office.com/webhook/XXX',
                             f'Limpeza de caixa d\'água: {r.nome}',
                             f'Faltam {dias} dias úteis para a limpeza programada.')
                registrar_alerta(session, r.id, 'teams', 'enviado', payload)
            except Exception as e:
                registrar_alerta(session, r.id, 'teams', 'falha', {'erro': str(e)})
            try:
                criar_chamado_itsm(r, dias)
                registrar_alerta(session, r.id, 'itsm', 'enviado', payload)
            except Exception as e:
                registrar_alerta(session, r.id, 'itsm', 'falha', {'erro': str(e)})
    session.close()

if __name__ == '__main__':
    main()

Integração com sensores e telemetria opcional

Se o prédio possui sensores de nível (ultrassônicos, radar ou boia magnética) com saída Modbus, LoRaWAN ou MQTT, você enriquece o alerta com dados em tempo real. Um vazamento lento ou consumo anômalo pode antecipar a necessidade de limpeza ou manutenção corretiva.

Um collector leve em Python lê o broker MQTT e grava leituras na tabela leituras_sensor (reservatorio_id, timestamp, nivel_percentual, vazao_l_min). O verificador diário consulta a última leitura e, se o nível cair abaixo de 20% sem motivo aparente, adiciona flag investigar_vazamento no payload do alerta.

Essa telemetria também alimenta dashboards no Grafana ou Power BI, dando visibilidade à gestão de facilities sem planilhas manuais. Para equipes que já usam stacks de observabilidade, o mesmo princípio de alerting as code aplicado a servidores vale para ativos hidráulicos.

Relatórios de conformidade e trilha de auditoria

A cada limpeza realizada, o responsável preenche um formulário digital (Google Forms, Microsoft Forms ou app interno) que dispara webhook para sua API. O endpoint valida os campos obrigatórios — data, empresa executora, CNPJ, responsável técnico, laudo anexo — e atualiza ultima_limpeza e proxima_limpeza do reservatório.

Um job mensal gera relatório consolidado em Markdown, commita no repositório Git privado da área de facilities e abre pull request para aprovação do gestor. O histórico de commits vira evidência documental para auditorias ISO 9001, ISO 14001 e fiscalizações do Ministério do Trabalho.


| Reservatório | Última Limpeza | Próxima Prevista | Status | Empresa Executora | Laudo |
|--------------|----------------|------------------|--------|-------------------|-------|
| Caixa Cobertura Bloco A | 2024-07-15 | 2025-01-15 | ✅ Conforme | HidroClean Ltda | [PDF](/laudos/2024-07-15_bloco_a.pdf) |
| Cisterna Subsolo Bloco B | 2024-06-20 | 2024-12-20 | ⚠️ Atrasada | - | - |
| Reservatório Casa de Máquinas | 2024-08-10 | 2025-02-10 | ✅ Conforme | AquaService | [PDF](/laudos/2024-08-10_casa_maquinas.pdf) |

> Gerado automaticamente em 2025-01-20 06:00 via `scheduler/relatorio_mensal.py`

Boas práticas de operação e evolução contínua

Trate o sistema como produto interno: versionamento semântico, changelog, testes automatizados (pytest + mocks de SMTP/HTTP) e pipeline de CI/CD que faz deploy em staging antes de produção. Documente runbooks para falhas comuns — expiração de token do Slack, mudança de API do Jira, feriado municipal não cadastrado no workalendar.

Revise trimestralmente a lista de contatos responsáveis, periodicidades e canais de notificação. Inclua o sistema no onboarding de novos analistas de facilities. Para expandir, adicione módulos de gestão de contratos com prestadores, SLA de atendimento e integração com dezjatodesentupidora.com.br/ quando a equipe interna não tiver capacidade técnica.

Automatizar alertas de limpeza de caixa d’água elimina o risco humano de esquecimento, cria evidências auditáveis e libera a equipe para tarefas de maior valor. Comece pequeno — um script, um reservatório, um canal — e evolua em ciclos curtos. A conformidade sanitária deixa de ser susto e vira rotina previsível.

Quer ver como aplicar esse mesmo padrão a outros ativos prediais? Confira nosso guia sobre automação de chamados de limpeza de caixa de água na Aclimação e o artigo sobre agendamento automatizado de limpeza de fossa em polos tecnológicos paulistanos. Para times que integram sensores em dashboards, o post sobre automatizando relatórios de hidrojateamento com Python mostra o próximo passo.

Checklist prático

0 de 9 concluídos

Perguntas frequentes

Qual a frequência ideal para limpeza de caixas d'água em escritórios?

A norma técnica recomenda limpeza semestral, mas ambientes com alto fluxo de pessoas ou água de poço podem exigir intervalos trimestrais. Consulte a vigilância sanitária local para adequar o cronograma.

Como integrar alertas de limpeza ao sistema de chamados da empresa?

Use webhooks ou APIs REST do seu ITSM (Jira, GLPI, ServiceNow) para criar tickets automáticos quando o script detectar a data limite. Inclua no payload: local, responsável, histórico e checklists anexos.

Sensores de nível substituem a inspeção visual periódica?

Não. Sensores monitoram volume e vazamentos, mas não detectam biofilme, sedimentos ou contaminação microbiológica. A inspeção física continua obrigatória por legislação sanitária.

Qual stack mínima para rodar esse agendamento em produção?

Um servidor Linux com Python 3.10+, cron ou systemd timers, banco SQLite/PostgreSQL para logs e acesso SMTP/Slack para notificações. Containers Docker facilitam portabilidade e updates.

Como tratar feriados e fins de semana nos alertas?

Use a biblioteca `workalendar` ou `bizdays` para calcular dias úteis. Programe o alerta para disparar com 15 dias úteis de antecedência, garantindo janela para contratação e execução do serviço.

É possível versionar o histórico de limpezas em Git?

Sim. Armazene relatórios em Markdown ou JSON num repositório privado. Commits automáticos via CI/CD criam trilha de auditoria imutável, útil para certificações ISO e auditorias do Ministério do Trabalho.