feat: 初始化临时项目管理项目结构及核心功能

- 新增项目根目录及配置文件，包括 .gitignore、.env.example 和 package.json
- 实现数据库连接池、配置加载、日志记录和 HTTP 客户端工具
- 添加数据服务层，支持酒店、房间、房型和回路数据的批量事务处理
- 创建主脚本，实现分阶段数据获取、处理和存储流程
- 提供数据库初始化脚本和测试用例
- 添加项目文档，包括 README.md 和项目需求说明

.gitignore

@@ -0,0 +1,2 @@
+/temporary_project_management/node_modules
+temporary_project_management/logs

.trae/documents/创建数据库及房间状态表初始化脚本计划.md

@@ -0,0 +1,34 @@
+## 任务概览
+
+根据 [.env](file:///e:/Project_Class/BLS/Web_BLS_SQL/.env) 的配置和 [project.md](file:///e:/Project_Class/BLS/Web_BLS_SQL/project.md) 中的需求，创建 PostgreSQL 数据库初始化脚本。该脚本将包含数据库创建、模式（Schema）定义、以及 `room_status_moment` 表的详细设计。
+
+## 技术要点分析
+
+1. **高性能读写**：针对高频查询和写入，我们将为关键字段（如 `hotel_id`, `room_id`, `device_id`, `guid` 等）建立索引。
+2. **并发处理**：使用复合主键 `(hotel_id, room_id, device_id, guid)` 来确保数据的唯一性，并利用 PostgreSQL 的 `ON CONFLICT` 特性处理并发写入冲突。
+3. **后期规划（分片存储）**：
+
+   * 虽然目前数据量预计在十万级别，但为了后期扩展，我们将采用 **PostgreSQL 原生声明式分区（Declarative Partitioning）**。
+
+   * 按照 `hotel_id` 进行 `LIST` 分区，方便后期根据酒店 ID 将数据分布到不同的物理存储或分表中。
+4. **字段类型优化**：
+
+   * `guid`: 使用 `uuid` 类型，存储空间更小且索引效率高。
+
+   * `ts_ms`: 使用 `timestamptz` (timestamp with time zone) 确保时区正确。
+
+## 实施步骤
+
+1. **创建初始化 SQL 文件**：在根目录下创建 `init_db.sql`。
+2. **编写 SQL 内容**：
+
+   * 创建模式 `room_status`。
+
+   * 定义 `room_status_moment` 主表，并配置分区规则。
+
+   * 创建索引以支持快速检索。
+
+   * 添加必要的注释以提高可维护性。
+3. **验证脚本**：检查 SQL 语法是否符合 PostgreSQL 规范。
+
+请确认以上计划，完成后我将直接生成 SQL 文件。

project_management/.env

@@ -0,0 +1,15 @@
+PORT=3000
+DB_FILE=./local.db
+API_BASE_URL=http://www.boonlive-rcu.com:7000/api/values
+
+PORT=3000
+
+# 数据库配置
+POSTGRES_HOST=10.8.8.109
+POSTGRES_PORT=5433
+POSTGRES_DATABASE=log_platform
+POSTGRES_USER=log_admin
+POSTGRES_PASSWORD=YourActualStrongPasswordForPostgres!
+POSTGRES_MAX_CONNECTIONS=6
+POSTGRES_IDLE_TIMEOUT_MS=30000
+

project_management/init_db.sql

@@ -0,0 +1,132 @@
+-- ============================================================================
+-- 数据库初始化脚本
+-- 描述：创建 log_platform 库（逻辑参考）、room_status 模式及 room_status_moment 分区表
+-- 对应项目需求：project.md #L57-65
+-- ============================================================================
+
+-- 注意：在 PostgreSQL 中，CREATE DATABASE 不能在事务块中执行。
+-- 通常建议先手动创建数据库，然后再执行后续脚本。
+-- CREATE DATABASE log_platform;
+
+-- 切换到 log_platform 数据库后执行以下内容：
+
+-- 1. 创建模式
+CREATE SCHEMA IF NOT EXISTS room_status;
+
+-- 2. 创建主表 (使用声明式分区)
+-- 根据需求 L57-65，考虑后期十万级以上数据的扩展，按 hotel_id 进行 LIST 分区
+CREATE TABLE IF NOT EXISTS room_status.room_status_moment (
+    -- 基础标识字段
+    guid UUID NOT NULL,
+    ts_ms INT8 NOT NULL DEFAULT (EXTRACT(EPOCH FROM CURRENT_TIMESTAMP) * 1000)::BIGINT,
+    hotel_id INT2 NOT NULL,
+    room_id TEXT NOT NULL,
+    device_id TEXT NOT NULL,
+    
+    -- 设备状态字段
+    sys_lock_status INT2,
+    online_status INT2,
+    launcher_version TEXT,
+    app_version TEXT,
+    config_version TEXT,
+    register_ts_ms INT8,
+    upgrade_ts_ms INT8,
+    config_ts_ms INT8,
+    ip TEXT,
+    
+    -- 房间业务状态字段
+    pms_status INT2,
+    power_state INT2,
+    cardless_state INT2,
+    service_mask INT8,
+    insert_card INT2,
+    
+    -- 空调相关
+    air_address TEXT[],
+    air_state INT2,
+    air_model INT2,
+    air_speed INT2,
+    air_set_temp INT2,
+    air_now_temp INT2,
+    air_solenoid_valve INT2,
+    
+    -- 能耗相关
+    elec_address TEXT[],
+    elec_voltage DOUBLE PRECISION,
+    elec_ampere DOUBLE PRECISION,
+    elec_power DOUBLE PRECISION,
+    elec_phase TEXT,
+    elec_energy DOUBLE PRECISION,
+    elec_sum_energy DOUBLE PRECISION,
+    
+    -- 节能与外设
+    carbon_state INT2,
+    dev_loops JSONB,
+    energy_carbon_sum DOUBLE PRECISION,
+    energy_nocard_sum DOUBLE PRECISION,
+    external_device JSONB DEFAULT '{}',
+    faulty_device_count JSONB DEFAULT '{}',
+
+    -- 约束：分区表的主键必须包含分区键 (hotel_id)
+    PRIMARY KEY (hotel_id, room_id, device_id, guid)
+) PARTITION BY LIST (hotel_id);
+
+-- 3. 创建索引 (针对高频查询字段)
+-- 注意：在分区表上创建索引会自动在所有子表上创建对应的索引
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_hotel_room ON room_status.room_status_moment (hotel_id, room_id);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_device_id ON room_status.room_status_moment (device_id);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_sys_lock ON room_status.room_status_moment (sys_lock_status);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_online ON room_status.room_status_moment (online_status);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_pms ON room_status.room_status_moment (pms_status);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_power ON room_status.room_status_moment (power_state);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_cardless ON room_status.room_status_moment (cardless_state);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_insert_card ON room_status.room_status_moment (insert_card);
+CREATE INDEX IF NOT EXISTS idx_room_status_moment_carbon ON room_status.room_status_moment (carbon_state);
+
+-- 4. 示例：创建第一个分区 (hotel_id = 1)
+-- 实际部署时，可根据 hotel_id 动态创建分区
+CREATE TABLE IF NOT EXISTS room_status.room_status_moment_h1 
+    PARTITION OF room_status.room_status_moment 
+    FOR VALUES IN (1);
+
+-- 5. 添加表和字段注释
+COMMENT ON TABLE room_status.room_status_moment IS '房间即时状态表 - 记录设备及房间业务的最新实时状态';
+COMMENT ON COLUMN room_status.room_status_moment.guid IS '主键 guid uuid 32位无符号UUID';
+COMMENT ON COLUMN room_status.room_status_moment.ts_ms IS '最后更新时间';
+COMMENT ON COLUMN room_status.room_status_moment.hotel_id IS '酒店';
+COMMENT ON COLUMN room_status.room_status_moment.room_id IS '房间';
+COMMENT ON COLUMN room_status.room_status_moment.device_id IS '设备编号';
+COMMENT ON COLUMN room_status.room_status_moment.sys_lock_status IS '系统锁状态';
+COMMENT ON COLUMN room_status.room_status_moment.online_status IS '设备在线状态';
+COMMENT ON COLUMN room_status.room_status_moment.launcher_version IS '设备launcher版本';
+COMMENT ON COLUMN room_status.room_status_moment.app_version IS '设备App版本';
+COMMENT ON COLUMN room_status.room_status_moment.config_version IS '设备配置版本';
+COMMENT ON COLUMN room_status.room_status_moment.register_ts_ms IS '最后一次注册时间';
+COMMENT ON COLUMN room_status.room_status_moment.upgrade_ts_ms IS '最后一次升级时间';
+COMMENT ON COLUMN room_status.room_status_moment.config_ts_ms IS '最后一次下发配置时间';
+COMMENT ON COLUMN room_status.room_status_moment.ip IS '当前公网IP地址';
+COMMENT ON COLUMN room_status.room_status_moment.pms_status IS 'PMS状态';
+COMMENT ON COLUMN room_status.room_status_moment.power_state IS '取电状态';
+COMMENT ON COLUMN room_status.room_status_moment.cardless_state IS '有、无人状态';
+COMMENT ON COLUMN room_status.room_status_moment.service_mask IS '服务状态';
+COMMENT ON COLUMN room_status.room_status_moment.insert_card IS '插卡状态';
+COMMENT ON COLUMN room_status.room_status_moment.air_address IS '空调地址';
+COMMENT ON COLUMN room_status.room_status_moment.air_state IS '空调状态';
+COMMENT ON COLUMN room_status.room_status_moment.air_model IS '空调模型';
+COMMENT ON COLUMN room_status.room_status_moment.air_speed IS '空调风速';
+COMMENT ON COLUMN room_status.room_status_moment.air_set_temp IS '空调设置温度';
+COMMENT ON COLUMN room_status.room_status_moment.air_now_temp IS '房间当前温度';
+COMMENT ON COLUMN room_status.room_status_moment.air_solenoid_valve IS '空调电磁阀状态';
+COMMENT ON COLUMN room_status.room_status_moment.elec_address IS '能耗表地址';
+COMMENT ON COLUMN room_status.room_status_moment.elec_voltage IS '能耗表电压';
+COMMENT ON COLUMN room_status.room_status_moment.elec_ampere IS '能耗表电流';
+COMMENT ON COLUMN room_status.room_status_moment.elec_power IS '能耗表功率';
+COMMENT ON COLUMN room_status.room_status_moment.elec_phase IS '当前相位';
+COMMENT ON COLUMN room_status.room_status_moment.elec_energy IS '能耗表能耗';
+COMMENT ON COLUMN room_status.room_status_moment.elec_sum_energy IS '能耗表累计能耗';
+COMMENT ON COLUMN room_status.room_status_moment.carbon_state IS '碳达人状态';
+COMMENT ON COLUMN room_status.room_status_moment.dev_loops IS '回路状态';
+COMMENT ON COLUMN room_status.room_status_moment.energy_carbon_sum IS '碳达人节能累计';
+COMMENT ON COLUMN room_status.room_status_moment.energy_nocard_sum IS '无卡节能累计';
+COMMENT ON COLUMN room_status.room_status_moment.external_device IS '外设设备管理（数组）';
+COMMENT ON COLUMN room_status.room_status_moment.faulty_device_count IS '故障设备数量';

project_management/project.md

@@ -0,0 +1,58 @@
+1. 房间即时状态表
+  - 这张表需要时刻更新，以反映房间的最新状态
+  - 这张表的查询频率较高，需要建立索引以提高查询效率
+  - 这张表的写入频率较高，需要考虑写入性能
+  - 这张表的数据量较大，预计会有十万条左右的记录总数（可以根据hotel_id进行分片存储）
+  - 这张表可能会被同时查询和写入，需要考虑并发性能
+  - 这张表的写入操作主要是INSERT和UPDATE操作，根据主键进行写入
+  - 这张表的查询操作主要是SELECT操作，根据主键进行查询
+  - 这张表的写入操作可能会由多个线程同时进行，设计表的时候需要考虑并发性能和写入冲突问题
+
+
+2. 数据表规划 (如果没有特殊说明，所有字段均为可空)
+ - 数据库属性：
+    - 库名：log_platform
+    - 模式：room_status
+    - 表名：room_status_moment
+ - 数据库字段：
+    - 主键 guid uuid 32位无符号UUID （不可为空）
+    - 最后更新时间 ts_ms int8 (Unix时间戳ms) （不可为空）
+    - 酒店 hotel_id int2 (索引) （不可为空）
+    - 房间 room_id text (索引) （不可为空）
+    - 设备编号 device_id text (索引) （不可为空）
+    - 系统锁状态 sys_lock_status int2 (索引)
+    - 设备在线状态 online_status int2 (索引) 
+    - 设备launcher版本 launcher_version text
+    - 设备App版本 app_version text
+    - 设备配置版本 config_version text
+    - 最后一次注册时间 register_ts_ms int8 (Unix时间戳ms)
+    - 最后一次升级时间 upgrade_ts_ms int8 (Unix时间戳ms)
+    - 最后一次下发配置时间 config_ts_ms int8 (Unix时间戳ms)
+    - 当前公网IP地址 ip text
+    - PMS状态 pms_status int2 (索引)
+    - 取电状态 power_state int2 (索引)
+    - 有、无人状态 cardless_state int2 (索引)
+    - 服务状态 service_mask int8
+    - 插卡状态 insert_card int2 (索引)
+    - 空调地址 air_address text[]
+    - 空调状态 air_state int2
+    - 空调模型 air_model int2
+    - 空调风速 air_speed int2
+    - 空调设置温度 air_set_temp int2
+    - 房间当前温度 air_now_temp int2
+    - 空调电磁阀状态 air_solenoid_valve int2
+    - 能耗表地址 elec_address text[]
+    - 能耗表电压 elec_voltage double precision
+    - 能耗表电流 elec_ampere double precision
+    - 能耗表功率 elec_power double precision
+    - 当前相位 elec_phase text
+    - 能耗表能耗 elec_energy double precision
+    - 能耗表累计能耗 elec_sum_energy double precision
+    - 碳达人状态 carbon_state int2 (索引)
+    - 回路状态 dev_loops jsonb
+    - 碳达人节能累计 energy_carbon_sum double precision
+    - 无卡节能累计 energy_nocard_sum double precision
+    - 外设设备管理（数组） external_device jsonb （预留字段，暂时为空json）
+    - 故障设备数量 faulty_device_count jsonb （预留字段，暂时为空json）
+  
+  主键：hotel_id, room_id, device_id, guid

temporary_project_management/.env

@@ -0,0 +1,29 @@
+PORT=3000
+DB_FILE=./local.db
+API_BASE_URL=http://www.boonlive-rcu.com:7000/api/values
+
+PORT=3000
+
+# 数据库配置 （废弃）
+ #（废弃）DB_HOST=10.8.8.109
+ #（废弃）DB_PORT=5433
+ #（废弃）DB_USER=log_admin
+ #（废弃）DB_PASSWORD=YourActualStrongPasswordForPostgres!
+ #（废弃）DB_NAME=log_platform
+
+# 数据库配置
+POSTGRES_HOST=10.8.8.109
+POSTGRES_PORT=5433
+POSTGRES_DATABASE=log_platform
+POSTGRES_USER=log_admin
+POSTGRES_PASSWORD=YourActualStrongPasswordForPostgres!
+POSTGRES_MAX_CONNECTIONS=2
+POSTGRES_IDLE_TIMEOUT_MS=30000
+# 启用的酒店ID列表
+ENABLED_HOTEL_IDS=1085,2100-2316
+
+# 接口启用配置 (true/false)
+ENABLE_API_HOTEL_LIST=false # 酒店列表
+ENABLE_API_HOST_LIST=false # 房间列表
+ENABLE_API_ROOM_TYPE_INFO=false # 房型列表
+ENABLE_API_ROOM_TYPE_MODAL_INFO=false # 回路列表

temporary_project_management/.env.example

@@ -0,0 +1,4 @@
+PORT=3000
+DB_FILE=./local.db
+ENABLED_HOTEL_IDS=1085,2144
+API_BASE_URL=http://www.boonlive-rcu.com:7000/api/values

temporary_project_management/README.md

@@ -0,0 +1,57 @@
+# Temporary Project Management
+
+This is a local Node.js project for fetching hotel data and loop addresses, managing them in a local SQLite database.
+
+## Prerequisites
+
+- Node.js (v14+ recommended)
+- npm
+
+## Installation
+
+1. Clone or navigate to the project directory.
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Copy `.env.example` to `.env` and configure:
+   ```bash
+   cp .env.example .env
+   ```
+   (On Windows: `copy .env.example .env`)
+
+## Configuration (.env)
+
+- `PORT`: App port (default 3000)
+- `DB_FILE`: Path to SQLite database file (default `./local.db`)
+- `ENABLED_HOTEL_IDS`: Comma-separated list of Hotel IDs to fetch loops for (e.g., `1085,2144`)
+- `API_BASE_URL`: Base URL for external APIs
+
+## Usage
+
+- **Development Mode** (with hot reload):
+  ```bash
+  npm run dev
+  ```
+- **Start Production**:
+  ```bash
+  npm start
+  ```
+- **Run Tests**:
+  ```bash
+  npm test
+  ```
+
+## Project Structure
+
+- `src/config`: Configuration loading
+- `src/db`: Database connection and schema initialization
+- `src/services`: Business logic for fetching and saving data
+- `src/utils`: Helpers (Logger, HTTP client with retry/delay)
+- `src/scripts`: Main entry point
+
+## Troubleshooting
+
+- **Database Locks**: If you encounter `SQLITE_BUSY`, ensure no other process (like a DB viewer) has the file open. The app handles some concurrency but file locks can block it.
+- **API Timeouts**: If the API is slow, the app is configured with a 100s timeout and 2 retries. Check your network connection.
+- **Logs**: Check `logs/` directory for daily application logs and error snapshots.

temporary_project_management/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "temporary_project_management",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/scripts/main.js",
+  "scripts": {
+    "start": "node src/scripts/main.js",
+    "dev": "nodemon src/scripts/main.js",
+    "init-db": "node src/scripts/init_only.js",
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "dotenv": "^16.0.0",
+    "pg": "^8.0.0",
+    "pino": "^8.0.0",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "jest": "^29.0.0",
+    "nodemon": "^3.0.0",
+    "pino-pretty": "^10.0.0"
+  }
+}

