cargo clippy

src/common/constant.rs

@@ -1,9 +1,9 @@
-pub const APP_VERSION: &'static str = "0.4.0-beta.4";
+pub const APP_VERSION: &str = "0.4.0-beta.4";
 
-pub const EMPTY_STR: &'static str = "";
+pub const EMPTY_STR: &str = "";
 
-pub const HTTP_METHOD_GET: &'static str = "GET";
-//pub const HTTP_METHOD_PUT:&'static str= "PUT";
-//pub const HTTP_METHOD_POST:&'static str= "POST";
-//pub const HTTP_METHOD_DELETE:&'static str= "DELETE";
-pub const HTTP_METHOD_ALL: &'static str = EMPTY_STR;
+pub const HTTP_METHOD_GET: &str = "GET";
+//pub const HTTP_METHOD_PUT:&str= "PUT";
+//pub const HTTP_METHOD_POST:&str= "POST";
+//pub const HTTP_METHOD_DELETE:&str= "DELETE";
+pub const HTTP_METHOD_ALL: &str = EMPTY_STR;

src/console/login_api.rs

@@ -40,7 +40,7 @@ pub async fn login(
     let captcha_check_result = if let Ok(Ok(CacheManagerResult::Value(CacheValue::String(v)))) =
         app.cache_manager.send(cache_req).await
     {
-        v.as_str() == &captcha_code
+        &captcha_code == v.as_ref()
     } else {
         false
     };

src/console/model/user_model.rs

@@ -36,12 +36,7 @@ impl UpdateUserInfoParam {
             if roles.is_empty() {
                 return None;
             }
-            Some(
-                roles
-                    .split(',')
-                    .map(|e| UserRoleHelper::get_role(e))
-                    .collect(),
-            )
+            Some(roles.split(',').map(UserRoleHelper::get_role).collect())
         } else {
             None
         }
@@ -56,7 +51,7 @@ impl From<UpdateUserInfoParam> for UserDto {
             nickname: value.nickname,
             password: value.password,
             enable: value.enable,
-            roles: roles,
+            roles,
             ..Default::default()
         }
     }

src/console/user_api.rs

@@ -72,43 +72,46 @@ pub async fn reset_password(
     app: Data<Arc<AppShareData>>,
     web::Form(param): web::Form<ResetPasswordParam>,
 ) -> actix_web::Result<impl Responder> {
-    if let Some(session) = req.extensions().get::<Arc<UserSession>>() {
+    let (msg, username) = if let Some(session) = req.extensions().get::<Arc<UserSession>>() {
         let username = Arc::new(session.username.to_string());
-        let msg = UserManagerReq::CheckUser {
-            name: username.clone(),
-            password: param.old_password,
-        };
-        if let Ok(Ok(v)) = app.user_manager.send(msg).await {
-            match v {
-                UserManagerResult::CheckUserResult(valid, _user) => {
-                    if valid {
-                        let msg = UserManagerReq::UpdateUser {
-                            user: UserDto {
-                                username: username,
-                                password: Some(param.new_password),
-                                ..Default::default()
-                            },
-                        };
-                        if let Ok(Ok(_r)) = app.user_manager.send(msg).await {
-                            return Ok(HttpResponse::Ok().json(ApiResult::success(Some(true))));
-                        }
+        (
+            UserManagerReq::CheckUser {
+                name: username.clone(),
+                password: param.old_password,
+            },
+            username,
+        )
+    } else {
+        return Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
+            "NOT_FOUND_USER_SESSION".to_owned(),
+            None,
+        )));
+    };
+    if let Ok(Ok(v)) = app.user_manager.send(msg).await {
+        match v {
+            UserManagerResult::CheckUserResult(valid, _user) => {
+                if valid {
+                    let msg = UserManagerReq::UpdateUser {
+                        user: UserDto {
+                            username,
+                            password: Some(param.new_password),
+                            ..Default::default()
+                        },
+                    };
+                    if let Ok(Ok(_r)) = app.user_manager.send(msg).await {
+                        return Ok(HttpResponse::Ok().json(ApiResult::success(Some(true))));
                     }
                 }
-                _ => {
-                    return Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
-                        "OLD_PASSWORD_INVALID".to_owned(),
-                        None,
-                    )))
-                }
+            }
+            _ => {
+                return Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
+                    "OLD_PASSWORD_INVALID".to_owned(),
+                    None,
+                )))
             }
         }
-        Ok(HttpResponse::Ok().json(ApiResult::<()>::error("SYSTEM_ERROR".to_owned(), None)))
-    } else {
-        Ok(HttpResponse::Ok().json(ApiResult::<()>::error(
-            "NOT_FOUND_USER_SESSION".to_owned(),
-            None,
-        )))
     }
+    Ok(HttpResponse::Ok().json(ApiResult::<()>::error("SYSTEM_ERROR".to_owned(), None)))
 }
 
 pub async fn get_user_page_list(

src/middle/login_middle.rs

@@ -182,10 +182,7 @@ async fn get_user_session(
     req: CacheManagerReq,
 ) -> anyhow::Result<Option<Arc<UserSession>>> {
     match cache_manager.send(req).await?? {
-        CacheManagerResult::Value(v) => match v {
-            CacheValue::UserSession(session) => Ok(Some(session)),
-            _ => Ok(None),
-        },
+        CacheManagerResult::Value(CacheValue::UserSession(session)) => Ok(Some(session)),
         _ => Ok(None),
     }
 }

src/user/permission.rs

@@ -312,7 +312,7 @@ impl UserRole {
                 .unwrap()
                 .web_resources
                 .iter()
-                .map(|e| *e)
+                .copied()
                 .collect();
         }
         let mut set = HashSet::new();
@@ -321,12 +321,12 @@ impl UserRole {
                 set.insert(*item);
             }
         }
-        set.into_iter().map(|e| e).collect()
+        set.into_iter().collect()
     }
 
     pub fn get_web_resources_by_roles(role_values: Vec<&str>) -> Vec<&'static str> {
         //log::info!("get_web_resources_by_roles {:?}", &role_values);
-        let roles: Vec<Self> = role_values.into_iter().map(|e| Self::new(e)).collect();
+        let roles: Vec<Self> = role_values.into_iter().map(Self::new).collect();
         if roles.len() == 1 {
             return roles.first().unwrap().get_web_resources();
         }
@@ -338,7 +338,7 @@ impl UserRole {
                 }
             }
         }
-        set.into_iter().map(|e| e).collect()
+        set.into_iter().collect()
     }
 }