70 lines
2.7 KiB
Rust
70 lines
2.7 KiB
Rust
|
|
use super::guards::APIProviderRequest;
|
|
use crate::api::guards;
|
|
use crate::errors::AutoDecryptError;
|
|
use crate::main;
|
|
use crate::orm::structures::{ProviderRecord};
|
|
use crate::orm::types::{AuthMethod, RecordStates};
|
|
use crate::services::providers::{ConsentMethode, ProviderAction, Providers, ActionType};
|
|
use crate::app_config::CONFIG;
|
|
use crate::orm::DbConn;
|
|
use diesel::expression::is_aggregate::No;
|
|
use rocket::get;
|
|
use rocket::http::Status;
|
|
use rocket::State;
|
|
use super::HttpResult;
|
|
|
|
async fn execute_action(action: &Providers, key: Option<&str>) -> Result<String, AutoDecryptError> {
|
|
|
|
let exec_action = match &action.execution_action {
|
|
ActionType::ForigneAction(forigne_action) => {
|
|
&forigne_action.to_executable_action(key)? as &dyn ProviderAction
|
|
},
|
|
_ => &action.execution_action as &dyn ProviderAction,
|
|
};
|
|
|
|
exec_action.execute().await
|
|
}
|
|
|
|
|
|
#[get("/<_>", rank = 1)]
|
|
pub(super) async fn request_handler(guard: Result<APIProviderRequest<'_>, HttpResult>, db_conn: &State<DbConn>) -> (Status, HttpResult) {
|
|
// We assume the request guard verified th access_key against the service_name
|
|
if let Err(err) = guard {
|
|
// This wrapper is nessesary to avoid needing to write catchers, and recompute the error
|
|
// See: https://github.com/rwf2/Rocket/issues/749
|
|
return err.into();
|
|
}
|
|
let guard = guard.expect("A rejected request guard was able to perseed!");
|
|
let mut expires_at = None;
|
|
let auth_methode: AuthMethod = AuthMethod::from(&guard.share.consent_methode);
|
|
let result: HttpResult = match guard.share.consent_methode {
|
|
ConsentMethode::None => {
|
|
// We do not wait for constent, direct feedback is impleied
|
|
match execute_action(guard.share, None).await {
|
|
Ok(response) => HttpResult::UnlockingSucceeded(response),
|
|
Err(err) => HttpResult::UnlockingFailed(err.to_string()),
|
|
}
|
|
},
|
|
_ => {
|
|
expires_at = Some(CONFIG.wait().user_confirmation_expiration);
|
|
HttpResult::AckAuthReq("An auth request has been sent.".to_string())
|
|
},
|
|
};
|
|
let record_state = match &result {
|
|
HttpResult::UnlockingSucceeded(_) => RecordStates::Accepted,
|
|
HttpResult::AckAuthReq(_) => RecordStates::Pending,
|
|
HttpResult::TimelimitExceeded(_) => RecordStates::Expired,
|
|
_ => RecordStates::Rejected,
|
|
};
|
|
|
|
db_conn.add_provider_record(&ProviderRecord {
|
|
service_name: guard.name.to_string(),
|
|
expires_at: expires_at, // Convert to sql timestamp + add used auth methode to record in db
|
|
auth_methode: auth_methode,
|
|
state: record_state,
|
|
awnsered_by: None,
|
|
});
|
|
return result.into();
|
|
|
|
} |