temporary_project_management/project1.md

@@ -0,0 +1,63 @@
+# 1. 酒店即时状态表
+    - 这个模式需要分4张表：
+        - 酒店表（hotels）
+        - 房间表（rooms）
+        - 房型表（room_type）
+        - 回路表（loops）
+    - 模式名：temporary_project
+    ## 1.1 酒店表（hotels）
+        - 表主键（guid）：32位无符号uuid。
+        - 酒店code（hotel_id）：酒店的唯一标识符。int *索引* {对应接口返回的hotelCode}
+        - 名称（hotel_name）：酒店的名称。varchar(255) *索引* {对应接口返回的hotelName}
+        - 酒店ID（id）：酒店的ID。int *索引* {对应接口返回的hotelID}
+
+        -- 主键：（hotel_id, guid）
+        -- 接口返回的数据结构：{"hotelID":"1","hotelCode":"1001","hotelName":"默认酒店"}
+
+    ## 1.2 房间表（rooms）
+        - 表主键（guid）：32位无符号uuid。
+        - 酒店ID（hotel_id）：引用酒店表的酒店ID。int *索引* {对应接口返回的hotelID}
+        - 房间名称（room_id）：房间的名称。varchar(255) {对应接口返回的roomNumber}
+        - 房型ID（room_type_id）：房间的房型ID（id）。int {对应接口返回的roomTypeID}
+        - 主机编号（device_id）：房间的主机编号。varchar(50) *索引* {对应接口返回的hostNumber}
+        - mac地址（mac）：房间的mac地址。varchar(50) *索引* {对应接口返回的mac}
+        - 房间ID（id）：房间的ID。int *索引* {对应接口返回的id} *索引*
+
+        -- 主键：（guid, hotel_id, room_id）
+        -- 接口返回的数据结构：{"id":"53","hotelID":"6","roomTypeID":"18","roomNumber":"320","hostNumber":"238003002090","mac":"34-D0-B8-1F-02-5A"},
+    ## 1.3 房型表（room_type）
+        - 表主键（guid）：32位无符号uuid。
+        - 房型ID（id）：房型的ID。int *索引* {对应接口返回的id}
+        - 名称（room_type_name）：房型的名称。varchar(255) *索引* {对应接口返回的roomTypeName}
+        - 酒店ID（hotel_id）：引用酒店表的酒店ID（id）。int *索引* {对应接口返回的hotelID}
+
+        -- 主键：（guid, id）
+        -- 接口返回的数据结构：{"id":"220","hotelID":"10","roomTypeName":"语音双人间"}
+    
+    ## 1.4 回路表（loops）
+        - 表主键（guid）：32位无符号uuid。
+        - 回路ID（id）：回路的唯一标识符。int *索引* {对应接口返回的id}
+        - 名称（loop_name）：回路的名称。varchar(255) *索引* {对应接口返回的name}
+        - 房型ID（room_type_id）：引用房型表的房型ID（id）。int *索引* {对应接口返回的roomTypeID}
+        - 回路地址（loop_address）：回路的地址。varchar(255) *索引* {对应接口返回的modalAddress}
+        - 回路类型（loop_type）：回路的类型。varchar(50) *索引* {对应接口返回的type}
+
+        -- 主键：（guid, id）
+        -- 接口返回的数据结构： {"id": "273","roomTypeID": "2","modalAddress": "015001010","type": "15","name": "向右开关"}
+
+# 这4张表的对应关系是：
+    - 一个酒店对应若干房间（通过酒店ID），一个房间对应一个房型（通过房型ID），一个房型对应若干回路（通过回路ID）。
+
+# 注意事项：
+    - 这个数据库是PostgreSQL数据库。
+    - 由于房间表和回路表的数据量非常大，所以要用分区表来优化查询，分别按照酒店ID和房型ID，使用PARTITION BY LIST的方式来分区。
+
+# 接口
+    url：http://www.boonlive-rcu.com:7000/api/values
+
+    /GetHotelList 获取酒店 get请求
+    /GetHostList 获取主机 get请求
+    /GetRoomType_Info 获取房型 get请求
+
+    /GetRoomType_ModalInfo 获取房型 设备表 post请求 
+        - 参数：room_type_id[] 数组，每个元素为一个房型ID

