661 lines
25 KiB
JavaScript
661 lines
25 KiB
JavaScript
#!/usr/bin/env node
|
||
import fs from "node:fs";
|
||
import path from "node:path";
|
||
import http from "node:http";
|
||
import { spawn } from "node:child_process";
|
||
|
||
const ROOT = path.resolve(new URL("..", import.meta.url).pathname, "..");
|
||
const BASE_DIR = process.env.TRAVEL_DELIVERY_ROOT || path.join(ROOT, "data", "source", "travel_delivery_20260602");
|
||
const OUT_DIR = path.join(BASE_DIR, "amap_js_enriched");
|
||
const CACHE_FILE = path.join(OUT_DIR, "_amap_js_cache.json");
|
||
const CHROME = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome";
|
||
const PROFILE = "/tmp/znkg-amap-js-enrich-profile";
|
||
const DEBUG_PORT = 9231;
|
||
|
||
const SCENIC_FILE = path.join(BASE_DIR, "scenic_for_amap.csv");
|
||
const HOTEL_FILE = path.join(BASE_DIR, "hotel_poi.csv");
|
||
const RESTAURANT_FILE = path.join(BASE_DIR, "restaurant_poi.csv");
|
||
|
||
function readEnvKey(file, key) {
|
||
const txt = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
|
||
for (const line of txt.split(/\r?\n/)) {
|
||
if (line.trim().startsWith(`${key}=`)) return line.split("=").slice(1).join("=").trim().replace(/^["']|["']$/g, "");
|
||
}
|
||
return "";
|
||
}
|
||
|
||
function parseCsv(text) {
|
||
text = text.replace(/^\uFEFF/, "");
|
||
const rows = [];
|
||
let row = [];
|
||
let cell = "";
|
||
let quoted = false;
|
||
for (let i = 0; i < text.length; i += 1) {
|
||
const ch = text[i];
|
||
const next = text[i + 1];
|
||
if (quoted) {
|
||
if (ch === '"' && next === '"') {
|
||
cell += '"';
|
||
i += 1;
|
||
} else if (ch === '"') {
|
||
quoted = false;
|
||
} else {
|
||
cell += ch;
|
||
}
|
||
} else if (ch === '"') {
|
||
quoted = true;
|
||
} else if (ch === ",") {
|
||
row.push(cell);
|
||
cell = "";
|
||
} else if (ch === "\n") {
|
||
row.push(cell);
|
||
rows.push(row);
|
||
row = [];
|
||
cell = "";
|
||
} else if (ch !== "\r") {
|
||
cell += ch;
|
||
}
|
||
}
|
||
if (cell || row.length) {
|
||
row.push(cell);
|
||
rows.push(row);
|
||
}
|
||
const headers = rows.shift() || [];
|
||
const data = rows
|
||
.filter((r) => r.some((v) => String(v || "").trim()))
|
||
.map((r) => Object.fromEntries(headers.map((h, i) => [h, r[i] ?? ""])));
|
||
return { headers, rows: data };
|
||
}
|
||
|
||
function csvEscape(value) {
|
||
const s = value == null ? "" : String(value);
|
||
return /[",\r\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
|
||
}
|
||
|
||
function writeCsv(file, rows, preferred = []) {
|
||
fs.mkdirSync(path.dirname(file), { recursive: true });
|
||
const headers = [];
|
||
for (const h of preferred) if (!headers.includes(h)) headers.push(h);
|
||
for (const row of rows) {
|
||
for (const h of Object.keys(row)) if (!headers.includes(h)) headers.push(h);
|
||
}
|
||
const lines = [headers.map(csvEscape).join(",")];
|
||
for (const row of rows) lines.push(headers.map((h) => csvEscape(row[h])).join(","));
|
||
fs.writeFileSync(file, `\uFEFF${lines.join("\n")}\n`, "utf8");
|
||
}
|
||
|
||
function readCsv(file) {
|
||
return parseCsv(fs.readFileSync(file, "utf8"));
|
||
}
|
||
|
||
function loadCache() {
|
||
if (!fs.existsSync(CACHE_FILE)) return {};
|
||
return JSON.parse(fs.readFileSync(CACHE_FILE, "utf8"));
|
||
}
|
||
|
||
function saveCache(cache) {
|
||
fs.mkdirSync(path.dirname(CACHE_FILE), { recursive: true });
|
||
fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), "utf8");
|
||
}
|
||
|
||
function httpJson(url) {
|
||
return new Promise((resolve, reject) => {
|
||
http.get(url, (res) => {
|
||
let data = "";
|
||
res.on("data", (chunk) => (data += chunk));
|
||
res.on("end", () => {
|
||
try {
|
||
resolve(JSON.parse(data));
|
||
} catch (e) {
|
||
reject(e);
|
||
}
|
||
});
|
||
}).on("error", reject);
|
||
});
|
||
}
|
||
|
||
class Cdp {
|
||
constructor(wsUrl) {
|
||
this.ws = new WebSocket(wsUrl);
|
||
this.seq = 1;
|
||
this.pending = new Map();
|
||
this.ws.onmessage = (event) => {
|
||
const msg = JSON.parse(event.data);
|
||
if (msg.id && this.pending.has(msg.id)) {
|
||
const { resolve, reject } = this.pending.get(msg.id);
|
||
this.pending.delete(msg.id);
|
||
if (msg.error) reject(new Error(JSON.stringify(msg.error)));
|
||
else resolve(msg.result);
|
||
}
|
||
};
|
||
}
|
||
async open() {
|
||
await new Promise((resolve, reject) => {
|
||
this.ws.onopen = resolve;
|
||
this.ws.onerror = reject;
|
||
});
|
||
}
|
||
call(method, params = {}) {
|
||
const id = this.seq++;
|
||
this.ws.send(JSON.stringify({ id, method, params }));
|
||
return new Promise((resolve, reject) => this.pending.set(id, { resolve, reject }));
|
||
}
|
||
close() {
|
||
this.ws.close();
|
||
}
|
||
}
|
||
|
||
async function wait(ms) {
|
||
await new Promise((resolve) => setTimeout(resolve, ms));
|
||
}
|
||
|
||
async function launchCdp() {
|
||
const chrome = spawn(
|
||
CHROME,
|
||
[
|
||
"--headless=new",
|
||
"--disable-gpu",
|
||
"--no-first-run",
|
||
"--no-default-browser-check",
|
||
`--remote-debugging-port=${DEBUG_PORT}`,
|
||
`--user-data-dir=${PROFILE}`,
|
||
"http://localhost:8102/admin/plaza/graph",
|
||
],
|
||
{ stdio: "ignore" },
|
||
);
|
||
let pages = null;
|
||
for (let i = 0; i < 40; i += 1) {
|
||
try {
|
||
pages = await httpJson(`http://127.0.0.1:${DEBUG_PORT}/json`);
|
||
if (pages?.[0]?.webSocketDebuggerUrl) break;
|
||
} catch {}
|
||
await wait(300);
|
||
}
|
||
if (!pages?.[0]?.webSocketDebuggerUrl) {
|
||
chrome.kill();
|
||
throw new Error("Chrome CDP not ready");
|
||
}
|
||
const cdp = new Cdp(pages[0].webSocketDebuggerUrl);
|
||
await cdp.open();
|
||
await cdp.call("Runtime.enable");
|
||
return { chrome, cdp };
|
||
}
|
||
|
||
function jsString(v) {
|
||
return JSON.stringify(v);
|
||
}
|
||
|
||
async function initAmap(cdp) {
|
||
const envPath = process.env.TRAVEL_KG_ENV_PATH || path.join(ROOT, ".env");
|
||
const key = readEnvKey(envPath, "AMAP_JS_KEY");
|
||
const security = readEnvKey(envPath, "AMAP_SECURITY_JSCODE");
|
||
if (!key || !security) throw new Error("missing AMap JS key/security");
|
||
const expr = `
|
||
(async () => {
|
||
if (!document.documentElement || !document.head || !document.body) {
|
||
document.open();
|
||
document.write('<!doctype html><html><head><meta charset="utf-8"></head><body><div id="amap-root"></div></body></html>');
|
||
document.close();
|
||
}
|
||
if (!document.head) document.documentElement.insertBefore(document.createElement('head'), document.documentElement.firstChild);
|
||
if (!document.body) document.documentElement.appendChild(document.createElement('body'));
|
||
window._AMapSecurityConfig = { securityJsCode: ${jsString(security)} };
|
||
await new Promise((resolve, reject) => {
|
||
if (window.AMap) return resolve();
|
||
const s = document.createElement('script');
|
||
s.src = 'https://webapi.amap.com/maps?v=2.0&key=${encodeURIComponent(key)}&plugin=AMap.PlaceSearch,AMap.Driving';
|
||
s.onload = resolve;
|
||
s.onerror = () => reject(new Error('amap script load failed'));
|
||
document.head.appendChild(s);
|
||
});
|
||
function simplifyPoi(poi) {
|
||
const loc = poi.location || {};
|
||
const photos = (poi.photos || []).map((p) => p.url || p).filter(Boolean);
|
||
return {
|
||
id: poi.id || '',
|
||
name: poi.name || '',
|
||
type: poi.type || '',
|
||
typecode: poi.typecode || '',
|
||
address: poi.address || '',
|
||
pname: poi.pname || poi.provinceName || '',
|
||
cityname: poi.cityname || poi.cityName || '',
|
||
adname: poi.adname || poi.district || '',
|
||
adcode: poi.adcode || '',
|
||
tel: poi.tel || '',
|
||
distance: poi.distance || '',
|
||
biz_ext: poi.biz_ext || {},
|
||
rating: poi.biz_ext?.rating || poi.rating || '',
|
||
cost: poi.biz_ext?.cost || poi.cost || '',
|
||
photos,
|
||
lng: loc.lng != null ? Number(loc.lng) : '',
|
||
lat: loc.lat != null ? Number(loc.lat) : '',
|
||
};
|
||
}
|
||
window.__znkgAmapSearch = (keyword, city, type, pageSize) => new Promise((resolve, reject) => {
|
||
const ps = new AMap.PlaceSearch({ city: city || undefined, type: type || undefined, pageSize: pageSize || 20, pageIndex: 1, extensions: 'all' });
|
||
ps.search(keyword, (status, result) => {
|
||
if (status === 'complete') resolve((result.poiList?.pois || []).map(simplifyPoi));
|
||
else reject(new Error(status + ':' + JSON.stringify(result)));
|
||
});
|
||
});
|
||
window.__znkgAmapNearby = (keyword, lng, lat, radius, type, pageSize) => new Promise((resolve, reject) => {
|
||
const ps = new AMap.PlaceSearch({ type: type || undefined, pageSize: pageSize || 25, pageIndex: 1, extensions: 'all' });
|
||
ps.searchNearBy(keyword || '', [Number(lng), Number(lat)], Number(radius), (status, result) => {
|
||
if (status === 'complete') resolve((result.poiList?.pois || []).map(simplifyPoi));
|
||
else reject(new Error(status + ':' + JSON.stringify(result)));
|
||
});
|
||
});
|
||
window.__znkgAmapDrive = (oLng, oLat, dLng, dLat) => new Promise((resolve, reject) => {
|
||
const driving = new AMap.Driving();
|
||
driving.search([Number(oLng), Number(oLat)], [Number(dLng), Number(dLat)], (status, result) => {
|
||
if (status === 'complete') {
|
||
const r = result.routes?.[0] || {};
|
||
resolve({ distance: r.distance || '', time: r.time || '', tolls: r.tolls || '' });
|
||
} else reject(new Error(status + ':' + JSON.stringify(result)));
|
||
});
|
||
});
|
||
return 'ok';
|
||
})()
|
||
`;
|
||
const out = await cdp.call("Runtime.evaluate", { expression: expr, awaitPromise: true, returnByValue: true });
|
||
if (out.exceptionDetails) throw new Error(JSON.stringify(out.exceptionDetails));
|
||
}
|
||
|
||
async function callPage(cdp, name, args) {
|
||
const expr = `window.${name}(${args.map(jsString).join(",")})`;
|
||
const out = await cdp.call("Runtime.evaluate", { expression: expr, awaitPromise: true, returnByValue: true });
|
||
if (out.exceptionDetails) throw new Error(out.exceptionDetails.text || JSON.stringify(out.exceptionDetails));
|
||
return out.result?.value;
|
||
}
|
||
|
||
function normName(value) {
|
||
let s = String(value || "");
|
||
for (const token of ["风景名胜区", "风景区", "旅游景区", "景区", "旅游区", "景点", "国家级", "贵州省"]) {
|
||
s = s.replaceAll(token, "");
|
||
}
|
||
return [...s].filter((ch) => /[a-zA-Z0-9\u4e00-\u9fff]/.test(ch)).join("").toLowerCase();
|
||
}
|
||
|
||
function poiScore(poi, targetName, city = "", district = "") {
|
||
let score = 0;
|
||
const n1 = normName(targetName);
|
||
const n2 = normName(poi.name);
|
||
if (n1 && n2) {
|
||
if (n1 === n2) score += 120;
|
||
else if (n2.includes(n1) || n1.includes(n2)) score += 80;
|
||
}
|
||
if (String(poi.type || "").includes("风景") || String(poi.type || "").includes("景点")) score += 25;
|
||
if (city && String(poi.cityname || "").startsWith(city.slice(0, 2))) score += 12;
|
||
const d = String(district || "").split("/")[0].replace(/[县区市]/g, "");
|
||
if (d && String(poi.adname || "").includes(d)) score += 18;
|
||
if (poi.photos?.length) score += 5;
|
||
return score;
|
||
}
|
||
|
||
function bestPoi(pois, targetName, city = "", district = "") {
|
||
if (!pois?.length) return null;
|
||
return [...pois].sort((a, b) => poiScore(b, targetName, city, district) - poiScore(a, targetName, city, district))[0];
|
||
}
|
||
|
||
function markerUrl(lng, lat, name) {
|
||
if (!lng || !lat) return "";
|
||
const params = new URLSearchParams({ position: `${lng},${lat}`, name: name || "", src: "znkg", coordinate: "gaode", callnative: "0" });
|
||
return `https://uri.amap.com/marker?${params}`;
|
||
}
|
||
|
||
function commonFields(poi) {
|
||
const photos = poi.photos || [];
|
||
return {
|
||
amap_name: poi.name || "",
|
||
amap_poi_id: poi.id || "",
|
||
amap_type: poi.type || "",
|
||
amap_typecode: poi.typecode || "",
|
||
province: poi.pname || "",
|
||
city: poi.cityname || "",
|
||
district: poi.adname || "",
|
||
adcode: poi.adcode || "",
|
||
formatted_address: poi.address || "",
|
||
geo_lng: poi.lng || "",
|
||
geo_lat: poi.lat || "",
|
||
tel: poi.tel || "",
|
||
amap_rating: poi.rating || "",
|
||
amap_avg_cost: poi.cost || "",
|
||
first_image_url: photos[0] || "",
|
||
all_image_urls: photos.join("|"),
|
||
image_count: photos.length,
|
||
amap_url: markerUrl(poi.lng, poi.lat, poi.name),
|
||
};
|
||
}
|
||
|
||
async function cached(cache, key, producer) {
|
||
if (cache[key]) return cache[key];
|
||
const value = await producer();
|
||
cache[key] = value;
|
||
if (Object.keys(cache).length % 20 === 0) saveCache(cache);
|
||
await wait(120);
|
||
return value;
|
||
}
|
||
|
||
async function searchText(cdp, cache, keyword, city = "", type = "", pageSize = 20) {
|
||
return cached(cache, `search|${keyword}|${city}|${type}|${pageSize}`, () => callPage(cdp, "__znkgAmapSearch", [keyword, city, type, pageSize]));
|
||
}
|
||
|
||
async function searchNearby(cdp, cache, keyword, lng, lat, radius, type = "", pageSize = 25) {
|
||
return cached(cache, `nearby|${keyword}|${lng}|${lat}|${radius}|${type}|${pageSize}`, () =>
|
||
callPage(cdp, "__znkgAmapNearby", [keyword, lng, lat, radius, type, pageSize]),
|
||
);
|
||
}
|
||
|
||
async function driving(cdp, cache, oLng, oLat, dLng, dLat) {
|
||
return cached(cache, `drive|${oLng},${oLat}|${dLng},${dLat}`, async () => {
|
||
try {
|
||
return await callPage(cdp, "__znkgAmapDrive", [oLng, oLat, dLng, dLat]);
|
||
} catch (e) {
|
||
return { error: String(e.message || e) };
|
||
}
|
||
});
|
||
}
|
||
|
||
async function enrichScenic(cdp, cache, scenicRows, scenicHeaders) {
|
||
const out = [];
|
||
for (let i = 0; i < scenicRows.length; i += 1) {
|
||
const row = scenicRows[i];
|
||
const name = row.name || "";
|
||
const city = row.city || "";
|
||
const district = row.district || "";
|
||
const keywords = [name, row.amap_search_keyword, `${city} ${name}`].filter(Boolean);
|
||
let selected = null;
|
||
for (const keyword of keywords) {
|
||
const pois = await searchText(cdp, cache, keyword, city, "", 20);
|
||
selected = bestPoi(pois, name, city, district);
|
||
if (selected) break;
|
||
}
|
||
const next = { ...row };
|
||
if (selected) {
|
||
const common = commonFields(selected);
|
||
Object.assign(next, common, {
|
||
has_geo: Boolean(common.geo_lng && common.geo_lat),
|
||
amap_match_status: "matched",
|
||
amap_match_score: poiScore(selected, name, city, district),
|
||
});
|
||
if (row.first_image_url && !common.first_image_url) {
|
||
next.first_image_url = row.first_image_url;
|
||
next.all_image_urls = row.all_image_urls || "";
|
||
next.image_count = row.image_count || "";
|
||
}
|
||
} else {
|
||
next.amap_match_status = "not_found";
|
||
}
|
||
out.push(next);
|
||
console.log(`[scenic] ${i + 1}/${scenicRows.length} ${name} -> ${next.amap_name || ""} ${next.geo_lng || ""},${next.geo_lat || ""}`);
|
||
}
|
||
writeCsv(path.join(OUT_DIR, "scenic_for_amap_enriched.csv"), out, scenicHeaders);
|
||
return out;
|
||
}
|
||
|
||
async function enrichExisting(cdp, cache, rows, headers, nameField, idPrefix, typeKeyword) {
|
||
const out = [];
|
||
for (let i = 0; i < rows.length; i += 1) {
|
||
const row = rows[i];
|
||
const name = row[nameField] || "";
|
||
const city = row.city || row.expected_city || "";
|
||
const keyword = row.amap_search_keyword || `${city} ${name}`;
|
||
let selected = null;
|
||
try {
|
||
selected = bestPoi(await searchText(cdp, cache, keyword, city, typeKeyword, 20), name, city, row.district || "");
|
||
} catch {
|
||
selected = bestPoi(await searchText(cdp, cache, keyword, city, "", 20), name, city, row.district || "");
|
||
}
|
||
const next = { ...row };
|
||
if (selected) {
|
||
Object.assign(next, commonFields(selected), {
|
||
[`${idPrefix.toLowerCase()}_id`]: `${idPrefix}_${selected.id || String(i + 1).padStart(4, "0")}`,
|
||
source: `${row.source || "source_csv"}+amap_js_text`,
|
||
amap_match_status: "matched",
|
||
amap_match_score: poiScore(selected, name, city, row.district || ""),
|
||
});
|
||
} else {
|
||
Object.assign(next, {
|
||
[`${idPrefix.toLowerCase()}_id`]: `${idPrefix}_UNMATCHED_${String(i + 1).padStart(4, "0")}`,
|
||
amap_match_status: "not_found",
|
||
});
|
||
}
|
||
out.push(next);
|
||
if ((i + 1) % 10 === 0 || i + 1 === rows.length) console.log(`[${idPrefix.toLowerCase()}] ${i + 1}/${rows.length}`);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
function uniqueBy(rows, keyFn) {
|
||
const seen = new Set();
|
||
const out = [];
|
||
for (const row of rows) {
|
||
const key = keyFn(row);
|
||
if (seen.has(key)) continue;
|
||
seen.add(key);
|
||
out.push(row);
|
||
}
|
||
return out;
|
||
}
|
||
|
||
async function nearby(cdp, cache, scenicRows, kind) {
|
||
const isHotel = kind === "hotel";
|
||
const keyword = isHotel ? "酒店" : "餐厅";
|
||
const type = isHotel ? "住宿服务" : "餐饮服务";
|
||
const resourceType = isHotel ? "Hotel" : "Restaurant";
|
||
const radii = [5000, 10000, 20000, 50000];
|
||
const master = [];
|
||
const rels = [];
|
||
for (let i = 0; i < scenicRows.length; i += 1) {
|
||
const s = scenicRows[i];
|
||
const lng = s.geo_lng;
|
||
const lat = s.geo_lat;
|
||
const selected = [];
|
||
const seen = new Set();
|
||
if (lng && lat) {
|
||
for (const radius of radii) {
|
||
let pois = [];
|
||
try {
|
||
pois = await searchNearby(cdp, cache, keyword, lng, lat, radius, type, 25);
|
||
} catch {
|
||
pois = await searchNearby(cdp, cache, keyword, lng, lat, radius, "", 25);
|
||
}
|
||
for (const poi of pois) {
|
||
const id = poi.id || `${poi.name}-${poi.lng}-${poi.lat}`;
|
||
if (!id || seen.has(id)) continue;
|
||
seen.add(id);
|
||
selected.push(poi);
|
||
if (selected.length >= 10) break;
|
||
}
|
||
if (selected.length >= 10) break;
|
||
}
|
||
}
|
||
for (let rank = 0; rank < Math.min(10, selected.length); rank += 1) {
|
||
const poi = selected[rank];
|
||
const common = commonFields(poi);
|
||
const resourceId = `${resourceType.toUpperCase()}_${poi.id || `${s.id}_${rank + 1}`}`;
|
||
master.push({
|
||
[`${kind}_id`]: resourceId,
|
||
[`${kind}_name`]: poi.name || "",
|
||
source: "amap_js_around",
|
||
...common,
|
||
});
|
||
const drive = common.geo_lng && common.geo_lat ? await driving(cdp, cache, lng, lat, common.geo_lng, common.geo_lat) : {};
|
||
rels.push({
|
||
scenic_id: s.id || "",
|
||
scenic_name: s.name || "",
|
||
scenic_lng: lng || "",
|
||
scenic_lat: lat || "",
|
||
resource_type: resourceType,
|
||
resource_id: resourceId,
|
||
resource_name: poi.name || "",
|
||
amap_poi_id: poi.id || "",
|
||
resource_lng: common.geo_lng || "",
|
||
resource_lat: common.geo_lat || "",
|
||
rank_for_scenic: rank + 1,
|
||
amap_around_distance_m: poi.distance || "",
|
||
drive_status: drive.error ? drive.error : "OK",
|
||
drive_distance_m: drive.distance || "",
|
||
drive_distance_km: drive.distance ? Math.round((Number(drive.distance) / 1000) * 100) / 100 : "",
|
||
drive_duration_s: drive.time || "",
|
||
drive_duration_min: drive.time ? Math.round((Number(drive.time) / 60) * 10) / 10 : "",
|
||
drive_tolls: drive.tolls || "",
|
||
province: common.province || "",
|
||
city: common.city || "",
|
||
district: common.district || "",
|
||
formatted_address: common.formatted_address || "",
|
||
amap_type: common.amap_type || "",
|
||
tel: common.tel || "",
|
||
first_image_url: common.first_image_url || "",
|
||
all_image_urls: common.all_image_urls || "",
|
||
amap_url: common.amap_url || "",
|
||
});
|
||
}
|
||
console.log(`[nearby:${kind}] ${i + 1}/${scenicRows.length} ${s.name} -> ${selected.length}`);
|
||
}
|
||
return { master: uniqueBy(master, (r) => r.amap_poi_id || r[`${kind}_name`]), rels };
|
||
}
|
||
|
||
function addNearestToMaster(masterRows, relRows, kind) {
|
||
const best = new Map();
|
||
for (const rel of relRows) {
|
||
const key = rel.amap_poi_id;
|
||
const cur = best.get(key);
|
||
const m = Number(rel.drive_duration_min || 999999);
|
||
if (!cur || m < Number(cur.drive_duration_min || 999999)) best.set(key, rel);
|
||
}
|
||
return masterRows.map((row) => {
|
||
const rel = best.get(row.amap_poi_id);
|
||
if (!rel) return row;
|
||
return {
|
||
...row,
|
||
nearest_scenic_id: rel.scenic_id,
|
||
nearest_scenic_name: rel.scenic_name,
|
||
nearest_drive_distance_km: rel.drive_distance_km,
|
||
nearest_drive_duration_min: rel.drive_duration_min,
|
||
};
|
||
});
|
||
}
|
||
|
||
function writeDictionary() {
|
||
const text = `# 高德 JS API POI 补全字段字典
|
||
|
||
## 本次输出文件
|
||
|
||
- scenic_for_amap_enriched.csv：景区 POI 补全结果。
|
||
- hotel_poi_enriched.csv：原酒店表匹配高德 POI 后的结果。
|
||
- restaurant_poi_enriched.csv：原餐饮表匹配高德 POI 后的结果。
|
||
- hotel_poi_amap_master.csv / restaurant_poi_amap_master.csv：原始资源 + 高德附近资源合并后的 POI 主表。
|
||
- scenic_hotel_nearby_10.csv / scenic_restaurant_nearby_10.csv：每个景区附近 10 个酒店/餐饮候选及驾车距离时间。
|
||
- scenic_resource_drive_metrics.csv：酒店与餐饮 nearby 关系合并表。
|
||
|
||
## 关键字段
|
||
|
||
| 字段 | 说明 |
|
||
|---|---|
|
||
| amap_poi_id | 高德 POI ID，外部来源唯一标识 |
|
||
| amap_name | 高德返回名称 |
|
||
| amap_type / amap_typecode | 高德行业分类 |
|
||
| province / city / district / adcode | 高德行政区 |
|
||
| formatted_address | 高德地址 |
|
||
| geo_lng / geo_lat | 高德 GCJ-02 坐标 |
|
||
| tel | 高德电话 |
|
||
| first_image_url / all_image_urls | 高德照片 URL |
|
||
| amap_url | 高德 marker URI，可用于前端跳转 |
|
||
| drive_distance_km | 景区到资源的高德驾车公里数 |
|
||
| drive_duration_min | 景区到资源的高德驾车分钟数 |
|
||
| rank_for_scenic | 某景区附近资源排序 |
|
||
| nearest_scenic_name | 主表中该资源离哪个景区车程最近 |
|
||
|
||
## 图谱建议
|
||
|
||
酒店和餐饮作为独立 POI 实体；景区到酒店/餐饮使用 NEARBY 关系，关系属性写入 drive_distance_km、drive_duration_min、rank_for_scenic。门票、小交通、保险等仍作为 TravelItem 绑定景区。
|
||
`;
|
||
fs.writeFileSync(path.join(OUT_DIR, "字段字典.md"), text, "utf8");
|
||
}
|
||
|
||
function writeReport({ scenicRows, hotelRows, restaurantRows, hotelRels, restaurantRels }) {
|
||
const matched = (rows) => rows.filter((r) => r.amap_match_status === "matched" || r.amap_poi_id).length;
|
||
const byScenic = new Map();
|
||
for (const r of hotelRels) byScenic.set(r.scenic_name, { ...(byScenic.get(r.scenic_name) || {}), hotel: ((byScenic.get(r.scenic_name) || {}).hotel || 0) + 1 });
|
||
for (const r of restaurantRels) byScenic.set(r.scenic_name, { ...(byScenic.get(r.scenic_name) || {}), restaurant: ((byScenic.get(r.scenic_name) || {}).restaurant || 0) + 1 });
|
||
const lines = [
|
||
"# 高德 JS API 补全报告",
|
||
"",
|
||
fLine("景区补全", matched(scenicRows), scenicRows.length),
|
||
fLine("原酒店 POI 匹配", matched(hotelRows), hotelRows.length),
|
||
fLine("原餐饮 POI 匹配", matched(restaurantRows), restaurantRows.length),
|
||
`- 景区附近酒店关系：${hotelRels.length} 条`,
|
||
`- 景区附近餐饮关系：${restaurantRels.length} 条`,
|
||
"",
|
||
"## 每个景区 nearby 覆盖",
|
||
"",
|
||
"| 景区 | 酒店候选 | 餐饮候选 |",
|
||
"|---|---:|---:|",
|
||
];
|
||
for (const [name, v] of [...byScenic.entries()].sort((a, b) => a[0].localeCompare(b[0], "zh-Hans-CN"))) {
|
||
lines.push(`| ${name} | ${v.hotel || 0} | ${v.restaurant || 0} |`);
|
||
}
|
||
fs.writeFileSync(path.join(OUT_DIR, "高德补全报告.md"), `${lines.join("\n")}\n`, "utf8");
|
||
}
|
||
|
||
function fLine(label, n, total) {
|
||
return `- ${label}：${n}/${total}`;
|
||
}
|
||
|
||
async function main() {
|
||
fs.mkdirSync(OUT_DIR, { recursive: true });
|
||
const cache = loadCache();
|
||
const { headers: scenicHeaders, rows: scenicRaw } = readCsv(SCENIC_FILE);
|
||
const { headers: hotelHeaders, rows: hotelRaw } = readCsv(HOTEL_FILE);
|
||
const { headers: restaurantHeaders, rows: restaurantRaw } = readCsv(RESTAURANT_FILE);
|
||
|
||
const { chrome, cdp } = await launchCdp();
|
||
try {
|
||
await initAmap(cdp);
|
||
const scenicRows = await enrichScenic(cdp, cache, scenicRaw, scenicHeaders);
|
||
saveCache(cache);
|
||
|
||
const hotelRows = await enrichExisting(cdp, cache, hotelRaw, hotelHeaders, "hotel_name", "HOTEL", "住宿服务");
|
||
writeCsv(path.join(OUT_DIR, "hotel_poi_enriched.csv"), hotelRows, hotelHeaders);
|
||
saveCache(cache);
|
||
|
||
const restaurantRows = await enrichExisting(cdp, cache, restaurantRaw, restaurantHeaders, "restaurant_name", "RESTAURANT", "餐饮服务");
|
||
writeCsv(path.join(OUT_DIR, "restaurant_poi_enriched.csv"), restaurantRows, restaurantHeaders);
|
||
saveCache(cache);
|
||
|
||
const nearbyHotels = await nearby(cdp, cache, scenicRows, "hotel");
|
||
saveCache(cache);
|
||
const nearbyRestaurants = await nearby(cdp, cache, scenicRows, "restaurant");
|
||
saveCache(cache);
|
||
|
||
const hotelMaster = addNearestToMaster(
|
||
uniqueBy([...hotelRows, ...nearbyHotels.master], (r) => r.amap_poi_id || r.hotel_name || r.hotel_name),
|
||
nearbyHotels.rels,
|
||
"hotel",
|
||
);
|
||
const restaurantMaster = addNearestToMaster(
|
||
uniqueBy([...restaurantRows, ...nearbyRestaurants.master], (r) => r.amap_poi_id || r.restaurant_name),
|
||
nearbyRestaurants.rels,
|
||
"restaurant",
|
||
);
|
||
|
||
writeCsv(path.join(OUT_DIR, "hotel_poi_amap_master.csv"), hotelMaster);
|
||
writeCsv(path.join(OUT_DIR, "restaurant_poi_amap_master.csv"), restaurantMaster);
|
||
writeCsv(path.join(OUT_DIR, "scenic_hotel_nearby_10.csv"), nearbyHotels.rels);
|
||
writeCsv(path.join(OUT_DIR, "scenic_restaurant_nearby_10.csv"), nearbyRestaurants.rels);
|
||
writeCsv(path.join(OUT_DIR, "scenic_resource_drive_metrics.csv"), [...nearbyHotels.rels, ...nearbyRestaurants.rels]);
|
||
writeDictionary();
|
||
writeReport({ scenicRows, hotelRows, restaurantRows, hotelRels: nearbyHotels.rels, restaurantRels: nearbyRestaurants.rels });
|
||
console.log(`done ${OUT_DIR}`);
|
||
} finally {
|
||
cdp.close();
|
||
chrome.kill();
|
||
}
|
||
}
|
||
|
||
main().catch((err) => {
|
||
console.error(err);
|
||
process.exit(1);
|
||
});
|