507 lines
17 KiB
JavaScript
Executable File
507 lines
17 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
||
// pospal.mjs — Pospal helper for tennis-booking skill.
|
||
// Pure data transformation; never holds network state; never persists secrets.
|
||
// Spec: see references/protocol.md in the same skill directory.
|
||
|
||
import { createHash } from 'node:crypto'
|
||
|
||
// ---------- CLI plumbing ----------
|
||
|
||
function usage() {
|
||
process.stderr.write(`Usage: pospal.mjs <subcommand> [options]
|
||
|
||
Subcommands:
|
||
parse-availability Read raw list JSON from stdin, write structured slots JSON
|
||
--date YYYY-MM-DD (required)
|
||
--pretty (indent output)
|
||
find-continuous Read parse-availability output from stdin, write matching sequence
|
||
--start HH (required, e.g. 19)
|
||
--end HH (required, e.g. 21)
|
||
build-booking-body Read find-continuous (found: true) output from stdin, write request body
|
||
--pretty
|
||
parse-booking-response Read raw booking response JSON from stdin, write sanitized booking summary
|
||
--slots <path> (path to the same find-continuous output used to book)
|
||
--pretty
|
||
fingerprint Read visitor ID from --visitor or POSPAL_VISITOR_ID env, write 12-char hex
|
||
redact Read any JSON from stdin, write redacted JSON (no paySign, no PII, no PSPL*)
|
||
--pretty
|
||
|
||
All subcommands read JSON from stdin unless noted.
|
||
Env:
|
||
POSPAL_VISITOR_ID Read by 'fingerprint' if --visitor is not given
|
||
`)
|
||
}
|
||
|
||
function die(msg, code = 1) {
|
||
process.stderr.write(`error: ${msg}\n`)
|
||
process.exit(code)
|
||
}
|
||
|
||
function parseArgs(argv) {
|
||
const flags = {}
|
||
const positional = []
|
||
for (let i = 0; i < argv.length; i++) {
|
||
const a = argv[i]
|
||
if (a.startsWith('--')) {
|
||
const key = a.slice(2)
|
||
const next = argv[i + 1]
|
||
if (next === undefined || next.startsWith('--')) {
|
||
flags[key] = true
|
||
} else {
|
||
flags[key] = next
|
||
i++
|
||
}
|
||
} else {
|
||
positional.push(a)
|
||
}
|
||
}
|
||
return { flags, positional }
|
||
}
|
||
|
||
async function readStdin() {
|
||
const chunks = []
|
||
for await (const chunk of process.stdin) chunks.push(chunk)
|
||
return Buffer.concat(chunks).toString('utf8')
|
||
}
|
||
|
||
function isRecord(v) {
|
||
return typeof v === 'object' && v !== null && !Array.isArray(v)
|
||
}
|
||
|
||
function isInt(n) {
|
||
return typeof n === 'number' && Number.isFinite(n)
|
||
}
|
||
|
||
const writeJson = (obj, pretty) => {
|
||
process.stdout.write(pretty ? JSON.stringify(obj, null, 2) : JSON.stringify(obj))
|
||
process.stdout.write('\n')
|
||
}
|
||
|
||
// ---------- shared helpers ----------
|
||
|
||
const TIME_RE = /(\d{2}):(\d{2})/
|
||
const DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2}) (\d{2}:\d{2}):\d{2}$/
|
||
|
||
function extractTime(value) {
|
||
if (typeof value !== 'string') return null
|
||
const m = TIME_RE.exec(value)
|
||
return m ? m[0] : null
|
||
}
|
||
|
||
function extractHour(time) {
|
||
if (typeof time !== 'string') return null
|
||
const m = TIME_RE.exec(time)
|
||
return m ? Number(m[1]) : null
|
||
}
|
||
|
||
function extractDate(dateTime) {
|
||
if (typeof dateTime !== 'string') return null
|
||
const m = DATE_TIME_RE.exec(dateTime)
|
||
return m ? m[1] : null
|
||
}
|
||
|
||
// ---------- parse-availability ----------
|
||
|
||
function parseEnrollment(raw) {
|
||
if (!isRecord(raw) || !isRecord(raw.enrollmentRule)) {
|
||
die('球场接口返回了无法识别的活动数据')
|
||
}
|
||
const rule = raw.enrollmentRule
|
||
const startTime = extractTime(rule.beginDate)
|
||
const endTime = extractTime(rule.endDate)
|
||
const deadline = extractTime(rule.enrollmentEndDate)
|
||
if (
|
||
typeof raw.txtClassroomUid !== 'string' ||
|
||
typeof raw.beginDatetime !== 'string' ||
|
||
typeof raw.endDatetime !== 'string' ||
|
||
typeof rule.uidTxt !== 'string' ||
|
||
typeof rule.title !== 'string' ||
|
||
startTime === null ||
|
||
endTime === null ||
|
||
!isInt(rule.enrollmentFee) ||
|
||
!isInt(rule.enrollmentLimitNum)
|
||
) {
|
||
die('球场接口返回了无法识别的活动数据')
|
||
}
|
||
const enrolledCount = isInt(rule.enrollmentCount)
|
||
? rule.enrollmentCount
|
||
: isInt(rule.ParticipateCount)
|
||
? rule.ParticipateCount
|
||
: 0
|
||
const participantNames = []
|
||
if (Array.isArray(rule.customerModels)) {
|
||
for (const c of rule.customerModels) {
|
||
if (isRecord(c) && typeof c.name === 'string' && c.name.trim()) {
|
||
participantNames.push(c.name.trim())
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
txtClassroomUid: raw.txtClassroomUid,
|
||
beginDatetime: raw.beginDatetime,
|
||
endDatetime: raw.endDatetime,
|
||
activity: {
|
||
id: rule.uidTxt,
|
||
title: rule.title,
|
||
startTime,
|
||
endTime,
|
||
feeCents: Math.round(rule.enrollmentFee * 100),
|
||
enrolledCount,
|
||
capacity: rule.enrollmentLimitNum,
|
||
participantNames: [...new Set(participantNames)],
|
||
...(deadline !== null ? { enrollmentDeadline: deadline } : {})
|
||
}
|
||
}
|
||
}
|
||
|
||
function parseSlot(raw, enrollments) {
|
||
if (!isRecord(raw)) die('球场接口返回了无法识别的时段数据')
|
||
const startTime = extractTime(raw.beginDatetime)
|
||
const endTime = extractTime(raw.endDatetime)
|
||
const appt = isRecord(raw.apptInfo) ? raw.apptInfo : null
|
||
const canBook = appt ? appt.canApptOrNot : undefined
|
||
if (
|
||
typeof raw.txtClassroomUid !== 'string' ||
|
||
raw.txtClassroomUid.trim() === '' ||
|
||
typeof raw.classRoomName !== 'string' ||
|
||
raw.classRoomName.trim() === '' ||
|
||
typeof raw.beginDatetime !== 'string' ||
|
||
typeof raw.endDatetime !== 'string' ||
|
||
startTime === null ||
|
||
endTime === null ||
|
||
!isInt(raw.cost) ||
|
||
!isInt(raw.status) ||
|
||
typeof canBook !== 'boolean'
|
||
) {
|
||
die('球场接口返回了无法识别的时段数据')
|
||
}
|
||
const enrollment = enrollments.find((e) =>
|
||
e.txtClassroomUid === raw.txtClassroomUid &&
|
||
raw.beginDatetime <= e.endDatetime &&
|
||
raw.endDatetime >= e.beginDatetime
|
||
)
|
||
let status
|
||
let unavailableLabel
|
||
if (enrollment) {
|
||
status = 'booked'
|
||
unavailableLabel = '已订'
|
||
} else if (canBook) {
|
||
status = 'available'
|
||
} else if (raw.status === 1) {
|
||
status = 'booked'
|
||
unavailableLabel = '已订'
|
||
} else {
|
||
status = 'blocked'
|
||
unavailableLabel = '排课'
|
||
}
|
||
let bookedBy
|
||
if (status === 'booked' && appt) {
|
||
const contacts = []
|
||
if (Array.isArray(appt.hadVenueAppts)) {
|
||
for (const v of appt.hadVenueAppts) {
|
||
if (!isRecord(v)) continue
|
||
const name = typeof v.customerName === 'string' ? v.customerName.trim() : ''
|
||
const phone = typeof v.customerTel === 'string' ? v.customerTel.trim() : ''
|
||
if (name || phone) contacts.push({ name: name || undefined, phone: phone || undefined })
|
||
}
|
||
}
|
||
if (contacts.length === 0 && Array.isArray(appt.customerNames)) {
|
||
for (const v of appt.customerNames) {
|
||
if (typeof v === 'string' && v.trim()) contacts.push({ name: v.trim() })
|
||
}
|
||
}
|
||
const unique = []
|
||
for (const c of contacts) {
|
||
if (!unique.some((u) => u.name === c.name && u.phone === c.phone)) unique.push(c)
|
||
}
|
||
if (unique.length > 0) bookedBy = unique
|
||
}
|
||
return {
|
||
id: `${raw.txtClassroomUid}:${raw.beginDatetime}:${raw.endDatetime}`,
|
||
courtLabel: raw.classRoomName,
|
||
startTime,
|
||
endTime,
|
||
priceCents: Math.round(raw.cost * 100),
|
||
status,
|
||
...(unavailableLabel ? { unavailableLabel } : {}),
|
||
...(bookedBy ? { bookedBy } : {}),
|
||
...(enrollment ? { enrollment: enrollment.activity } : {}),
|
||
providerReference: {
|
||
classroomUid: raw.txtClassroomUid,
|
||
beginDatetime: raw.beginDatetime,
|
||
endDatetime: raw.endDatetime
|
||
},
|
||
sourceLabel: '范思伯特实时接口'
|
||
}
|
||
}
|
||
|
||
async function cmdParseAvailability({ flags }) {
|
||
const date = flags.date
|
||
if (typeof date !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(date)) {
|
||
die('--date YYYY-MM-DD is required')
|
||
}
|
||
const raw = await readStdin()
|
||
let payload
|
||
try { payload = JSON.parse(raw) } catch { die('stdin is not valid JSON') }
|
||
if (!isRecord(payload)) die('球场接口响应格式错误')
|
||
if (payload.successed !== true || !isRecord(payload.result)) {
|
||
die('球场接口拒绝了可订时段查询')
|
||
}
|
||
const slots = payload.result.slots
|
||
if (!Array.isArray(slots)) die('球场接口响应缺少时段列表')
|
||
const enrollRaw = payload.result.enrollSlots
|
||
if (enrollRaw !== undefined && !Array.isArray(enrollRaw)) {
|
||
die('球场接口响应中的活动列表格式错误')
|
||
}
|
||
const enrollments = []
|
||
if (Array.isArray(enrollRaw)) {
|
||
for (const e of enrollRaw) enrollments.push(parseEnrollment(e))
|
||
}
|
||
const parsedSlots = slots.map((s) => parseSlot(s, enrollments))
|
||
writeJson({
|
||
courtId: 'fansibote-fuzhong',
|
||
date,
|
||
updatedAt: new Date().toISOString(),
|
||
slots: parsedSlots
|
||
}, !!flags.pretty)
|
||
}
|
||
|
||
// ---------- find-continuous ----------
|
||
|
||
function isContinuousSingleCourt(slots) {
|
||
if (slots.length === 0) return false
|
||
const firstUid = slots[0].providerReference?.classroomUid
|
||
if (!firstUid) return false
|
||
for (const s of slots) {
|
||
if (s.providerReference?.classroomUid !== firstUid) return false
|
||
}
|
||
for (let i = 1; i < slots.length; i++) {
|
||
const prevEnd = extractHour(slots[i - 1].endTime)
|
||
const curStart = extractHour(slots[i].startTime)
|
||
if (prevEnd === null || curStart === null || prevEnd + 1 !== curStart) return false
|
||
}
|
||
return true
|
||
}
|
||
|
||
async function cmdFindContinuous({ flags }) {
|
||
const start = flags.start
|
||
const end = flags.end
|
||
if (typeof start !== 'string' || typeof end !== 'string') {
|
||
die('--start HH and --end HH are required')
|
||
}
|
||
const startHour = Number(start)
|
||
const endHour = Number(end)
|
||
if (!Number.isInteger(startHour) || !Number.isInteger(endHour) ||
|
||
startHour < 0 || endHour > 24 || startHour >= endHour) {
|
||
die('invalid --start/--end (must be integers, 0 <= start < end <= 24)')
|
||
}
|
||
const raw = await readStdin()
|
||
let payload
|
||
try { payload = JSON.parse(raw) } catch { die('stdin is not valid JSON') }
|
||
if (!isRecord(payload) || !Array.isArray(payload.slots)) {
|
||
die('stdin is not a parse-availability output (missing slots array)')
|
||
}
|
||
const bookable = payload.slots.filter((s) =>
|
||
(s.status === 'available' || s.status === 'limited') &&
|
||
!s.enrollment
|
||
)
|
||
const sorted = [...bookable].sort((a, b) => {
|
||
if (a.providerReference.classroomUid !== b.providerReference.classroomUid) {
|
||
return a.providerReference.classroomUid.localeCompare(b.providerReference.classroomUid)
|
||
}
|
||
return a.startTime.localeCompare(b.startTime)
|
||
})
|
||
const groups = new Map()
|
||
for (const s of sorted) {
|
||
const uid = s.providerReference.classroomUid
|
||
if (!groups.has(uid)) groups.set(uid, [])
|
||
groups.get(uid).push(s)
|
||
}
|
||
const matches = []
|
||
const span = endHour - startHour
|
||
for (const [uid, slots] of groups) {
|
||
for (let i = 0; i + span <= slots.length; i++) {
|
||
const window = slots.slice(i, i + span)
|
||
const firstHour = extractHour(window[0].startTime)
|
||
const lastEndHour = extractHour(window[window.length - 1].endTime)
|
||
if (firstHour !== startHour || lastEndHour + 1 !== endHour) continue
|
||
if (!isContinuousSingleCourt(window)) continue
|
||
matches.push({
|
||
txtClassroomUid: uid,
|
||
courtLabel: window[0].courtLabel,
|
||
startTime: window[0].startTime,
|
||
endTime: window[window.length - 1].endTime,
|
||
slots: window
|
||
})
|
||
}
|
||
}
|
||
if (matches.length === 0) {
|
||
writeJson({ found: false }, false)
|
||
return
|
||
}
|
||
matches.sort((a, b) => {
|
||
if (a.startTime !== b.startTime) return a.startTime.localeCompare(b.startTime)
|
||
const aCost = a.slots.reduce((s, x) => s + x.priceCents, 0)
|
||
const bCost = b.slots.reduce((s, x) => s + x.priceCents, 0)
|
||
if (aCost !== bCost) return aCost - bCost
|
||
return a.courtLabel.localeCompare(b.courtLabel)
|
||
})
|
||
writeJson({
|
||
found: true,
|
||
match: matches[0],
|
||
alternatives: matches.slice(1)
|
||
}, false)
|
||
}
|
||
|
||
// ---------- build-booking-body ----------
|
||
|
||
const DEFAULT_VENUE_ID_NUM = 6038652
|
||
|
||
async function cmdBuildBookingBody({ flags }) {
|
||
const raw = await readStdin()
|
||
let payload
|
||
try { payload = JSON.parse(raw) } catch { die('stdin is not valid JSON') }
|
||
if (!isRecord(payload) || payload.found !== true || !isRecord(payload.match)) {
|
||
die('stdin is not a find-continuous output (found: true required)')
|
||
}
|
||
const slots = payload.match.slots
|
||
if (!Array.isArray(slots) || slots.length === 0) die('no slots in match')
|
||
if (!isContinuousSingleCourt(slots)) die('match is not a single-court continuous sequence')
|
||
const body = {
|
||
userId: DEFAULT_VENUE_ID_NUM,
|
||
projectType: 0,
|
||
classroomItems: slots.map((s) => ({
|
||
classroomUid: s.providerReference.classroomUid,
|
||
beginDatetime: s.providerReference.beginDatetime,
|
||
endDatetime: s.providerReference.endDatetime,
|
||
peopleNum: 1
|
||
})),
|
||
remark: '',
|
||
combinationPayments: [
|
||
{
|
||
paymentMethod: 900,
|
||
cost: slots.reduce((sum, s) => sum + s.priceCents, 0) / 100
|
||
}
|
||
]
|
||
}
|
||
writeJson(body, !!flags.pretty)
|
||
}
|
||
|
||
// ---------- parse-booking-response ----------
|
||
|
||
async function cmdParseBookingResponse({ flags }) {
|
||
const slotsPath = flags.slots
|
||
if (typeof slotsPath !== 'string') die('--slots <path> is required')
|
||
const fs = await import('node:fs/promises')
|
||
let slotsDoc
|
||
try {
|
||
slotsDoc = JSON.parse(await fs.readFile(slotsPath, 'utf8'))
|
||
} catch (err) {
|
||
die(`cannot read --slots: ${err.message}`)
|
||
}
|
||
const sl = slotsDoc?.match?.slots ?? slotsDoc?.slots
|
||
if (!Array.isArray(sl) || sl.length === 0) {
|
||
die('--slots must point to a find-continuous (with .match.slots) or parse-availability (with .slots) output')
|
||
}
|
||
const respRaw = await readStdin()
|
||
let payload
|
||
try { payload = JSON.parse(respRaw) } catch { die('stdin is not valid JSON') }
|
||
if (!isRecord(payload)) die('球场下单接口响应格式错误')
|
||
if (payload.successed !== true) {
|
||
const detail = []
|
||
for (const k of ['message', 'msg', 'errorMessage', 'errorMsg', 'status', 'errorCode']) {
|
||
const v = payload[k]
|
||
if (typeof v === 'string' || typeof v === 'number') {
|
||
detail.push(`${k}=${String(v).slice(0, 200)}`)
|
||
}
|
||
}
|
||
die(`球场下单接口拒绝了锁场请求${detail.length ? `（${detail.join(', ')}）` : ''}`)
|
||
}
|
||
if (!isRecord(payload.result)) die('球场下单接口响应格式错误')
|
||
const result = payload.result
|
||
if (
|
||
typeof result.apptUid !== 'string' ||
|
||
!isRecord(result.script) ||
|
||
typeof result.script.expireTime !== 'string' ||
|
||
!Array.isArray(result.venueAppointUids) ||
|
||
!result.venueAppointUids.every((v) => typeof v === 'string')
|
||
) {
|
||
die('球场下单接口响应格式错误')
|
||
}
|
||
const sorted = [...sl].sort((a, b) => a.startTime.localeCompare(b.startTime))
|
||
const amountCents = sorted.reduce((s, x) => s + x.priceCents, 0)
|
||
const summary = {
|
||
courtId: 'fansibote-fuzhong',
|
||
orderId: result.apptUid,
|
||
venueAppointmentIds: result.venueAppointUids,
|
||
amountCents,
|
||
courtLabel: sorted[0].courtLabel,
|
||
startTime: sorted[0].startTime,
|
||
endTime: sorted[sorted.length - 1].endTime,
|
||
expiresAt: result.script.expireTime,
|
||
status: 'pending-payment',
|
||
_note: 'script 对象（paySign 等）已剥离；请到小程序完成支付。'
|
||
}
|
||
writeJson(summary, !!flags.pretty)
|
||
}
|
||
|
||
// ---------- fingerprint ----------
|
||
|
||
async function cmdFingerprint({ flags }) {
|
||
let visitor = typeof flags.visitor === 'string' ? flags.visitor : ''
|
||
if (!visitor) visitor = process.env.POSPAL_VISITOR_ID ?? ''
|
||
if (!visitor) die('fingerprint needs --visitor or POSPAL_VISITOR_ID env')
|
||
const fp = createHash('sha256').update(visitor).digest('hex').slice(0, 12)
|
||
process.stdout.write(fp)
|
||
process.stdout.write('\n')
|
||
}
|
||
|
||
// ---------- redact ----------
|
||
|
||
const SENSITIVE_KEY = /^(?:visitor|paysign|prepay|nonce|package|token|cookie|authorization)$|^(?:pspl|customer|phone|tel)/i
|
||
|
||
function redactValue(value, key) {
|
||
if (typeof key === 'string' && SENSITIVE_KEY.test(key)) return '[REDACTED]'
|
||
if (Array.isArray(value)) return value.map((v) => redactValue(v, ''))
|
||
if (isRecord(value)) {
|
||
const out = {}
|
||
for (const [k, v] of Object.entries(value)) out[k] = redactValue(v, k)
|
||
return out
|
||
}
|
||
return value
|
||
}
|
||
|
||
async function cmdRedact({ flags }) {
|
||
const raw = await readStdin()
|
||
let payload
|
||
try { payload = JSON.parse(raw) } catch { die('stdin is not valid JSON') }
|
||
writeJson(redactValue(payload, ''), !!flags.pretty)
|
||
}
|
||
|
||
// ---------- main ----------
|
||
|
||
async function main() {
|
||
const argv = process.argv.slice(2)
|
||
if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
|
||
usage()
|
||
process.exit(argv.length === 0 ? 1 : 0)
|
||
}
|
||
const sub = argv[0]
|
||
const parsed = parseArgs(argv.slice(1))
|
||
switch (sub) {
|
||
case 'parse-availability': return cmdParseAvailability(parsed)
|
||
case 'find-continuous': return cmdFindContinuous(parsed)
|
||
case 'build-booking-body': return cmdBuildBookingBody(parsed)
|
||
case 'parse-booking-response': return cmdParseBookingResponse(parsed)
|
||
case 'fingerprint': return cmdFingerprint(parsed)
|
||
case 'redact': return cmdRedact(parsed)
|
||
default: {
|
||
process.stderr.write(`unknown subcommand: ${sub}\n\n`)
|
||
usage()
|
||
process.exit(1)
|
||
}
|
||
}
|
||
}
|
||
|
||
main().catch((err) => die(err?.stack ?? String(err)))
|