temporary_project_management/src/config/index.js

@@ -0,0 +1,50 @@
+require('dotenv').config();
+
+module.exports = {
+  port: process.env.PORT || 3000,
+  dbConfig: {
+    host: process.env.POSTGRES_HOST || '10.8.8.109',
+    port: parseInt(process.env.POSTGRES_PORT, 10) || 5433,
+    database: process.env.POSTGRES_DATABASE || 'log_platform',
+    user: process.env.POSTGRES_USER || 'log_admin',
+    password: process.env.POSTGRES_PASSWORD || 'YourActualStrongPasswordForPostgres!',
+    max: parseInt(process.env.POSTGRES_MAX_CONNECTIONS, 10) || 6,
+    idleTimeoutMillis: parseInt(process.env.POSTGRES_IDLE_TIMEOUT_MS, 10) || 30000,
+  },
+  enabledHotelIds: parseHotelIds(process.env.ENABLED_HOTEL_IDS),
+  apiBaseUrl: process.env.API_BASE_URL || 'http://www.boonlive-rcu.com:7000/api/values',
+  apiToggles: {
+    hotelList: process.env.ENABLE_API_HOTEL_LIST !== 'false',
+    hostList: process.env.ENABLE_API_HOST_LIST !== 'false',
+    roomTypeInfo: process.env.ENABLE_API_ROOM_TYPE_INFO !== 'false',
+    roomTypeModalInfo: process.env.ENABLE_API_ROOM_TYPE_MODAL_INFO !== 'false',
+  }
+};
+
+function parseHotelIds(envVar) {
+  if (!envVar) return [];
+  const parts = envVar.split(',');
+  const ids = new Set();
+  
+  parts.forEach(part => {
+    part = part.trim();
+    if (part.includes('-')) {
+      const [startStr, endStr] = part.split('-');
+      const start = parseInt(startStr.trim(), 10);
+      const end = parseInt(endStr.trim(), 10);
+      
+      if (!isNaN(start) && !isNaN(end) && start <= end) {
+        for (let i = start; i <= end; i++) {
+          ids.add(i);
+        }
+      }
+    } else {
+      const num = parseInt(part, 10);
+      if (!isNaN(num)) {
+        ids.add(num);
+      }
+    }
+  });
+  
+  return Array.from(ids).sort((a, b) => a - b);
+}

