chore: expect is no more

Author: filipton

src/bluetooth.rs

@@ -389,14 +389,14 @@ async fn load_bonding_info(nvs: &esp_hal_wifimanager::Nvs) -> Option<BondInforma
         return None;
     }
 
-    let bd_addr = BdAddr::new(buf[..6].try_into().expect(""));
+    let bd_addr = BdAddr::new(buf[..6].try_into().unwrap_or_default());
     let security_level = match buf[22] {
         0 => SecurityLevel::NoEncryption,
         1 => SecurityLevel::Encrypted,
         2 => SecurityLevel::EncryptedAuthenticated,
         _ => return None,
     };
-    let ltk = LongTermKey::from_le_bytes(buf[6..22].try_into().expect(""));
+    let ltk = LongTermKey::from_le_bytes(buf[6..22].try_into().unwrap_or_default());
 
     Some(BondInformation {
         identity: Identity { bd_addr, irk: None },

src/buttons.rs

@@ -485,44 +485,47 @@ async fn delegate_hold(
                 return Ok(false);
             }
 
-            if state_val.session_id.is_none() {
-                state_val.session_id = Some(uuid::Uuid::new_v4().to_string());
-            }
-
-            if state_val.current_competitor.is_none() || state_val.solve_group.is_none() {
+            let (Some(current_competitor), Some(solve_group)) = (
+                state_val.current_competitor,
+                state_val.solve_group.clone().map(|x| x.group_id),
+            ) else {
                 log::error!("Delegate hold: competitor or solve_group none!");
                 return Ok(false);
-            }
+            };
 
             if unsafe { !crate::state::TRUST_SERVER } {
                 log::error!("Skipping delegate hold. Server not trusted!");
                 return Ok(false);
             }
 
             let inspection_time = if state_val.use_inspection()
-                && state_val.inspection_start.is_some()
-                && state_val.inspection_end.is_some()
+                && let Some(start) = state_val.inspection_start
+                && let Some(end) = state_val.inspection_end
             {
-                (state_val.inspection_end.expect("") - state_val.inspection_start.expect(""))
-                    .as_millis() as i64
+                (end - start).as_millis() as i64
             } else {
                 0
             };
 
-            if state_val.session_id.is_none() {
-                state_val.session_id = Some(uuid::Uuid::new_v4().to_string());
-            }
+            let session_id = match &state_val.session_id {
+                Some(sess_id) => sess_id.clone(),
+                None => {
+                    let sess_id = uuid::Uuid::new_v4().to_string();
+                    state_val.session_id = Some(sess_id.clone());
+                    sess_id
+                }
+            };
 
             let packet = crate::structs::TimerPacketInner::Solve {
                 solve_time: state_val.solve_time.unwrap_or(0),
                 penalty: state_val.penalty.unwrap_or(0) as i64,
-                competitor_id: state_val.current_competitor.expect(""),
+                competitor_id: current_competitor,
                 judge_id: state_val.current_judge.unwrap_or(0),
                 timestamp: current_epoch(),
-                session_id: state_val.session_id.clone().expect(""),
+                session_id,
                 delegate: true,
                 inspection_time,
-                group_id: state_val.solve_group.clone().map(|r| r.group_id).expect(""),
+                group_id: solve_group,
                 sign_key: unsafe { crate::state::SIGN_KEY },
             };
 

src/main.rs

@@ -264,7 +264,7 @@ async fn main(spawner: Spawner) {
 
                     mdns_res.to_string()
                 } else {
-                    conn_settings.ws_url.clone().expect("")
+                    conn_settings.ws_url.clone().unwrap_or_default()
                 };
 
             let ws_url = WsUrl::from_str(&url);

src/rfid.rs

@@ -304,7 +304,7 @@ pub async fn rfid_task(
                 continue;
             }
 
-            let secured_uid = u128::from_be_bytes(buff[..16].try_into().expect(""));
+            let secured_uid = u128::from_be_bytes(buff[..16].try_into().unwrap_or_default());
             if secured_uid != card_uid {
                 log::error!("Card is not secure!");
                 log::debug!("read: {res:?}, data: {buff:#?}");
@@ -404,8 +404,8 @@ async fn process_card_info_response(
         crate::state::Scene::Finished => {
             if state.current_competitor != Some(resp.card_id) && state.time_confirmed {
                 state.current_judge = Some(resp.card_id);
-            } else if state.current_competitor.is_some()
-                && state.current_judge.is_some()
+            } else if let Some(current_competitor) = state.current_competitor
+                && let Some(current_judge) = state.current_judge
                 && state.current_competitor == Some(resp.card_id)
                 && state.time_confirmed
             {
@@ -416,14 +416,19 @@ async fn process_card_info_response(
                     .map(|(end, start)| (end - start).as_millis() as i64)
                     .unwrap_or(0);
 
-                if state.session_id.is_none() {
-                    state.session_id = Some(uuid::Uuid::new_v4().to_string());
-                }
+                let session_id = match &state.session_id {
+                    Some(sess_id) => sess_id.clone(),
+                    None => {
+                        let sess_id = uuid::Uuid::new_v4().to_string();
+                        state.session_id = Some(sess_id.clone());
+                        sess_id
+                    }
+                };
 
-                if state.solve_group.is_none() {
+                let Some(ref solve_group) = state.solve_group else {
                     log::error!("Solve group is none! (How would that happen?)");
                     return Ok(());
-                }
+                };
 
                 if unsafe { !crate::state::TRUST_SERVER } {
                     log::error!("Skipping solve send. Server not trusted!");
@@ -434,20 +439,20 @@ async fn process_card_info_response(
                     crate::structs::TimerPacketInner::Solve {
                         solve_time: state.solve_time.ok_or(anyhow!("Solve time is None"))?,
                         penalty: state.penalty.unwrap_or(0) as i64,
-                        competitor_id: state.current_competitor.expect(""),
-                        judge_id: state.current_judge.expect(""),
+                        competitor_id: current_competitor,
+                        judge_id: current_judge,
                         timestamp: current_epoch(),
-                        session_id: state.session_id.clone().expect(""),
+                        session_id,
                         delegate: false,
                         inspection_time,
-                        group_id: state.solve_group.clone().map(|r| r.group_id).expect(""),
+                        group_id: solve_group.group_id.clone(),
                         sign_key: unsafe { crate::state::SIGN_KEY },
                     },
                 )
                 .await;
 
                 if resp.is_ok() {
-                    log::info!("solve_resp: {resp:?}");
+                    log::warn!("solve_resp: {resp:?}");
                     state.reset_solve_state(Some(&global_state.nvs)).await;
                 }
             }

src/ws.rs

@@ -219,8 +219,8 @@ async fn ws_loop(
                 .await
                 .decrypt(&mut block, esp_hal::aes::Key::Key128(key));
 
-            let recv_random = u64::from_be_bytes(block[..8].try_into().expect(""));
-            let fkm_token = i32::from_be_bytes(block[8..12].try_into().expect(""));
+            let recv_random = u64::from_be_bytes(block[..8].try_into().unwrap_or_default());
+            let fkm_token = i32::from_be_bytes(block[8..12].try_into().unwrap_or_default());
 
             log::debug!(
                 "[trust] random: {random}, recv_random: {recv_random} | fkm_token: {fkm_token}"