fmt

auth/casbin/src/main.rs

@@ -5,10 +5,7 @@ use tokio::sync::RwLock;
 use actix_web::{middleware, web, App, HttpRequest, HttpResponse, HttpServer};
 
 /// simple handle
-async fn success(
-    enforcer: web::Data<RwLock<Enforcer>>,
-    req: HttpRequest,
-) -> HttpResponse {
+async fn success(enforcer: web::Data<RwLock<Enforcer>>, req: HttpRequest) -> HttpResponse {
     let mut e = enforcer.write().await;
     println!("{:?}", req);
     assert_eq!(vec!["data2_admin"], e.get_roles_for_user("alice", None));

auth/simple-auth-server/src/email_service.rs

@@ -11,8 +11,8 @@ static ref API_KEY: String = std::env::var("SPARKPOST_API_KEY").expect("SPARKPOS
 
 pub fn send_invitation(invitation: &Invitation) -> Result<(), ServiceError> {
     let tm = Transmission::new_eu(API_KEY.as_str());
-    let sending_email = std::env::var("SENDING_EMAIL_ADDRESS")
-        .expect("SENDING_EMAIL_ADDRESS must be set");
+    let sending_email =
+        std::env::var("SENDING_EMAIL_ADDRESS").expect("SENDING_EMAIL_ADDRESS must be set");
     // new email message with sender name and email
     let mut email = Message::new(EmailAddress::new(sending_email, "Let's Organise"));
 

auth/simple-auth-server/src/errors.rs

@@ -20,14 +20,11 @@ pub enum ServiceError {
 impl ResponseError for ServiceError {
     fn error_response(&self) -> HttpResponse {
         match self {
-            ServiceError::InternalServerError => HttpResponse::InternalServerError()
-                .json("Internal Server Error, Please try later"),
-            ServiceError::BadRequest(ref message) => {
-                HttpResponse::BadRequest().json(message)
-            }
-            ServiceError::Unauthorized => {
-                HttpResponse::Unauthorized().json("Unauthorized")
+            ServiceError::InternalServerError => {
+                HttpResponse::InternalServerError().json("Internal Server Error, Please try later")
             }
+            ServiceError::BadRequest(ref message) => HttpResponse::BadRequest().json(message),
+            ServiceError::Unauthorized => HttpResponse::Unauthorized().json("Unauthorized"),
         }
     }
 }
@@ -47,8 +44,7 @@ impl From<DBError> for ServiceError {
         match error {
             DBError::DatabaseError(kind, info) => {
                 if let DatabaseErrorKind::UniqueViolation = kind {
-                    let message =
-                        info.details().unwrap_or_else(|| info.message()).to_string();
+                    let message = info.details().unwrap_or_else(|| info.message()).to_string();
                     return ServiceError::BadRequest(message);
                 }
                 ServiceError::InternalServerError

auth/simple-auth-server/src/invitation_handler.rs

@@ -15,8 +15,7 @@ pub async fn post_invitation(
     pool: web::Data<Pool>,
 ) -> Result<HttpResponse, actix_web::Error> {
     // run diesel blocking code
-    web::block(move || create_invitation(invitation_data.into_inner().email, pool))
-        .await??;
+    web::block(move || create_invitation(invitation_data.into_inner().email, pool)).await??;
 
     Ok(HttpResponse::Ok().finish())
 }
@@ -30,10 +29,7 @@ fn create_invitation(
 }
 
 /// Diesel query
-fn query(
-    eml: String,
-    pool: web::Data<Pool>,
-) -> Result<Invitation, crate::errors::ServiceError> {
+fn query(eml: String, pool: web::Data<Pool>) -> Result<Invitation, crate::errors::ServiceError> {
     use crate::schema::invitations::dsl::invitations;
 
     let new_invitation: Invitation = eml.into();

auth/simple-auth-server/src/main.rs

@@ -31,8 +31,7 @@ async fn main() -> std::io::Result<()> {
     let pool: models::Pool = r2d2::Pool::builder()
         .build(manager)
         .expect("Failed to create pool.");
-    let domain: String =
-        std::env::var("DOMAIN").unwrap_or_else(|_| "localhost".to_string());
+    let domain: String = std::env::var("DOMAIN").unwrap_or_else(|_| "localhost".to_string());
 
     // Start http server
     HttpServer::new(move || {

auth/simple-auth-server/src/utils.rs

@@ -20,9 +20,10 @@ pub fn hash_password(password: &str) -> Result<String, ServiceError> {
 }
 
 pub fn verify(hash: &str, password: &str) -> Result<bool, ServiceError> {
-    argon2::verify_encoded_ext(hash, password.as_bytes(), SECRET_KEY.as_bytes(), &[])
-        .map_err(|err| {
+    argon2::verify_encoded_ext(hash, password.as_bytes(), SECRET_KEY.as_bytes(), &[]).map_err(
+        |err| {
             dbg!(err);
             ServiceError::Unauthorized
-        })
+        },
+    )
 }