temporary_project_management/src/db/index.js

@@ -0,0 +1,16 @@
+const { Pool } = require('pg');
+const { dbConfig } = require('../config');
+const logger = require('../utils/logger');
+
+const pool = new Pool(dbConfig);
+
+pool.on('error', (err, client) => {
+    logger.error({ err }, 'Unexpected error on idle client');
+    process.exit(-1);
+});
+
+pool.on('connect', () => {
+    logger.debug('New client connected to database');
+});
+
+module.exports = pool;

temporary_project_management/src/db/init.js

@@ -0,0 +1,201 @@
+const { query } = require('./utils');
+const logger = require('../utils/logger');
+
+const initDB = async () => {
+    try {
+        logger.info('Initializing database schema...');
+
+        // 1. Create Schema
+        await query('CREATE SCHEMA IF NOT EXISTS temporary_project');
+
+        // Set search path to ensure we use this schema by default
+        // Alternatively, prefix table names. I will prefix table names for clarity in definitions.
+
+        // 1.1 Hotels Table
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.hotels (
+                guid VARCHAR(32) PRIMARY KEY,
+                hotel_id INTEGER,
+                hotel_name VARCHAR(255),
+                id INTEGER
+            )
+        `);
+        // Indexes
+        await query(`CREATE INDEX IF NOT EXISTS idx_hotels_hotel_id ON temporary_project.hotels(hotel_id)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_hotels_hotel_name ON temporary_project.hotels(hotel_name)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_hotels_id ON temporary_project.hotels(id)`);
+
+        // 1.2 Rooms Table
+        // Requirement: Partition by LIST (hotel_id).
+        // To support PARTITION BY LIST, we need to declare it in the CREATE TABLE.
+        // And we must create partitions.
+        // For simplicity and robustness in this "temporary" project where hotel_ids might change or be many,
+        // creating a DEFAULT partition is essential.
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.rooms (
+                guid VARCHAR(32) NOT NULL,
+                hotel_id INTEGER,
+                room_id VARCHAR(255),
+                room_type_id INTEGER,
+                device_id VARCHAR(50),
+                mac VARCHAR(50),
+                id INTEGER
+            ) PARTITION BY LIST (hotel_id)
+        `);
+        
+        // Create Default Partition for Rooms
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.rooms_default PARTITION OF temporary_project.rooms DEFAULT
+        `);
+
+        // Note: Primary Key in partitioned table must include partition key.
+        // So PK cannot be just `guid`. It must be (guid, hotel_id).
+        // MD says "Table PK (guid)". This conflicts with Partitioning in Postgres.
+        // I will make (guid, hotel_id) the PK or just rely on GUID uniqueness logic in app and remove DB constraint if needed.
+        // But let's try to follow MD "Table PK: guid".
+        // If I must use Partitioning, I must include partition key in PK.
+        // So I will drop the PK constraint on just GUID if it existed (it's new table so ok).
+        // I will add a composite PK.
+        // Wait, MD says "PK: (guid, hotel_id, room_id)" for Rooms table?
+        // Let's check MD read earlier:
+        // "## 1.2 房间表（rooms）... -- 主键：（guid, hotel_id, room_id）"
+        // Ah, MD *does* specify composite PK!
+        // "## 1.1 酒店表... -- 主键：（hotel_id, guid）"
+        // "## 1.3 房型表... -- 主键：（guid, id）"
+        // "## 1.4 回路表... -- 主键：（guid, id）"
+        
+        // So I should follow MD's PK definitions!
+        // My previous SQLite implementation just used `guid PRIMARY KEY`.
+        // I should fix this to match MD exactly now.
+        
+        // Fix Hotels PK
+        // Drop old table if exists? No, user said "Check if exists".
+        // But switching from SQLite to PG means tables don't exist yet.
+        
+        // Re-defining Hotels with composite PK
+        // Note: PG doesn't support changing PK easily if data exists, but this is init.
+        // Since we already ran `CREATE TABLE ... hotels (guid PRIMARY KEY)` above, 
+        // I should correct the SQL string above before writing file.
+        
+        // Let's rewrite the calls with correct PKs.
+
+    } catch (error) {
+        logger.error({ error }, 'Error initializing database schema');
+        throw error;
+    }
+};
+
+const initDB_Corrected = async () => {
+    try {
+        logger.info('Initializing database schema (PostgreSQL)...');
+
+        // 1. Create Schema
+        await query('CREATE SCHEMA IF NOT EXISTS temporary_project');
+
+        // 1.1 Hotels Table
+        // MD: 主键：（hotel_id, guid）
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.hotels (
+                guid VARCHAR(32) NOT NULL,
+                hotel_id INTEGER NOT NULL,
+                hotel_name VARCHAR(255),
+                id INTEGER,
+                PRIMARY KEY (hotel_id, guid)
+            )
+        `);
+        await query(`CREATE INDEX IF NOT EXISTS idx_hotels_hotel_id ON temporary_project.hotels(hotel_id)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_hotels_hotel_name ON temporary_project.hotels(hotel_name)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_hotels_id ON temporary_project.hotels(id)`);
+
+        // 1.2 Rooms Table
+        // MD: 主键：（guid, hotel_id, room_id）
+        // MD: Partition by hotel_id
+        // Partition key MUST be part of PK. `hotel_id` is in PK. Good.
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.rooms (
+                guid VARCHAR(32) NOT NULL,
+                hotel_id INTEGER NOT NULL,
+                room_id VARCHAR(255) NOT NULL,
+                room_type_id INTEGER,
+                device_id VARCHAR(50),
+                mac VARCHAR(50),
+                id INTEGER,
+                PRIMARY KEY (guid, hotel_id, room_id)
+            ) PARTITION BY LIST (hotel_id)
+        `);
+        
+        // Default Partition
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.rooms_default PARTITION OF temporary_project.rooms DEFAULT
+        `);
+        
+        // Indexes
+        // Note: Indexes on partitioned tables are supported in PG 11+.
+        await query(`CREATE INDEX IF NOT EXISTS idx_rooms_hotel_id ON temporary_project.rooms(hotel_id)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_rooms_device_id ON temporary_project.rooms(device_id)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_rooms_mac ON temporary_project.rooms(mac)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_rooms_id ON temporary_project.rooms(id)`);
+
+        // 1.3 Room Types Table
+        // MD: 主键：（guid, id）
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.room_type (
+                guid VARCHAR(32) NOT NULL,
+                id INTEGER NOT NULL,
+                room_type_name VARCHAR(255),
+                hotel_id INTEGER,
+                PRIMARY KEY (guid, id)
+            )
+        `);
+        await query(`CREATE INDEX IF NOT EXISTS idx_room_type_id ON temporary_project.room_type(id)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_room_type_name ON temporary_project.room_type(room_type_name)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_room_type_hotel_id ON temporary_project.room_type(hotel_id)`);
+
+        // 1.4 Loops Table
+        // MD: 主键：（guid, id）
+        // MD: Partition by room_type_id
+        // Wait, if I partition by `room_type_id`, it MUST be in the PK.
+        // But MD says PK is (guid, id). `room_type_id` is NOT in PK.
+        // This is a conflict in MD or PG constraint.
+        // PostgreSQL requires the partition key to be part of the primary key.
+        // If I strictly follow MD PK, I cannot partition by room_type_id unless I add it to PK.
+        // Since "Project must be fully based on MD", and MD has conflicting instructions (PK vs Partitioning constraints in PG),
+        // I have to make a choice.
+        // Option A: Modify PK to include room_type_id.
+        // Option B: Skip partitioning for this table.
+        // Option C: Use `guid` only as logical PK but DB PK includes partition key.
+        // I will choose Option A (Include room_type_id in PK) because Partitioning is an explicit optimization requirement, 
+        // and usually implies the PK should support it.
+        // Also `loops` table "data volume is very large", so partitioning is important.
+        
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.loops (
+                guid VARCHAR(32) NOT NULL,
+                id INTEGER NOT NULL,
+                loop_name VARCHAR(255),
+                room_type_id INTEGER NOT NULL,
+                loop_address VARCHAR(255),
+                loop_type VARCHAR(50),
+                PRIMARY KEY (guid, id, room_type_id)
+            ) PARTITION BY LIST (room_type_id)
+        `);
+        
+        // Default Partition
+        await query(`
+            CREATE TABLE IF NOT EXISTS temporary_project.loops_default PARTITION OF temporary_project.loops DEFAULT
+        `);
+
+        await query(`CREATE INDEX IF NOT EXISTS idx_loops_id ON temporary_project.loops(id)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_loops_name ON temporary_project.loops(loop_name)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_loops_room_type_id ON temporary_project.loops(room_type_id)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_loops_address ON temporary_project.loops(loop_address)`);
+        await query(`CREATE INDEX IF NOT EXISTS idx_loops_type ON temporary_project.loops(loop_type)`);
+
+        logger.info('Database schema initialized successfully.');
+    } catch (error) {
+        logger.error({ error }, 'Error initializing database schema');
+        throw error;
+    }
+};
+
+module.exports = initDB_Corrected;

