375 lines
13 KiB
TypeScript
375 lines
13 KiB
TypeScript
import { ipcMain } from 'electron'
|
|
import type {
|
|
Branch,
|
|
PriceOption,
|
|
ReservationRequest,
|
|
ReservationResult,
|
|
ReservationSelection,
|
|
Theme,
|
|
ThemeDetail,
|
|
TimeSlot,
|
|
} from '../../src/type/reservation'
|
|
import { edgeBrowserHeaders, encodeMultipart, requestKeyescape } from './keyescape-http'
|
|
import { openCaptchaWindow } from './captcha-window'
|
|
|
|
const BASE_URL = 'https://www.keyescape.com'
|
|
const API_URL = `${BASE_URL}/controller/run_proc.php`
|
|
const REQUEST_TIMEOUT_MS = 12_000
|
|
|
|
interface ApiEnvelope<T> {
|
|
status?: boolean
|
|
msg?: string
|
|
data?: T
|
|
}
|
|
|
|
function asPositiveInteger(value: unknown, label: string): number {
|
|
const number = Number(value)
|
|
if (!Number.isSafeInteger(number) || number <= 0) {
|
|
throw new Error(`${label} 값이 올바르지 않습니다.`)
|
|
}
|
|
return number
|
|
}
|
|
|
|
function asDate(value: unknown): string {
|
|
const date = String(value ?? '')
|
|
if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) {
|
|
throw new Error('예약 날짜가 올바르지 않습니다.')
|
|
}
|
|
return date
|
|
}
|
|
|
|
function cleanText(value: unknown, maxLength = 200): string {
|
|
return String(value ?? '').trim().slice(0, maxLength)
|
|
}
|
|
|
|
async function fetchWithTimeout(url: string, init?: RequestInit): Promise<Response> {
|
|
const controller = new AbortController()
|
|
const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS)
|
|
|
|
try {
|
|
const response = await fetch(url, {
|
|
...init,
|
|
signal: controller.signal,
|
|
headers: {
|
|
...edgeBrowserHeaders(),
|
|
...init?.headers,
|
|
},
|
|
})
|
|
if (!response.ok) {
|
|
throw new Error(`예약 서버가 HTTP ${response.status} 오류를 반환했습니다.`)
|
|
}
|
|
return response
|
|
} catch (error) {
|
|
if (error instanceof Error && error.name === 'AbortError') {
|
|
throw new Error('예약 서버 응답 시간이 초과되었습니다.')
|
|
}
|
|
throw error
|
|
} finally {
|
|
clearTimeout(timeout)
|
|
}
|
|
}
|
|
|
|
async function postApi<T>(body: Record<string, string>, referer: string): Promise<ApiEnvelope<T>> {
|
|
const response = await fetchWithTimeout(API_URL, {
|
|
method: 'POST',
|
|
headers: {
|
|
...edgeBrowserHeaders({
|
|
accept: 'application/json, text/javascript, */*; q=0.01',
|
|
referer,
|
|
xhr: true,
|
|
}),
|
|
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
|
|
},
|
|
body: new URLSearchParams(body),
|
|
})
|
|
|
|
try {
|
|
return await response.json() as ApiEnvelope<T>
|
|
} catch {
|
|
throw new Error('예약 서버 응답을 해석하지 못했습니다.')
|
|
}
|
|
}
|
|
|
|
export function parseBranches(html: string): Branch[] {
|
|
const match = html.match(/const\s+originalZizumData\s*=\s*(\[[\s\S]*?\]);/)
|
|
if (!match) return []
|
|
|
|
try {
|
|
const values = JSON.parse(match[1]) as Array<Record<string, unknown>>
|
|
return values
|
|
.filter((item) => item.category === 'room')
|
|
.map((item) => ({
|
|
num: Number(item.num),
|
|
name: cleanText(item.name, 80),
|
|
phone: cleanText(item.phone, 30),
|
|
}))
|
|
.filter((item) => Number.isSafeInteger(item.num) && item.num > 0 && item.name.length > 0)
|
|
} catch {
|
|
return []
|
|
}
|
|
}
|
|
|
|
export function parsePriceOptions(html: string): PriceOption[] {
|
|
const select = html.match(/<select[^>]+name=["']person["'][^>]*>([\s\S]*?)<\/select>/i)?.[1] ?? ''
|
|
const options = [...select.matchAll(/<option[^>]+value=["']?(\d+)["']?[^>]+data-rev_price=["']?(\d+)["']?[^>]*>/gi)]
|
|
return options.map((match) => ({
|
|
person: Number(match[1]),
|
|
totalPrice: Number(match[2]),
|
|
})).filter((option) => option.person > 0 && option.totalPrice >= 0)
|
|
}
|
|
|
|
async function getBranches(): Promise<Branch[]> {
|
|
const response = await fetchWithTimeout(`${BASE_URL}/reservation.php`, {
|
|
headers: edgeBrowserHeaders({ referer: `${BASE_URL}/works.php`, navigation: true }),
|
|
})
|
|
const branches = parseBranches(await response.text())
|
|
if (branches.length === 0) {
|
|
throw new Error('지점 목록을 찾지 못했습니다. 사이트 구조가 변경되었을 수 있습니다.')
|
|
}
|
|
return branches
|
|
}
|
|
|
|
async function getThemes(rawBranchNum: unknown): Promise<Theme[]> {
|
|
const branchNum = asPositiveInteger(rawBranchNum, '지점')
|
|
const result = await postApi<Array<Record<string, unknown>>>({
|
|
t: 'get_theme_info_list',
|
|
zizum_num: String(branchNum),
|
|
}, `${BASE_URL}/reservation.php`)
|
|
|
|
if (!result.status || !Array.isArray(result.data)) {
|
|
throw new Error(cleanText(result.msg) || '테마 목록을 불러오지 못했습니다.')
|
|
}
|
|
|
|
return result.data.map((item) => ({
|
|
infoNum: Number(item.info_num),
|
|
themeNum: Number(item.theme_num),
|
|
name: cleanText(item.info_name, 100),
|
|
doing: Number(item.doing) || 1,
|
|
memo: cleanText(item.memo, 4_000),
|
|
})).filter((item) => item.infoNum > 0 && item.themeNum > 0 && item.name.length > 0)
|
|
}
|
|
|
|
async function getThemeDetail(rawThemeInfoNum: unknown): Promise<ThemeDetail> {
|
|
const themeInfoNum = asPositiveInteger(rawThemeInfoNum, '테마')
|
|
const result = await postApi<Record<string, unknown>>({
|
|
t: 'get_theme_date',
|
|
num: String(themeInfoNum),
|
|
}, `${BASE_URL}/reservation1.php`) as ApiEnvelope<Record<string, unknown>> & {
|
|
calendarData?: Record<string, unknown>
|
|
}
|
|
|
|
if (!result.status || !result.data) {
|
|
throw new Error(cleanText(result.msg) || '테마 정보를 불러오지 못했습니다.')
|
|
}
|
|
|
|
return {
|
|
name: cleanText(result.data.name, 100),
|
|
imageUrl: cleanText(result.data.image_url, 500),
|
|
genre: cleanText(result.data.genre, 100),
|
|
level: cleanText(result.data.level, 20),
|
|
playTime: cleanText(result.data.play_time, 20),
|
|
memo: cleanText(result.data.memo, 4_000),
|
|
serverToday: asDate(result.calendarData?.today),
|
|
}
|
|
}
|
|
|
|
async function getTimes(rawSelection: Record<string, unknown>): Promise<TimeSlot[]> {
|
|
const branchNum = asPositiveInteger(rawSelection.branchNum, '지점')
|
|
const themeNum = asPositiveInteger(rawSelection.themeNum, '테마')
|
|
const date = asDate(rawSelection.date)
|
|
const result = await postApi<Array<Record<string, unknown>>>({
|
|
t: 'get_theme_time',
|
|
date,
|
|
zizumNum: String(branchNum),
|
|
themeNum: String(themeNum),
|
|
}, `${BASE_URL}/reservation1.php?zizum_num=${branchNum}&theme_num=${themeNum}`)
|
|
|
|
if (!result.status || !Array.isArray(result.data)) {
|
|
throw new Error(cleanText(result.msg) || '시간 목록을 불러오지 못했습니다.')
|
|
}
|
|
|
|
return result.data.map((item) => ({
|
|
num: Number(item.num),
|
|
time: `${cleanText(item.hh, 2)}:${cleanText(item.mm, 2)}`,
|
|
available: item.enable === 'Y',
|
|
saleText: cleanText(item.sale_txt, 80),
|
|
})).filter((item) => item.num > 0 && /^\d{2}:\d{2}$/.test(item.time))
|
|
}
|
|
|
|
function normalizeSelection(rawSelection: Record<string, unknown>): ReservationSelection {
|
|
return {
|
|
branchNum: asPositiveInteger(rawSelection.branchNum, '지점'),
|
|
themeNum: asPositiveInteger(rawSelection.themeNum, '테마'),
|
|
themeInfoNum: asPositiveInteger(rawSelection.themeInfoNum, '테마 정보'),
|
|
date: asDate(rawSelection.date),
|
|
timeNum: asPositiveInteger(rawSelection.timeNum, '예약 시간'),
|
|
timeLabel: cleanText(rawSelection.timeLabel, 20),
|
|
themeName: cleanText(rawSelection.themeName, 100),
|
|
}
|
|
}
|
|
|
|
async function prepare(rawSelection: Record<string, unknown>): Promise<PriceOption[]> {
|
|
const selection = normalizeSelection(rawSelection)
|
|
const form = new FormData()
|
|
form.set('zizumNum', String(selection.branchNum))
|
|
form.set('themeNum', String(selection.themeNum))
|
|
form.set('themeInfoNum', String(selection.themeInfoNum))
|
|
form.set('revDays', selection.date)
|
|
form.set('themeTimeNum', String(selection.timeNum))
|
|
form.set('revTimes', selection.timeLabel)
|
|
form.set('themeName', selection.themeName)
|
|
|
|
const response = await fetchWithTimeout(`${BASE_URL}/reservation2.php`, {
|
|
method: 'POST',
|
|
headers: {
|
|
...edgeBrowserHeaders({
|
|
referer: `${BASE_URL}/reservation1.php?zizum_num=${selection.branchNum}&theme_num=${selection.themeNum}&theme_info_num=${selection.themeInfoNum}`,
|
|
navigation: true,
|
|
}),
|
|
},
|
|
body: form,
|
|
})
|
|
const options = parsePriceOptions(await response.text())
|
|
if (options.length === 0) {
|
|
throw new Error('인원별 금액을 불러오지 못했습니다. 선택한 시간이 마감되었을 수 있습니다.')
|
|
}
|
|
return options
|
|
}
|
|
|
|
async function openCaptcha(rawSelection: Record<string, unknown>) {
|
|
return openCaptchaWindow(normalizeSelection(rawSelection))
|
|
}
|
|
|
|
let reservationSubmissionInFlight = false
|
|
|
|
async function executeReservationOnce(rawRequest: ReservationRequest): Promise<ReservationResult> {
|
|
const requestRecord = rawRequest as unknown as Record<string, unknown>
|
|
const selection = normalizeSelection(requestRecord)
|
|
const person = asPositiveInteger(rawRequest.person, '인원')
|
|
const totalPrice = asPositiveInteger(rawRequest.totalPrice, '결제 금액')
|
|
const name = cleanText(rawRequest.name, 50)
|
|
const phone = cleanText(rawRequest.phone, 20).replace(/\D/g, '')
|
|
const captchaToken = cleanText(rawRequest.captchaToken, 8_000)
|
|
|
|
if (!name) throw new Error('예약자명을 입력해주세요.')
|
|
if (!/^01\d{8,9}$/.test(phone)) throw new Error('휴대폰 번호를 올바르게 입력해주세요.')
|
|
if (captchaToken.length < 30) throw new Error('캡차 토큰을 올바르게 붙여넣어 주세요.')
|
|
|
|
const mobile1 = phone.slice(0, 3)
|
|
const remainder = phone.slice(3)
|
|
const values: Record<string, string> = {
|
|
device: 'pc',
|
|
t: 'ins_rev',
|
|
theme_info_num: String(selection.themeInfoNum),
|
|
zizum_num: String(selection.branchNum),
|
|
theme_num: String(selection.themeNum),
|
|
rev_days: selection.date,
|
|
theme_time_num: String(selection.timeNum),
|
|
rev_price: String(totalPrice),
|
|
person: String(person),
|
|
name,
|
|
mobile1,
|
|
mobile2: remainder.slice(0, remainder.length - 4),
|
|
mobile3: remainder.slice(-4),
|
|
'g-recaptcha-response': captchaToken,
|
|
payment: 'D',
|
|
agree_all: 'on',
|
|
agree_1: 'on',
|
|
agree_2: 'on',
|
|
agree_3: 'on',
|
|
}
|
|
const multipart = encodeMultipart(values)
|
|
const response = await requestKeyescape({
|
|
method: 'POST',
|
|
path: '/controller/run_proc.php',
|
|
headers: {
|
|
...edgeBrowserHeaders({
|
|
accept: 'application/json, text/javascript, */*; q=0.01',
|
|
referer: `${BASE_URL}/reservation2.php`,
|
|
xhr: true,
|
|
}),
|
|
'Content-Type': `multipart/form-data; boundary=${multipart.boundary}`,
|
|
'Content-Length': String(multipart.body.length),
|
|
},
|
|
body: multipart.body,
|
|
timeoutMs: REQUEST_TIMEOUT_MS,
|
|
})
|
|
|
|
if (response.statusCode < 200 || response.statusCode >= 300) {
|
|
throw new Error(`예약 서버가 HTTP ${response.statusCode} 오류를 반환했습니다.`)
|
|
}
|
|
|
|
let result: ApiEnvelope<Record<string, unknown>>
|
|
try {
|
|
result = JSON.parse(response.body.toString('utf8')) as ApiEnvelope<Record<string, unknown>>
|
|
} catch {
|
|
throw new Error('예약 서버 응답을 해석하지 못했습니다.')
|
|
}
|
|
|
|
const message = cleanText(result.msg, 500) || (result.status ? '예약이 접수되었습니다.' : '예약에 실패했습니다.')
|
|
const observedServerDateMs = Date.parse(Array.isArray(response.headers.date)
|
|
? response.headers.date[0]
|
|
: response.headers.date ?? '')
|
|
const transport = {
|
|
sentAtMs: response.sentAtMs,
|
|
receivedAtMs: response.receivedAtMs,
|
|
rttMs: response.rttMs,
|
|
httpStatus: response.statusCode,
|
|
remoteIp: response.remoteIp,
|
|
reusedSocket: response.reusedSocket,
|
|
protocol: response.protocol,
|
|
connectionId: response.connectionId,
|
|
observedServerDateMs: Number.isFinite(observedServerDateMs) ? observedServerDateMs : undefined,
|
|
}
|
|
if (!result.status || !result.data) return { success: false, message, transport }
|
|
|
|
const reservationNum = cleanText(result.data.num, 100)
|
|
const checkCode = cleanText(result.data.ck_code, 200)
|
|
const confirmationUrl = reservationNum && checkCode
|
|
? `${BASE_URL}/reservation3.php?num=${encodeURIComponent(reservationNum)}&ck_code=${encodeURIComponent(checkCode)}`
|
|
: undefined
|
|
return { success: true, message, reservationNum, confirmationUrl, transport }
|
|
}
|
|
|
|
export async function executeReservation(rawRequest: ReservationRequest): Promise<ReservationResult> {
|
|
if (reservationSubmissionInFlight) throw new Error('이미 예약 요청이 진행 중입니다.')
|
|
reservationSubmissionInFlight = true
|
|
try {
|
|
return await executeReservationOnce(rawRequest)
|
|
} finally {
|
|
reservationSubmissionInFlight = false
|
|
}
|
|
}
|
|
|
|
// 다중 시도(살보)용: 단일 실행 잠금을 거치지 않고 각 시도를 실제로 병렬 전송한다.
|
|
// 각 시도가 서로 다른 토큰을 소비하므로 잠금으로 서로를 막지 않는다.
|
|
export function executeReservationConcurrent(rawRequest: ReservationRequest): Promise<ReservationResult> {
|
|
return executeReservationOnce(rawRequest)
|
|
}
|
|
|
|
function handle<TArgs extends unknown[], TResult>(
|
|
channel: string,
|
|
handler: (...args: TArgs) => Promise<TResult>,
|
|
) {
|
|
ipcMain.handle(channel, async (_event, ...args: TArgs) => {
|
|
try {
|
|
return { ok: true, data: await handler(...args) }
|
|
} catch (error) {
|
|
return {
|
|
ok: false,
|
|
error: error instanceof Error ? error.message : '알 수 없는 오류가 발생했습니다.',
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
export function registerReservationHandlers() {
|
|
handle('reservation:get-branches', getBranches)
|
|
handle('reservation:get-themes', getThemes)
|
|
handle('reservation:get-theme-detail', getThemeDetail)
|
|
handle('reservation:get-times', getTimes)
|
|
handle('reservation:prepare', prepare)
|
|
handle('reservation:open-captcha', openCaptcha)
|
|
handle('reservation:submit', executeReservation)
|
|
}
|