what

src/route/error.rs

@@ -6,15 +6,15 @@ use axum::{
 use serde::Serialize;
 
 #[derive(Debug, Serialize)]
-pub struct ApiError {
+pub struct ApiError<T: Serialize> {
     #[serde(skip_serializing, skip_deserializing)]
     pub code: StatusCode,
-    pub error: String,
+    pub error: T,
 }
 
-impl ApiError {
+impl<T: Serialize> ApiError<T> {
     /// [StatusCode::INTERNAL_SERVER_ERROR] shortcut
-    pub const fn ise(error: String) -> Self {
+    pub const fn ise(error: T) -> Self {
         Self {
             code: StatusCode::INTERNAL_SERVER_ERROR,
             error,
@@ -22,7 +22,7 @@ impl ApiError {
     }
 }
 
-impl IntoResponse for ApiError {
+impl<T: Serialize> IntoResponse for ApiError<T> {
     fn into_response(self) -> Response {
         (self.code, Json(self)).into_response()
     }

src/route/mod.rs

@@ -12,6 +12,7 @@ use crate::route::api::status_redirect;
 use crate::route::api::status_smart_redirect;
 use crate::route::devs::devs_router;
 use crate::route::dhcp::get_dhcp_leases;
+use crate::route::error::ApiError;
 use crate::route::status::get_status_json;
 use crate::route::wake::wake_multi;
 
@@ -48,7 +49,7 @@ pub fn api_router() -> Router {
             "/mac-cache",
             get(async || match load_mac_name_cache().await {
                 Ok(h) => Json(h).into_response(),
-                Err(e) => e.to_string().into_response(),
+                Err(e) => ApiError::ise(e.to_string()).into_response(),
             }),
         )
         .layer(middleware::from_fn(add_performance_header))

src/route/wake/impls.rs

@@ -4,23 +4,6 @@ use crate::route::wake::{
     WakeTargetStatus as RouteWakeStatus,
 };
 
-#[derive(Debug, Clone, Copy)]
-pub struct Incomplete;
-
-impl TryFrom<RouteWakeTarget> for WakeTarget {
-    type Error = Incomplete;
-    fn try_from(value: RouteWakeTarget) -> Result<Self, Self::Error> {
-        if let RouteWakeTarget {
-            ip: Some(ip),
-            mac: Some(mac),
-        } = value
-        {
-            Ok(Self { ip, mac })
-        } else {
-            Err(Incomplete)
-        }
-    }
-}
 
 impl From<WakeTarget> for RouteWakeTarget {
     fn from(WakeTarget { ip, mac }: WakeTarget) -> Self {

src/route/wake/mod.rs

@@ -4,8 +4,8 @@ use std::net::IpAddr;
 
 /* use crate::arpparse::IpNeighLine;
 use crate::route::api::Status; */
-use crate::utils::parse::mac;
 use crate::utils::wake::wake_one;
+use crate::{route::error::ApiError, utils::parse::mac};
 use axum::{extract::Json, http::StatusCode, response::IntoResponse};
 use futures::TryFutureExt;
 use macaddr::MacAddr;
@@ -13,12 +13,9 @@ use serde::{Deserialize, Serialize};
 use serde_with::skip_serializing_none;
 use tokio::net::UdpSocket;
 
-#[skip_serializing_none]
 #[derive(Debug, Default, Serialize, Clone)]
 pub struct WakeResult {
-    pub success: bool,
-    pub result: Option<Vec<WakeTargetResult>>,
-    pub error: Option<String>,
+    pub result: Vec<WakeTargetResult>,
 }
 #[skip_serializing_none]
 #[derive(Debug, Serialize, Clone, Copy)]
@@ -50,24 +47,10 @@ pub struct WakeTarget {
 
 pub async fn wake_multi(Json(req): Json<Vec<WakeTarget>>) -> impl IntoResponse {
     match wake_multi_split(req).await {
-        Ok(results) => (
-            StatusCode::OK,
-            Json(WakeResult {
-                success: true,
-                result: Some(results),
-                ..Default::default()
-            }),
-        ),
+        Ok(result) => (StatusCode::OK, Json(WakeResult { result })).into_response(),
         Err(error) => {
-            let error = Some(format!("Error: {}", error));
-            (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                Json(WakeResult {
-                    success: false,
-                    error,
-                    ..Default::default()
-                }),
-            )
+            let error = format!("Error: {}", error);
+            ApiError::ise(error).into_response()
         }
     }
 }

src/utils/wake.rs

@@ -6,6 +6,8 @@ use futures::TryFutureExt;
 use macaddr::MacAddr;
 use tokio::net::UdpSocket;
 
+use crate::route::wake::WakeTarget as RouteWakeTarget;
+
 #[derive(Debug, Clone, Copy, Hash)]
 pub struct WakeTarget {
     pub ip: IpAddr,
@@ -36,6 +38,25 @@ impl WakeTarget {
         WakeTargetResult::new(self, WakeStatus::NonexistentAddress)
     }
 }
+
+#[derive(Debug, Clone, Copy)]
+pub struct Incomplete;
+
+impl TryFrom<RouteWakeTarget> for WakeTarget {
+    type Error = Incomplete;
+    fn try_from(value: RouteWakeTarget) -> Result<Self, Self::Error> {
+        if let RouteWakeTarget {
+            ip: Some(ip),
+            mac: Some(mac),
+        } = value
+        {
+            Ok(Self { ip, mac })
+        } else {
+            Err(Incomplete)
+        }
+    }
+}
+
 impl WakeTargetResult {
     const fn new(target: WakeTarget, status: WakeStatus) -> Self {
         Self { target, status }

static/home_2/wake.js

@@ -33,7 +33,7 @@ export async function sendWake(name) {
 
     const j = await r.json();
 
-    if (!j.success) {
+    if (j.error) {
       elLog.textContent = `wake error: ${j.error}`;
       setPill("bad", "error");
       return;