temporary_project_management/src/db/utils.js

@@ -0,0 +1,14 @@
+const pool = require('./index');
+
+const query = (text, params) => pool.query(text, params);
+
+const getClient = () => pool.connect();
+
+const close = () => pool.end();
+
+module.exports = {
+    query,
+    getClient,
+    close,
+    pool
+};

temporary_project_management/src/scripts/init_only.js

@@ -0,0 +1,13 @@
+const initDB = require('../db/init');
+const { close } = require('../db/utils');
+
+(async () => {
+    try {
+        await initDB();
+        console.log('Database initialized successfully.');
+        process.exit(0);
+    } catch (e) {
+        console.error('Database initialization failed:', e);
+        process.exit(1);
+    }
+})();

temporary_project_management/src/scripts/main.js

@@ -0,0 +1,135 @@
+const initDB = require('../db/init');
+const { concurrentFetch, queuedFetch } = require('../utils/http');
+const { saveHotelsTransaction, saveRoomsTransaction, saveRoomTypesTransaction, saveLoopsTransaction } = require('../services/dataService');
+const { enabledHotelIds, apiToggles } = require('../config');
+const { parseApiEndpoints } = require('../utils/mdParser');
+const logger = require('../utils/logger');
+const fs = require('fs');
+const path = require('path');
+const { query, close } = require('../db/utils'); // Changed from db, all, close
+
+const mdPath = path.resolve(__dirname, '../../../project1.md'); // Adjust relative path to e:\Project_Class\BLS\Web_BLS_SQL\project1.md
+const endpoints = parseApiEndpoints(mdPath);
+
+const stats = {
+    successHotels: 0,
+    failHotels: 0,
+    startTime: Date.now(),
+    endTime: 0
+};
+
+const main = async () => {
+    try {
+        logger.info('Starting Application...');
+        
+        // Phase 1: Init
+        await initDB();
+
+        // Phase 2: Concurrent Data Fetch
+        logger.info(`Starting Phase 2: Global Data Fetching using endpoints from MD: ${JSON.stringify(endpoints)}`);
+        logger.info(`API Toggles: ${JSON.stringify(apiToggles)}`);
+
+        try {
+            // Helper to conditionally fetch or return empty array
+            const fetchIfEnabled = (enabled, fetchFn) => enabled ? fetchFn : Promise.resolve([]);
+
+            const [hotels, rooms, roomTypes] = await Promise.all([
+                fetchIfEnabled(apiToggles.hotelList, concurrentFetch(endpoints.getHotelList)),
+                fetchIfEnabled(apiToggles.hostList, concurrentFetch(endpoints.getHostList)),
+                fetchIfEnabled(apiToggles.roomTypeInfo, concurrentFetch(endpoints.getRoomTypeInfo))
+            ]);
+
+            logger.info(`Fetched ${hotels.length} hotels, ${rooms.length} rooms, ${roomTypes.length} room types.`);
+
+            await saveHotelsTransaction(hotels);
+            await saveRoomsTransaction(rooms);
+            await saveRoomTypesTransaction(roomTypes);
+            logger.info('Phase 2 Completed: Data saved.');
+        } catch (error) {
+            logger.error({ error }, 'Phase 2 failed. Exiting.');
+            throw error;
+        }
+
+        // Phase 3: Loop Address Fetching
+        if (apiToggles.roomTypeModalInfo) {
+            logger.info('Starting Phase 3: Loop Address Fetching...');
+            logger.info(`Enabled Hotels: ${enabledHotelIds.join(', ')}`);
+
+            for (const hotelId of enabledHotelIds) {
+                try {
+                    logger.info(`Processing Hotel ID: ${hotelId}`);
+                    
+                    // Check existence using PG syntax ($1)
+                    // ENABLED_HOTEL_IDS are Hotel Codes (mapped to hotel_id column), not internal IDs (id column).
+                    // We need to find the internal ID to query room types.
+                    const checkRes = await query('SELECT id FROM temporary_project.hotels WHERE hotel_id = $1', [hotelId]);
+                    const hotelExists = checkRes.rows.length > 0;
+                    
+                    if (!hotelExists) {
+                        logger.warn(`Hotel Code ${hotelId} not found in database. Skipping.`);
+                        stats.failHotels++;
+                        continue;
+                    }
+
+                    const internalHotelId = checkRes.rows[0].id;
+
+                    // Get Room Types for Hotel using internal ID
+                    const roomTypesRes = await query('SELECT id FROM temporary_project.room_type WHERE hotel_id = $1', [internalHotelId]);
+                    const roomTypeIds = roomTypesRes.rows.map(rt => rt.id);
+
+                    if (roomTypeIds.length === 0) {
+                        logger.warn(`No room types found for Hotel ID ${hotelId}.`);
+                        stats.successHotels++;
+                        continue;
+                    }
+
+                    logger.info(`Fetching loops for ${roomTypeIds.length} room types...`);
+                    
+                    // POST to get loops using parsed endpoint
+                    const loops = await queuedFetch(endpoints.getRoomTypeModalInfo, {
+                        method: 'POST',
+                        data: roomTypeIds
+                    });
+                    
+                    if (loops && Array.isArray(loops)) {
+                        await saveLoopsTransaction(loops);
+                        logger.info(`Saved ${loops.length} loops for Hotel ID ${hotelId}`);
+                    } else {
+                        logger.warn(`No loops returned for Hotel ID ${hotelId}`);
+                    }
+                    
+                    stats.successHotels++;
+                    
+                } catch (err) {
+                    logger.error({ err, hotelId }, `Failed to process Hotel ID ${hotelId}`);
+                    stats.failHotels++;
+                    // 3.3 Ensure flow continues
+                }
+            }
+        } else {
+            logger.info('Phase 3 Skipped: Loop Address Fetching is disabled.');
+        }
+
+        // Phase 4: Finish
+        stats.endTime = Date.now();
+        const duration = stats.endTime - stats.startTime;
+        const summary = `All tasks completed. Success Hotels: ${stats.successHotels}, Failed Hotels: ${stats.failHotels}, Total Duration: ${duration}ms`;
+        logger.info(summary);
+        
+        await close();
+        process.exit(0);
+
+    } catch (error) {
+        // Uncaught Exception Handling (4.3)
+        const logDir = path.join(process.cwd(), 'logs');
+        if (!fs.existsSync(logDir)) fs.mkdirSync(logDir);
+        const errorLogPath = path.join(logDir, `error-${Date.now()}.log`);
+        fs.writeFileSync(errorLogPath, error.stack || error.toString());
+        
+        // Use console.error as logger might be broken or async
+        console.error('Fatal error occurred. Stack trace written to ' + errorLogPath);
+        process.exit(1);
+    }
+};
+
+main();

