业务目标


构建面向数据中心、


运营商机房及


政企


网络的高密度、


模块化光纤


配线单元（


ODF）软件


管理系统。核心目标


包括


：
1.


物理连接数字化管理


实现光纤端口、


纤


芯、熔接


盘及光缆芯


号的精准映射与


全


链路溯源，替代


传统纸质台账。


. **高可靠


运维支撑**：


提供


实时设备状态监控


、异常


告警与自动化


数据同步能力，


降低


人工巡检与调度


错误率。


. **标准化与安全


合规**：严格


遵循通信布线行业标准


（YD


/T 77


68等）


及安全规范，保障


数据机密性、


完整性


与系统环境适应性


。
4


. **可扩展架构


演进


**：采用分层


松


耦合设计，支持


软硬件独立升级、


第三方综合布线系统


对接及海量非


结构化资料


存储。

##


功能清单
|


功能模块 |


核心


功能点 |


对应


软件单元 |


**端口映射管理


** | 端口


唯一编号校验、


映射关系


新增/删除/


更新/查询、


冲突


检测、路由信息


维护 | PM


端口映射管理器


设备状态监控**


| 硬件节点


健康


度轮询、


离线


/故障告警


生成


、环境参数采集


与阈值比对 |


02 设备


监控器 |


| **用户认证


与授权** |


账号登录验证


、RB


AC角色权限控制


、会话


超时管理、操作


审计日志记录 |


UA


用户认证服务


数据同步服务**


| 与第三方


综合布线管理软件双向


同步、增量/


全量映射数据


推送、冲突解决


策略 | DS-


数据同步服务


文件资源管理**


设备说明书、安装


视频、现场照片


等多媒体资料的上传


下载/分片


断点续传


对象存储服务（


基础设施


层） |


| **系统配置


与维护


** | 数据库


主从切换监控


、备份策略执行


、代码版本回


滚、自动化部署


脚本管理 |


层/DevOps


流程


数据结构
###


核心关系


型数据表：


| 字段


名称 | 字段


代码 | 数据类型


| 约束/


说明 |
|


| 映射


ID | `


mapping_id` |


INT | 主


键，自增


，唯一标识 |


| 端口


编号 | `port


_code` | VARCHAR


| 字母数字


组合，唯一索引


，加密传输 |


纤芯编号


| `fiber_core


` | VARCHAR(


10) |


字母数字组合


，高精度标识 |


熔接盘号


| `splice_tr


ay` | VARCHAR


| 关联物理


熔接盘位置


光缆芯号 |


` | VARCHAR |


关联上游光缆


资源


路由信息 | `


route_info` |


TEXT | 详细


光路走向与


跳


接记录 |


创建时间 | `


create_time` |


DATETIME |


记录首次映射时间


更新时间 | `


update_time` |


记录最后一次变更时间


其他关键数据结构


用户与权限模型


**：基于RB


AC的`


Users`、`


Roles


`、`Permissions


`关联表，


支持细


粒度API访问控制


- **设备状态


快照**：JSON


格式存储传感器节点


上报


的温度、湿度、


端口


活跃状态（ACTIVE


/INACTIVE


/ERROR）。


- **文件


元数据索引**


：分布式


对象存储中的文件


UUID


、访问权限策略


、分片哈希


值及上传时间


戳。


## 接口


或命令
###


外部通信接口


`IF-DATA


- **协议


与格式**：


REST


ful API，HTTP


POST/GET/


PUT


/DELETE，请求


/响应体为


JSON，传输层


强制


HTTPS加密。


核心端点与


签名


| 接口名称


| 输入参数


| 输出


参数 | 业务


语义 |


addMapping` |


| `result_code


` | 创建


新端口映射，


触发


唯一性校验 |


deleteMapping` |


` | 解除


端口绑定，清理


关联缓存 |


`getMapping`


| `port_code


` | `mapping


_info` |


查询完整映射详情


及路由拓扑 |


`updateMapping`


`, `new_f


iber_core` |


| 变更纤


芯绑定


，记录审计日志


- **数据特征


**：`port


要求高精度、实时


高频交互


；`status`


枚举值限制为


`ACTIVE`


/`INACTIVE


/`ERROR`


，低频小容量


上报


约束
1


. **环境与硬件


约束**：


部署于室内机房


工作温度-5


℃，防护IP


20）；


计算


资源限制为双


核CPU


、4GB RAM


SSD、千兆以太网


2. **


技术栈约束**


：后端


语言限定Java；


关系


型数据库采用MySQL


主从复制


架构；非结构化


文件采用分布式


对象存储；源码


托管于GitLab


按


模块分仓。


**标准与合规


约束**：


必须符合YD/T


、TIA/E


IEC


1布线标准；


硬件


材料满足RoHS


ACH环保指令。


**安全约束**


：实施


纵深防御，敏感


字段加密存储与


传输；启用会话


超时机制；所有


输入需经严格


校验防


注入；权限最小


化原则。


5. **


性能约束**：


CRUD操作响应


时间


需达毫秒级


；支持


高并发读取与


大数据


量查询；系统


需通过JMeter


/Load


Runner压力验证。


测试建议
|


测试类型 |


测试重点 |


推荐工具/


方法 |


验收标准 |


| **性能


测试** |


并发请求处理能力、


百万


级映射记录查询


效率、长时间


运行稳定性 | J


Meter（Web/API


压测）、Load


Runner


（复杂协议评估


） | 吞吐量


达标，P9


无内存泄漏 |


| **可靠性


异常捕获恢复、


数据库主从


切换、故障注入


与回滚策略


| 混沌工程


工具


、自动化故障模拟


脚本 | 单


点故障恢复时间


<MTTR指标


，数据零丢失


**安全性测试**


| RBAC越


权访问、SQL


/注入攻击、


HTTPS


证书有效性、会话


劫


持防护 | OW


ASP ZAP、


Burp Suite、


渗透测试流程 |


高危


漏洞清零，未


授权请求10


0%拦截


环境适应性测试**


| 高低温


循环、湿热试验


机柜振动模拟 |


环境试验箱


、振动台（


依据国标） |


硬件


不宕机，


软件


服务自动重连


并


恢复 |
|


**集成与同步


测试** |


第三方系统数据一致性


、增量同步延迟


、断


点续传可靠性


| Postman、


Mock Server


、数据比对脚本


同步成功率>9


9%，冲突记录


可追溯 |


**代码级测试


核心函数路径覆盖


、边界


条件处理、单元测试


隔离性 | J


Unit/TestNG、


Son


arQube静态


分析 | 核心


函数覆盖率≥8


%，无严重代码


异味 |


需求


可追踪性明细


| 需求


标识 | 需求


名称 | 需求


描述 | 来源


文档 | 建议


由哪一层职责


或


业务方法实现/


验证 |
|


| SRS-F


001 |


端口唯一编号


系统 | 确保


每个物理端口具备


全局唯一标识，


支持快速检索与


防重复分配校验


| 软件设计


表7/表


8） | **


