清理所有的unwrap()

htycommons/src/common.rs

@@ -115,7 +115,8 @@ pub fn parse_date_time(date_time: &String) -> anyhow::Result<NaiveDateTime> {
 }
 
 pub fn parse_bool(bool_val: &String) -> anyhow::Result<bool> {
-    Ok(bool_val.trim().parse().unwrap())
+    bool_val.trim().parse()
+        .map_err(|e| anyhow::anyhow!("Failed to parse bool: {}", e))
 }
 
 pub fn get_some_from_query_params<T: FromStr + Default>(
@@ -159,35 +160,35 @@ pub fn strip_result_vec<T>(in_vec: Vec<anyhow::Result<T>>) -> anyhow::Result<Vec
     Ok(out_vec)
 }
 
-pub fn extract_filename_from_url(url: &String) -> String {
-    url.split("/").last().unwrap().to_string()
+pub fn extract_filename_from_url(url: &String) -> Option<String> {
+    url.split("/").last().filter(|s| !s.is_empty()).map(|s| s.to_string())
 }
 
 pub fn date_to_string(date: &NaiveDateTime) -> String {
     date.format("%Y-%m-%d").to_string()
 }
 
 pub fn string_to_datetime(datetime: &Option<String>) -> anyhow::Result<Option<NaiveDateTime>> {
-    if datetime.is_none() {
-        return Ok(None);
-    } else {
+    if let Some(dt) = datetime {
         Ok(Some(NaiveDateTime::parse_from_str(
-            datetime.as_ref().unwrap().as_str(),
+            dt.as_str(),
             "%Y-%m-%d %H:%M:%S",
         )?))
+    } else {
+        Ok(None)
     }
 }
 
 pub fn string_to_date(date: &Option<String>) -> anyhow::Result<Option<NaiveDateTime>> {
     debug!("string_to_date -> {:?}", date);
 
-    if date.is_none() {
-        return Ok(None);
-    } else {
+    if let Some(d) = date {
         Ok(Some(
-            NaiveDate::parse_from_str(date.as_ref().unwrap().as_str(), "%Y-%m-%d")?
+            NaiveDate::parse_from_str(d.as_str(), "%Y-%m-%d")?
                 .and_time(NaiveTime::from_str("00:00:00")?),
         ))
+    } else {
+        Ok(None)
     }
 }
 

htycommons/src/db.rs

@@ -47,7 +47,7 @@ pub fn pool(db_url: &str) -> PgPool {
     let max_size = env::var("POOL_SIZE")
         .expect("POOL_SIZE must be set")
         .parse::<u32>()
-        .unwrap();
+        .unwrap_or_else(|e| panic!("Failed to parse POOL_SIZE: {}", e));
 
     Pool::builder()
         .max_size(max_size)

htycommons/src/jwt.rs

@@ -21,9 +21,18 @@ pub fn jwt_key() -> String {
 }
 
 pub fn jwt_encode_token(token: HtyToken) -> Result<String, HtyErr> {
-    let t = n_hour_later(&current_local_datetime(), 10000).and_utc().timestamp() as usize;
+    let t = n_hour_later(&current_local_datetime(), 10000)
+        .map_err(|e| HtyErr {
+            code: HtyErrCode::JwtErr,
+            reason: Some(format!("Failed to calculate expiration time: {}", e)),
+        })?
+        .and_utc().timestamp() as usize;
     let claims = HtyJwtClaims {
-        sub: serde_json::to_string(&token).unwrap(),
+        sub: serde_json::to_string(&token)
+            .map_err(|e| HtyErr {
+                code: HtyErrCode::JwtErr,
+                reason: Some(format!("Failed to serialize token: {}", e)),
+            })?,
         exp: t,
         iat: t,
     };
@@ -57,7 +66,11 @@ fn _jwt_decode_claims(token: &String, validation: &Validation) -> Result<HtyToke
         Ok(v) => {
             //debug(format!("decoded obj -> {:?}", v).as_str());
             debug!("_jwt_decode_claims -> decoded token:  {:?}", v);
-            Ok(serde_json::from_str::<HtyToken>(v.claims.sub.as_str()).unwrap())
+            serde_json::from_str::<HtyToken>(v.claims.sub.as_str())
+                .map_err(|e| HtyErr {
+                    code: HtyErrCode::JwtErr,
+                    reason: Some(format!("Failed to deserialize token: {}", e)),
+                })
         }
         Err(err) => Err(wrap_err(JwtErr, Box::from(err))),
     }

htycommons/src/lib.rs

@@ -53,8 +53,10 @@ pub fn pass_or_panic2<T>(res: anyhow::Result<T>) {
     }
 }
 
-pub fn n_hour_later(now: &NaiveDateTime, n: i64) -> NaiveDateTime {
-    *now + chrono::Duration::try_hours(n).unwrap()
+pub fn n_hour_later(now: &NaiveDateTime, n: i64) -> anyhow::Result<NaiveDateTime> {
+    chrono::Duration::try_hours(n)
+        .map(|duration| *now + duration)
+        .ok_or_else(|| anyhow::anyhow!("Invalid number of hours: {}", n))
 }
 
 pub fn remove_quote(str: &String) -> String {

htycommons/src/logger.rs

@@ -64,7 +64,7 @@ pub fn logger_init() -> () {
     // let timer = UtcTime::new(time::format_description::well_known::Rfc3339);
     // https://rustcc.cn/article?id=66e2a76e-8c65-42f7-a773-66dff1a2a21e
     let local_time = OffsetTime::new(
-        UtcOffset::from_hms(8, 0, 0).unwrap(),
+        UtcOffset::from_hms(8, 0, 0).unwrap_or_else(|_| UtcOffset::from_hms(0, 0, 0).expect("Failed to create UTC offset")),
         format_description!("[year]-[month]-[day] [hour]:[minute]:[second].[subsecond digits:3]"),
     );
 

htycommons/src/pagination.rs

@@ -11,7 +11,7 @@ pub trait Paginate: Sized {
 
 impl<T> Paginate for T {
     fn paginate(self, page: Option<i64>) -> Paginated<Self> {
-        let offset = if page.is_some() { (page.clone().unwrap() - 1) * DEFAULT_PER_PAGE } else { -1 };
+        let offset = if let Some(p) = page { (p - 1) * DEFAULT_PER_PAGE } else { -1 };
         Paginated {
             query: self,
             some_per_page: Some(DEFAULT_PER_PAGE),
@@ -35,8 +35,8 @@ pub struct Paginated<T> {
 
 impl<T> Paginated<T> {
     pub fn per_page(self, some_per_page: Option<i64>) -> Self {
-        let per_page = if some_per_page.is_some() { some_per_page.clone().unwrap() } else { -1 };
-        let offset = if some_per_page.is_some() && self.page.is_some() { (self.page.clone().unwrap() - 1) * some_per_page.clone().unwrap() } else { -1 };
+        let per_page = some_per_page.unwrap_or(-1);
+        let offset = if let (Some(sp), Some(p)) = (some_per_page, self.page) { (p - 1) * sp } else { -1 };
 
         Paginated {
             some_per_page,
@@ -60,8 +60,7 @@ impl<T> Paginated<T> {
 
         let unwrapped_results = results?;
 
-        if some_page.is_some() && some_per_page.is_some() {
-            let per_page = some_per_page.unwrap();
+        if let (Some(_), Some(per_page)) = (some_page, some_per_page) {
             let total = unwrapped_results.get(0).map(|x| x.1).unwrap_or(0);
             let records = unwrapped_results.into_iter().map(|x| x.0).collect();
             let total_pages = (total as f64 / per_page as f64).ceil() as i64;

htycommons/src/redis_util.rs

@@ -17,11 +17,11 @@ pub const OPENID_INFO: &str = "OPENID_INFO_";
 pub const CACHED: &str = "C_";
 
 
-pub fn get_token_expiration_days() -> usize {
+pub fn get_token_expiration_days() -> anyhow::Result<usize> {
     env::var("EXPIRATION_DAYS")
         .expect("EXPIRATION_DAYS not set!!!")
         .parse()
-        .unwrap()
+        .map_err(|e| anyhow::anyhow!("Failed to parse EXPIRATION_DAYS: {}", e))
 }
 
 pub fn get_redis_url() -> anyhow::Result<String> {
@@ -50,7 +50,7 @@ pub fn save_token_with_exp_days(token: &HtyToken, expiration_day: usize) -> anyh
     prefix_key.push_str(token.clone().token_id.as_str());
 
     save_kv_to_redis_with_exp_days(&prefix_key,
-                                   &jwt_encode_token(token.clone()).unwrap(),
+                                   &jwt_encode_token(token.clone())?,
                                    expiration_day)
 }
 
@@ -79,7 +79,7 @@ pub fn save_kv_to_redis(key: &String, value: &String) -> anyhow::Result<()> {
 
     let mut prefix_key = HTY_REDIS_KEY_PREFIX.to_string();
     prefix_key.push_str(key);
-    let redis_url = get_redis_url().unwrap();
+    let redis_url = get_redis_url()?;
 
     match Client::open(redis_url.clone()) {
         Ok(cli) => match cli.get_connection() {
@@ -113,7 +113,7 @@ pub fn save_kv_to_redis_with_exp_secs(key: &String, value: &String, expiration_s
 
     let mut prefix_key = HTY_REDIS_KEY_PREFIX.to_string();
     prefix_key.push_str(key);
-    let redis_url = get_redis_url().unwrap();
+    let redis_url = get_redis_url()?;
 
     match Client::open(redis_url.clone()) {
         Ok(cli) => match cli.get_connection() {
@@ -153,7 +153,7 @@ pub fn get_value_from_redis(key: &String) -> anyhow::Result<String> {
     let mut prefix_key = HTY_REDIS_KEY_PREFIX.to_string();
     prefix_key.push_str(key);
     debug!("get_value_from_redis() -> key / {:?}", &prefix_key);
-    let redis_url = get_redis_url().unwrap();
+    let redis_url = get_redis_url()?;
     let mut redis_conn = Client::open(redis_url.clone())?.get_connection()?;
     let value = redis_conn.get(prefix_key)?;
     debug!("get_value_from_redis() -> token : {:?}", value);
@@ -164,15 +164,15 @@ pub fn get_opt_value_from_redis(key: &String) -> anyhow::Result<Option<String>>
     let mut prefix_key = HTY_REDIS_KEY_PREFIX.to_string();
     prefix_key.push_str(key);
     debug!("get_value_from_redis2() -> key / {:?}", &prefix_key);
-    let redis_url = get_redis_url().unwrap();
+    let redis_url = get_redis_url()?;
     let mut redis_conn = Client::open(redis_url.clone())?.get_connection()?;
     let value = redis_conn.get(prefix_key)?;
     debug!("get_value_from_redis2() -> token : {:?}", value);
     Ok(value)
 }
 
 pub fn is_key_exist_in_redis(key: &String) -> anyhow::Result<bool> {
-    let redis_url = get_redis_url().unwrap();
+    let redis_url = get_redis_url()?;
 
     let mut prefix_key = HTY_REDIS_KEY_PREFIX.to_string();
     prefix_key.push_str(key);
@@ -187,7 +187,7 @@ pub fn is_key_exist_in_redis(key: &String) -> anyhow::Result<bool> {
 pub fn verify_jwt(jwt_token: &String) -> anyhow::Result<()> {
     dotenv().ok();
     //Save token to redis
-    let redis_url = get_redis_url().unwrap();
+    let redis_url = get_redis_url()?;
     debug!("verify_jwt -> redis_url / {:?}", redis_url.clone());
     debug!("verify_jwt -> jwt_token to verify: {:?}", jwt_token.clone());
 
@@ -227,7 +227,7 @@ pub fn del_from_redis(key: &String) -> anyhow::Result<String> {
     let mut prefix_key = HTY_REDIS_KEY_PREFIX.to_string();
     prefix_key.push_str(key);
 
-    let redis_url = get_redis_url().unwrap();
+    let redis_url = get_redis_url()?;
 
     let mut redis_conn = Client::open(redis_url.clone())?.get_connection()?;
 

htycommons/src/test_scaffold.rs

@@ -74,9 +74,9 @@ pub fn my_assert_not_none<T: Eq + Debug>(val: &Option<T>) -> Result<(), HtyErr>
 }
 
 
-pub fn get_test_app_domain() -> u16 {
+pub fn get_test_app_domain() -> anyhow::Result<u16> {
     env::var("TEST_APP_DOMAIN")
         .expect("TEST_APP_DOMAIN not set!!!")
         .parse()
-        .unwrap()
+        .map_err(|e| anyhow::anyhow!("Failed to parse TEST_APP_DOMAIN: {}", e))
 }

htycommons/src/upyun.rs

@@ -72,7 +72,8 @@ pub async fn upyun_delete_by_filename(in_filename: &String, sudoer: &String, hos
     let url = format!("{}/image/upyun_remove", get_ngx_url());
     debug!("upyun_delete_by_filename -> url: {}", url);
 
-    let body = serde_json::to_string::<UpyunFilename>(&upyun_filename).unwrap();
+    let body = serde_json::to_string::<UpyunFilename>(&upyun_filename)
+        .map_err(|e| anyhow::anyhow!("Failed to serialize upyun_filename: {}", e))?;
     debug!("upyun_delete_by_filename -> body: {}", body);