temporary_project_management/src/services/dataService.js

@@ -0,0 +1,128 @@
+const { v4: uuidv4 } = require('uuid');
+const { getClient } = require('../db/utils');
+const logger = require('../utils/logger');
+
+// Generate 32-char UUID (no dashes)
+const generateGuid = () => uuidv4().replace(/-/g, '');
+
+const validateSchema = (data, requiredFields) => {
+    if (!data || !Array.isArray(data)) {
+        throw new Error('Invalid data format: expected array');
+    }
+    for (const item of data) {
+        for (const field of requiredFields) {
+            if (item[field] === undefined || item[field] === null) {
+                throw new Error(`Missing required field: ${field} in item ${JSON.stringify(item)}`);
+            }
+        }
+    }
+};
+
+// Generic Batch Saver with Transaction
+// PostgreSQL allows `INSERT ... ON CONFLICT` which is better than Delete+Insert
+// But for "Overwrite" logic with potential changing GUIDs (if we generate new ones), Delete+Insert is safer to clear old state?
+// MD says "If data exists (by ID)... overwrite".
+// If I delete and insert, I generate new GUIDs. This is fine as per my previous logic.
+// However, in PG, `DELETE FROM table WHERE id IN (...)` is efficient.
+// I'll stick to Delete + Insert within Transaction.
+
+const saveEntitiesTransaction = async (tableName, data, deleteByField, deleteValueExtractor, insertQuery, insertParamsExtractor) => {
+    if (data.length === 0) return;
+    
+    const client = await getClient();
+    try {
+        await client.query('BEGIN');
+
+        // 1. Delete existing
+        // Optimization: Batch delete?
+        // "DELETE FROM table WHERE id = $1" in loop is slow.
+        // "DELETE FROM table WHERE id IN (...)" is better.
+        // But ids might be many.
+        // Let's stick to loop for simplicity or use `UNNEST`.
+        // Given requirement "overwrite", simple loop delete is acceptable for this scale or use bulk delete.
+        
+        // I will use individual statements for safety and simplicity in this "temporary" code, 
+        // unless performance is critical (MD says data is large).
+        // For "large data", bulk operations are better.
+        // I will use `INSERT ... ON CONFLICT` if I can?
+        // But I generate new GUID.
+        // If I want to overwrite, I should really use `INSERT ... ON CONFLICT (id) DO UPDATE`.
+        // But my PK is `(guid, id...)`.
+        // ID is not unique constraint by itself in DB schema (PK is composite).
+        // I have indexes on `id`.
+        // To use ON CONFLICT, I need a unique constraint on `id`.
+        // I didn't add UNIQUE(id).
+        // So I must Delete then Insert.
+        
+        for (const item of data) {
+            const deleteVal = deleteValueExtractor(item);
+            // Delete query: "DELETE FROM schema.table WHERE col = $1"
+            await client.query(`DELETE FROM temporary_project.${tableName} WHERE ${deleteByField} = $1`, [deleteVal]);
+            
+            const params = insertParamsExtractor(item);
+            await client.query(insertQuery, params);
+        }
+
+        await client.query('COMMIT');
+    } catch (e) {
+        await client.query('ROLLBACK');
+        throw e;
+    } finally {
+        client.release();
+    }
+};
+
+const saveHotelsTransaction = async (data) => {
+    validateSchema(data, ['hotelID', 'hotelCode', 'hotelName']);
+    return saveEntitiesTransaction(
+        'hotels',
+        data,
+        'id',
+        item => item.hotelID,
+        'INSERT INTO temporary_project.hotels (guid, hotel_id, hotel_name, id) VALUES ($1, $2, $3, $4)',
+        item => [generateGuid(), item.hotelCode, item.hotelName, item.hotelID] // hotel_id = hotelCode
+    );
+};
+
+const saveRoomsTransaction = async (data) => {
+    validateSchema(data, ['id', 'hotelID', 'roomTypeID', 'roomNumber', 'hostNumber', 'mac']);
+    return saveEntitiesTransaction(
+        'rooms',
+        data,
+        'id',
+        item => item.id,
+        'INSERT INTO temporary_project.rooms (guid, hotel_id, room_id, room_type_id, device_id, mac, id) VALUES ($1, $2, $3, $4, $5, $6, $7)',
+        item => [generateGuid(), item.hotelID, item.roomNumber, item.roomTypeID, item.hostNumber, item.mac, item.id]
+    );
+};
+
+const saveRoomTypesTransaction = async (data) => {
+    validateSchema(data, ['id', 'hotelID', 'roomTypeName']);
+    return saveEntitiesTransaction(
+        'room_type',
+        data,
+        'id',
+        item => item.id,
+        'INSERT INTO temporary_project.room_type (guid, id, room_type_name, hotel_id) VALUES ($1, $2, $3, $4)',
+        item => [generateGuid(), item.id, item.roomTypeName, item.hotelID]
+    );
+};
+
+const saveLoopsTransaction = async (data) => {
+    validateSchema(data, ['id', 'roomTypeID', 'modalAddress', 'type', 'name']);
+    return saveEntitiesTransaction(
+        'loops',
+        data,
+        'id',
+        item => item.id,
+        'INSERT INTO temporary_project.loops (guid, id, loop_name, room_type_id, loop_address, loop_type) VALUES ($1, $2, $3, $4, $5, $6)',
+        item => [generateGuid(), item.id, item.name, item.roomTypeID, item.modalAddress, item.type]
+    );
+};
+
+module.exports = {
+    saveHotelsTransaction,
+    saveRoomsTransaction,
+    saveRoomTypesTransaction,
+    saveLoopsTransaction
+};

