ATT
This commit is contained in:
Andrey Cunha
parent
bbb9a16986
commit
94a7bc5e1b
BIN
__pycache__/installments_reader.cpython-311.pyc
Normal file
BIN
__pycache__/installments_reader.cpython-311.pyc
Normal file
Binary file not shown.
@ -1,48 +0,0 @@
|
||||
import os
|
||||
from datetime import date
|
||||
|
||||
import installments_reader
|
||||
|
||||
|
||||
def _setdefault_env(key: str, value: str) -> None:
|
||||
if not os.getenv(key):
|
||||
os.environ[key] = value
|
||||
|
||||
|
||||
def main() -> None:
|
||||
today = date.today()
|
||||
start_of_year = date(today.year, 1, 1)
|
||||
|
||||
defaults = {
|
||||
"STORE_CHANNEL": "VD",
|
||||
"START_INSTALLMENT_CHANGE_DATE": start_of_year.isoformat(),
|
||||
"END_INSTALLMENT_CHANGE_DATE": today.isoformat(),
|
||||
"CHUNK_DAYS": "30",
|
||||
"LAST_N_DAYS": "",
|
||||
"STORE_WORKERS": "1",
|
||||
"GROUP_WORKERS": "1",
|
||||
"WRITE_SQL": "1",
|
||||
"SAVE_JSON": "0",
|
||||
"INCREMENTAL_MODE": "0",
|
||||
"LOG_GROUP_CODES": "0",
|
||||
"INSTALLMENTS_PAGE_SIZE": "50",
|
||||
"FLUSH_EVERY_PAGES": "50",
|
||||
"INSTALLMENTS_MIN_INTERVAL_MS": "3500",
|
||||
"INSTALLMENTS_429_MIN_WAIT_SEC": "45",
|
||||
"THROTTLE_RECOVERY_PAUSE_SEC": "900",
|
||||
}
|
||||
for key, value in defaults.items():
|
||||
_setdefault_env(key, value)
|
||||
|
||||
print(
|
||||
"[backfill] modo=VD "
|
||||
f"periodo={os.environ['START_INSTALLMENT_CHANGE_DATE']}..{os.environ['END_INSTALLMENT_CHANGE_DATE']} "
|
||||
f"chunk_days={os.environ['CHUNK_DAYS']} write_sql={os.environ['WRITE_SQL']} "
|
||||
f"min_interval_ms={os.environ['INSTALLMENTS_MIN_INTERVAL_MS']} "
|
||||
f"wait429_min_s={os.environ['INSTALLMENTS_429_MIN_WAIT_SEC']}"
|
||||
)
|
||||
installments_reader.main()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,185 +0,0 @@
|
||||
"""
|
||||
Consulta a API de parcelas por installmentGroupCode (orderNumber) e grava
|
||||
em DocPedidos + DocPedidosParcelas.
|
||||
|
||||
Fonte dos códigos: SELECT orderNumber FROM Grgb_fiscal_invoices_items
|
||||
"""
|
||||
import os
|
||||
import time
|
||||
import requests
|
||||
|
||||
import installments_reader
|
||||
from installments_reader import Auth, get_installments_page, upsert_doc_pedidos_sqlserver
|
||||
|
||||
# ─── CONFIGURE AQUI ───────────────────────────────────────────────────────────
|
||||
WRITE_SQL = True # True = grava no banco | False = só lê e exibe
|
||||
SKIP_EXISTING = True # True = pula códigos já gravados em DocPedidos
|
||||
BATCH_SIZE = 10 # grava no banco a cada N pedidos processados
|
||||
MIN_INTERVAL_MS = 3500 # ms mínimo entre chamadas à API
|
||||
# ──────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
SQL_CONN = (
|
||||
"DRIVER={ODBC Driver 17 for SQL Server};"
|
||||
"SERVER=10.77.77.10;"
|
||||
"DATABASE=GINSENG;"
|
||||
"UID=andrey;"
|
||||
"PWD=88253332;"
|
||||
"TrustServerCertificate=yes;"
|
||||
)
|
||||
|
||||
|
||||
def _get_order_numbers() -> list[str]:
|
||||
import pyodbc
|
||||
cn = pyodbc.connect(SQL_CONN, timeout=30)
|
||||
cur = cn.cursor()
|
||||
cur.execute(
|
||||
"SELECT DISTINCT [orderNumber] "
|
||||
"FROM [GINSENG].[dbo].[Grgb_fiscal_invoices_items] "
|
||||
"WHERE [orderNumber] IS NOT NULL AND LTRIM(RTRIM(CAST([orderNumber] AS VARCHAR))) <> ''"
|
||||
)
|
||||
return [str(row[0]).strip() for row in cur.fetchall()]
|
||||
|
||||
|
||||
def _get_existing_group_codes() -> set[str]:
|
||||
import pyodbc
|
||||
try:
|
||||
cn = pyodbc.connect(SQL_CONN, timeout=30)
|
||||
cur = cn.cursor()
|
||||
cur.execute("SELECT InstallmentGroupCode FROM dbo.DocPedidos")
|
||||
return {str(row[0]).strip() for row in cur.fetchall()}
|
||||
except Exception:
|
||||
return set()
|
||||
|
||||
|
||||
def _fetch_all_pages(session: requests.Session, auth: Auth, group_code: str) -> list:
|
||||
all_items = []
|
||||
page = 1
|
||||
while True:
|
||||
body = get_installments_page(
|
||||
session=session,
|
||||
auth=auth,
|
||||
start_date=None,
|
||||
end_date=None,
|
||||
installment_change=None,
|
||||
mediator_code=None,
|
||||
page=page,
|
||||
installment_group_code=group_code,
|
||||
cookie_header=None,
|
||||
)
|
||||
items = ((body.get("data") or {}).get("installments")) or []
|
||||
all_items.extend(items)
|
||||
|
||||
pagination = (body.get("data") or {}).get("pagination") or {}
|
||||
total = int(pagination.get("total") or 0)
|
||||
limit = int(pagination.get("limit") or len(items) or 10)
|
||||
total_pages = max(1, (total + limit - 1) // limit) if total else page
|
||||
|
||||
print(f" pagina={page}/{total_pages} itens={len(items)}")
|
||||
if not items or page >= total_pages:
|
||||
break
|
||||
page += 1
|
||||
|
||||
return all_items
|
||||
|
||||
|
||||
def _flush(batch: list, label: str = "") -> dict:
|
||||
if not batch or not WRITE_SQL:
|
||||
return {}
|
||||
stats = upsert_doc_pedidos_sqlserver(batch, SQL_CONN)
|
||||
print(
|
||||
f"[sql] {label} "
|
||||
f"pedidos={stats.get('pedidos', 0)} parcelas={stats.get('parcelas', 0)}"
|
||||
)
|
||||
return stats
|
||||
|
||||
|
||||
def main() -> None:
|
||||
os.environ.setdefault("INSTALLMENTS_MIN_INTERVAL_MS", str(MIN_INTERVAL_MS))
|
||||
os.environ.setdefault("INSTALLMENTS_429_MIN_WAIT_SEC", "45")
|
||||
os.environ.setdefault("THROTTLE_RECOVERY_PAUSE_SEC", "900")
|
||||
|
||||
print("[info] buscando orderNumbers no banco...")
|
||||
order_numbers = _get_order_numbers()
|
||||
print(f"[info] total encontrado: {len(order_numbers)}")
|
||||
|
||||
existing: set[str] = set()
|
||||
if SKIP_EXISTING:
|
||||
existing = _get_existing_group_codes()
|
||||
print(f"[info] já em DocPedidos: {len(existing)} — serão pulados")
|
||||
|
||||
pending = [c for c in order_numbers if c not in existing]
|
||||
print(f"[info] para consultar na API: {len(pending)}\n")
|
||||
|
||||
session = requests.Session()
|
||||
session.trust_env = False
|
||||
auth = Auth(session)
|
||||
|
||||
batch: list = []
|
||||
batch_first_idx: int = 0
|
||||
batch_first_code: str = ""
|
||||
total_pedidos = 0
|
||||
total_parcelas = 0
|
||||
erros = 0
|
||||
start_ts = time.monotonic()
|
||||
|
||||
def _fmt(s: float) -> str:
|
||||
s = int(s)
|
||||
if s < 60:
|
||||
return f"{s}s"
|
||||
if s < 3600:
|
||||
return f"{s // 60}m:{s % 60:02d}s"
|
||||
return f"{s // 3600}h:{(s % 3600) // 60:02d}m"
|
||||
|
||||
for idx, group_code in enumerate(pending, 1):
|
||||
elapsed = time.monotonic() - start_ts
|
||||
avg_s = elapsed / idx
|
||||
restante = avg_s * (len(pending) - idx)
|
||||
print(f"[{idx}/{len(pending)}] group_code={group_code} "
|
||||
f"decorrido={_fmt(elapsed)} restante~{_fmt(restante)}")
|
||||
try:
|
||||
items = _fetch_all_pages(session, auth, group_code)
|
||||
if not items:
|
||||
print(" sem dados na API")
|
||||
continue
|
||||
|
||||
if not batch:
|
||||
batch_first_idx = idx
|
||||
batch_first_code = group_code
|
||||
|
||||
batch.append({
|
||||
"installmentGroupCode": group_code,
|
||||
"rawResponse": {"data": {"installments": items}},
|
||||
"installments": items,
|
||||
})
|
||||
|
||||
if len(batch) >= BATCH_SIZE:
|
||||
label = (f"inserindo consultas {batch_first_idx}..{idx} "
|
||||
f"(group {batch_first_code} até {group_code})")
|
||||
stats = _flush(batch, label)
|
||||
total_pedidos += stats.get("pedidos", 0)
|
||||
total_parcelas += stats.get("parcelas", 0)
|
||||
batch = []
|
||||
batch_first_idx = 0
|
||||
batch_first_code = ""
|
||||
|
||||
except Exception as exc:
|
||||
print(f" [erro] {exc}")
|
||||
erros += 1
|
||||
|
||||
# flush final
|
||||
if batch:
|
||||
label = (f"inserindo consultas {batch_first_idx}..{len(pending)} "
|
||||
f"(group {batch_first_code} até {batch[-1]['installmentGroupCode']})")
|
||||
else:
|
||||
label = "flush final"
|
||||
stats = _flush(batch, label)
|
||||
total_pedidos += stats.get("pedidos", 0)
|
||||
total_parcelas += stats.get("parcelas", 0)
|
||||
|
||||
print(
|
||||
f"\n[fim] pedidos={total_pedidos} parcelas={total_parcelas} erros={erros}"
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
556
recebiveis_report_importer.py
Normal file
556
recebiveis_report_importer.py
Normal file
@ -0,0 +1,556 @@
|
||||
"""
|
||||
Baixa relatórios de recebíveis via API /v2/franchisee/reports e importa no SQL Server.
|
||||
|
||||
Modos de operação:
|
||||
- INCREMENTAL=True → importa do dia seguinte ao último importado até ontem (diário)
|
||||
- INCREMENTAL=False → importa o intervalo fixo START_DATE..END_DATE
|
||||
|
||||
Deduplicação:
|
||||
- dbo.Grgb_vendas_import_log registra cada arquivo já importado pelo fileName
|
||||
- Se o arquivo já constar no log, a importação é pulada
|
||||
|
||||
Mediadores:
|
||||
- USE_ALL_MEDIATORS=True → busca todos via API de lojas (get_store_codes)
|
||||
- USE_ALL_MEDIATORS=False → usa a lista MEDIATOR_CODES abaixo
|
||||
"""
|
||||
import csv
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import time
|
||||
import requests
|
||||
from datetime import date, timedelta
|
||||
from typing import Optional
|
||||
|
||||
from installments_reader import Auth
|
||||
|
||||
# ─── CONFIGURE AQUI ───────────────────────────────────────────────────────────
|
||||
USE_ALL_MEDIATORS = True # True = usa ALL_MEDIATOR_CODES abaixo; False = usa MEDIATOR_CODES
|
||||
MEDIATOR_CODES = ["23708"] # usado apenas se USE_ALL_MEDIATORS = False
|
||||
|
||||
# Lista exata dos mediatorCodes válidos para o relatório (copiado do portal)
|
||||
ALL_MEDIATOR_CODES = [
|
||||
"checkAll",
|
||||
"19334", "19335", "19336", "20008", "20010", "20029", "20058", "20059",
|
||||
"20060", "20061", "20062", "20063", "20064", "20142", "20364", "20443",
|
||||
"20444", "20621", "20622", "20623", "20772", "20773", "20774", "20775",
|
||||
"20776", "20777", "20778", "20779", "20780", "20781", "20968", "20969",
|
||||
"20970", "20986", "20988", "20989", "20991", "20992", "20993", "20994",
|
||||
"20995", "20996", "20997", "20998", "20999", "21000", "21001", "21278",
|
||||
"21279", "21375", "21383", "21495", "22448", "22541", "23703", "23704",
|
||||
"23708", "23711", "23712", "23713", "23813", "24255", "24257", "24269",
|
||||
"24293", "24447", "24451", "24457", "24458", "4494",
|
||||
]
|
||||
|
||||
INCREMENTAL = True # True = modo diário incremental
|
||||
START_DATE = "2026-01-01" # usado apenas se INCREMENTAL = False
|
||||
END_DATE = "2026-01-31" # usado apenas se INCREMENTAL = False
|
||||
INCREMENTAL_DEFAULT_START = "2026-01-01" # data inicial no primeiro run incremental
|
||||
|
||||
DATA_TYPE = "VENDAS"
|
||||
REPORT_TYPE = "F360"
|
||||
MAX_DAYS_PER_CHUNK = 15 # API limita a 15 dias por requisição com todos os mediadores
|
||||
POLL_INTERVAL_S = 20
|
||||
POLL_TIMEOUT_S = 600
|
||||
WRITE_SQL = True
|
||||
_SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
|
||||
WATERMARK_FILE = os.path.join(_SCRIPT_DIR, "vendas_watermark.json")
|
||||
IMPORT_BATCH_SIZE = 500 # linhas por lote no SQL Server
|
||||
# ──────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
SQL_CONN = (
|
||||
"DRIVER={ODBC Driver 17 for SQL Server};"
|
||||
"SERVER=10.77.77.10;"
|
||||
"DATABASE=GINSENG;"
|
||||
"UID=andrey;"
|
||||
"PWD=88253332;"
|
||||
"TrustServerCertificate=yes;"
|
||||
)
|
||||
|
||||
REPORTS_URL = (
|
||||
"https://bff-portal-apigw.produto-financeiro.grupoboticario.digital"
|
||||
"/v2/franchisee/reports"
|
||||
)
|
||||
|
||||
_DONE_STATUSES = {"generated", "generated_csv", "done", "completed", "ready", "available"}
|
||||
_FAIL_STATUSES = {"failed", "error", "erro", "falha"}
|
||||
|
||||
|
||||
# ─── WATERMARK ────────────────────────────────────────────────────────────────
|
||||
|
||||
def _load_watermark() -> str:
|
||||
"""Retorna a última data importada (YYYY-MM-DD) ou a data padrão inicial."""
|
||||
try:
|
||||
if os.path.exists(WATERMARK_FILE):
|
||||
with open(WATERMARK_FILE, encoding="utf-8") as f:
|
||||
data = json.load(f)
|
||||
val = str(data.get("last_end_date") or "").strip()
|
||||
if val:
|
||||
return val
|
||||
except Exception:
|
||||
pass
|
||||
return ""
|
||||
|
||||
|
||||
def _save_watermark(end_date: str) -> None:
|
||||
tmp = WATERMARK_FILE + ".tmp"
|
||||
with open(tmp, "w", encoding="utf-8") as f:
|
||||
json.dump({"last_end_date": end_date}, f)
|
||||
os.replace(tmp, WATERMARK_FILE)
|
||||
|
||||
|
||||
# ─── API ──────────────────────────────────────────────────────────────────────
|
||||
|
||||
def _headers(auth: Auth) -> dict:
|
||||
return {
|
||||
"Authorization": auth.get_bearer(),
|
||||
"Accept": "*/*",
|
||||
"Content-Type": "application/json",
|
||||
"Origin": "https://extranet.grupoboticario.com.br",
|
||||
"Referer": "https://extranet.grupoboticario.com.br/",
|
||||
"User-Agent": "Mozilla/5.0",
|
||||
}
|
||||
|
||||
|
||||
def _find_pending_in_list(
|
||||
session: requests.Session,
|
||||
auth: Auth,
|
||||
start_date: str,
|
||||
end_date: str,
|
||||
) -> Optional[str]:
|
||||
"""
|
||||
Após um 504 no POST, o servidor pode ter criado o relatório mesmo sem responder.
|
||||
Busca na listagem um relatório recente com o mesmo período.
|
||||
"""
|
||||
try:
|
||||
raw = session.get(
|
||||
REPORTS_URL,
|
||||
params={"type": REPORT_TYPE, "dataType": DATA_TYPE},
|
||||
headers=_headers(auth),
|
||||
timeout=30,
|
||||
).json()
|
||||
reports = raw.get("data", {}).get("reports") or []
|
||||
for rep in reports:
|
||||
# compara datas do relatório — a API retorna solicitedAt, não as datas do período,
|
||||
# então usamos o índice 0 (mais recente) criado nos últimos 5 minutos
|
||||
solicited = str(rep.get("solicitedAt") or "")
|
||||
# pega o mais recente (lista já vem ordenada por data desc)
|
||||
rid = str(rep.get("id") or "")
|
||||
if rid:
|
||||
print(f"[info] relatório encontrado na lista após 504: id={rid} status={rep.get('status')}")
|
||||
return rid
|
||||
except Exception as exc:
|
||||
print(f"[warn] falha ao buscar lista após 504: {exc}")
|
||||
return None
|
||||
|
||||
|
||||
def _create_report(
|
||||
session: requests.Session,
|
||||
auth: Auth,
|
||||
mediator_codes: list[str],
|
||||
start_date: str,
|
||||
end_date: str,
|
||||
) -> str:
|
||||
"""Solicita criação do relatório e retorna o report_id."""
|
||||
payload = {
|
||||
"dataType": DATA_TYPE,
|
||||
"startSolicitedDate": start_date,
|
||||
"endSolicitedDate": end_date,
|
||||
"installmentCode": "",
|
||||
"installmentGroupCode": "",
|
||||
"mediatorCodes": mediator_codes,
|
||||
"type": REPORT_TYPE,
|
||||
}
|
||||
print(f"[POST] {DATA_TYPE} {start_date}..{end_date} mediadores={len(mediator_codes)}")
|
||||
transient = {429, 500, 502, 503, 504}
|
||||
for attempt in range(1, 6):
|
||||
try:
|
||||
r = session.post(REPORTS_URL, json=payload, headers=_headers(auth), timeout=60)
|
||||
if r.status_code in transient:
|
||||
wait = min(60, 10 * attempt)
|
||||
print(f"[warn] POST {r.status_code} (tentativa {attempt}/5), aguardando {wait}s...")
|
||||
time.sleep(wait)
|
||||
# 504 pode significar que o servidor criou mas não respondeu — checa a lista
|
||||
if r.status_code == 504:
|
||||
rid = _find_pending_in_list(session, auth, start_date, end_date)
|
||||
if rid:
|
||||
return rid
|
||||
continue
|
||||
if not r.ok:
|
||||
print(f"[erro] POST {r.status_code}: {r.text[:300].encode('ascii','replace').decode()}")
|
||||
r.raise_for_status()
|
||||
resp = r.json()
|
||||
rid = _extract_report_id(resp)
|
||||
if not rid:
|
||||
raise RuntimeError(f"report_id ausente na resposta: {resp}")
|
||||
fname = _extract_file_name(resp).encode("ascii", "replace").decode()
|
||||
print(f"[info] report_id={rid} fileName={fname}")
|
||||
return rid
|
||||
except requests.exceptions.Timeout:
|
||||
wait = min(60, 10 * attempt)
|
||||
print(f"[warn] POST timeout (tentativa {attempt}/5), aguardando {wait}s...")
|
||||
time.sleep(wait)
|
||||
rid = _find_pending_in_list(session, auth, start_date, end_date)
|
||||
if rid:
|
||||
return rid
|
||||
raise RuntimeError("POST /reports falhou após 5 tentativas (504/timeout persistente)")
|
||||
|
||||
|
||||
def _extract_report_id(response: dict) -> Optional[str]:
|
||||
data = response.get("data") or {}
|
||||
if isinstance(data.get("report"), dict):
|
||||
rid = data["report"].get("id")
|
||||
if rid:
|
||||
return str(rid)
|
||||
for key in ("id", "reportId", "uuid", "code"):
|
||||
if data.get(key):
|
||||
return str(data[key])
|
||||
return None
|
||||
|
||||
|
||||
def _extract_file_name(response: dict) -> str:
|
||||
data = response.get("data") or {}
|
||||
rep = data.get("report") or data
|
||||
return str(rep.get("filename") or rep.get("fileName") or "")
|
||||
|
||||
|
||||
def _find_download_url(obj: dict) -> Optional[str]:
|
||||
for key in ("fileLink", "url", "downloadUrl", "fileUrl", "s3Url", "link",
|
||||
"presignedUrl", "signedUrl"):
|
||||
if obj.get(key):
|
||||
return str(obj[key])
|
||||
return None
|
||||
|
||||
|
||||
def _fetch_report_by_id(
|
||||
session: requests.Session, auth: Auth, report_id: str
|
||||
) -> tuple[Optional[str], str]:
|
||||
"""Retorna (download_url, file_name) buscando o relatório pelo id."""
|
||||
r = session.get(f"{REPORTS_URL}/{report_id}", headers=_headers(auth), timeout=30)
|
||||
if r.status_code != 200:
|
||||
return None, ""
|
||||
body = r.json()
|
||||
data = body.get("data") or {}
|
||||
rep = data.get("report") or data
|
||||
url = _find_download_url(rep) or _find_download_url(data) or _find_download_url(body)
|
||||
name = str(rep.get("fileName") or rep.get("filename") or "")
|
||||
return url, name
|
||||
|
||||
|
||||
def _poll_until_ready(
|
||||
session: requests.Session,
|
||||
auth: Auth,
|
||||
report_id: str,
|
||||
) -> tuple[str, str]:
|
||||
"""
|
||||
Consulta GET /reports?type=F360&dataType=RECEBIVEIS a cada POLL_INTERVAL_S segundos.
|
||||
Quando o relatório chegar em GENERATED, busca o fileLink via GET /reports/{id}.
|
||||
Retorna (download_url, file_name).
|
||||
"""
|
||||
deadline = time.monotonic() + POLL_TIMEOUT_S
|
||||
attempt = 0
|
||||
while time.monotonic() < deadline:
|
||||
attempt += 1
|
||||
raw = session.get(
|
||||
REPORTS_URL,
|
||||
params={"type": REPORT_TYPE, "dataType": DATA_TYPE},
|
||||
headers=_headers(auth),
|
||||
timeout=30,
|
||||
).json()
|
||||
|
||||
reports = raw.get("data", {}).get("reports") or []
|
||||
for rep in reports:
|
||||
if str(rep.get("id") or "") != report_id:
|
||||
continue
|
||||
status = str(rep.get("status") or "").strip().lower()
|
||||
if status in _FAIL_STATUSES:
|
||||
raise RuntimeError(f"Relatório falhou: {rep}")
|
||||
if status in _DONE_STATUSES:
|
||||
url, file_name = _fetch_report_by_id(session, auth, report_id)
|
||||
if url:
|
||||
print(f"[poll] pronto após {attempt} tentativa(s) (status={status})")
|
||||
return url, file_name
|
||||
print(f"[poll] tentativa {attempt} status={status}, aguardando {POLL_INTERVAL_S}s...")
|
||||
break
|
||||
else:
|
||||
print(f"[poll] tentativa {attempt} relatório não listado ainda, "
|
||||
f"aguardando {POLL_INTERVAL_S}s...")
|
||||
|
||||
time.sleep(POLL_INTERVAL_S)
|
||||
|
||||
raise TimeoutError(f"Relatório não ficou pronto em {POLL_TIMEOUT_S}s")
|
||||
|
||||
|
||||
def _download_csv(url: str) -> str:
|
||||
print("[download] baixando CSV do S3...")
|
||||
r = requests.get(url, timeout=180)
|
||||
r.raise_for_status()
|
||||
for enc in ("utf-8-sig", "utf-8", "latin-1"):
|
||||
try:
|
||||
return r.content.decode(enc)
|
||||
except UnicodeDecodeError:
|
||||
continue
|
||||
return r.content.decode("latin-1", errors="replace")
|
||||
|
||||
|
||||
# ─── SQL ──────────────────────────────────────────────────────────────────────
|
||||
|
||||
def _sql_conn_str() -> str:
|
||||
s = SQL_CONN.rstrip(";")
|
||||
if not re.search(r"(?i)\bEncrypt\b", s):
|
||||
s += ";Encrypt=no"
|
||||
if not re.search(r"(?i)\bTrustServerCertificate\b", s):
|
||||
s += ";TrustServerCertificate=yes"
|
||||
return s + ";"
|
||||
|
||||
|
||||
def _safe_col(name: str) -> str:
|
||||
name = re.sub(r"[^a-zA-Z0-9_]", "_", name.strip())
|
||||
if name and name[0].isdigit():
|
||||
name = "c_" + name
|
||||
return name[:128] or "col"
|
||||
|
||||
|
||||
def _ensure_tables(cur, csv_cols: list[str]) -> list[str]:
|
||||
"""Garante que as tabelas de dados e log existam, com todas as colunas do CSV."""
|
||||
# tabela de log de importações (controle de duplicatas)
|
||||
cur.execute("""
|
||||
IF OBJECT_ID('dbo.Grgb_vendas_import_log', 'U') IS NULL
|
||||
BEGIN
|
||||
CREATE TABLE dbo.Grgb_vendas_import_log (
|
||||
Id INT IDENTITY(1,1) PRIMARY KEY,
|
||||
FileName VARCHAR(120) NOT NULL UNIQUE,
|
||||
PeriodoInicio DATE NULL,
|
||||
PeriodoFim DATE NULL,
|
||||
TotalLinhas INT NOT NULL DEFAULT 0,
|
||||
ImportadoEm DATETIME2 NOT NULL DEFAULT SYSUTCDATETIME()
|
||||
)
|
||||
END
|
||||
""")
|
||||
|
||||
# tabela de dados
|
||||
cur.execute("""
|
||||
IF OBJECT_ID('dbo.Grgb_vendas_report', 'U') IS NULL
|
||||
BEGIN
|
||||
CREATE TABLE dbo.Grgb_vendas_report (
|
||||
Id INT IDENTITY(1,1) PRIMARY KEY,
|
||||
NomeArquivo VARCHAR(120) NULL,
|
||||
CriadoEm DATETIME2 NOT NULL DEFAULT SYSUTCDATETIME()
|
||||
)
|
||||
END
|
||||
""")
|
||||
# garante coluna NomeArquivo
|
||||
cur.execute("""
|
||||
SELECT LOWER(COLUMN_NAME) FROM INFORMATION_SCHEMA.COLUMNS
|
||||
WHERE TABLE_SCHEMA='dbo' AND TABLE_NAME='Grgb_vendas_report'
|
||||
""")
|
||||
existing = {r[0] for r in cur.fetchall()}
|
||||
if "nomearquivo" not in existing:
|
||||
cur.execute("ALTER TABLE dbo.Grgb_vendas_report ADD [NomeArquivo] VARCHAR(120) NULL")
|
||||
|
||||
safe_cols = [_safe_col(c) for c in csv_cols]
|
||||
# recarrega colunas existentes
|
||||
cur.execute("""
|
||||
SELECT LOWER(COLUMN_NAME) FROM INFORMATION_SCHEMA.COLUMNS
|
||||
WHERE TABLE_SCHEMA='dbo' AND TABLE_NAME='Grgb_vendas_report'
|
||||
""")
|
||||
existing = {r[0] for r in cur.fetchall()}
|
||||
for col in safe_cols:
|
||||
if col.lower() not in existing:
|
||||
cur.execute(
|
||||
f"ALTER TABLE dbo.Grgb_vendas_report ADD [{col}] NVARCHAR(500) NULL"
|
||||
)
|
||||
print(f"[schema] coluna adicionada: {col}")
|
||||
|
||||
return safe_cols
|
||||
|
||||
|
||||
def _is_already_imported(cur, file_name: str) -> bool:
|
||||
cur.execute(
|
||||
"SELECT 1 FROM dbo.Grgb_vendas_import_log WHERE FileName = ?", file_name
|
||||
)
|
||||
return cur.fetchone() is not None
|
||||
|
||||
|
||||
def _import_csv(
|
||||
rows: list[dict],
|
||||
csv_cols: list[str],
|
||||
file_name: str,
|
||||
start_date: str,
|
||||
end_date: str,
|
||||
) -> int:
|
||||
import pyodbc
|
||||
|
||||
conn_str = _sql_conn_str()
|
||||
total = len(rows)
|
||||
|
||||
# --- conexão inicial: garante schema e checa log ---
|
||||
cn = pyodbc.connect(conn_str, timeout=60)
|
||||
cn.autocommit = False
|
||||
cur = cn.cursor()
|
||||
safe_cols = _ensure_tables(cur, csv_cols)
|
||||
cn.commit()
|
||||
|
||||
if _is_already_imported(cur, file_name):
|
||||
print(f"[skip] {file_name} ja importado anteriormente")
|
||||
cur.close(); cn.close()
|
||||
return 0
|
||||
|
||||
# limpa linhas parciais de execuções que falharam no meio
|
||||
cur.execute("DELETE FROM dbo.Grgb_vendas_report WHERE NomeArquivo = ?", file_name)
|
||||
cn.commit()
|
||||
cur.close(); cn.close()
|
||||
|
||||
# --- insere em lotes para não derrubar a conexão ---
|
||||
all_cols = ["NomeArquivo"] + safe_cols
|
||||
col_list = ", ".join(f"[{c}]" for c in all_cols)
|
||||
placeholders = ", ".join("?" for _ in all_cols)
|
||||
sql = (
|
||||
f"INSERT INTO dbo.Grgb_vendas_report ({col_list}) "
|
||||
f"VALUES ({placeholders})"
|
||||
)
|
||||
|
||||
inserted = 0
|
||||
for batch_start in range(0, total, IMPORT_BATCH_SIZE):
|
||||
batch_rows = rows[batch_start: batch_start + IMPORT_BATCH_SIZE]
|
||||
batch = [
|
||||
(file_name,) + tuple(
|
||||
(str(row.get(orig, "") or "")[:500] or None)
|
||||
for orig in csv_cols
|
||||
)
|
||||
for row in batch_rows
|
||||
]
|
||||
|
||||
cn = pyodbc.connect(conn_str, timeout=60)
|
||||
cn.autocommit = False
|
||||
cur = cn.cursor()
|
||||
cur.fast_executemany = True
|
||||
try:
|
||||
cur.executemany(sql, batch)
|
||||
cn.commit()
|
||||
inserted += len(batch)
|
||||
print(f"[sql] {inserted}/{total} linhas arquivo={file_name}")
|
||||
except Exception:
|
||||
cn.rollback()
|
||||
raise
|
||||
finally:
|
||||
cur.close(); cn.close()
|
||||
|
||||
# registra no log de controle
|
||||
cn = pyodbc.connect(conn_str, timeout=60)
|
||||
cn.autocommit = False
|
||||
cur = cn.cursor()
|
||||
try:
|
||||
cur.execute(
|
||||
"""
|
||||
INSERT INTO dbo.Grgb_vendas_import_log
|
||||
(FileName, PeriodoInicio, PeriodoFim, TotalLinhas)
|
||||
VALUES (?, ?, ?, ?)
|
||||
""",
|
||||
file_name, start_date, end_date, inserted,
|
||||
)
|
||||
cn.commit()
|
||||
except Exception:
|
||||
cn.rollback()
|
||||
raise
|
||||
finally:
|
||||
cur.close(); cn.close()
|
||||
|
||||
print(f"[sql] importacao concluida: {inserted} linhas arquivo={file_name}")
|
||||
return inserted
|
||||
|
||||
|
||||
# ─── MAIN ─────────────────────────────────────────────────────────────────────
|
||||
|
||||
def _resolve_date_range() -> tuple[str, str]:
|
||||
"""Sempre importa D-1. Antes das 9h30 BRT, dados ainda não disponíveis."""
|
||||
from datetime import datetime, timezone, timedelta as td
|
||||
BRT = timezone(td(hours=-3))
|
||||
now_brt = datetime.now(tz=BRT)
|
||||
cutoff = now_brt.replace(hour=9, minute=30, second=0, microsecond=0)
|
||||
|
||||
if now_brt < cutoff:
|
||||
print("[info] antes das 9h30 BRT — dados de D-1 ainda nao disponiveis.")
|
||||
return "", ""
|
||||
|
||||
yesterday = (now_brt - td(days=1)).date().isoformat()
|
||||
return yesterday, yesterday
|
||||
|
||||
|
||||
def _build_chunks(start_date: str, end_date: str) -> list[tuple[str, str]]:
|
||||
"""Divide o intervalo em janelas de MAX_DAYS_PER_CHUNK dias."""
|
||||
chunks = []
|
||||
cursor = date.fromisoformat(start_date)
|
||||
end = date.fromisoformat(end_date)
|
||||
step = timedelta(days=MAX_DAYS_PER_CHUNK - 1)
|
||||
while cursor <= end:
|
||||
chunk_end = min(cursor + step, end)
|
||||
chunks.append((cursor.isoformat(), chunk_end.isoformat()))
|
||||
cursor = chunk_end + timedelta(days=1)
|
||||
return chunks
|
||||
|
||||
|
||||
def main() -> None:
|
||||
start_date, end_date = _resolve_date_range()
|
||||
|
||||
if not start_date:
|
||||
print("[info] dados já estão atualizados até ontem, nada a importar.")
|
||||
return
|
||||
|
||||
print(f"[info] período a importar: {start_date} .. {end_date}")
|
||||
|
||||
session = requests.Session()
|
||||
session.trust_env = False
|
||||
auth = Auth(session)
|
||||
|
||||
# resolve mediator codes
|
||||
if USE_ALL_MEDIATORS:
|
||||
mediator_codes = ALL_MEDIATOR_CODES
|
||||
print(f"[info] usando todos os mediadores ({len(mediator_codes) - 1} lojas + checkAll)")
|
||||
else:
|
||||
mediator_codes = list(MEDIATOR_CODES)
|
||||
|
||||
if not mediator_codes:
|
||||
print("[erro] nenhum mediator code disponível, abortando.")
|
||||
return
|
||||
|
||||
chunks = _build_chunks(start_date, end_date)
|
||||
print(f"[info] {len(chunks)} janela(s) de até {MAX_DAYS_PER_CHUNK} dias")
|
||||
|
||||
total_linhas = 0
|
||||
last_ok_end = _load_watermark() if INCREMENTAL else ""
|
||||
|
||||
for i, (chunk_start, chunk_end) in enumerate(chunks, 1):
|
||||
print(f"\n[chunk {i}/{len(chunks)}] {chunk_start} .. {chunk_end}")
|
||||
|
||||
report_id = _create_report(session, auth, mediator_codes, chunk_start, chunk_end)
|
||||
|
||||
download_url, file_name = _poll_until_ready(session, auth, report_id)
|
||||
print(f"[info] fileName={file_name.encode('ascii','replace').decode()}")
|
||||
|
||||
csv_text = _download_csv(download_url)
|
||||
reader = csv.DictReader(io.StringIO(csv_text))
|
||||
csv_cols = list(reader.fieldnames or [])
|
||||
rows = list(reader)
|
||||
print(f"[csv] {len(rows)} linhas {len(csv_cols)} colunas")
|
||||
|
||||
if not rows:
|
||||
print("[info] chunk vazio.")
|
||||
elif not WRITE_SQL:
|
||||
print("[info] WRITE_SQL=False — primeiras 2 linhas:")
|
||||
for r in rows[:2]:
|
||||
print(json.dumps(r, ensure_ascii=False))
|
||||
else:
|
||||
n = _import_csv(rows, csv_cols, file_name, chunk_start, chunk_end)
|
||||
total_linhas += n
|
||||
|
||||
if INCREMENTAL:
|
||||
_save_watermark(chunk_end)
|
||||
last_ok_end = chunk_end
|
||||
|
||||
print(f"\n[fim] total={total_linhas} linhas watermark={last_ok_end}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Loading…
x
Reference in New Issue
Block a user