ae/ECAP_Server
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

缩减代码

Browse Source
This commit is contained in:
种太阳的热带美短
2026-08-09 22:00:30 +08:00
parent 11e7affc75
commit 256c41fa9c
28 changed files with 157 additions and 1024 deletions
Download Patch File Download Diff File Expand all files Collapse all files
module/Local_Server/server/Adminive_Config.cpp
+71 -129
View File
@@ -229,10 +229,10 @@ struct Type_View_Descriptor<Mode_ACS_Config_Data> {
static Form_View edit() {
using T = Mode_ACS_Config_Data;
return edit_form<T>(vertical(
group("基础时序", grid(2, use<&T::timeout_seconds>(), use<&T::read_milliseconds>(), use<&T::air_pos_timeout>(), use<&T::surface_pos_timeout>())),
group("基础时序", grid(2, use<&T::timeout_seconds>(), use<&T::air_pos_timeout>(), use<&T::surface_pos_timeout>())),
group("过滤参数", grid(2, use<&T::max_speed_m_s>(), use<&T::time_space_filter>(), use<&T::speed_filter>(), use<&T::aircraft_change_list_adsb_range_filter>(), use<&T::aircraft_change_list_adsb_range_factor>(), use<&T::adsb_theoretical_target_altitude_meters>())),
group("容量与上报", grid(2, use<&T::max_track_point_size>(), use<&T::mode_s_max_num>(), use<&T::mode_other_max_num>(), use<&T::report_data_feed_msg_mum>(), use<&T::default_min_aircraft_list_num>(), use<&T::aircraft_change_list_min_position_points>())),
group("运行开关", grid(2, use<&T::wait_process_msg>(), use<&T::ignore_df_11>(), use<&T::monitor_msg_live>())))).submit("保存 Mode ACS 配置");
group("运行开关", grid(2, use<&T::wait_process_msg>(), use<&T::monitor_msg_live>())))).submit("保存 Mode ACS 配置");
}
};
template <>
@@ -250,14 +250,14 @@ template <>
struct Type_View_Descriptor<Data_feed_Config_Data> {
static Form_View edit() {
using T = Data_feed_Config_Data;
return edit_form<T>(grid(2, use<&T::packet_byte_size>(), use<&T::empty_wait_milliseconds>(), use<&T::tcp_server_default_connect_user_buffer_size>(), use<&T::tcp_server_default_connect_system_buffer_size>())).submit("保存数据馈送全局配置");
return edit_form<T>(grid(2, use<&T::packet_byte_size>())).submit("保存数据馈送全局配置");
}
};
template <>
struct Type_View_Descriptor<MLAT_Config_Data> {
static Form_View edit() {
using T = MLAT_Config_Data;
return edit_form<T>(grid(2, use<&T::enable>(), use<&T::merge>(), use<&T::library_path>(), use<&T::function_name>())).submit("保存 MLAT 配置");
return edit_form<T>(grid(2, use<&T::merge>())).submit("保存 MLAT 配置");
}
};
}
@@ -268,41 +268,38 @@ class Conflict_Error final : public std::runtime_error {
public:
using std::runtime_error::runtime_error;
};
class Bad_Request_Error final : public std::runtime_error {
public:
using std::runtime_error::runtime_error;
};
template <class Model>
adminive::Resource_Transaction<Model> value_section_transaction(Config_Section section) {
adminive::Resource_Transaction<Model> transaction;
transaction.commit = [section](const Model& value, const adminive::Request_Context&) {
Config::save(section, value.to_base_json());
};
transaction.rollback = [section](const Model& value, const adminive::Request_Context&) {
Config::save(section, value.to_base_json());
};
transaction.rollback = transaction.commit;
return transaction;
}
adminive::Resource_Transaction<Mode_ACS_Config_Data> mode_acs_transaction() {
adminive::Resource_Transaction<Mode_ACS_Config_Data> transaction;
transaction.commit = [](const Mode_ACS_Config_Data& value, const adminive::Request_Context&) {
SSR::Monitor_Mode_ACS_Message_Num = value.monitor_msg_live;
Config::merge(Config_Section::mode_acs, value.to_base_json());
};
transaction.rollback = [](const Mode_ACS_Config_Data& value, const adminive::Request_Context&) {
const auto persist = [](const Mode_ACS_Config_Data& value, const adminive::Request_Context&) {
SSR::Monitor_Mode_ACS_Message_Num = value.monitor_msg_live;
Config::merge(Config_Section::mode_acs, value.to_base_json());
};
transaction.commit = persist;
transaction.rollback = persist;
return transaction;
}
adminive::Resource_Transaction<Data_feed_Config_Data> data_feed_settings_transaction() {
adminive::Resource_Transaction<Data_feed_Config_Data> transaction;
transaction.commit = [](const Data_feed_Config_Data& value, const adminive::Request_Context&) {
auto patch = Psc::JSON::object();
patch.append({"data_feed", value.to_base_json()});
Config::merge(Config_Section::mode_acs, patch);
};
transaction.rollback = [](const Data_feed_Config_Data& value, const adminive::Request_Context&) {
const auto persist = [](const Data_feed_Config_Data& value, const adminive::Request_Context&) {
auto patch = Psc::JSON::object();
patch.append({"data_feed", value.to_base_json()});
Config::merge(Config_Section::mode_acs, patch);
};
transaction.commit = persist;
transaction.rollback = persist;
return transaction;
}
adminive::Resource_Transaction<Map_View_Config> map_view_transaction(Global* global) {
@@ -321,20 +318,15 @@ adminive::Resource_Transaction<Map_View_Config> map_view_transaction(Global* glo
throw adminive::Field_Validation_Error("map3d.current_terrain_key", "地形源不存在");
});
};
transaction.commit = [global](const Map_View_Config& value, const adminive::Request_Context&) {
global->map_resources_config.write([&](auto& resources) {
resources.current_imagery_key = value.scene_mode == "2d" ? value.map2d.current_imagery_key : value.map3d.current_imagery_key;
});
Config::save(Config_Section::map_view, value.to_base_json());
Config::save(Config_Section::map_resources);
};
transaction.rollback = [global](const Map_View_Config& value, const adminive::Request_Context&) {
const auto persist = [global](const Map_View_Config& value, const adminive::Request_Context&) {
global->map_resources_config.write([&](auto& resources) {
resources.current_imagery_key = value.scene_mode == "2d" ? value.map2d.current_imagery_key : value.map3d.current_imagery_key;
});
Config::save(Config_Section::map_view, value.to_base_json());
Config::save(Config_Section::map_resources);
};
transaction.commit = persist;
transaction.rollback = persist;
return transaction;
}
void save_data_sources(Global* global) {
@@ -358,6 +350,8 @@ template <class Function>
adminive::Http_Response<Json> business_response(Function&& function) noexcept {
try {
return std::forward<Function>(function)();
} catch(const Bad_Request_Error& error) {
return adminive::make_http_error<Json>(400, error.what());
} catch(const Conflict_Error& error) {
return adminive::make_http_error<Json>(409, error.what());
} catch(const std::out_of_range& error) {
@@ -370,6 +364,15 @@ adminive::Http_Response<Json> business_response(Function&& function) noexcept {
return adminive::make_http_error<Json>(500, "unknown server error");
}
}
Json read_request_body(std::string_view body) {
try {
auto input = adminive::parse_json<Json>(body);
adminive::Json_Adapter<Json>::erase(input, "id");
return input;
} catch(const std::exception& error) {
throw Bad_Request_Error(error.what());
}
}
template <class Function>
void complete_business_request(std::function<void(const drogon::HttpResponsePtr&)>& callback, Function&& function) noexcept {
callback(adminive::make_drogon_response(business_response(std::forward<Function>(function))));
@@ -630,6 +633,29 @@ adminive::Http_Response<Json> item_response(std::string path, std::vector<Row> r
adminive::Collection_Service<Row, Json> collection(std::move(path), std::move(rows));
return collection.item_response(id);
}
template <class Row, class Descriptor_Factory, class Rows_Factory, class Schema_Factory>
void bind_collection_read_handlers(drogon::HttpAppFramework& app, std::string path,
Descriptor_Factory descriptor_factory, Rows_Factory rows_factory,
Schema_Factory schema_factory, bool bind_item) {
const auto get = adminive::make_drogon_constraints(drogon::Get, {});
app.registerHandler(path + "/descriptor", [descriptor_factory](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(descriptor_factory())));
}, get);
app.registerHandler(path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Row>(adminive::describe_table_view<Row>()))));
}, get);
app.registerHandler(path + "/amis", [schema_factory](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(schema_factory())));
}, get);
app.registerHandler(path, [path, rows_factory](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(list_response<Row>(path, rows_factory(), read_collection_query(request))));
}, get);
if(bind_item) {
app.registerHandler(path + "/{1:id}", [path, rows_factory](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
callback(adminive::make_drogon_response(item_response<Row>(path, rows_factory(), id)));
}, get);
}
}
std::vector<Data_Source_Row> source_rows(Global* global) {
std::vector<Data_Source_Row> rows;
for(const auto& source : global->mode_acs.data_source_config.map.list())
@@ -832,51 +858,23 @@ private:
}, get);
}
void bind_external_resources(drogon::HttpAppFramework& app) {
const auto get = adminive::make_drogon_constraints(drogon::Get, {});
app.registerHandler(external_resources_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_descriptor_json<Json, External_Resource_Row>())));
}, get);
app.registerHandler(external_resources_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, External_Resource_Row>(adminive::describe_table_view<External_Resource_Row>()))));
}, get);
app.registerHandler(external_resources_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(external_resource_amis_schema())));
}, get);
app.registerHandler(external_resources_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(list_response<External_Resource_Row>(external_resources_path, external_resource_rows(global_), read_collection_query(request))));
}, get);
bind_collection_read_handlers<External_Resource_Row>(app, external_resources_path,
[] { return adminive::to_descriptor_json<Json, External_Resource_Row>(); },
[this] { return external_resource_rows(global_); },
[] { return external_resource_amis_schema(); }, false);
}
void bind_data_sources(drogon::HttpAppFramework& app) {
const auto get = adminive::make_drogon_constraints(drogon::Get, {});
const auto post = adminive::make_drogon_constraints(drogon::Post, {});
const auto put = adminive::make_drogon_constraints(drogon::Put, {});
const auto patch = adminive::make_drogon_constraints(drogon::Patch, {});
const auto remove = adminive::make_drogon_constraints(drogon::Delete, {});
app.registerHandler(data_sources_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(data_source_descriptor())));
}, get);
app.registerHandler(data_sources_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Data_Source_Row>(adminive::describe_table_view<Data_Source_Row>()))));
}, get);
app.registerHandler(data_sources_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(source_amis_schema())));
}, get);
app.registerHandler(data_sources_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(list_response<Data_Source_Row>(data_sources_path, source_rows(global_), read_collection_query(request))));
}, get);
app.registerHandler(data_sources_path + "/{1:id}", [this](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
callback(adminive::make_drogon_response(item_response<Data_Source_Row>(data_sources_path, source_rows(global_), id)));
}, get);
bind_collection_read_handlers<Data_Source_Row>(app, data_sources_path,
[] { return data_source_descriptor(); }, [this] { return source_rows(global_); },
[] { return source_amis_schema(); }, true);
app.registerHandler(data_sources_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
complete_business_request(callback, [this, body = std::string(request->getBody())] {
std::lock_guard lock(topology_mutex_);
Json input;
try {
input = adminive::parse_json<Json>(body);
} catch(const std::exception& error) {
return adminive::make_http_error<Json>(400, error.what());
}
adminive::Json_Adapter<Json>::erase(input, "id");
auto input = read_request_body(body);
Data_Source_Row row;
const auto result = adminive::apply_frontend_create<Json>(row, input);
if(!result.success)
@@ -897,13 +895,7 @@ private:
std::lock_guard lock(topology_mutex_);
const auto list = global_->mode_acs.data_source_config.map.list();
auto source = item_by_id(list, id);
Json input;
try {
input = adminive::parse_json<Json>(body);
} catch(const std::exception& error) {
return adminive::make_http_error<Json>(400, error.what());
}
adminive::Json_Adapter<Json>::erase(input, "id");
auto input = read_request_body(body);
auto row = source_row(source);
const auto result = adminive::apply_frontend_patch<Json>(row, input);
if(!result.success)
@@ -945,36 +937,17 @@ private:
}, post);
}
void bind_data_feeds(drogon::HttpAppFramework& app) {
const auto get = adminive::make_drogon_constraints(drogon::Get, {});
const auto post = adminive::make_drogon_constraints(drogon::Post, {});
const auto put = adminive::make_drogon_constraints(drogon::Put, {});
const auto patch = adminive::make_drogon_constraints(drogon::Patch, {});
const auto remove = adminive::make_drogon_constraints(drogon::Delete, {});
app.registerHandler(data_feeds_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_descriptor_json<Json, Data_Feed_Row>())));
}, get);
app.registerHandler(data_feeds_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Data_Feed_Row>(adminive::describe_table_view<Data_Feed_Row>()))));
}, get);
app.registerHandler(data_feeds_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(feed_amis_schema())));
}, get);
app.registerHandler(data_feeds_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(list_response<Data_Feed_Row>(data_feeds_path, feed_rows(global_), read_collection_query(request))));
}, get);
app.registerHandler(data_feeds_path + "/{1:id}", [this](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
callback(adminive::make_drogon_response(item_response<Data_Feed_Row>(data_feeds_path, feed_rows(global_), id)));
}, get);
bind_collection_read_handlers<Data_Feed_Row>(app, data_feeds_path,
[] { return adminive::to_descriptor_json<Json, Data_Feed_Row>(); },
[this] { return feed_rows(global_); }, [] { return feed_amis_schema(); }, true);
app.registerHandler(data_feeds_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
complete_business_request(callback, [this, body = std::string(request->getBody())] {
std::lock_guard lock(topology_mutex_);
Json input;
try {
input = adminive::parse_json<Json>(body);
} catch(const std::exception& error) {
return adminive::make_http_error<Json>(400, error.what());
}
adminive::Json_Adapter<Json>::erase(input, "id");
auto input = read_request_body(body);
Data_Feed_Row row;
const auto result = adminive::apply_frontend_create<Json>(row, input);
if(!result.success)
@@ -995,13 +968,7 @@ private:
std::lock_guard lock(topology_mutex_);
const auto list = global_->mode_acs.data_feed_config.map.list();
auto feed = item_by_id(list, id);
Json input;
try {
input = adminive::parse_json<Json>(body);
} catch(const std::exception& error) {
return adminive::make_http_error<Json>(400, error.what());
}
adminive::Json_Adapter<Json>::erase(input, "id");
auto input = read_request_body(body);
auto row = feed_row(feed);
const auto result = adminive::apply_frontend_patch<Json>(row, input);
if(!result.success)
@@ -1043,36 +1010,17 @@ private:
}, post);
}
void bind_relations(drogon::HttpAppFramework& app) {
const auto get = adminive::make_drogon_constraints(drogon::Get, {});
const auto post = adminive::make_drogon_constraints(drogon::Post, {});
const auto put = adminive::make_drogon_constraints(drogon::Put, {});
const auto patch = adminive::make_drogon_constraints(drogon::Patch, {});
const auto remove = adminive::make_drogon_constraints(drogon::Delete, {});
app.registerHandler(relations_path + "/descriptor", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_descriptor_json<Json, Source_Feed_Relation_Row>())));
}, get);
app.registerHandler(relations_path + "/view", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(adminive::to_view_json<Json, Source_Feed_Relation_Row>(adminive::describe_table_view<Source_Feed_Relation_Row>()))));
}, get);
app.registerHandler(relations_path + "/amis", [](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(adminive::make_http_success<Json>(relation_amis_schema())));
}, get);
app.registerHandler(relations_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
callback(adminive::make_drogon_response(list_response<Source_Feed_Relation_Row>(relations_path, relation_rows(global_), read_collection_query(request))));
}, get);
app.registerHandler(relations_path + "/{1:id}", [this](const drogon::HttpRequestPtr&, std::function<void(const drogon::HttpResponsePtr&)>&& callback, std::uint64_t id) {
callback(adminive::make_drogon_response(item_response<Source_Feed_Relation_Row>(relations_path, relation_rows(global_), id)));
}, get);
bind_collection_read_handlers<Source_Feed_Relation_Row>(app, relations_path,
[] { return adminive::to_descriptor_json<Json, Source_Feed_Relation_Row>(); },
[this] { return relation_rows(global_); }, [] { return relation_amis_schema(); }, true);
app.registerHandler(relations_path, [this](const drogon::HttpRequestPtr& request, std::function<void(const drogon::HttpResponsePtr&)>&& callback) {
complete_business_request(callback, [this, body = std::string(request->getBody())] {
std::lock_guard lock(topology_mutex_);
Json input;
try {
input = adminive::parse_json<Json>(body);
} catch(const std::exception& error) {
return adminive::make_http_error<Json>(400, error.what());
}
adminive::Json_Adapter<Json>::erase(input, "id");
auto input = read_request_body(body);
Source_Feed_Relation_Row row;
const auto result = adminive::apply_frontend_create<Json>(row, input);
if(!result.success)
@@ -1092,13 +1040,7 @@ private:
std::lock_guard lock(topology_mutex_);
const auto list = global_->mode_acs.source_feed_relation_config.map.list();
auto relation = item_by_id(list, id);
Json input;
try {
input = adminive::parse_json<Json>(body);
} catch(const std::exception& error) {
return adminive::make_http_error<Json>(400, error.what());
}
adminive::Json_Adapter<Json>::erase(input, "id");
auto input = read_request_body(body);
auto row = relation_row(relation);
const auto result = adminive::apply_frontend_patch<Json>(row, input);
if(!result.success)