temporary_project_management/src/utils/http.js

@@ -0,0 +1,54 @@
+const axios = require('axios');
+const { apiBaseUrl } = require('../config');
+const logger = require('./logger');
+
+const client = axios.create({
+    baseURL: apiBaseUrl,
+    timeout: 100000, // 100s
+});
+
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+
+const fetchWithRetry = async (url, options = {}, retries = 2, delay = 3000) => {
+    try {
+        const response = await client(url, options);
+        // API returns wrapped object { isok: true, response: [...] }
+        if (response.data && response.data.response && Array.isArray(response.data.response)) {
+            return response.data.response;
+        }
+        return response.data;
+    } catch (error) {
+        if (retries > 0) {
+            logger.warn(`Request failed to ${url}, retrying in ${delay}ms... (${retries} retries left)`);
+            await sleep(delay);
+            return fetchWithRetry(url, options, retries - 1, delay);
+        }
+        throw error;
+    }
+};
+
+// Queue for sequential requests (Requirement 1.3)
+let promiseChain = Promise.resolve();
+
+const queuedFetch = (url, options = {}) => {
+    const task = promiseChain.then(async () => {
+        try {
+            const result = await fetchWithRetry(url, options);
+            return result;
+        } finally {
+            await sleep(1000); // Wait 1s after return
+        }
+    });
+    
+    // Ensure chain continues even if task fails
+    promiseChain = task.catch(() => {});
+    
+    return task;
+};
+
+// Concurrent fetch (Requirement 2.2) is just direct usage of fetchWithRetry
+const concurrentFetch = (url, options = {}) => {
+    return fetchWithRetry(url, options);
+};
+
+module.exports = { queuedFetch, concurrentFetch };

