first commit

This commit is contained in:
dahyeon committed 2026-08-12 17:28:30 +09:00
1 parent 18d31d5dcf
commit 77a5f5248c
31 files changed
+6637 -30

No files matched your search

+370
View File
@@ -0,0 +1,370 @@
import { ipcMain, shell } from 'electron'
import type {
Branch,
PriceOption,
ReservationRequest,
ReservationResult,
ReservationSelection,
Theme,
ThemeDetail,
TimeSlot,
} from '../../src/type/reservation'
import { edgeBrowserHeaders, encodeMultipart, requestKeyescape } from './keyescape-http'
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>): Promise<void> {
const branchNum = asPositiveInteger(rawSelection.branchNum, '지점')
const themeNum = asPositiveInteger(rawSelection.themeNum, '테마')
const themeInfoNum = asPositiveInteger(rawSelection.themeInfoNum, '테마 정보')
await shell.openExternal(
`${BASE_URL}/reservation1.php?zizum_num=${branchNum}&theme_num=${themeNum}&theme_info_num=${themeInfoNum}`,
)
}
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,
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
}
}
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)
}