first commit
This commit is contained in:
Cauê Faleiros
557
kanban/main.py
Normal file
557
kanban/main.py
Normal file
@@ -0,0 +1,557 @@
|
||||
"""
|
||||
Kanban da sala de DTF — roda no servidor da fábrica, rede interna.
|
||||
|
||||
Princípio: o KANBAN é a única interface. O operador move o card aqui e as
|
||||
pastas do servidor seguem sozinhas — ninguém abre o Explorer.
|
||||
Decidido em 30/08/2026: não existe watchdog de pastas. Movimento feito fora do
|
||||
kanban não é suportado.
|
||||
|
||||
A fila é sempre por HORÁRIO DE CHEGADA: quem chegou primeiro fica em cima.
|
||||
Mover o card grava o movimento, move o arquivo, enfileira o marcador no Tiny
|
||||
e o WhatsApp ao cliente. Ninguém abre o Tiny para atualizar nada.
|
||||
|
||||
O log de movimentos é gravado SEMPRE, mesmo se o Tiny estiver fora do ar.
|
||||
A medição de tempo por etapa nunca depende de API de terceiro.
|
||||
|
||||
Rodar:
|
||||
uvicorn main:app --host 0.0.0.0 --port 8080
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import sqlite3
|
||||
import threading
|
||||
import time
|
||||
from datetime import datetime, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
from fastapi import FastAPI, HTTPException
|
||||
from fastapi.responses import FileResponse, RedirectResponse
|
||||
from pydantic import BaseModel
|
||||
|
||||
import tiny
|
||||
import whats
|
||||
|
||||
BANCO = Path(os.environ.get("KANBAN_DB", r"C:\dtf\kanban.db"))
|
||||
RAIZ = Path(os.environ.get("PASTA_DTF", r"\\servidor\DTF"))
|
||||
|
||||
# O KANBAN é a fonte de verdade da operação. O marcador no Tiny existe só para
|
||||
# quem NÃO abre o kanban: comercial atendendo cliente no telefone, expedição
|
||||
# conferindo se o DTF saiu, e o Marcus olhando pelo celular fora da fábrica.
|
||||
#
|
||||
# Por isso o Tiny recebe o estágio grosso, não o detalhe fino:
|
||||
# está sendo feito · travou · ficou pronto
|
||||
#
|
||||
# Três chamadas por pedido em vez de sete. A 213 pedidos/dia, são 640 requisições
|
||||
# em vez de 1.500 — folga no limite da API e menos job para o TI monitorar.
|
||||
COLUNAS = [
|
||||
("aut", "Aguardando autorização", "05_AUTORIZACAO", None, False), # só retrabalho
|
||||
("rec", "Arte recebida", "00_ARTE_RECEBIDA", None, False),
|
||||
("tra", "Arte tratada", "10_ARTE_TRATADA", None, False),
|
||||
("apc", "Aprovação de cor", "15_APROVACAO_COR", "DTF-PROVA-COR",False),
|
||||
("fil", "Fila de impressão", "20_FILA_IMPRESSAO", None, False),
|
||||
("imp", "Imprimindo", "30_IMPRIMINDO", "DTF-PRODUCAO", False),
|
||||
("cor", "Correção", "40_CORRECAO", "CORRECAO DTF", False),
|
||||
("fin", "Finalizado", "60_FINALIZADO", "DTF-PRONTO", False),
|
||||
]
|
||||
# A sala só IMPRIME o filme — quem aplica na peça é o cliente.
|
||||
# Por isso não existe coluna de aplicação nem causa de retrabalho por aplicação.
|
||||
IDS = [c[0] for c in COLUNAS]
|
||||
INFO = {c[0]: c for c in COLUNAS}
|
||||
AVISA_CLIENTE = {"apc": "prova_cor", "imp": "producao",
|
||||
"cor": "correcao", "fin": "concluido"}
|
||||
|
||||
app = FastAPI(title="Kanban DTF")
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Distribuição entre as máquinas — POR PUXADA, não por empurro
|
||||
# ---------------------------------------------------------------------------
|
||||
# O sistema NÃO decide qual máquina roda qual pedido. A fila é única, por
|
||||
# horário de chegada, e a máquina que termina puxa o próximo.
|
||||
#
|
||||
# Empurrar exigiria adivinhar qual máquina estará livre daqui a duas horas. Se
|
||||
# uma travar, a fila dela para enquanto outra fica ociosa, e alguém remaneja na
|
||||
# mão. Por puxada nunca desbalanceia.
|
||||
#
|
||||
# Para o operador: um botão "puxar próximo". O arquivo já vem com o spot pronto
|
||||
# do robô — ele só abre no Flexi e roda.
|
||||
# Ajustado em 02/09/2026 pelo Thales e Alexandre:
|
||||
# "reserva de 15 min é demais, no máx 3 min"
|
||||
# "pedido por vez" — não puxar lote de trabalho
|
||||
RESERVA_MIN = 3 # sem entrar em Imprimindo nesse prazo, volta para a fila
|
||||
PUXAR_ATE_MIN = 0 # 0 = um pedido por vez, como a sala pediu
|
||||
|
||||
|
||||
class Puxar(BaseModel):
|
||||
maquina: int
|
||||
usuario: str
|
||||
minutos: int = PUXAR_ATE_MIN
|
||||
|
||||
|
||||
@app.post("/api/puxar")
|
||||
def puxar(p: Puxar):
|
||||
"""
|
||||
A máquina puxa o próximo da fila. Reserva por 15 min e move o arquivo para
|
||||
a hot folder daquela máquina — o FlexiPRINT processa sozinho de lá.
|
||||
"""
|
||||
agora = datetime.now()
|
||||
limite = (agora - timedelta(minutes=RESERVA_MIN)).isoformat(timespec="seconds")
|
||||
pegos, minutos = [], 0
|
||||
|
||||
with con() as c:
|
||||
# solta reservas vencidas antes de distribuir
|
||||
c.execute("UPDATE card SET reservado_por=NULL, reservado_em=NULL "
|
||||
"WHERE reservado_em IS NOT NULL AND reservado_em < ?", (limite,))
|
||||
|
||||
fila = c.execute(
|
||||
"SELECT * FROM card WHERE coluna='fil' AND reservado_por IS NULL "
|
||||
"ORDER BY desde").fetchall() # sempre por horário de chegada
|
||||
|
||||
for card in fila:
|
||||
# estimativa de máquina: o campo do card manda; sem ele, calcula pelos metros
|
||||
mm = card["minutos_maquina"] or round(card["metros"] / 20 * 60)
|
||||
if pegos: # um pedido por vez
|
||||
break
|
||||
c.execute("UPDATE card SET reservado_por=?, reservado_em=?, maquina=? "
|
||||
"WHERE arte_id=?",
|
||||
(f"Maq {p.maquina}", agora.isoformat(timespec="seconds"),
|
||||
f"Maq {p.maquina}", card["arte_id"]))
|
||||
mover_arquivos(card["pedido"], "20_FILA_IMPRESSAO", f"30_MAQ{p.maquina}")
|
||||
pegos.append({"pedido": card["pedido"], "metros": card["metros"],
|
||||
"minutos": mm})
|
||||
minutos += mm
|
||||
|
||||
return {"maquina": f"Maq {p.maquina}", "pedidos": pegos,
|
||||
"minutos_total": minutos,
|
||||
"reserva_expira_em": RESERVA_MIN}
|
||||
|
||||
|
||||
@app.post("/api/devolver")
|
||||
def devolver(arte_id: int, usuario: str):
|
||||
"""
|
||||
Máquina travou no meio. O pedido volta ao TOPO da fila, não ao fim —
|
||||
ele já esperou uma vez.
|
||||
"""
|
||||
with con() as c:
|
||||
card = c.execute("SELECT * FROM card WHERE arte_id=?", (arte_id,)).fetchone()
|
||||
if not card:
|
||||
raise HTTPException(404)
|
||||
maq = (card["maquina"] or "Maq 1").replace("Maq ", "")
|
||||
mover_arquivos(card["pedido"], f"30_MAQ{maq}", "20_FILA_IMPRESSAO")
|
||||
# desde antigo = volta para o topo da ordem por horário de chegada
|
||||
c.execute("UPDATE card SET coluna='fil', reservado_por=NULL, "
|
||||
"reservado_em=NULL, maquina=NULL WHERE arte_id=?", (arte_id,))
|
||||
c.execute("""INSERT INTO movimento
|
||||
(arte_id,pedido,de,para,entrou_em,saiu_em,segundos,usuario,maquina)
|
||||
VALUES (?,?,?,?,?,?,?,?,?)""",
|
||||
(arte_id, card["pedido"], "imp", "fil", card["desde"],
|
||||
datetime.now().isoformat(timespec="seconds"), 0, usuario, card["maquina"]))
|
||||
return {"ok": True, "voltou_ao_topo": True}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Aprovação de cor — evita o retrabalho em vez de repor depois
|
||||
# ---------------------------------------------------------------------------
|
||||
# Imprime uma amostra pequena, fotografa e manda ao cliente. Ele aprova, e só
|
||||
# então o pedido vai para a fila. Custa centímetros de filme e evita metros.
|
||||
#
|
||||
# Dispara sozinho em três situações:
|
||||
PROVA_METROS = 10.0 # arquivo grande: erro de cor custa caro
|
||||
PROVA_CLIENTE_NOVO = True # primeiro pedido do cliente
|
||||
# cores fora do gamut CMYK, que quase nunca saem como o cliente vê na tela
|
||||
PROVA_CORES_TENSAS = {
|
||||
"vermelho_saturado", "laranja", "verde_vivo", "azul_royal",
|
||||
"roxo", "tom_de_pele", "cinza_neutro",
|
||||
}
|
||||
|
||||
|
||||
def precisa_prova_cor(metros: float, cliente_novo: bool,
|
||||
cores_detectadas: set[str]) -> tuple[bool, str]:
|
||||
if metros >= PROVA_METROS:
|
||||
return True, f"arquivo de {metros:.1f} m"
|
||||
if cliente_novo and PROVA_CLIENTE_NOVO:
|
||||
return True, "primeiro pedido do cliente"
|
||||
tensas = cores_detectadas & PROVA_CORES_TENSAS
|
||||
if tensas:
|
||||
return True, "cor fora do gamut: " + ", ".join(sorted(tensas))
|
||||
return False, ""
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Retrabalho — SKU CRRMP.TX.100CM
|
||||
# ---------------------------------------------------------------------------
|
||||
# A causa é obrigatória e define quem absorve o custo. Sem ela o card não anda.
|
||||
CAUSAS = {
|
||||
"arte_cliente": ("Arte ruim aprovada pelo cliente", "cliente"),
|
||||
"tratamento": ("Erro de tratamento", "casa"),
|
||||
"impressao": ("Falha de impressão", "casa"),
|
||||
"perfil_cor": ("Perfil de cor", "casa"),
|
||||
"pedido": ("Erro de pedido", "casa"),
|
||||
}
|
||||
|
||||
# Quem abre e quem autoriza são pessoas diferentes, de propósito.
|
||||
#
|
||||
# MAYANA abre e CLASSIFICA a causa. Ela conhece o cliente e sabe se a
|
||||
# reclamação procede. A causa fica TRAVADA depois de aberta.
|
||||
#
|
||||
# THALES ou ALEXANDRE autorizam. O retrabalho da casa entra na meta e na
|
||||
# remuneração deles — então têm incentivo real para questionar o que não
|
||||
# procede. É controle natural, não burocracia.
|
||||
#
|
||||
# Por que a causa não pode ser mudada por quem autoriza: com o indicador
|
||||
# atrelado a bônus, existiria incentivo para reclassificar falha de máquina
|
||||
# como "arte do cliente". Quem discorda CONTESTA, e a contestação fica
|
||||
# registrada com quem pediu e quem decidiu.
|
||||
ABRE = "mayana"
|
||||
AUTORIZA = ("thales", "alexandre")
|
||||
|
||||
# Alçada por metragem. Cada metro custa R$ 4,94 de insumo mais tempo de máquina.
|
||||
ALCADA = [(15.0, "sala"), (float("inf"), "financeiro")]
|
||||
# Meta por causa, não meta única. Cada um responde pelo que controla.
|
||||
# 0,4% em cada uma das quatro causas da casa = 1,6% no total.
|
||||
#
|
||||
# Perfil de cor é causa PRÓPRIA, separada de falha de impressão. Cor errada é o
|
||||
# retrabalho mais comum de DTF e quase nunca é defeito de máquina: ou a arte
|
||||
# veio em CMYK, ou o monitor do cliente não é calibrado, ou o perfil da
|
||||
# impressora está desatualizado. Só o terceiro é da casa — e separando dá para
|
||||
# saber quanto é cada coisa.
|
||||
META_POR_CAUSA = {
|
||||
"impressao": (0.4, "Thales e Alexandre"),
|
||||
"perfil_cor": (0.4, "Thales e Alexandre"),
|
||||
"tratamento": (0.4, "designers"),
|
||||
"pedido": (0.4, "comercial"),
|
||||
"arte_cliente": (None, None), # reposição comercial: fora da meta
|
||||
}
|
||||
# soma das metas da casa = 1,6%
|
||||
TETO_MES_PCT = 6.0 # acima disso tudo sobe uma alçada
|
||||
TETO_CLIENTE_PCT = 10.0 # cliente acima disso fica sinalizado no painel
|
||||
|
||||
|
||||
def quem_autoriza(metros: float, vez: int, pct_mes: float) -> str:
|
||||
"""Reincidência e teto do mês sobem a alçada automaticamente."""
|
||||
if vez >= 3:
|
||||
return "diretoria"
|
||||
nivel = next(n for lim, n in ALCADA if metros <= lim)
|
||||
if vez == 2:
|
||||
nivel = {"sala": "financeiro"}.get(nivel, "diretoria")
|
||||
if pct_mes > TETO_MES_PCT:
|
||||
nivel = {"sala": "financeiro", "financeiro": "diretoria"}.get(nivel, "diretoria")
|
||||
return nivel
|
||||
|
||||
|
||||
def conta_na_meta(causa: str) -> bool:
|
||||
"""Só o retrabalho da casa entra na meta. O do cliente, não."""
|
||||
return CAUSAS[causa][1] == "casa"
|
||||
|
||||
|
||||
@app.get("/api/relatorio/retrabalho")
|
||||
def retrabalho(dias: int = 30):
|
||||
"""
|
||||
Retrabalho por causa, com responsável e meta.
|
||||
Base para a bonificação: cada equipe é medida só pelo que controla.
|
||||
"""
|
||||
with con() as c:
|
||||
total = c.execute(
|
||||
"SELECT COUNT(*) n FROM card WHERE desde >= date('now', ?)",
|
||||
(f"-{dias} days",)).fetchone()["n"] or 1
|
||||
linhas = c.execute("""
|
||||
SELECT causa, COUNT(*) n, SUM(metros) m
|
||||
FROM retrabalho WHERE aberto_em >= date('now', ?)
|
||||
GROUP BY causa""", (f"-{dias} days",)).fetchall()
|
||||
|
||||
saida, casa = [], 0.0
|
||||
for r in linhas:
|
||||
pct = r["n"] / total * 100
|
||||
meta, quem = META_POR_CAUSA.get(r["causa"], (None, None))
|
||||
if conta_na_meta(r["causa"]):
|
||||
casa += pct
|
||||
saida.append({
|
||||
"causa": r["causa"], "descricao": CAUSAS[r["causa"]][0],
|
||||
"responsavel": quem, "pedidos": r["n"], "metros": r["m"],
|
||||
"pct": round(pct, 2), "meta": meta,
|
||||
"bate": None if meta is None else pct <= meta,
|
||||
})
|
||||
return {"por_causa": saida, "total_casa_pct": round(casa, 2),
|
||||
"meta_casa_pct": round(sum(m for m, _ in META_POR_CAUSA.values()
|
||||
if m is not None), 2)}
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
def con():
|
||||
c = sqlite3.connect(BANCO, timeout=10)
|
||||
c.row_factory = sqlite3.Row
|
||||
return c
|
||||
|
||||
|
||||
def criar_tabelas() -> None:
|
||||
with con() as c:
|
||||
c.executescript("""
|
||||
CREATE TABLE IF NOT EXISTS card(
|
||||
arte_id INTEGER PRIMARY KEY, pedido TEXT, cliente TEXT, metros REAL,
|
||||
coluna TEXT DEFAULT 'rec', desde TEXT, maquina TEXT, partes INTEGER,
|
||||
reservado_por TEXT, reservado_em TEXT,
|
||||
minutos_maquina INTEGER); -- estimativa; herda os marcadores 30min/1h/3h
|
||||
CREATE TABLE IF NOT EXISTS movimento(
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
arte_id INTEGER, pedido TEXT, de TEXT, para TEXT,
|
||||
entrou_em TEXT, saiu_em TEXT, segundos INTEGER,
|
||||
usuario TEXT, maquina TEXT);
|
||||
CREATE TABLE IF NOT EXISTS job(
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
tipo TEXT, payload TEXT, tentativas INTEGER DEFAULT 0,
|
||||
proxima_em REAL, erro TEXT, feito INTEGER DEFAULT 0);
|
||||
CREATE INDEX IF NOT EXISTS ix_mov_arte ON movimento(arte_id);
|
||||
CREATE INDEX IF NOT EXISTS ix_job_fila ON job(feito, proxima_em);
|
||||
""")
|
||||
|
||||
|
||||
criar_tabelas()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
class Mover(BaseModel):
|
||||
arte_id: int
|
||||
para: str
|
||||
usuario: str
|
||||
maquina: str | None = None
|
||||
|
||||
|
||||
@app.get("/api/quadro")
|
||||
def quadro():
|
||||
agora = datetime.now()
|
||||
with con() as c:
|
||||
cards = c.execute("SELECT * FROM card ORDER BY desde").fetchall()
|
||||
|
||||
saida = {i: [] for i in IDS}
|
||||
for r in cards:
|
||||
desde = datetime.fromisoformat(r["desde"])
|
||||
saida[r["coluna"]].append({
|
||||
"arte_id": r["arte_id"], "pedido": r["pedido"], "cliente": r["cliente"],
|
||||
"metros": r["metros"], "maquina": r["maquina"], "partes": r["partes"],
|
||||
"desde": r["desde"],
|
||||
"parado_seg": int((agora - desde).total_seconds()),
|
||||
"minutos_maquina": round(r["metros"] / 20 * 60), # 20 m/h por máquina
|
||||
})
|
||||
return {"colunas": [{"id": c[0], "nome": c[1]} for c in COLUNAS], "cards": saida}
|
||||
|
||||
|
||||
@app.post("/api/mover")
|
||||
def mover(m: Mover):
|
||||
if m.para not in IDS:
|
||||
raise HTTPException(400, "coluna inválida")
|
||||
|
||||
agora = datetime.now()
|
||||
with con() as c:
|
||||
card = c.execute("SELECT * FROM card WHERE arte_id=?", (m.arte_id,)).fetchone()
|
||||
if not card:
|
||||
raise HTTPException(404, "card não encontrado")
|
||||
if card["coluna"] == m.para:
|
||||
return {"ok": True, "sem_mudanca": True}
|
||||
|
||||
de = card["coluna"]
|
||||
desde = datetime.fromisoformat(card["desde"])
|
||||
|
||||
# 1. o movimento é gravado ANTES de qualquer integração externa
|
||||
c.execute("""INSERT INTO movimento
|
||||
(arte_id,pedido,de,para,entrou_em,saiu_em,segundos,usuario,maquina)
|
||||
VALUES (?,?,?,?,?,?,?,?,?)""",
|
||||
(m.arte_id, card["pedido"], de, m.para, card["desde"],
|
||||
agora.isoformat(timespec="seconds"),
|
||||
int((agora - desde).total_seconds()), m.usuario,
|
||||
m.maquina or card["maquina"]))
|
||||
|
||||
c.execute("UPDATE card SET coluna=?, desde=?, maquina=COALESCE(?,maquina) "
|
||||
"WHERE arte_id=?",
|
||||
(m.para, agora.isoformat(timespec="seconds"), m.maquina, m.arte_id))
|
||||
|
||||
# 2. arquivo acompanha o card
|
||||
mover_arquivos(card["pedido"], INFO[de][2], INFO[m.para][2])
|
||||
|
||||
# 3. jobs: marcador no Tiny e WhatsApp
|
||||
# a máquina fica só no kanban — no Tiny basta saber que entrou em produção
|
||||
marcador = INFO[m.para][3]
|
||||
if marcador:
|
||||
enfileirar(c, "tiny_marcador",
|
||||
{"pedido": card["pedido"], "marcador": marcador})
|
||||
if m.para in AVISA_CLIENTE:
|
||||
enfileirar(c, "whats",
|
||||
{"pedido": card["pedido"], "tipo": AVISA_CLIENTE[m.para]})
|
||||
|
||||
return {"ok": True, "de": de, "para": m.para}
|
||||
|
||||
|
||||
def mover_arquivos(pedido: str, pasta_de: str, pasta_para: str) -> None:
|
||||
origem, destino = RAIZ / pasta_de, RAIZ / pasta_para
|
||||
destino.mkdir(parents=True, exist_ok=True)
|
||||
for f in origem.glob(f"{pedido}_*"):
|
||||
shutil.move(str(f), str(destino / f.name))
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# Fila de jobs — tabela simples, sem Redis nem Celery
|
||||
# --------------------------------------------------------------------------
|
||||
def enfileirar(c, tipo: str, payload: dict) -> None:
|
||||
c.execute("INSERT INTO job(tipo,payload,proxima_em) VALUES (?,?,?)",
|
||||
(tipo, json.dumps(payload), time.time()))
|
||||
|
||||
|
||||
ESPERA = [60, 300, 1800] # 1 min, 5 min, 30 min
|
||||
|
||||
|
||||
def worker() -> None:
|
||||
while True:
|
||||
try:
|
||||
with con() as c:
|
||||
job = c.execute(
|
||||
"SELECT * FROM job WHERE feito=0 AND proxima_em<=? "
|
||||
"ORDER BY id LIMIT 1", (time.time(),)).fetchone()
|
||||
if not job:
|
||||
time.sleep(3)
|
||||
continue
|
||||
|
||||
p = json.loads(job["payload"])
|
||||
try:
|
||||
if job["tipo"] == "tiny_marcador":
|
||||
tiny.marcador(p["pedido"], p["marcador"])
|
||||
elif job["tipo"] == "whats":
|
||||
whats.avisar(p["pedido"], p["tipo"])
|
||||
c.execute("UPDATE job SET feito=1 WHERE id=?", (job["id"],))
|
||||
except Exception as e:
|
||||
n = job["tentativas"] + 1
|
||||
if n > len(ESPERA):
|
||||
c.execute("UPDATE job SET feito=1, erro=? WHERE id=?",
|
||||
(f"desistiu: {e}", job["id"]))
|
||||
# TODO: alertar o TI
|
||||
else:
|
||||
c.execute(
|
||||
"UPDATE job SET tentativas=?, proxima_em=?, erro=? WHERE id=?",
|
||||
(n, time.time() + ESPERA[n - 1], str(e), job["id"]))
|
||||
except Exception:
|
||||
time.sleep(5)
|
||||
|
||||
|
||||
threading.Thread(target=worker, daemon=True).start()
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# QR do carimbo aponta para cá
|
||||
# --------------------------------------------------------------------------
|
||||
@app.get("/p/{pedido}")
|
||||
def abrir_card(pedido: str):
|
||||
"""A revisão bipa o QR do filme e cai direto no card."""
|
||||
with con() as c:
|
||||
card = c.execute("SELECT arte_id FROM card WHERE pedido=?", (pedido,)).fetchone()
|
||||
if not card:
|
||||
raise HTTPException(404, "pedido não encontrado no kanban")
|
||||
return RedirectResponse(f"/?card={card['arte_id']}")
|
||||
|
||||
|
||||
@app.get("/api/pedido/{pedido}")
|
||||
def trilha(pedido: str):
|
||||
"""Tempo em cada etapa e quanto do total foi só esperando."""
|
||||
PARADO = {"rec", "tra", "fil", "cor"}
|
||||
with con() as c:
|
||||
movs = c.execute(
|
||||
"SELECT * FROM movimento WHERE pedido=? ORDER BY id", (pedido,)).fetchall()
|
||||
card = c.execute("SELECT * FROM card WHERE pedido=?", (pedido,)).fetchone()
|
||||
if not card:
|
||||
raise HTTPException(404)
|
||||
|
||||
agora = int((datetime.now() - datetime.fromisoformat(card["desde"])).total_seconds())
|
||||
etapas = [{"coluna": m["de"], "nome": INFO[m["de"]][1], "segundos": m["segundos"]}
|
||||
for m in movs]
|
||||
etapas.append({"coluna": card["coluna"], "nome": INFO[card["coluna"]][1],
|
||||
"segundos": agora, "atual": True})
|
||||
|
||||
total = sum(e["segundos"] for e in etapas)
|
||||
esperando = sum(e["segundos"] for e in etapas if e["coluna"] in PARADO)
|
||||
return {"pedido": pedido, "cliente": card["cliente"], "metros": card["metros"],
|
||||
"etapas": etapas, "total_seg": total, "esperando_seg": esperando}
|
||||
|
||||
|
||||
PERIODOS = {"hoje": 1, "7": 7, "30": 30, "mes": 30, "ant": 60}
|
||||
|
||||
|
||||
@app.get("/api/relatorio/impressao")
|
||||
def tempo_impressao(dias: int = 7):
|
||||
"""
|
||||
Tempo médio de impressão e velocidade real por máquina.
|
||||
Sai da coluna 'imp' da tabela movimento, cruzada com os metros do card.
|
||||
É este número que diz se 20 m/h é a velocidade real ou só a de catálogo.
|
||||
"""
|
||||
with con() as c:
|
||||
linhas = c.execute("""
|
||||
SELECT m.maquina, COUNT(*) n,
|
||||
AVG(m.segundos) media_seg,
|
||||
SUM(c.metros) metros,
|
||||
SUM(m.segundos) total_seg
|
||||
FROM movimento m JOIN card c ON c.arte_id = m.arte_id
|
||||
WHERE m.de = 'imp' AND m.saiu_em >= date('now', ?)
|
||||
GROUP BY m.maquina""", (f"-{dias} days",)).fetchall()
|
||||
saida = []
|
||||
for r in linhas:
|
||||
horas = (r["total_seg"] or 0) / 3600
|
||||
saida.append({
|
||||
"maquina": r["maquina"], "pedidos": r["n"],
|
||||
"media_min": round((r["media_seg"] or 0) / 60),
|
||||
"metros": round(r["metros"] or 0, 1),
|
||||
"m_por_hora": round((r["metros"] or 0) / horas, 1) if horas else None,
|
||||
})
|
||||
return saida
|
||||
|
||||
|
||||
# Depósito do Tiny para onde o insumo é transferido antes de imprimir.
|
||||
# A Altus também VENDE insumo, então esse depósito separa o que é consumo
|
||||
# interno do que é revenda. Confirmar o nome exato no cadastro do Tiny.
|
||||
DEPOSITO_IMPRESSAO = "Sala DTF"
|
||||
SKU_FILME = "DTF.FILME.57"
|
||||
|
||||
|
||||
@app.get("/api/relatorio/aproveitamento")
|
||||
def aproveitamento(dias: int = 30):
|
||||
"""
|
||||
Quanto do filme transferido virou metro faturado.
|
||||
|
||||
Compra-se rolo de 100 m e imprime-se cerca de 90, por acerto de máquina,
|
||||
prova de cor, refile e sobra de ponta. Cada ponto percentual vale cerca de
|
||||
R$ 980/mês no volume atual.
|
||||
|
||||
NÃO exige apontamento novo na sala: o consumo já é registrado hoje, quando
|
||||
o insumo é transferido para o depósito de impressão no Tiny. Este endpoint
|
||||
só lê a movimentação desse depósito.
|
||||
"""
|
||||
fat = 0.0
|
||||
with con() as c:
|
||||
fat = c.execute(
|
||||
"SELECT SUM(metros) m FROM card WHERE coluna='fin' AND desde >= date('now', ?)",
|
||||
(f"-{dias} days",)).fetchone()["m"] or 0
|
||||
|
||||
cons = tiny.transferido_para_deposito(
|
||||
sku=SKU_FILME, deposito=DEPOSITO_IMPRESSAO, dias=dias)
|
||||
|
||||
pct = fat / cons * 100 if cons else None
|
||||
return {"metros_faturados": round(fat, 1),
|
||||
"metros_de_filme": round(cons, 1),
|
||||
"fonte": f"transferências para o depósito {DEPOSITO_IMPRESSAO} no Tiny",
|
||||
"aproveitamento_pct": round(pct, 1) if pct else None,
|
||||
"valor_do_ponto_mes": 980}
|
||||
|
||||
|
||||
@app.get("/api/relatorio/etapas")
|
||||
def relatorio(dias: int = 7):
|
||||
"""Tempo médio por etapa. É o número que hoje não existe em lugar nenhum."""
|
||||
with con() as c:
|
||||
linhas = c.execute("""
|
||||
SELECT de, COUNT(*) n, AVG(segundos) media, MAX(segundos) pior
|
||||
FROM movimento
|
||||
WHERE saiu_em >= date('now', ?)
|
||||
GROUP BY de""", (f"-{dias} days",)).fetchall()
|
||||
return [{"coluna": r["de"], "nome": INFO[r["de"]][1], "movimentos": r["n"],
|
||||
"media_min": round(r["media"] / 60), "pior_min": round(r["pior"] / 60)}
|
||||
for r in linhas]
|
||||
|
||||
|
||||
@app.get("/")
|
||||
def index():
|
||||
return FileResponse("static/kanban.html")
|
||||
Reference in New Issue
Block a user