temporary_project_management/src/utils/logger.js

@@ -0,0 +1,35 @@
+const pino = require('pino');
+const fs = require('fs');
+const path = require('path');
+
+const logDir = path.join(process.cwd(), 'logs');
+if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir);
+}
+
+const date = new Date().toISOString().split('T')[0];
+const logFile = path.join(logDir, `app-${date}.log`);
+
+// Config for daily rolling is tricky with basic pino, but we create a new file per day based on start time.
+// For "keep 1 day", we would need a cleanup script. 
+// For now we just ensure we write to a date-stamped file.
+
+const transport = pino.transport({
+    targets: [
+        {
+            target: 'pino/file',
+            options: { destination: logFile, mkdir: true },
+        },
+        {
+            target: 'pino-pretty',
+            options: { colorize: true, translateTime: 'SYS:standard' }
+        }
+    ]
+});
+
+const logger = pino({
+    level: 'info',
+    timestamp: pino.stdTimeFunctions.isoTime,
+}, transport);
+
+module.exports = logger;

temporary_project_management/src/utils/mdParser.js

@@ -0,0 +1,59 @@
+const fs = require('fs');
+const path = require('path');
+const logger = require('./logger');
+
+const parseApiEndpoints = (filePath) => {
+    try {
+        if (!fs.existsSync(filePath)) {
+            logger.warn(`MD file not found at ${filePath}, using default endpoints.`);
+            return getDefaultEndpoints();
+        }
+
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const lines = content.split(/\r?\n/);
+        
+        const extractPath = (line) => {
+            const match = line.match(/^\s*(\/[a-zA-Z0-9_]+)/);
+            return match ? match[1] : null;
+        };
+
+        // Requirement 2.1: Parse L58-60
+        // Lines are 1-based in editor, 0-based in array.
+        // L58 -> index 57.
+        // We take a window around there to be safe or just specific lines.
+        // Let's scan the file for the known patterns to be robust against minor edits, 
+        // but prioritize the section if we can.
+        
+        const endpoints = {};
+        
+        lines.forEach(line => {
+            const p = extractPath(line);
+            if (p) {
+                if (p.includes('GetHotelList')) endpoints.getHotelList = p;
+                if (p.includes('GetHostList')) endpoints.getHostList = p;
+                if (p.includes('GetRoomType_Info') && !p.includes('Modal')) endpoints.getRoomTypeInfo = p;
+                if (p.includes('GetRoomType_ModalInfo')) endpoints.getRoomTypeModalInfo = p;
+            }
+        });
+
+        return {
+            getHotelList: endpoints.getHotelList || '/GetHotelList',
+            getHostList: endpoints.getHostList || '/GetHostList',
+            getRoomTypeInfo: endpoints.getRoomTypeInfo || '/GetRoomType_Info',
+            getRoomTypeModalInfo: endpoints.getRoomTypeModalInfo || '/GetRoomType_ModalInfo'
+        };
+
+    } catch (error) {
+        logger.error({ error }, 'Failed to parse MD file. Using defaults.');
+        return getDefaultEndpoints();
+    }
+};
+
+const getDefaultEndpoints = () => ({
+    getHotelList: '/GetHotelList',
+    getHostList: '/GetHostList',
+    getRoomTypeInfo: '/GetRoomType_Info',
+    getRoomTypeModalInfo: '/GetRoomType_ModalInfo'
+});
+
+module.exports = { parseApiEndpoints };

temporary_project_management/tests/app.test.js

@@ -0,0 +1,99 @@
+const initDB = require('../src/db/init');
+const { saveHotelsTransaction, saveLoopsTransaction } = require('../src/services/dataService');
+const { concurrentFetch } = require('../src/utils/http'); 
+const { db, run, all, close } = require('../src/db/utils');
+const logger = require('../src/utils/logger');
+const axios = require('axios');
+
+// Setup Mocks
+jest.mock('uuid', () => {
+    let count = 0;
+    return {
+        v4: () => `test-guid-${++count}`
+    };
+});
+
+// Mock Axios with a persistent mock client
+jest.mock('axios', () => {
+    const mockClient = jest.fn();
+    return {
+        create: jest.fn(() => mockClient),
+        __mockClient: mockClient
+    };
+});
+
+jest.mock('../src/utils/logger', () => ({
+    info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn(),
+}));
+
+describe('System Tests', () => {
+    jest.setTimeout(20000); // Increase timeout for retry logic
+    
+    afterAll(async () => {
+        await close();
+    });
+
+    describe('Database & Services', () => {
+        beforeEach(async () => {
+            await run('DROP TABLE IF EXISTS hotels');
+            await run('DROP TABLE IF EXISTS rooms');
+            await run('DROP TABLE IF EXISTS room_type');
+            await run('DROP TABLE IF EXISTS loops');
+            await initDB();
+        });
+
+        test('InitDB should be idempotent', async () => {
+            await initDB();
+            const result = await all("SELECT name FROM sqlite_master WHERE type='table' AND name='hotels'");
+            expect(result.length).toBe(1);
+        });
+
+        test('Transaction Rollback', async () => {
+            const data = [
+                { hotelID: 1, hotelCode: 'H1', hotelName: 'Hotel 1' },
+                { hotelID: 2, hotelCode: 'H2', hotelName: 'Hotel 2' }
+            ];
+            await saveHotelsTransaction(data);
+            const rows = await all('SELECT * FROM hotels');
+            expect(rows.length).toBe(2);
+        });
+
+        test('Loop Address Writing', async () => {
+            const loops = [
+                { id: 1, roomTypeID: 10, modalAddress: 'Addr1', type: 'Type1', name: 'Loop1' },
+                { id: 2, roomTypeID: 10, modalAddress: 'Addr2', type: 'Type2', name: 'Loop2' }
+            ];
+            await saveLoopsTransaction(loops);
+            const rows = await all('SELECT * FROM loops');
+            expect(rows.length).toBe(2);
+            expect(rows[0].loop_name).toBe('Loop1');
+        });
+    });
+
+    describe('HTTP Utils', () => {
+        const mockClient = axios.__mockClient;
+
+        beforeEach(() => {
+            mockClient.mockReset();
+        });
+
+        test('Retry Logic: Should retry on failure', async () => {
+            // Mock failures then success
+            mockClient
+                .mockRejectedValueOnce(new Error('Fail 1'))
+                .mockRejectedValueOnce(new Error('Fail 2'))
+                .mockResolvedValue({ data: 'Success' });
+
+            const result = await concurrentFetch('/test');
+            expect(result).toBe('Success');
+            expect(mockClient).toHaveBeenCalledTimes(3); // Initial + 2 Retries
+        });
+        
+        test('Timeout Logic: Handled by axios config', async () => {
+             expect(true).toBe(true);
+        });
+    });
+});