delete api token endpoint

This commit is contained in:
Brandon Thomas committed 2022-02-18 00:04:01 -05:00
1 parent 54ca8d4c7a
commit cb3c91f802
5 files changed
+211 -1

No files matched your search

@@ -0,0 +1,38 @@
use anyhow::anyhow;
use container_common::anyhow_result::AnyhowResult;
use log::warn;
use sqlx::MySqlPool;
use std::collections::{HashSet, HashMap};
pub async fn delete_api_token(
user_token: &str,
api_token: &str,
ip_address_update: &str,
mysql_pool: &MySqlPool
) -> AnyhowResult<bool> {
let query = sqlx::query!(
r#"
UPDATE api_tokens
SET
deleted_at = CURRENT_TIMESTAMP,
ip_address_last_update = ?
WHERE
user_token = ?
AND api_token = ?
LIMIT 1
"#,
ip_address_update,
user_token,
api_token,
);
let result = query.execute(mysql_pool).await;
match result {
Err(err) => {
Err(anyhow!("error with query: {:?}", err))
},
Ok(results) => Ok(true),
}
}
@@ -1,3 +1,4 @@
pub mod create_api_token;
pub mod delete_api_token;
pub mod edit_api_token;
pub mod list_available_api_tokens_for_user;
@@ -0,0 +1,143 @@
use actix_http::Error;
use actix_http::http::header;
use actix_web::HttpResponseBuilder;
use actix_web::cookie::Cookie;
use actix_web::error::ResponseError;
use actix_web::http::StatusCode;
use actix_web::web::{Path, Json};
use actix_web::{Responder, web, HttpResponse, error, HttpRequest};
use crate::database::queries::categories::get_category_by_token::get_category_by_token;
use crate::http_server::web_utils::ip_address::get_request_ip;
use crate::http_server::web_utils::response_error_helpers::to_simple_json_error;
use crate::http_server::web_utils::response_success_helpers::simple_json_success;
use crate::server_state::ServerState;
use database_queries::api_tokens::list_available_api_tokens_for_user::list_available_api_tokens_for_user;
use http_server_common::response::serialize_as_json_error::serialize_as_json_error;
use log::{info, warn, log, error};
use regex::Regex;
use sqlx::MySqlPool;
use sqlx::error::DatabaseError;
use sqlx::error::Error::Database;
use sqlx::mysql::MySqlDatabaseError;
use std::fmt;
use std::sync::Arc;
use database_queries::api_tokens::delete_api_token::delete_api_token;
// =============== Request ===============
// NB: `api_token` is only in PathInfo because we're deleting it.
#[derive(Deserialize)]
pub struct DeleteApiTokenPathInfo {
api_token: String,
}
// =============== Success Response ===============
#[derive(Serialize)]
pub struct DeleteApiTokenResponse {
pub success: bool,
}
// =============== Error Response ===============
#[derive(Debug, Serialize)]
pub enum DeleteApiTokenError {
BadInput(String),
NotFound,
NotAuthorized,
ServerError,
}
impl ResponseError for DeleteApiTokenError {
fn status_code(&self) -> StatusCode {
match *self {
DeleteApiTokenError::BadInput(_) => StatusCode::BAD_REQUEST,
DeleteApiTokenError::NotFound => StatusCode::NOT_FOUND,
DeleteApiTokenError::NotAuthorized => StatusCode::UNAUTHORIZED,
DeleteApiTokenError::ServerError => StatusCode::INTERNAL_SERVER_ERROR,
}
}
fn error_response(&self) -> HttpResponse {
serialize_as_json_error(self)
}
}
// NB: Not using derive_more::Display since Clion doesn't understand it.
impl fmt::Display for DeleteApiTokenError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}", self)
}
}
// =============== Handler ===============
pub async fn delete_api_token_handler(
http_request: HttpRequest,
path: Path<DeleteApiTokenPathInfo>,
server_state: web::Data<Arc<ServerState>>) -> Result<HttpResponse, DeleteApiTokenError>
{
let maybe_user_session = server_state
.session_checker
.maybe_get_user_session(&http_request, &server_state.mysql_pool)
.await
.map_err(|e| {
warn!("Session checker error: {:?}", e);
DeleteApiTokenError::ServerError
})?;
let user_session = match maybe_user_session {
Some(session) => session,
None => {
warn!("not logged in");
return Err(DeleteApiTokenError::NotAuthorized);
}
};
if user_session.is_banned {
warn!("banned users cannot edit API tokens");
return Err(DeleteApiTokenError::NotAuthorized);
}
let tokens = list_available_api_tokens_for_user(&user_session.user_token,
&server_state.mysql_pool)
.await
.map_err(|e| {
warn!("Error querying tokens: {:?}", e);
return DeleteApiTokenError::ServerError;
})?;
let valid_token = tokens.iter()
.find(|t| t.api_token.eq(&path.api_token))
.is_some();
if !valid_token {
warn!("Invalid API Token");
return Err(DeleteApiTokenError::NotFound);
}
let creator_ip_address = get_request_ip(&http_request);
let _r = delete_api_token(
&user_session.user_token,
&path.api_token,
&creator_ip_address,
&server_state.mysql_pool)
.await
.map_err(|e| {
error!("Error with query: {:?}", e);
return DeleteApiTokenError::ServerError;
});
let response = DeleteApiTokenResponse {
success: true,
};
let body = serde_json::to_string(&response)
.map_err(|e| DeleteApiTokenError::ServerError)?;
Ok(HttpResponse::Ok()
.content_type("application/json")
.body(body))
}
@@ -4,6 +4,7 @@ use actix_web::dev::{ServiceRequest, ServiceResponse};
use actix_web::error::Error;
use actix_web::{App, web, HttpResponse};
use crate::http_server::endpoints::api_tokens::create_api_token::create_api_token_handler;
use crate::http_server::endpoints::api_tokens::delete_api_token::delete_api_token_handler;
use crate::http_server::endpoints::api_tokens::edit_api_token::edit_api_token_handler;
use crate::http_server::endpoints::api_tokens::list_api_tokens::list_api_tokens_handler;
use crate::http_server::endpoints::categories::assign_tts_category::assign_tts_category_handler;
@@ -555,6 +556,10 @@ fn add_api_token_routes<T, B> (app: App<T, B>) -> App<T, B>
.route(web::post().to(edit_api_token_handler))
.route(web::head().to(|| HttpResponse::Ok()))
)
.service(web::resource("/{api_token}/delete")
.route(web::post().to(delete_api_token_handler))
.route(web::head().to(|| HttpResponse::Ok()))
)
.service(web::resource("/list")
.route(web::get().to(list_api_tokens_handler))
.route(web::head().to(|| HttpResponse::Ok()))
@@ -1,11 +1,14 @@
#!/usr/bin/env python3
import requests
import json
import re
import requests
import uuid
login_url = 'http://localhost:12345/login'
create_api_token_url = 'http://localhost:12345/api_tokens/create'
edit_api_token_url = 'http://localhost:12345/api_tokens/edit'
delete_api_token_url = 'http://localhost:12345/api_tokens/{}/delete'
payload = {
'username_or_email': 'echelon',
@@ -36,3 +39,23 @@ print("===== Created API Token =====")
print('Status: {}'.format(r.status_code))
print(r.content)
api_token = json.loads(r.content)
payload = {
'api_token': api_token['api_token'],
'maybe_short_description': 'this describes my token',
}
r = requests.post(edit_api_token_url, cookies=cookies, json=payload)
print("===== Edited API Token =====")
print('Status: {}'.format(r.status_code))
print(r.content)
url = delete_api_token_url.format(api_token['api_token'])
r = requests.post(url, cookies=cookies)
print("===== Deleted API Token =====")
print('Status: {}'.format(r.status_code))
print(r.content)