Public Source Viewer
비나래아카이브 개발자 포털

실제 서비스 구조를 살펴볼 수 있는 공개용 코드 뷰어입니다. 인증, 세션, 외부 연동, 토큰, 관리자 식별 등 보안상 민감한 구현은 파일 단위 또는 줄 단위로 검열됩니다.
Redacted View
src/services/hinana-rail-reference.service.ts
공개 가능
                            
                            import fs from 'fs';
                        
                            import path from 'path';
                        
                            import { CONFIG_DIR } from '../utils/paths';
                        
                            interface Reference {
                        
                                distanceSource: { url: string; date: string };
                        
                                corridors: { line: string; kind: string; stations: { name: string; km: number }[] }[];
                        
                                sources: { title: string; effective: string; url: string; group: string; trains: { number: string; line: string; stops: { station: string; time: string }[] }[] }[];
                        
                            }
                        
                            export interface RailLookupInput { date: string; trainNumber: string; trainType: string; departure: string; arrival: string; departureTime?: string }
                        
                            let cached: Reference;
                        
                            export function normalizeRailStation(value: string): string {
                        
                                const name = value.trim().replace(/\s/g, '').replace(/역$/, '').replace(/\(.*\)/g, '');
                        
                                return ({ 신경주: '경주', 평내호: '평내호평' } as Record<string,string>)[name] || (value.includes('김천') && value.includes('구미') ? '김천구미' : name);
                        
                            }
                        
                            export function lookupRailReference(input: RailLookupInput, reference?: Reference) {
                        
                                if (!/^\d{4}-\d{2}-\d{2}$/.test(input.date) || !Number.isFinite(Date.parse(input.date)) || new Date(input.date).toISOString().slice(0,10) !== input.date || !/^\d{1,5}$/.test(input.trainNumber)) {
                        
                                    throw new Error('이용 날짜와 열차 번호를 확인해 주세요.');
                        
                                }
                        
                                const departure=normalizeRailStation(input.departure), arrival=normalizeRailStation(input.arrival);
                        
                                if(!departure || !arrival || departure===arrival)throw new Error('출발역과 도착역을 확인해 주세요.');
                        
                                if(!reference) {
                        
                            [SECURITY REDACTED] 민감한 설정/인증/토큰 관련 코드입니다.
                        
                                    reference=cached;
                        
                                }
                        
                                const group=input.trainType.startsWith('KTX')?'KTX':input.trainType==='ITX-청춘'?'ITX-청춘':input.trainType==='SRT'?'SRT':'general';
                        
                                const sources=reference.sources.filter(s=>s.group===group && s.effective<=input.date);
                        
                                const latest=sources.map(s=>s.effective).sort().pop();
                        
                                const unavailable={ matched:false, message:'해당 날짜·열차·승차 구간을 공식 시간표에서 확인하지 못했습니다. 노선과 거리는 직접 입력할 수 있습니다.' };
                        
                                if(!latest || Date.parse(input.date)-Date.parse(latest)>180*86400000)return unavailable;
                        
                                const matches=[];
                        
                                for(const source of sources.filter(s=>s.effective===latest))for(const train of source.trains) {
                        
                                    if(train.number!==String(Number(input.trainNumber)))continue;
                        
                                    const from=train.stops.findIndex(s=>normalizeRailStation(s.station)===departure);
                        
                                    const to=train.stops.findIndex(s=>normalizeRailStation(s.station)===arrival);
                        
                                    if(from<0 || to<=from || (input.departureTime && train.stops[from].time!==input.departureTime))continue;
                        
                                    const corridors=reference.corridors.filter(c=>c.line===train.line && (group==='KTX'?c.kind==='high-speed':c.kind===input.trainType));
                        
                                    const distances=[];
                        
                                    // Only use a published corridor that contains the complete ordered stopping pattern.
                        
                                    // Never substitute a straight-line or shortest-path estimate for the travelled distance.
                        
                                    for(const corridor of corridors) {
                        
                                        const indexes=train.stops.map(s=>corridor.stations.findIndex(p=>normalizeRailStation(p.name)===normalizeRailStation(s.station)));
                        
                                        if(indexes.some(n=>n<0))continue;
                        
                                        if(!indexes.every((n,i)=>i===0||n>indexes[i-1]) && !indexes.every((n,i)=>i===0||n<indexes[i-1]))continue;
                        
                                        distances.push(Math.round(Math.abs(corridor.stations[indexes[to]].km-corridor.stations[indexes[from]].km)*10)/10);
                        
                                    }
                        
                                    const unique=[...new Set(distances)];
                        
                                    matches.push({line:train.line,distance:unique.length===1?unique[0]:null,source});
                        
                                }
                        
                                if(!matches.length)return unavailable;
                        
                                if(new Set(matches.map(m=>m.line)).size!==1)return {matched:false,message:'시간표에서 여러 노선이 확인됩니다. 출발 시간을 입력해 다시 조회해 주세요.'};
                        
                                const distances=[...new Set(matches.map(m=>m.distance))];
                        
                                const distance=distances.length===1?distances[0]:null;
                        
                                const match=matches[0];
                        
                                return {matched:true, draft:{line:match.line,distance}, source:{title:match.source.title,url:match.source.url,distanceDate:reference.distanceSource.date,distanceUrl:reference.distanceSource.url},
                        
                                    message:distance===null?'노선을 확인했습니다. 해당 경유 구간의 거리는 자료에서 확인되지 않았습니다.':`승차 거리 ${distance} km · 거리표 ${reference.distanceSource.date} 기준. 경유 구간과 운행일을 확인해 주세요.`};
                        
                            }