业务逻辑层(P


`addMapping`


/`getMapping


`函数实现唯一


性校验；**


单元测试**验证数据库


唯一索引与冲突


拦截逻辑。 |


| SRS


| 产品型号


编码结构 |


遵循附录A规范


定义的产品型号编码


规则（


如ODF-


M-R-BK


），用于资产分类


、识别与批量


导入解析。 |


软件


（表7/


表8/附录


A） | **


业务逻辑层(P


输入参数解析模块


实现正则匹配与


格式校验；**


集成测试**验证


编码生成、解析


与导出


功能的准确性。 |


SRS-F-


03 |


内部组件编号与


溯源 | 记录


熔接盘号


、光缆芯号


等内部组件信息


，支持全链路


物理拓扑追溯与


变更


历史留存。 |


软件


（表7/


表8） |


**业务逻辑层


通过`updateMapping


`维护`splice


/`cable


**审计日志审查


**与数据库时间


戳比对验证溯源


完整性。


 |
| S


4 | 端口


映射记录表支持


| 提供结构化


数据存储方案，支持


端口与纤芯


的映射关系增


删改查、


历史版本管理及跨


系统同步。 |


软件设计说明书


.docx（表


） | **数据


访问层(PM


`表设计ORM


映射；DS-


通过`syncData


`实现第三方同步


；**DBA


脚本验证


**与同步接口


压测确认


数据一致性。 |


| SRS


-NFR-SRS


| CSCI运行


适应性需求 |


系统需适应室内


机房环境，具备


硬件状态监控


、异常告警


、宽温元器件


适配及高可用


容错能力


。 | 软件


（表7/


节） | **


基础设施/监控层


通过`checkStatus


`轮询传感器


节点并生成告


警；**


环境试验室温湿度


/振动测试**


结合故障注入


验证系统鲁棒


性。 |


| SRS


-NFR-SRS


| 安全性需求


| 实施纵深


防御策略，包含


身份认证、RB


AC权限控制、


HTTPS加密


传输、输入校验


及


会话安全管理。 |


软件设计


表7/表


） | **安全


网关/认证层


通过`authenticate`


实现令牌签发与


权限拦截；**


渗透


测试**扫描漏洞


模拟越权/


会话劫持操作


验证防护机制有效性


<status type="coding


">开始生成 O


DF 光纤配


线单元管理系统 C


++ 工程


。将依据需求


可


追踪性明细，


在


`include/app.hpp


` 与 `


src/app.cpp


` 中实现


端口映射、设备


监控


、用户认证等


核心模块，并为


每个业务函数添加


对应的 `@require


ment`


标签。工程


采用 C++1


7 标准


与 CMake


构建


，不包含第三方依赖


。</status>


{"path":


"codegen-runs


MakeLists.txt


, "content": "cmake


(odf_manager LANG


UAGES CXX


)\n\nset(C


\nset(CMAKE


ON)\n\nif


(MSVC)


\n    add_compile


()\n\n#


主程序


src/main.cpp


\n    src/app


.cpp\n)


(odf_manager PRIVATE


include)\n\n#


基础测试可


执行文件\nadd


PRIVATE include)


, "overwrite": true


cmake_minimum_required(VERSION 3.14)
project(odf_manager LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

if (MSVC)
    add_compile_options(/utf-8)
endif()

# 主程序
add_executable(odf_manager
    src/main.cpp
    src/app.cpp
)
target_include_directories(odf_manager PRIVATE include)

# 基础测试可执行文件
add_executable(odf_basic_test
    tests/basic_test.cpp
    src/app.cpp
)
target_include_directories(odf_basic_test PRIVATE include)


开始生成 ODF 光纤配线单元管理系统 C++ 工程。将依据需求可追踪性明细，在 `include/app.hpp` 与 `src/app.cpp` 中实现端口映射、设备监控、用户认证等核心模块，并为每个业务函数添加对应的 `@requirement` 标签。工程采用 C++17 标准与 CMake 构建，不包含第三方依赖。


已写入文件：codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/CMakeLists.txt


{"content": "#ifndef O


\n#define O


\n\n#include


<string>\n#include


<vector>\n#include


<map>


\n#include <optional>


\n#include


<chrono>\n#include


<mutex>\n


\nnamespace odf {


\n\n// 端口


状态枚举\nenum


class PortStatus {


\n    ACTIVE,


\n    INACTIVE


,\n    ERROR


\n//


端口映射数据结构


\nstruct PortMapping


{\n


int mapping_id;


\n    std::


string port_code;


string fiber_core;


string splice_tray


;\n    std


::string cable_core


::string route_info


::chrono::system


\n    std::chrono


time_point update_time


;\n};\n


\n// 设备


健康状态\nstruct


Device


Health {\n


std::string node


double temperature_celsius


;\n


double humidity_percent;


\n    bool


\n


PortStatus port_status


;\n};


\n\n// 用户


角色枚举\nenum


class UserRole


{\n    ADMIN


,\n    OPER


ATOR,\n


VIEWER\n};


信息\nstruct UserInfo


{\n    std


::string username;


\n    UserRole role


;\n


bool is_session_valid


;\n};\n


\n/**\n *


端口映射管理器，


负责端口唯一性


校验、映射关系的


增删改查


及冲突检测。


\n */


\nclass PortMapping


Manager {\npublic


:\n    /**


\n     *


添加新的端口映射


记录


。\n     *


\n     * @


requirement(name=\"


端口唯一编号系统


\", id=\"S


* @requirement


(name=\"产品型号


编码结构\",


id=\"SRS


\")\n     *


@requirement(name


=\"内部组件编号


与溯源


(name=\"端口映射


记录表支持\",


@param port_code


端口唯一编号


param fiber_core


纤芯编号


\n     * @param


熔接盘号


\n     * @


param cable_core


光缆芯号


route_info 路由


信息\n     *


@return 映射


ID，如果失败


（如重复或


格式错误）返回


1\n     */


\n    int add


Mapping(const std::


string& port_code


, const std::


string&


\n                   const std::


string& splice_tr


ay = \"\", const


std::string&


cable_core = \"\",


\n                   const std


::string& route


_info = \"\");\n


\n    /**


\n     * 删除


指定端口的映射


记录。


\n     *


\n     * @require


ment(name=\"端口


映射记录表支持


\", id=\"S


* @param port


_code 要解除


绑定的端口编号


\n     * @


return 是否删除


成功\n     */


\n    bool delete


Mapping(const std::


string& port_code


);\n\n    /**


查询指定端口的


完整映射详情。


\n     *


\n     * @require


ment(name=\"端口


唯一编号系统\",


id=\"SRS


\")\n     *


@param port_code


端口


编号\n     *


return 映射对象


，若未找到


则返回


std::nullo


pt\n


*/\n    std


::optional


<PortMapping> getMapping


(const std::string


& port_code);


\n\n    /**


\n     * 更新


指定端口的纤


芯绑定及其他信息


。\n


*\n     *


@requirement(name


=\"内部组件编号


与溯源\", id


=\"SRS-F


\n     * @


requirement(name=\"


端口映射记录表


支持\", id=\"


SRS-F-


\n     * @param


port_code 端口


编号\n     *


@param new_f


新的纤芯编号


param splice_tray


新的熔接


盘号\n


* @param cable


_core 新的光缆


芯号\n


* @param route


_info 新的


路由信息\n


* @return


是否更新成功


\n     */\n


bool updateMapping(const


std::string&


port_code, const


,\n                       const


std::string


& splice_tray


= \"\", const std


::string&


cable_core = \"\",


\n                       const std


::string& route


_info = \"\");\n


\nprivate:


\n    // 模拟


数据库存储\n


std::map


<std::string, PortMapping> mappings_;


\n    int


next_id_ =


\n    std::


mutex mutex_;\n


\n    // 辅助


：验证端口编码


格式 (


SRS-F-


\n    bool validatePort


CodeFormat(const std


::string& code


) const;


\n};


\n\n/**\n *


设备


监控器，负责


硬件节点健康度


轮询、离线


/故障告警


生成及环境参数


采集。\n */


\nclass DeviceMonitor


{\npublic:


\n    /**


\n     * 检查


并上报设备节点


的健康状态


。\n     *


\n     * @


requirement(name=\"


CSCI运行适应性


需求\", id=\"


SRS-NFR


\n     * @param


node_id 设备


节点ID\n


* @param temperature


当前温度


\n     *


@param humidity


当前湿度\n


* @param is


_connected 物理连接


状态\n


* @return


设备健康快照


\n     */\n


DeviceHealth checkStatus


(const std::string


& node_id,


double temperature,


\n                             double humidity,

\n                             double humidity,


bool is_connected);


\n\n    /**


\n     * 根据


阈值判断是否产生


告警。


\n     *


\n     * @require


ment(name=\"C


SCI运行适应性需求


\", id=\"S


RS-NFR-S


* @param health


设备健康状态


\n     * @


param temp_threshold


温度


告警阈值


\n     * @param


humidity_threshold 湿度


\n     * @return


告警消息


，若无异常返回


空字符串\n


*/\n    std


::string generateAlert


(const DeviceHealth&


health, double temp


_threshold =


double humidity_threshold =


\n\n/**\n *


用户认证服务


，负责账号登录


验证、RB


AC角色权限控制


及会话


管理。\n */


\nclass UserService {


\npublic:


\n    /**


\n     * 验证


用户登录凭证并


签发


会话令牌。


\n     *


\n     * @


requirement(name=\"


安全性需求\", id


=\"SRS-N


FR-SRS-


\")\n     *


@param username


用户名\n     *


@param password


密码\n     *


@return


用户信息，


若验证失败返回


n


ullopt\n


*/\n    std


::optional


<UserInfo> authenticate(const std


::string& username


, const std::


string& password);


\n\n    /**


\n     * 检查


用户是否具有执行特定


操作所需的


角色权限。


\n


*\n     *


@requirement(name


=\"安全性需求\",


id=\"SRS


-NFR-SRS


\")\n     *


@param user


当前


用户\n     *


@param required_role


所需最低角色


\n     *


@return 是否


拥有权限\n


\n    bool has


Permission(const UserInfo&


user, UserRole


\n    /**\n


* 注销用户


会话，


使其失效。


\n     *\n


* @requirement


(name=\"安全性


需求\", id=\"


SRS-NFR


\n     * @param


username 用户名


\n     */


\n    void logout


(const std::string


username);\n\nprivate


:\n    std


::map


<std::string, UserInfo>


\n    std::mutex


\n\n} // namespace


odf\n\n#endif


// ODF_MANAGER


, "path": "


codegen-runs/code


.hpp


, "overwrite":


true


#ifndef ODF_MANAGER_APP_HPP
#define ODF_MANAGER_APP_HPP

#include <string>
#include <vector>
#include <map>
#include <optional>
#include <chrono>
#include <mutex>

namespace odf {

// 端口状态枚举
enum class PortStatus {
    ACTIVE,
    INACTIVE,
    ERROR_STATE
};

// 端口映射数据结构
struct PortMapping {
    int mapping_id;
    std::string port_code;
    std::string fiber_core;
    std::string splice_tray;
    std::string cable_core;
    std::string route_info;
    std::chrono::system_clock::time_point create_time;
    std::chrono::system_clock::time_point update_time;
};

// 设备健康状态
struct DeviceHealth {
    std::string node_id;
    double temperature_celsius;
    double humidity_percent;
    bool is_online;
    PortStatus port_status;
};

// 用户角色枚举
enum class UserRole {
    ADMIN,
    OPERATOR,
    VIEWER
};

// 用户信息
struct UserInfo {
    std::string username;
    UserRole role;
    bool is_session_valid;
};

/**
 * 端口映射管理器，负责端口唯一性校验、映射关系的增删改查及冲突检测。
 */
class PortMappingManager {
public:
    /**
     * 添加新的端口映射记录。
     *
     * @requirement(name="端口唯一编号系统", id="SRS-F-05-001")
     * @requirement(name="产品型号编码结构", id="SRS-F-05-002")
     * @requirement(name="内部组件编号与溯源", id="SRS-F-05-003")
     * @requirement(name="端口映射记录表支持", id="SRS-F-05-004")
     * @param port_code 端口唯一编号
     * @param fiber_core 纤芯编号
     * @param splice_tray 熔接盘号
     * @param cable_core 光缆芯号
     * @param route_info 路由信息
     * @return 映射ID，如果失败（如重复或格式错误）返回 -1
     */
    int addMapping(const std::string& port_code, const std::string& fiber_core,
                   const std::string& splice_tray = "", const std::string& cable_core = "",
                   const std::string& route_info = "");

    /**
     * 删除指定端口的映射记录。
     *
     * @requirement(name="端口映射记录表支持", id="SRS-F-05-004")
     * @param port_code 要解除绑定的端口编号
     * @return 是否删除成功
     */
    bool deleteMapping(const std::string& port_code);

    /**
     * 查询指定端口的完整映射详情。
     *
     * @requirement(name="端口唯一编号系统", id="SRS-F-05-001")
     * @param port_code 端口编号
     * @return 映射对象，若未找到则返回 std::nullopt
     */
    std::optional<PortMapping> getMapping(const std::string& port_code);

    /**
     * 更新指定端口的纤芯绑定及其他信息。
     *
     * @requirement(name="内部组件编号与溯源", id="SRS-F-05-003")
     * @requirement(name="端口映射记录表支持", id="SRS-F-05-004")
     * @param port_code 端口编号
     * @param new_fiber_core 新的纤芯编号
     * @param splice_tray 新的熔接盘号
     * @param cable_core 新的光缆芯号
     * @param route_info 新的路由信息
     * @return 是否更新成功
     */
    bool updateMapping(const std::string& port_code, const std::string& new_fiber_core,
                       const std::string& splice_tray = "", const std::string& cable_core = "",
                       const std::string& route_info = "");

private:
    // 模拟数据库存储
    std::map<std::string, PortMapping> mappings_;
    int next_id_ = 1;
    std::mutex mutex_;

    // 辅助：验证端口编码格式 (SRS-F-05-002)
    bool validatePortCodeFormat(const std::string& code) const;
};

/**
 * 设备监控器，负责硬件节点健康度轮询、离线/故障告警生成及环境参数采集。
 */
class DeviceMonitor {
public:
    /**
     * 检查并上报设备节点的健康状态。
     *
     * @requirement(name="CSCI运行适应性需求", id="SRS-NFR-SRS-010")
     * @param node_id 设备节点ID
     * @param temperature 当前温度
     * @param humidity 当前湿度
     * @param is_connected 物理连接状态
     * @return 设备健康快照
     */
    DeviceHealth checkStatus(const std::string& node_id, double temperature,
                             double humidity, bool is_connected);

    /**
     * 根据阈值判断是否产生告警。
     *
     * @requirement(name="CSCI运行适应性需求", id="SRS-NFR-SRS-010")
     * @param health 设备健康状态
     * @param temp_threshold 温度告警阈值
     * @param humidity_threshold 湿度告警阈值
     * @return 告警消息，若无异常返回空字符串
     */
    std::string generateAlert(const DeviceHealth& health, double temp_threshold = 40.0,
                              double humidity_threshold = 80.0);
};

/**
 * 用户认证服务，负责账号登录验证、RBAC角色权限控制及会话管理。
 */
class UserService {
public:
    /**
     * 验证用户登录凭证并签发会话令牌。
     *
     * @requirement(name="安全性需求", id="SRS-NFR-SRS-011")
     * @param username 用户名
     * @param password 密码
     * @return 用户信息，若验证失败返回 nullopt
     */
    std::optional<UserInfo> authenticate(const std::string& username, const std::string& password);

    /**
     * 检查用户是否具有执行特定操作所需的角色权限。
     *
     * @requirement(name="安全性需求", id="SRS-NFR-SRS-011")
     * @param user 当前用户
     * @param required_role 所需最低角色
     * @return 是否拥有权限
     */
    bool hasPermission(const UserInfo& user, UserRole required_role);

    /**
     * 注销用户会话，使其失效。
     *
     * @requirement(name="安全性需求", id="SRS-NFR-SRS-011")
     * @param username 用户名
     */
    void logout(const std::string& username);

private:
    std::map<std::string, UserInfo> users_;
    std::mutex mutex_;
};

} // namespace odf

#endif // ODF_MANAGER_APP_HPP


已写入文件：codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/include/app.hpp


{"content": "


#include \"app.hpp


\n#include <algorithm>


\n#include


<regex>\n#include


<iostream>


\n#include <sstream>


\n\nnamespace o


df {\n\n//


==================== PortMapping


Manager


实现 ====================\n


\nbool PortMappingManager


validatePortCodeFormat


(const std::string


& code) const


{\n    //


SRS-F-


产品型号编码


结构校验\n


简化正则：允许


字母、数字、


连字符


，长度 1


static const std::


regex


A-Za-z


\n    return std


, port_regex


);\n}\n


\nint PortMappingManager


::addMapping(const


std::string&


port_code, const


\n                                   const std::

\n                                   const std::


string& splice_tr


ay, const std


::string& cable


const std::string


& route_info)


{\n    std


<std::mutex> lock


\n    // SRS


1: 端口


唯一编号系统 -


校验格式与


唯一性\n


if (!validatePort


)) {\n


std::cerr <


< \"Invalid port code format: \" <


< port_code <


< std::endl;\n        return -1;\n    }\n\n    if (mappings_.find(port_code) != mappings_.end()) {\n        std::cerr <


< \"Port code already exists: \" <


< std::endl;\n        return -1;\n    }\n\n    PortMapping pm;\n    pm.mapping_id = next_id_++;\n    pm.port_code = port_code;\n    pm.fiber_core = fiber_core;\n    pm.splice_tray = splice_tray;\n    pm.cable_core = cable_core;\n    pm.route_info = route_info;\n    pm.create_time = std::chrono::system_clock::now();\n    pm.update_time = pm.create_time;\n\n    mappings_[port_code] = pm;\n    return pm.mapping_id;\n}\n\nbool PortMappingManager::deleteMapping(const std::string& port_code) {\n    std::lock_guard


<std::mutex> lock(mutex


auto


it = mappings_.


\n    if (


it != mappings_.


end()) {


\n        mappings_.erase


(it);\n


return true;


\n    }\n


return false;


\n}\n\nstd::


optional


<PortMapping> PortMappingManager


::getMapping(const


std::string&


port_code) {


\n    std::


<std::mutex> lock(mutex


auto it = mappings


);\n    if


(it != mappings


_.end()) {


\n        return it


->second;


return std::n


ullopt;


\n}\n\nbool Port


MappingManager::


updateMapping(const std


::string& port


_code, const std


::string&


,\n                                       const

,\n                                       const


std::string


& splice_tray


, const std::


string& cable_core


std::string&


route_info) {


\n    std::


<std::mutex> lock(mutex


auto it = mappings


);\n    if


(it == mappings


{\n        return


false;\n


}\n\n    //


SRS-F-


内部组件编号与


溯源 - 更新


组件信息并记录


时间戳


\n    it->second


.fiber_core =


;\n    if


.empty())


it->second.splice


_tray = splice


\n    if (!c


it->second.c


able_core = cable


if (!route_info


.empty()) it->


second.route_info =


.update_time = std


::chrono::system


\n\n    return true


;\n}\n


\n// ==================== Device


Monitor 实现 =================


===\n\nDeviceHealth


DeviceMonitor::


checkStatus(const std


::string& node


_id, double temperature


,\n                                        double

,\n                                        double


humidity, bool


is_connected) {


\n    // S


RS-N


FR-SRS-


CSCI运行适应性


需求 - 采集


环境参数\n


DeviceHealth health;


\n    health


.node_id = node


= temperature;


\n    health.humidity


_percent = humidity;


\n    health.is


_online = is_connected


;\n    \n


if


\n        health.port


_status = PortStatus


\n    }


else if (temperature


> 40


.0 || humidity


> 80


0) {


\n        health.port_status


= PortStatus::


\n    } else {


::ACTIVE;


\n    }\n


\n    return health


;\n}\n


\nstd::string Device


Monitor::generateAlert


(const DeviceHealth&


health, double temp


double humidity_threshold)


{\n    //


SRS-NFR


10: C


SCI运行适应性需求


- 异常告


警生成


\n    std::ostringstream


oss;


\n    if (!


{\n


oss <


< \"ALERT: Node \" <


< health.node_id <


< \" is offline.\";\n    } else {\n        if (health.temperature_celsius > temp_threshold)


{\n            oss


< \"ALERT: High temperature on \" <


< health.node_id \n                <


< health.temperature_celsius <


< \"°C\";\n        }\n        if (health.humidity_percent > humidity_threshold


) {\n


< \"ALERT: High humidity on \" <


< health.node_id \n                << \": \" <

< health.node_id \n                << \": \" <


< health.humidity_percent <


< \"%\";\n        }\n    }\n    return oss.str();\n}\n\n// ==================== UserService 实现 ====================\n\nstd::optional


<UserInfo> UserService::authenticate


(const std::string


& username, const


std::string&


password) {


\n    // SRS


-NFR-SRS


: 安全性需求


- 身份


认证与会话管理


\n


<std::mutex>


\n    \n    //


模拟


简单的用户验证逻辑


\n    //


实际


场景中应查询数据库


并


比对哈希密码


\n    if (


username.empty() ||


password.empty()) {


\n        return std


::nullopt


;\n


}\n\n    UserInfo


user;\n


user.username = username


;\n    //


默认分配角色


实际应根据数据库中的


Roles/Permissions


表


确定\n    if


username == \"admin


\") {\n


user.role = UserRole


::ADMIN;


\n    } else if


(username == \"


operator\") {


\n        user.role =


UserRole::OPERATOR


;\n    }


else {\n


::VIEWER;


\n    }


\n    user.is_session


= true;


\n    \n    users_[


username] =


user;\n


return user;


\n}\n\nbool UserService


::hasPermission(const


UserInfo& user,


UserRole required_role)


{\n    //


SRS-NFR


安全性需求 - RB


AC权限控制


\n    if


_valid) {


\n        return false;


\n    }


\n    \n    //


简单层级比较：


ADMIN >


OPERATOR > VIEW


ER\n    int


user_level = static


<int>(user.role


);\n    int


required_level = static


\n    return user_level


>= required_level;


\n}\n\nvoid


UserService::logout(const


std::string&


username) {


\n    std::lock


<std::mutex> lock(mutex_


);\n    auto


it = users_.


find(username);


\n    if (it


!= users_.end


()) {\n


it->second.is


_session_valid = false


;\n    }


\n}\n


\n} // namespace o


df


, "path": "codegen


-runs/codegen


, "overwrite":


true


#include "app.hpp"
#include <algorithm>
#include <regex>
#include <iostream>
#include <sstream>

namespace odf {

// ==================== PortMappingManager 实现 ====================

bool PortMappingManager::validatePortCodeFormat(const std::string& code) const {
    // SRS-F-05-002: 产品型号编码结构校验
    // 简化正则：允许字母、数字、连字符，长度 1-10
    static const std::regex port_regex("^[A-Za-z0-9\\-]{1,10}$");
    return std::regex_match(code, port_regex);
}

int PortMappingManager::addMapping(const std::string& port_code, const std::string& fiber_core,
                                   const std::string& splice_tray, const std::string& cable_core,
                                   const std::string& route_info) {
    std::lock_guard<std::mutex> lock(mutex_);

    // SRS-F-05-001: 端口唯一编号系统 - 校验格式与唯一性
    if (!validatePortCodeFormat(port_code)) {
        std::cerr << "Invalid port code format: " << port_code << std::endl;
        return -1;
    }

    if (mappings_.find(port_code) != mappings_.end()) {
        std::cerr << "Port code already exists: " << port_code << std::endl;
        return -1;
    }

    PortMapping pm;
    pm.mapping_id = next_id_++;
    pm.port_code = port_code;
    pm.fiber_core = fiber_core;
    pm.splice_tray = splice_tray;
    pm.cable_core = cable_core;
    pm.route_info = route_info;
    pm.create_time = std::chrono::system_clock::now();
    pm.update_time = pm.create_time;

    mappings_[port_code] = pm;
    return pm.mapping_id;
}

bool PortMappingManager::deleteMapping(const std::string& port_code) {
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = mappings_.find(port_code);
    if (it != mappings_.end()) {
        mappings_.erase(it);
        return true;
    }
    return false;
}

std::optional<PortMapping> PortMappingManager::getMapping(const std::string& port_code) {
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = mappings_.find(port_code);
    if (it != mappings_.end()) {
        return it->second;
    }
    return std::nullopt;
}

bool PortMappingManager::updateMapping(const std::string& port_code, const std::string& new_fiber_core,
                                       const std::string& splice_tray, const std::string& cable_core,
                                       const std::string& route_info) {
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = mappings_.find(port_code);
    if (it == mappings_.end()) {
        return false;
    }

    // SRS-F-05-003: 内部组件编号与溯源 - 更新组件信息并记录时间戳
    it->second.fiber_core = new_fiber_core;
    if (!splice_tray.empty()) it->second.splice_tray = splice_tray;
    if (!cable_core.empty()) it->second.cable_core = cable_core;
    if (!route_info.empty()) it->second.route_info = route_info;
    it->second.update_time = std::chrono::system_clock::now();

    return true;
}

// ==================== DeviceMonitor 实现 ====================

DeviceHealth DeviceMonitor::checkStatus(const std::string& node_id, double temperature,
                                        double humidity, bool is_connected) {
    // SRS-NFR-SRS-010: CSCI运行适应性需求 - 采集环境参数
    DeviceHealth health;
    health.node_id = node_id;
    health.temperature_celsius = temperature;
    health.humidity_percent = humidity;
    health.is_online = is_connected;

    if (!is_connected) {
        health.port_status = PortStatus::ERROR_STATE;
    } else if (temperature > 40.0 || humidity > 80.0) {
        health.port_status = PortStatus::ERROR_STATE;
    } else {
        health.port_status = PortStatus::ACTIVE;
    }

    return health;
}

std::string DeviceMonitor::generateAlert(const DeviceHealth& health, double temp_threshold,
                                         double humidity_threshold) {
    // SRS-NFR-SRS-010: CSCI运行适应性需求 - 异常告警生成
    std::ostringstream oss;
    if (!health.is_online) {
        oss << "ALERT: Node " << health.node_id << " is offline.";
    } else {
        if (health.temperature_celsius > temp_threshold) {
            oss << "ALERT: High temperature on " << health.node_id
                << ": " << health.temperature_celsius << "°C";
        }
        if (health.humidity_percent > humidity_threshold) {
            oss << "ALERT: High humidity on " << health.node_id
                << ": " << health.humidity_percent << "%";
        }
    }
    return oss.str();
}

// ==================== UserService 实现 ====================

std::optional<UserInfo> UserService::authenticate(const std::string& username, const std::string& password) {
    // SRS-NFR-SRS-011: 安全性需求 - 身份认证与会话管理
    std::lock_guard<std::mutex> lock(mutex_);

    // 模拟简单的用户验证逻辑
    // 实际场景中应查询数据库并比对哈希密码
    if (username.empty() || password.empty()) {
        return std::nullopt;
    }

    UserInfo user;
    user.username = username;
    // 默认分配角色，实际应根据数据库中的 Roles/Permissions 表确定
    if (username == "admin") {
        user.role = UserRole::ADMIN;
    } else if (username == "operator") {
        user.role = UserRole::OPERATOR;
    } else {
        user.role = UserRole::VIEWER;
    }
    user.is_session_valid = true;

    users_[username] = user;
    return user;
}

bool UserService::hasPermission(const UserInfo& user, UserRole required_role) {
    // SRS-NFR-SRS-011: 安全性需求 - RBAC权限控制
    if (!user.is_session_valid) {
        return false;
    }

    // 简单层级比较：ADMIN > OPERATOR > VIEWER
    int user_level = static_cast<int>(user.role);
    int required_level = static_cast<int>(required_role);

    return user_level >= required_level;
}

void UserService::logout(const std::string& username) {
    std::lock_guard<std::mutex> lock(mutex_);
    auto it = users_.find(username);
    if (it != users_.end()) {
        it->second.is_session_valid = false;
    }
}

} // namespace odf


已写入文件：codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/src/app.cpp


{"content": "


#include \"app.hpp


\"\n#include


<iostream>\n\nint


main() {


\n    using namespace


odf;


\n\n    std::


cout <


< \"=== ODF Fiber Distribution Management System ===\" <


< std::endl;\n\n    // 1. 端口映射管理测试 (SRS-F-05-001, SRS-F-05-002, SRS-F-05-003, SRS-F-05-004)\n    PortMappingManager pm_manager;\n    \n    std::cout <


< \"\\n--- Testing Port Mapping ---\" <


< std::endl;\n    \n    // 添加有效映射\n    int id1 = pm_manager.addMapping(\"PORT-001\", \"FIBER-A1\", \"TRAY-01\", \"CABLE-X1\", \"Route A->B\");


\n    std::


< \"Added mapping ID: \" <


< id1 <


< std::endl;\n    \n    // 添加重复端口（应失败）\n    int id2 = pm_manager.addMapping(\"PORT-001\", \"FIBER-B2\");\n    std::cout <


< \"Duplicate add result: \" <


< id2 <


< \" (expected -1)\" <


< std::endl;\n    \n    // 添加无效格式端口（应失败，SRS-F-05-002）\n    int id3 = pm_manager.addMapping(\"INVALID PORT!\", \"FIBER-C3\");\n    std::cout <


< \"Invalid format add result: \" << id3 <


< std::endl;\n    \n    // 查询映射\n    auto map_opt = pm_manager.getMapping(\"PORT-001\");\n    if (map_opt) {\n        std::cout <


< \"Found mapping: Port=\" <


< map_opt->port_code


\n                  <


< \", Fiber=\" <


< map_opt->fiber


_core \n                  <


< \", Tray=\" <


< map_opt->splice


_tray <


< std::endl;\n    } else {\n        std::cout <

< std::endl;\n    } else {\n        std::cout <


< \"Mapping not found.\" <


< std::endl;\n    }\n    \n    // 更新映射 (SRS-F-05-003)\n    bool updated = pm_manager.updateMapping(\"PORT-001\", \"FIBER-A1-UPDATED\", \"TRAY-02\");\n    std::cout <


< \"Update result: \" <


< (updated ? \"Success\" : \"Failed\") <


< std::endl;\n    \n    // 删除映射\n    bool deleted = pm_manager.deleteMapping(\"PORT-001\");\n    std::cout <


< \"Delete result: \" <


< (deleted ? \"Success\" : \"Failed\") <


< std::endl;\n\n    // 2. 设备状态监控测试 (SRS-NFR-SRS-010)\n    DeviceMonitor monitor;\n    \n    std::cout <


< \"\\n--- Testing Device Monitor ---\" <


< std::endl;\n    \n    DeviceHealth healthy = monitor.checkStatus(\"NODE-1\", 25.0, 50.0, true);\n    std::string alert1 = monitor.generateAlert(healthy);\n    std::cout <


< \"Healthy node alert: '\" <


< alert1 <


< \"' (expected empty)\" <


< std::endl;\n    \n    DeviceHealth overheated = monitor.checkStatus(\"NODE-2\", 45.0, 60.0, true);\n    std::string alert2 = monitor.generateAlert(overheated);\n    std::cout <


< \"Overheated node alert: '\" <


< alert2 << \"'\" <


< std::endl;\n    \n    DeviceHealth offline = monitor.checkStatus(\"NODE-3\", 20.0, 40.0, false);\n    std::string alert3 = monitor.generateAlert(offline);\n    std::cout <


< \"Offline node alert: '\" << alert3 <


< std::endl;\n\n    // 3. 用户认证与授权测试 (SRS-NFR-SRS-011)\n    UserService user_service;\n    \n    std::cout <


< \"\\n--- Testing User Service ---\" <


< std::endl;\n    \n    auto admin_user = user_service.authenticate(\"admin\", \"password123\");\n    if (admin_user) {\n        std::cout <


< \"Admin login success. Role: \" <


< static_cast<int>(admin


< std::endl;\n        \n        bool can_manage = user_service.hasPermission(*admin_user, UserRole::OPERATOR);\n        std::cout <


< \"Admin has OPERATOR permission: \" <


< (can_manage ? \"Yes\" : \"No\") <


< std::endl;\n        \n        bool can_view = user_service.hasPermission(*admin_user, UserRole::VIEWER);\n        std::cout <


< \"Admin has VIEWER permission: \" <


< (can_view ? \"Yes\" : \"No\") <


< \"Admin login failed.\" <


< std::endl;\n    }\n    \n    auto viewer_user = user_service.authenticate(\"viewer\", \"pass456\");\n    if (viewer_user) {\n        bool can_operate = user_service.hasPermission(*viewer_user, UserRole::OPERATOR);\n        std::cout <


< \"Viewer has OPERATOR permission: \" <


< (can_operate ? \"Yes\" : \"No\") <


< std::endl;\n        \n        user_service.logout(\"viewer\");\n        bool still_valid = user_service.hasPermission(*viewer_user, UserRole::VIEWER);\n        std::cout <


< \"Viewer session valid after logout: \" <


< (still_valid ? \"Yes\" : \"No\") <


< std::endl;\n    }\n\n    std::cout <


< \"\\n=== All Tests Completed ===\" <


< std::endl;\n    return 0;\n}"


, "path": "codegen-r


, "overwrite": true


#include "app.hpp"
#include <iostream>

int main() {
    using namespace odf;

    std::cout << "=== ODF Fiber Distribution Management System ===" << std::endl;

    // 1. 端口映射管理测试 (SRS-F-05-001, SRS-F-05-002, SRS-F-05-003, SRS-F-05-004)
    PortMappingManager pm_manager;

    std::cout << "\n--- Testing Port Mapping ---" << std::endl;

    // 添加有效映射
    int id1 = pm_manager.addMapping("PORT-001", "FIBER-A1", "TRAY-01", "CABLE-X1", "Route A->B");
    std::cout << "Added mapping ID: " << id1 << std::endl;

    // 添加重复端口（应失败）
    int id2 = pm_manager.addMapping("PORT-001", "FIBER-B2");
    std::cout << "Duplicate add result: " << id2 << " (expected -1)" << std::endl;

    // 添加无效格式端口（应失败，SRS-F-05-002）
    int id3 = pm_manager.addMapping("INVALID PORT!", "FIBER-C3");
    std::cout << "Invalid format add result: " << id3 << " (expected -1)" << std::endl;

    // 查询映射
    auto map_opt = pm_manager.getMapping("PORT-001");
    if (map_opt) {
        std::cout << "Found mapping: Port=" << map_opt->port_code
                  << ", Fiber=" << map_opt->fiber_core
                  << ", Tray=" << map_opt->splice_tray << std::endl;
    } else {
        std::cout << "Mapping not found." << std::endl;
    }

    // 更新映射 (SRS-F-05-003)
    bool updated = pm_manager.updateMapping("PORT-001", "FIBER-A1-UPDATED", "TRAY-02");
    std::cout << "Update result: " << (updated ? "Success" : "Failed") << std::endl;

    // 删除映射
    bool deleted = pm_manager.deleteMapping("PORT-001");
    std::cout << "Delete result: " << (deleted ? "Success" : "Failed") << std::endl;

    // 2. 设备状态监控测试 (SRS-NFR-SRS-010)
    DeviceMonitor monitor;

    std::cout << "\n--- Testing Device Monitor ---" << std::endl;

    DeviceHealth healthy = monitor.checkStatus("NODE-1", 25.0, 50.0, true);
    std::string alert1 = monitor.generateAlert(healthy);
    std::cout << "Healthy node alert: '" << alert1 << "' (expected empty)" << std::endl;

    DeviceHealth overheated = monitor.checkStatus("NODE-2", 45.0, 60.0, true);
    std::string alert2 = monitor.generateAlert(overheated);
    std::cout << "Overheated node alert: '" << alert2 << "'" << std::endl;

    DeviceHealth offline = monitor.checkStatus("NODE-3", 20.0, 40.0, false);
    std::string alert3 = monitor.generateAlert(offline);
    std::cout << "Offline node alert: '" << alert3 << "'" << std::endl;

    // 3. 用户认证与授权测试 (SRS-NFR-SRS-011)
    UserService user_service;

    std::cout << "\n--- Testing User Service ---" << std::endl;

    auto admin_user = user_service.authenticate("admin", "password123");
    if (admin_user) {
        std::cout << "Admin login success. Role: " << static_cast<int>(admin_user->role) << std::endl;

        bool can_manage = user_service.hasPermission(*admin_user, UserRole::OPERATOR);
        std::cout << "Admin has OPERATOR permission: " << (can_manage ? "Yes" : "No") << std::endl;

        bool can_view = user_service.hasPermission(*admin_user, UserRole::VIEWER);
        std::cout << "Admin has VIEWER permission: " << (can_view ? "Yes" : "No") << std::endl;
    } else {
        std::cout << "Admin login failed." << std::endl;
    }

    auto viewer_user = user_service.authenticate("viewer", "pass456");
    if (viewer_user) {
        bool can_operate = user_service.hasPermission(*viewer_user, UserRole::OPERATOR);
        std::cout << "Viewer has OPERATOR permission: " << (can_operate ? "Yes" : "No") << std::endl;

        user_service.logout("viewer");
        bool still_valid = user_service.hasPermission(*viewer_user, UserRole::VIEWER);
        std::cout << "Viewer session valid after logout: " << (still_valid ? "Yes" : "No") << std::endl;
    }

    std::cout << "\n=== All Tests Completed ===" << std::endl;
    return 0;
}


已写入文件：codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/src/main.cpp


{"content": "


#include \"app.hpp


\"\n#include


<cassert>\n#include


<iostream>\n


\nvoid test_port_mapping


_id() {


\n


// SRS-F


1: 端口


唯一编号系统


\n    odf::


PortMapping


Manager pm;


\n    \n    int id


1 = pm


.addMapping(\"P


\n    assert(id1


> 0);


\n    \n    int


id2 = pm


\", \"F-


\n    assert(id


2 > 0


);\n    assert


(id2 != id


\n    // 重复


端口应返回 -


int id_dup =


pm.addMapping


01\", \"


assert(id_dup ==


\n    \n    std::


cout <


< \"[PASS] test_port_mapping_unique_id\" <


< std::endl;\n}\n\nvoid test_port_mapping_format_validation() {\n    // SRS-F-05-002: 产品型号编码结构\n    odf::PortMappingManager pm;\n    \n    // 有效格式\n    int id_valid = pm.addMapping(\"ODF-1U-24\", \"F-001\");\n    assert(id_valid > 0);


\n    \n    //


无效格式（


包含空格或过长


）\n    int


id_invalid = pm


.addMapping(\"INVALID


PORT!\", \"F


\");\n    assert


(id_invalid == -


\n    std::cout


< \"[PASS] test_port_mapping_format_validation\" <


< std::endl;\n}\n\nvoid test_port_mapping_update_traceability() {\n    // SRS-F-05-003: 内部组件编号与溯源\n    odf::PortMappingManager pm;\n    \n    pm.addMapping(\"P-001\", \"F-OLD\", \"TRAY-1\", \"CABLE-A\", \"Route 1\");\n    \n    bool updated = pm.updateMapping(\"P-001\", \"F-NEW\", \"TRAY-2\", \"CABLE-B\", \"Route 2\");\n    assert(updated);\n    \n    auto mapping = pm.getMapping(\"P-001\");\n    assert(mapping.has_value());\n    assert(mapping->fiber


_core == \"F


-NEW\");


\n    assert(mapping->


splice_tray ==


\"TRAY-


assert(mapping->c


able_core == \"


CABLE-B\");


\n    assert(mapping


->route_info ==


\"Route 2


\");\n    \n


std::cout <


< \"[PASS] test_port_mapping_update_traceability\" <


< std::endl;\n}\n\nvoid test_port_mapping_crud() {\n    // SRS-F-05-004: 端口映射记录表支持\n    odf::PortMappingManager pm;\n    \n    // Create\n    int id = pm.addMapping(\"P-CRUD\", \"F-CRUD\");\n    assert(id >


\n    \n    // Read


\n    auto opt


= pm.getMapping


(\"P-CR


UD\");\n


());\n    assert


== \"P-C


RUD\");


\n    \n    // Update


\n    bool upd


= pm.updateMapping


UD\", \"F


-CRUD-V


assert(upd);


\n    \n    //


Delete\n    bool


del = pm.delete


Mapping(\"P-C


\n    assert(del);


Verify deleted\n


auto opt


_after_del = pm


.getMapping


(\"P-CR


UD\");\n


\n    \n    std


::cout <


< \"[PASS] test_port_mapping_crud\" <


< std::endl;\n}\n\nvoid test_device_monitor_status() {\n    // SRS-NFR-SRS-010: CSCI运行适应性需求\n    odf::DeviceMonitor monitor;\n    \n    // 正常状态\n    auto healthy = monitor.checkStatus(\"N1\", 25.0, 50.0, true);\n    assert(healthy.port_status == odf::PortStatus::ACTIVE);\n    assert(monitor.generateAlert(healthy).empty());\n    \n    // 高温告警\n    auto hot = monitor.checkStatus(\"N2\", 45.0, 50.0, true);\n    assert(hot.port_status == odf::PortStatus::ERROR_STATE);\n    assert(!monitor.generateAlert(hot).empty());\n    \n    // 离线告警\n    auto offline = monitor.checkStatus(\"N3\", 20.0, 40.0, false);\n    assert(offline.port_status == odf::PortStatus::ERROR_STATE);\n    assert(!monitor.generateAlert(offline).empty());\n    \n    std::cout <


< \"[PASS] test_device_monitor_status\" <


< std::endl;\n}\n\nvoid test_user_authentication() {\n    // SRS-NFR-SRS-011: 安全性需求\n    odf::UserService service;\n    \n    // 登录成功\n    auto user = service.authenticate(\"admin\", \"pass\");\n    assert(user.has_value());\n    assert(user->is_session_valid


\n    \n    //


权限检查\n


assert(service.hasPermission


(*user, o


df::UserRole::


ADMIN));\n


OPERATOR));


\n    assert(service.has


Permission(*user,


odf::UserRole


::VIEWER));


登出后


权限失效\n


service.logout(\"admin


\");\n    assert


(!service.hasPermission


(*user


, odf::


UserRole::VIEWER


));\n    \n


std::cout <


< \"[PASS] test_user_authentication\" <


< std::endl;\n}\n\nint main() {\n    std::cout <


< \"Running ODF Manager Basic Tests...\" <


< std::endl;\n    \n    test_port_mapping_unique_id();\n    test_port_mapping_format_validation();\n    test_port_mapping_update_traceability();\n    test_port_mapping_crud();\n    test_device_monitor_status();\n    test_user_authentication();\n    \n    std::cout <


< \"All basic tests passed!\" <


< std::endl;\n    return 0;\n}"


, "path": "codegen-r


, "overwrite": true


#include "app.hpp"
#include <cassert>
#include <iostream>

void test_port_mapping_unique_id() {
    // SRS-F-05-001: 端口唯一编号系统
    odf::PortMappingManager pm;

    int id1 = pm.addMapping("P-001", "F-001");
    assert(id1 > 0);

    int id2 = pm.addMapping("P-002", "F-002");
    assert(id2 > 0);
    assert(id2 != id1);

    // 重复端口应返回 -1
    int id_dup = pm.addMapping("P-001", "F-003");
    assert(id_dup == -1);

    std::cout << "[PASS] test_port_mapping_unique_id" << std::endl;
}

void test_port_mapping_format_validation() {
    // SRS-F-05-002: 产品型号编码结构
    odf::PortMappingManager pm;

    // 有效格式
    int id_valid = pm.addMapping("ODF-1U-24", "F-001");
    assert(id_valid > 0);

    // 无效格式（包含空格或过长）
    int id_invalid = pm.addMapping("INVALID PORT!", "F-002");
    assert(id_invalid == -1);

    std::cout << "[PASS] test_port_mapping_format_validation" << std::endl;
}

void test_port_mapping_update_traceability() {
    // SRS-F-05-003: 内部组件编号与溯源
    odf::PortMappingManager pm;

    pm.addMapping("P-001", "F-OLD", "TRAY-1", "CABLE-A", "Route 1");

    bool updated = pm.updateMapping("P-001", "F-NEW", "TRAY-2", "CABLE-B", "Route 2");
    assert(updated);

    auto mapping = pm.getMapping("P-001");
    assert(mapping.has_value());
    assert(mapping->fiber_core == "F-NEW");
    assert(mapping->splice_tray == "TRAY-2");
    assert(mapping->cable_core == "CABLE-B");
    assert(mapping->route_info == "Route 2");

    std::cout << "[PASS] test_port_mapping_update_traceability" << std::endl;
}

void test_port_mapping_crud() {
    // SRS-F-05-004: 端口映射记录表支持
    odf::PortMappingManager pm;

    // Create
    int id = pm.addMapping("P-CRUD", "F-CRUD");
    assert(id > 0);

    // Read
    auto opt = pm.getMapping("P-CRUD");
    assert(opt.has_value());
    assert(opt->port_code == "P-CRUD");

    // Update
    bool upd = pm.updateMapping("P-CRUD", "F-CRUD-V2");
    assert(upd);

    // Delete
    bool del = pm.deleteMapping("P-CRUD");
    assert(del);

    // Verify deleted
    auto opt_after_del = pm.getMapping("P-CRUD");
    assert(!opt_after_del.has_value());

    std::cout << "[PASS] test_port_mapping_crud" << std::endl;
}

void test_device_monitor_status() {
    // SRS-NFR-SRS-010: CSCI运行适应性需求
    odf::DeviceMonitor monitor;

    // 正常状态
    auto healthy = monitor.checkStatus("N1", 25.0, 50.0, true);
    assert(healthy.port_status == odf::PortStatus::ACTIVE);
    assert(monitor.generateAlert(healthy).empty());

    // 高温告警
    auto hot = monitor.checkStatus("N2", 45.0, 50.0, true);
    assert(hot.port_status == odf::PortStatus::ERROR_STATE);
    assert(!monitor.generateAlert(hot).empty());

    // 离线告警
    auto offline = monitor.checkStatus("N3", 20.0, 40.0, false);
    assert(offline.port_status == odf::PortStatus::ERROR_STATE);
    assert(!monitor.generateAlert(offline).empty());

    std::cout << "[PASS] test_device_monitor_status" << std::endl;
}

void test_user_authentication() {
    // SRS-NFR-SRS-011: 安全性需求
    odf::UserService service;

    // 登录成功
    auto user = service.authenticate("admin", "pass");
    assert(user.has_value());
    assert(user->is_session_valid);

    // 权限检查
    assert(service.hasPermission(*user, odf::UserRole::ADMIN));
    assert(service.hasPermission(*user, odf::UserRole::OPERATOR));
    assert(service.hasPermission(*user, odf::UserRole::VIEWER));

    // 登出后权限失效
    service.logout("admin");
    assert(!service.hasPermission(*user, odf::UserRole::VIEWER));

    std::cout << "[PASS] test_user_authentication" << std::endl;
}

int main() {
    std::cout << "Running ODF Manager Basic Tests..." << std::endl;

    test_port_mapping_unique_id();
    test_port_mapping_format_validation();
    test_port_mapping_update_traceability();
    test_port_mapping_crud();
    test_device_monitor_status();
    test_user_authentication();

    std::cout << "All basic tests passed!" << std::endl;
    return 0;
}


已写入文件：codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/tests/basic_test.cpp


<result type


="summary">


已成功生成 ODF


光纤配


线单元管理系统 C


++ 代码工程


生成的文件清单


. **codegen-r


uns/codegen


f/CMakeLists


.txt**


- CMake


构建配置，支持


和 MSVC


UTF


-8 编译


选项
   -


构建主程序


` 和测试


程序 `odf


2. **


codegen-runs/code


.hpp**


- 头文件


，定义核心数据结构


PortMapping、Device


Health、UserInfo）


声明三个核心


类：PortMapping


Manager、Device


Monitor、UserService


所有公开 API


均使用 Do


xygen 风格注释


，并在


紧邻上方的注释块


中使用


`@requirement


` 标签关联


需求

3.


**codegen-r


/src/app.cpp**


源文件，实现


上述


三个类的业务逻辑


每个业务函数


均标注了对应的


需求标识：


addMapping`: S


1, SRS


, SRS-F


SRS-F-


- `deleteMapping


`: SRS-F


- `get


Mapping`: SRS


updateMapping`: S


3, SRS


checkStatus`: S


RS-NFR-S


0
     -


`generateAlert`:


SRS-NFR


- `authenticate`:


- `hasPermission


`: SRS-N


FR-SRS-


- `logout


4. **codegen


-runs/codegen


命令行入口，


演示端口映射管理


、设备监控、


用户认证三大模块


的功能

5.


codegen-runs/code


- 基础


单元测试，使用标准


库


`assert`


验证


各业务函数的正确


性


## 本地编译


运行步骤

```


bash
#


进入项目目录


cd code


gen-runs/code


9f

#


创建构建目录


并进入
mkdir


build &&


 cd build

#


生成


构建文件
cm


ake ..


# 编译


cm


ake --build .


# 运行


主程序（演示


所有


功能）
./


# 运行单元测试


./odf


_test
```


## 需求可


追踪性说明


`@requirement


标签的 id


均严格取自


输入文档


中的"CSCI需求


标识"列，


name


取自"CSCI


需求名称"


列。未出现


虚构需求标识或


错误使用软件单元


标识


（如 PM-


等）的情况


。类级注释


仅描述


整体职责，不包含


`@requirement


标签，所有


需求


关联均在函数级


完成


。
</result


已成功生成 ODF 光纤配线单元管理系统 C++ 代码工程。

## 生成的文件清单

1. **codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/CMakeLists.txt**
   - CMake 构建配置，支持 C++17 和 MSVC UTF-8 编译选项
   - 构建主程序 `odf_manager` 和测试程序 `odf_basic_test`

2. **codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/include/app.hpp**
   - 头文件，定义核心数据结构（PortMapping、DeviceHealth、UserInfo）
   - 声明三个核心类：PortMappingManager、DeviceMonitor、UserService
   - 所有公开 API 均使用 Doxygen 风格注释，并在紧邻上方的注释块中使用 `@requirement` 标签关联需求

3. **codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/src/app.cpp**
   - 源文件，实现上述三个类的业务逻辑
   - 每个业务函数均标注了对应的需求标识：
     - `addMapping`: SRS-F-05-001, SRS-F-05-002, SRS-F-05-003, SRS-F-05-004
     - `deleteMapping`: SRS-F-05-004
     - `getMapping`: SRS-F-05-001
     - `updateMapping`: SRS-F-05-003, SRS-F-05-004
     - `checkStatus`: SRS-NFR-SRS-010
     - `generateAlert`: SRS-NFR-SRS-010
     - `authenticate`: SRS-NFR-SRS-011
     - `hasPermission`: SRS-NFR-SRS-011
     - `logout`: SRS-NFR-SRS-011

4. **codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/src/main.cpp**
   - 命令行入口，演示端口映射管理、设备监控、用户认证三大模块的功能

5. **codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f/tests/basic_test.cpp**
   - 基础单元测试，使用标准库 `assert` 验证各业务函数的正确性

## 本地编译运行步骤

```bash
# 进入项目目录
cd codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f

# 创建构建目录并进入
mkdir build && cd build

# 生成构建文件
cmake ..

# 编译
cmake --build .

# 运行主程序（演示所有功能）
./odf_manager

# 运行单元测试
./odf_basic_test
```

## 需求可追踪性说明

所有 `@requirement` 标签的 id 均严格取自输入文档中的"CSCI需求标识"列，name 取自"CSCI需求名称"列。未出现虚构需求标识或错误使用软件单元标识（如 PM-001、DM-002 等）的情况。类级注释仅描述整体职责，不包含 `@requirement` 标签，所有需求关联均在函数级完成。


# 进入项目目录
cd codegen-runs/codegen_b8528778ead64e3588cd3d3e22202f9f

# 创建构建目录并进入
mkdir build && cd build

# 生成构建文件
cmake ..

# 编译
cmake --build .

# 运行主程序（演示所有功能）
./odf_manager

# 运行单元测试
./odf_basic_test


end