145 lines
6.4 KiB
Python
Executable file
145 lines
6.4 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
"""Read back suite-created entities so later flows can use real IDs.
|
|
|
|
Modes:
|
|
--staff login only -> STAFF_ID=<id>
|
|
--stores match STORE1/STORE2 by name -> STORE1_ID / STORE2_ID
|
|
--slots verify the 8 generated slots -> SLOTn_DATE/HOUR/MIN (actual delivery time)
|
|
|
|
Slot verification (fail fast, exit != 0):
|
|
- exactly one active slot per target date+hour (from gen/slot-targets.env)
|
|
- consecutive deliveries exactly 2h apart
|
|
- freeze == delivery - 15min (tolerates 1min wheel-drift: 14..16min)
|
|
"""
|
|
import json
|
|
import os
|
|
import sys
|
|
import urllib.request
|
|
import urllib.parse
|
|
from datetime import datetime, timedelta
|
|
|
|
BASE = os.environ.get('BACKEND_URL', 'http://127.0.0.1:8787')
|
|
ADMIN_NAME = os.environ['ADMIN_NAME']
|
|
ADMIN_PASSWORD = os.environ['ADMIN_PASSWORD']
|
|
HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
|
|
def call(token, path, data=None):
|
|
url = f'{BASE}/api/trpc/{path}?batch=1'
|
|
headers = {'content-type': 'application/json'}
|
|
if token:
|
|
headers['Authorization'] = f'Bearer {token}'
|
|
body = None
|
|
if data is not None:
|
|
body = json.dumps({0: data}).encode()
|
|
req = urllib.request.Request(url, data=body, headers=headers, method='POST')
|
|
else:
|
|
req = urllib.request.Request(url, headers=headers, method='GET')
|
|
with urllib.request.urlopen(req, timeout=30) as r:
|
|
out = json.loads(r.read().decode())
|
|
if isinstance(out, list) and out and out[0].get('error'):
|
|
raise RuntimeError(f'{path}: {out[0]["error"].get("message")}')
|
|
return (out[0] if isinstance(out, list) else out)['result']['data']
|
|
|
|
|
|
def login():
|
|
data = call(None, 'admin.staffUser.login', {'name': ADMIN_NAME, 'password': ADMIN_PASSWORD})
|
|
return data['token'], data['staff']
|
|
|
|
|
|
def parse_time(v):
|
|
if isinstance(v, (int, float)):
|
|
return datetime.fromtimestamp(v / 1000 if v > 1e12 else v)
|
|
from datetime import timezone, timedelta
|
|
s = str(v).replace('Z', '+00:00')
|
|
dt = datetime.fromisoformat(s)
|
|
# Backend stores UTC; suite targets are IST. Compare in IST.
|
|
if dt.tzinfo:
|
|
dt = dt.astimezone(timezone(timedelta(hours=5, minutes=30)))
|
|
return dt.replace(tzinfo=None)
|
|
|
|
|
|
mode = sys.argv[1]
|
|
token, staff = login()
|
|
|
|
if mode == '--staff':
|
|
print(f'STAFF_ID={staff["id"]}')
|
|
|
|
elif mode == '--stores':
|
|
s1, s2 = os.environ['STORE1'], os.environ['STORE2']
|
|
stores = call(token, 'admin.store.getStores')['stores']
|
|
by_name = {s['name']: s['id'] for s in stores}
|
|
assert s1 in by_name, f'store missing: {s1} (have {sorted(by_name)})'
|
|
assert s2 in by_name, f'store missing: {s2} (have {sorted(by_name)})'
|
|
print(f'STORE1_ID={by_name[s1]}')
|
|
print(f'STORE2_ID={by_name[s2]}')
|
|
|
|
elif mode == '--tags':
|
|
t1, t2 = os.environ['TAG1'], os.environ['TAG2']
|
|
tags = call(token, 'admin.product.getProductTags')['tags']
|
|
by_name = {t['tagName']: t for t in tags}
|
|
assert t1 in by_name, f'tag missing: {t1}'
|
|
assert t2 in by_name, f'tag missing: {t2}'
|
|
print(f'TAG1_ID={by_name[t1]["id"]} TAG2_ID={by_name[t2]["id"]}')
|
|
|
|
elif mode == '--skus':
|
|
names = [os.environ['P1'], os.environ['P2']]
|
|
products = call(token, 'admin.product.getProducts')['products']
|
|
by_name = {p['name']: p for p in products}
|
|
for n in names:
|
|
assert n in by_name, f'product missing: {n}'
|
|
p1skus = sorted(s['id'] for s in by_name[os.environ['P1']].get('skus', []))
|
|
p2skus = sorted(s['id'] for s in by_name[os.environ['P2']].get('skus', []))
|
|
assert len(p1skus) == 2, f'P1 skus: {p1skus}'
|
|
assert len(p2skus) == 4, f'P2 skus: {p2skus}'
|
|
print(f'P1SK0={p1skus[0]} P1SK1={p1skus[1]}')
|
|
print(f'P2SK0={p2skus[0]} P2SK1={p2skus[1]} P2SK2={p2skus[2]} P2SK3={p2skus[3]}')
|
|
combo = by_name.get(os.environ.get('COMBO', ''))
|
|
if combo and combo.get('skus'):
|
|
print(f'CBSK={sorted(s["id"] for s in combo["skus"])[0]}')
|
|
|
|
elif mode == '--slots':
|
|
targets = {}
|
|
with open(os.path.join(HERE, 'gen', 'slot-targets.env')) as f:
|
|
for line in f.read().split():
|
|
k, v = line.split('=', 1)
|
|
n = int(k[4]) if k.startswith('SLOT') else None
|
|
key = k.split('_', 1)[1]
|
|
targets.setdefault(n, {})[key] = v
|
|
slots = call(token, 'admin.slots.getAll')['slots']
|
|
matched = {}
|
|
for s in slots:
|
|
d = parse_time(s['deliveryTime'])
|
|
key = (d.strftime('%Y-%m-%d'), f'{d.hour:02d}')
|
|
for n, t in targets.items():
|
|
if (t['DDATE'], t['DHOUR']) == key and n not in matched:
|
|
matched[n] = (s, d)
|
|
assert len(matched) == 8, f'matched {len(matched)}/8 slots: {sorted(matched)}'
|
|
ordered = [matched[n] for n in sorted(matched)]
|
|
for i in range(1, 8):
|
|
gap = (ordered[i][1] - ordered[i - 1][1]).total_seconds()
|
|
# Exact 2h grid can't hold (wild minutes); each slot already matched
|
|
# its target date+hour above, so this is an order/sanity check.
|
|
assert 5400 <= gap <= 9000, f'slot {i}->{i + 1} gap {gap}s, expected ~7200'
|
|
for n, (s, d) in sorted(matched.items()):
|
|
fz = parse_time(s['freezeTime'])
|
|
delta = (d - fz).total_seconds()
|
|
assert 12 * 60 <= delta <= 18 * 60, f'slot {n} freeze gap {delta}s'
|
|
got = set(s.get('skuIds') or [p.get('id') for p in s.get('products', [])])
|
|
want = set(int(x) for x in os.environ.get(f'SLOT{n}_SKUS', '').split(',') if x.strip())
|
|
assert want and want <= got, f'slot {n} skus {sorted(got)} missing {sorted(want - got)}'
|
|
print(f'SLOT{n}_DATE={d.strftime("%Y-%m-%d")} SLOT{n}_HOUR={d.hour:02d} SLOT{n}_MIN={d.minute:02d} SLOT{n}_ID={s["id"]}')
|
|
# Live-slot pointers for the user leg: first two slots whose freeze is
|
|
# still >5min out (as dialog testIDs). Normally slots 1+2; if the run
|
|
# straddles early freezes, the flow uses live ones instead of dead IDs.
|
|
from datetime import timezone as _tz
|
|
now_ist = datetime.now(_tz.utc).astimezone(_tz(timedelta(hours=5, minutes=30))).replace(tzinfo=None)
|
|
live = [(n, s, d) for n, (s, d) in sorted(matched.items())
|
|
if (parse_time(s['freezeTime']) - now_ist).total_seconds() > 300]
|
|
assert len(live) >= 2, f'need 2 live slots, have {len(live)}'
|
|
for var, (n, s, d) in zip(('SLOT_A', 'SLOT_B'), live[:2]):
|
|
print(f'{var}=slot-{d.strftime("%Y-%m-%d")}-{d.hour:02d}-{d.minute:02d}')
|
|
print('slots verified: 8 x 2h apart, freeze ~15min prior, SKUs attached', file=sys.stderr)
|
|
|
|
else:
|
|
raise SystemExit(f'unknown mode {mode}')
|