409/warren
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

warren creation / edit / deletion

Browse Source
This commit is contained in:
Shawn
2025-07-22 22:01:43 +02:00
parent 2ed69ae498
commit b3e68deb38
27 changed files with 1345 additions and 25 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
backend/src/lib/domain/warren/models/warren/requests.rs
View File

@@ -8,7 +8,7 @@ use crate::domain::warren::models::file::{
RelativeFilePath, RenameEntryError, RenameEntryRequest,
};
use super::Warren;
use super::{Warren, WarrenName};
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct FetchWarrenRequest {
@@ -517,3 +517,87 @@ pub enum ListWarrensError {
#[error(transparent)]
Unknown(#[from] anyhow::Error),
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct CreateWarrenRequest {
name: WarrenName,
path: AbsoluteFilePath,
}
impl CreateWarrenRequest {
pub fn new(name: WarrenName, path: AbsoluteFilePath) -> Self {
Self { name, path }
}
pub fn name(&self) -> &WarrenName {
&self.name
}
pub fn path(&self) -> &AbsoluteFilePath {
&self.path
}
}
#[derive(Debug, Error)]
pub enum CreateWarrenError {
#[error(transparent)]
Unknown(#[from] anyhow::Error),
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EditWarrenRequest {
id: Uuid,
name: WarrenName,
path: AbsoluteFilePath,
}
impl EditWarrenRequest {
pub fn new(warren_id: Uuid, name: WarrenName, path: AbsoluteFilePath) -> Self {
Self {
id: warren_id,
name,
path,
}
}
pub fn id(&self) -> &Uuid {
&self.id
}
pub fn name(&self) -> &WarrenName {
&self.name
}
pub fn path(&self) -> &AbsoluteFilePath {
&self.path
}
}
#[derive(Debug, Error)]
pub enum EditWarrenError {
#[error(transparent)]
Unknown(#[from] anyhow::Error),
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DeleteWarrenRequest {
id: Uuid,
}
impl DeleteWarrenRequest {
pub fn new(warren_id: Uuid) -> Self {
Self { id: warren_id }
}
pub fn id(&self) -> &Uuid {
&self.id
}
}
#[derive(Debug, Error)]
pub enum DeleteWarrenError {
#[error("This warren does not exist")]
NotFound,
#[error(transparent)]
Unknown(#[from] anyhow::Error),
}

18
backend/src/lib/domain/warren/ports/metrics.rs
View File

@@ -1,4 +1,13 @@
pub trait WarrenMetrics: Clone + Send + Sync + 'static {
fn record_warren_creation_success(&self) -> impl Future<Output = ()> + Send;
fn record_warren_creation_failure(&self) -> impl Future<Output = ()> + Send;
fn record_warren_edit_success(&self) -> impl Future<Output = ()> + Send;
fn record_warren_edit_failure(&self) -> impl Future<Output = ()> + Send;
fn record_warren_deletion_success(&self) -> impl Future<Output = ()> + Send;
fn record_warren_deletion_failure(&self) -> impl Future<Output = ()> + Send;
fn record_warren_fetch_success(&self) -> impl Future<Output = ()> + Send;
fn record_warren_fetch_failure(&self) -> impl Future<Output = ()> + Send;
@@ -53,6 +62,15 @@ pub trait FileSystemMetrics: Clone + Send + Sync + 'static {
}
pub trait AuthMetrics: Clone + Send + Sync + 'static {
fn record_auth_warren_creation_success(&self) -> impl Future<Output = ()> + Send;
fn record_auth_warren_creation_failure(&self) -> impl Future<Output = ()> + Send;
fn record_auth_warren_edit_success(&self) -> impl Future<Output = ()> + Send;
fn record_auth_warren_edit_failure(&self) -> impl Future<Output = ()> + Send;
fn record_auth_warren_deletion_success(&self) -> impl Future<Output = ()> + Send;
fn record_auth_warren_deletion_failure(&self) -> impl Future<Output = ()> + Send;
fn record_user_registration_success(&self) -> impl Future<Output = ()> + Send;
fn record_user_registration_failure(&self) -> impl Future<Output = ()> + Send;

38
backend/src/lib/domain/warren/ports/mod.rs
View File

@@ -35,8 +35,10 @@ use super::models::{
},
warren::{
CreateWarrenDirectoryError, CreateWarrenDirectoryRequest, CreateWarrenDirectoryResponse,
DeleteWarrenDirectoryError, DeleteWarrenDirectoryRequest, DeleteWarrenDirectoryResponse,
DeleteWarrenFileError, DeleteWarrenFileRequest, DeleteWarrenFileResponse, FetchWarrenError,
CreateWarrenError, CreateWarrenRequest, DeleteWarrenDirectoryError,
DeleteWarrenDirectoryRequest, DeleteWarrenDirectoryResponse, DeleteWarrenError,
DeleteWarrenFileError, DeleteWarrenFileRequest, DeleteWarrenFileResponse,
DeleteWarrenRequest, EditWarrenError, EditWarrenRequest, FetchWarrenError,
FetchWarrenRequest, FetchWarrensError, FetchWarrensRequest, ListWarrenFilesError,
ListWarrenFilesRequest, ListWarrenFilesResponse, ListWarrensError, ListWarrensRequest,
RenameWarrenEntryError, RenameWarrenEntryRequest, RenameWarrenEntryResponse,
@@ -45,6 +47,19 @@ use super::models::{
};
pub trait WarrenService: Clone + Send + Sync + 'static {
fn create_warren(
&self,
request: CreateWarrenRequest,
) -> impl Future<Output = Result<Warren, CreateWarrenError>> + Send;
fn edit_warren(
&self,
request: EditWarrenRequest,
) -> impl Future<Output = Result<Warren, EditWarrenError>> + Send;
fn delete_warren(
&self,
request: DeleteWarrenRequest,
) -> impl Future<Output = Result<Warren, DeleteWarrenError>> + Send;
fn fetch_warrens(
&self,
request: FetchWarrensRequest,
@@ -119,6 +134,25 @@ pub trait FileSystemService: Clone + Send + Sync + 'static {
}
pub trait AuthService: Clone + Send + Sync + 'static {
/// MUST REQUIRE ADMIN PRIVILEGES
fn create_warren<WS: WarrenService>(
&self,
request: AuthRequest<CreateWarrenRequest>,
warren_service: &WS,
) -> impl Future<Output = Result<Warren, AuthError<CreateWarrenError>>> + Send;
/// MUST REQUIRE ADMIN PRIVILEGES
fn edit_warren<WS: WarrenService>(
&self,
request: AuthRequest<EditWarrenRequest>,
warren_service: &WS,
) -> impl Future<Output = Result<Warren, AuthError<EditWarrenError>>> + Send;
/// MUST REQUIRE ADMIN PRIVILEGES
fn delete_warren<WS: WarrenService>(
&self,
request: AuthRequest<DeleteWarrenRequest>,
warren_service: &WS,
) -> impl Future<Output = Result<Warren, AuthError<DeleteWarrenError>>> + Send;
fn register_user(
&self,
request: RegisterUserRequest,

17
backend/src/lib/domain/warren/ports/notifier.rs
View File

@@ -12,6 +12,10 @@ use crate::domain::warren::models::{
};
pub trait WarrenNotifier: Clone + Send + Sync + 'static {
fn warren_created(&self, warren: &Warren) -> impl Future<Output = ()> + Send;
fn warren_edited(&self, warren: &Warren) -> impl Future<Output = ()> + Send;
fn warren_deleted(&self, warren: &Warren) -> impl Future<Output = ()> + Send;
fn warrens_fetched(&self, warrens: &Vec<Warren>) -> impl Future<Output = ()> + Send;
fn warren_fetched(&self, warren: &Warren) -> impl Future<Output = ()> + Send;
fn warrens_listed(&self, warrens: &Vec<Warren>) -> impl Future<Output = ()> + Send;
@@ -72,6 +76,19 @@ pub trait FileSystemNotifier: Clone + Send + Sync + 'static {
}
pub trait AuthNotifier: Clone + Send + Sync + 'static {
fn auth_warren_created(
&self,
creator: &User,
warren: &Warren,
) -> impl Future<Output = ()> + Send;
fn auth_warren_edited(&self, editor: &User, warren: &Warren)
-> impl Future<Output = ()> + Send;
fn auth_warren_deleted(
&self,
deleter: &User,
warren: &Warren,
) -> impl Future<Output = ()> + Send;
fn user_registered(&self, user: &User) -> impl Future<Output = ()> + Send;
fn user_logged_in(&self, response: &LoginUserResponse) -> impl Future<Output = ()> + Send;
fn user_created(&self, creator: &User, created: &User) -> impl Future<Output = ()> + Send;

18
backend/src/lib/domain/warren/ports/repository.rs
View File

@@ -27,14 +27,28 @@ use crate::domain::warren::models::{
},
},
warren::{
FetchWarrenError, FetchWarrenRequest, FetchWarrensError, FetchWarrensRequest,
ListWarrensError, ListWarrensRequest, Warren,
CreateWarrenError, CreateWarrenRequest, DeleteWarrenError, DeleteWarrenRequest,
EditWarrenError, EditWarrenRequest, FetchWarrenError, FetchWarrenRequest,
FetchWarrensError, FetchWarrensRequest, ListWarrensError, ListWarrensRequest, Warren,
},
};
use super::WarrenService;
pub trait WarrenRepository: Clone + Send + Sync + 'static {
fn create_warren(
&self,
request: CreateWarrenRequest,
) -> impl Future<Output = Result<Warren, CreateWarrenError>> + Send;
fn edit_warren(
&self,
request: EditWarrenRequest,
) -> impl Future<Output = Result<Warren, EditWarrenError>> + Send;
fn delete_warren(
&self,
request: DeleteWarrenRequest,
) -> impl Future<Output = Result<Warren, DeleteWarrenError>> + Send;
fn fetch_warrens(
&self,
request: FetchWarrensRequest,

110
backend/src/lib/domain/warren/service/auth.rs
View File

@@ -26,13 +26,15 @@ use crate::{
},
warren::{
CreateWarrenDirectoryError, CreateWarrenDirectoryRequest,
CreateWarrenDirectoryResponse, DeleteWarrenDirectoryError,
DeleteWarrenDirectoryRequest, DeleteWarrenDirectoryResponse, DeleteWarrenFileError,
DeleteWarrenFileRequest, DeleteWarrenFileResponse, FetchWarrenError,
FetchWarrenRequest, FetchWarrensRequest, ListWarrenFilesError,
ListWarrenFilesRequest, ListWarrenFilesResponse, RenameWarrenEntryError,
RenameWarrenEntryRequest, RenameWarrenEntryResponse, UploadWarrenFilesError,
UploadWarrenFilesRequest, UploadWarrenFilesResponse, Warren,
CreateWarrenDirectoryResponse, CreateWarrenError, CreateWarrenRequest,
DeleteWarrenDirectoryError, DeleteWarrenDirectoryRequest,
DeleteWarrenDirectoryResponse, DeleteWarrenError, DeleteWarrenFileError,
DeleteWarrenFileRequest, DeleteWarrenFileResponse, DeleteWarrenRequest,
EditWarrenError, EditWarrenRequest, FetchWarrenError, FetchWarrenRequest,
FetchWarrensRequest, ListWarrenFilesError, ListWarrenFilesRequest,
ListWarrenFilesResponse, RenameWarrenEntryError, RenameWarrenEntryRequest,
RenameWarrenEntryResponse, UploadWarrenFilesError, UploadWarrenFilesRequest,
UploadWarrenFilesResponse, Warren,
},
},
ports::{AuthMetrics, AuthNotifier, AuthRepository, AuthService, WarrenService},
@@ -102,6 +104,100 @@ where
M: AuthMetrics,
N: AuthNotifier,
{
async fn create_warren<WS: WarrenService>(
&self,
request: AuthRequest<CreateWarrenRequest>,
warren_service: &WS,
) -> Result<Warren, AuthError<CreateWarrenError>> {
let (session, request) = request.unpack();
let session_response = self
.fetch_auth_session(FetchAuthSessionRequest::new(session.session_id().clone()))
.await?;
if !session_response.user().admin() {
return Err(AuthError::InsufficientPermissions);
}
let result = warren_service
.create_warren(request)
.await
.map_err(AuthError::Custom);
if let Ok(warren) = result.as_ref() {
self.metrics.record_auth_warren_creation_success().await;
self.notifier
.auth_warren_created(&session_response.user(), warren)
.await;
} else {
self.metrics.record_auth_warren_creation_failure().await;
}
result
}
async fn edit_warren<WS: WarrenService>(
&self,
request: AuthRequest<EditWarrenRequest>,
warren_service: &WS,
) -> Result<Warren, AuthError<EditWarrenError>> {
let (session, request) = request.unpack();
let session_response = self
.fetch_auth_session(FetchAuthSessionRequest::new(session.session_id().clone()))
.await?;
if !session_response.user().admin() {
return Err(AuthError::InsufficientPermissions);
}
let result = warren_service
.edit_warren(request)
.await
.map_err(AuthError::Custom);
if let Ok(warren) = result.as_ref() {
self.metrics.record_auth_warren_edit_success().await;
self.notifier
.auth_warren_edited(&session_response.user(), warren)
.await;
} else {
self.metrics.record_auth_warren_edit_failure().await;
}
result
}
async fn delete_warren<WS: WarrenService>(
&self,
request: AuthRequest<DeleteWarrenRequest>,
warren_service: &WS,
) -> Result<Warren, AuthError<DeleteWarrenError>> {
let (session, request) = request.unpack();
let session_response = self
.fetch_auth_session(FetchAuthSessionRequest::new(session.session_id().clone()))
.await?;
if !session_response.user().admin() {
return Err(AuthError::InsufficientPermissions);
}
let result = warren_service
.delete_warren(request)
.await
.map_err(AuthError::Custom);
if let Ok(warren) = result.as_ref() {
self.metrics.record_auth_warren_deletion_success().await;
self.notifier
.auth_warren_deleted(&session_response.user(), warren)
.await;
} else {
self.metrics.record_auth_warren_deletion_failure().await;
}
result
}
async fn register_user(&self, request: RegisterUserRequest) -> Result<User, RegisterUserError> {
let result = self.repository.create_user(request.into()).await;

53
backend/src/lib/domain/warren/service/warren.rs
View File

@@ -1,9 +1,11 @@
use crate::domain::warren::{
models::warren::{
CreateWarrenDirectoryResponse, DeleteWarrenDirectoryResponse, DeleteWarrenFileResponse,
FetchWarrensError, FetchWarrensRequest, ListWarrenFilesResponse, ListWarrensError,
ListWarrensRequest, RenameWarrenEntryError, RenameWarrenEntryRequest,
RenameWarrenEntryResponse, UploadWarrenFilesResponse,
CreateWarrenDirectoryResponse, CreateWarrenError, CreateWarrenRequest,
DeleteWarrenDirectoryResponse, DeleteWarrenError, DeleteWarrenFileResponse,
DeleteWarrenRequest, EditWarrenError, EditWarrenRequest, FetchWarrensError,
FetchWarrensRequest, ListWarrenFilesResponse, ListWarrensError, ListWarrensRequest,
RenameWarrenEntryError, RenameWarrenEntryRequest, RenameWarrenEntryResponse,
UploadWarrenFilesResponse,
},
ports::FileSystemService,
};
@@ -56,6 +58,49 @@ where
N: WarrenNotifier,
FSS: FileSystemService,
{
async fn create_warren(
&self,
request: CreateWarrenRequest,
) -> Result<Warren, CreateWarrenError> {
let result = self.repository.create_warren(request).await;
if let Ok(warren) = result.as_ref() {
self.metrics.record_warren_creation_success().await;
self.notifier.warren_created(warren).await;
} else {
self.metrics.record_warren_creation_failure().await;
}
result
}
async fn edit_warren(&self, request: EditWarrenRequest) -> Result<Warren, EditWarrenError> {
let result = self.repository.edit_warren(request).await;
if let Ok(warren) = result.as_ref() {
self.metrics.record_warren_edit_success().await;
self.notifier.warren_edited(warren).await;
} else {
self.metrics.record_warren_edit_failure().await;
}
result
}
async fn delete_warren(
&self,
request: DeleteWarrenRequest,
) -> Result<Warren, DeleteWarrenError> {
let result = self.repository.delete_warren(request).await;
if let Ok(warren) = result.as_ref() {
self.metrics.record_warren_deletion_success().await;
self.notifier.warren_deleted(warren).await;
} else {
self.metrics.record_warren_deletion_failure().await;
}
result
}
async fn fetch_warrens(
&self,
request: FetchWarrensRequest,

83
backend/src/lib/inbound/http/handlers/admin/create_warren.rs Normal file
View File

@@ -0,0 +1,83 @@
use axum::{Json, extract::State, http::StatusCode};
use serde::Deserialize;
use thiserror::Error;
use crate::{
domain::warren::{
models::{
auth_session::AuthRequest,
file::{AbsoluteFilePathError, FilePath, FilePathError},
warren::{CreateWarrenRequest, WarrenName, WarrenNameError},
},
ports::{AuthService, WarrenService},
},
inbound::http::{
AppState,
handlers::{AdminWarrenData, extractors::SessionIdHeader},
responses::{ApiError, ApiSuccess},
},
};
#[derive(Debug, Clone, Error)]
pub(super) enum ParseCreateWarrenHttpRequestError {
#[error(transparent)]
WarrenName(#[from] WarrenNameError),
#[error(transparent)]
FilePath(#[from] FilePathError),
#[error(transparent)]
AbsoluteFilePath(#[from] AbsoluteFilePathError),
}
impl From<ParseCreateWarrenHttpRequestError> for ApiError {
fn from(value: ParseCreateWarrenHttpRequestError) -> Self {
match value {
ParseCreateWarrenHttpRequestError::WarrenName(err) => match err {
WarrenNameError::Empty => {
Self::BadRequest("The warren name must not be empty".to_string())
}
},
ParseCreateWarrenHttpRequestError::FilePath(err) => match err {
FilePathError::InvalidPath => Self::BadRequest("The path is invalid".to_string()),
},
ParseCreateWarrenHttpRequestError::AbsoluteFilePath(err) => match err {
AbsoluteFilePathError::NotAbsolute => {
Self::BadRequest("The path must be absolute".to_string())
}
},
}
}
}
#[derive(Debug, Clone, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub(super) struct CreateWarrenHttpRequestBody {
name: String,
path: String,
}
impl CreateWarrenHttpRequestBody {
fn try_into_domain(self) -> Result<CreateWarrenRequest, ParseCreateWarrenHttpRequestError> {
let name = WarrenName::new(&self.name)?;
let path = FilePath::new(&self.path)?.try_into()?;
Ok(CreateWarrenRequest::new(name, path))
}
}
pub async fn create_warren<WS: WarrenService, AS: AuthService>(
State(state): State<AppState<WS, AS>>,
SessionIdHeader(session): SessionIdHeader,
Json(request): Json<CreateWarrenHttpRequestBody>,
) -> Result<ApiSuccess<AdminWarrenData>, ApiError> {
let domain_request = request.try_into_domain()?;
state
.auth_service
.create_warren(
AuthRequest::new(session, domain_request),
state.warren_service.as_ref(),
)
.await
.map(|warren| ApiSuccess::new(StatusCode::CREATED, warren.into()))
.map_err(ApiError::from)
}

45
backend/src/lib/inbound/http/handlers/admin/delete_warren.rs Normal file
View File

@@ -0,0 +1,45 @@
use axum::{Json, extract::State, http::StatusCode};
use serde::Deserialize;
use uuid::Uuid;
use crate::{
domain::warren::{
models::{auth_session::AuthRequest, warren::DeleteWarrenRequest},
ports::{AuthService, WarrenService},
},
inbound::http::{
AppState,
handlers::{AdminWarrenData, extractors::SessionIdHeader},
responses::{ApiError, ApiSuccess},
},
};
#[derive(Debug, Clone, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub(super) struct DeleteWarrenHttpRequestBody {
id: Uuid,
}
impl DeleteWarrenHttpRequestBody {
fn into_domain(self) -> DeleteWarrenRequest {
DeleteWarrenRequest::new(self.id)
}
}
pub async fn delete_warren<WS: WarrenService, AS: AuthService>(
State(state): State<AppState<WS, AS>>,
SessionIdHeader(session): SessionIdHeader,
Json(request): Json<DeleteWarrenHttpRequestBody>,
) -> Result<ApiSuccess<AdminWarrenData>, ApiError> {
let domain_request = request.into_domain();
state
.auth_service
.delete_warren(
AuthRequest::new(session, domain_request),
state.warren_service.as_ref(),
)
.await
.map(|warren| ApiSuccess::new(StatusCode::CREATED, warren.into()))
.map_err(ApiError::from)
}

85
backend/src/lib/inbound/http/handlers/admin/edit_warren.rs Normal file
View File

@@ -0,0 +1,85 @@
use axum::{Json, extract::State, http::StatusCode};
use serde::Deserialize;
use thiserror::Error;
use uuid::Uuid;
use crate::{
domain::warren::{
models::{
auth_session::AuthRequest,
file::{AbsoluteFilePathError, FilePath, FilePathError},
warren::{EditWarrenRequest, WarrenName, WarrenNameError},
},
ports::{AuthService, WarrenService},
},
inbound::http::{
AppState,
handlers::{AdminWarrenData, extractors::SessionIdHeader},
responses::{ApiError, ApiSuccess},
},
};
#[derive(Debug, Clone, Error)]
pub(super) enum ParseEditWarrenHttpRequestError {
#[error(transparent)]
WarrenName(#[from] WarrenNameError),
#[error(transparent)]
FilePath(#[from] FilePathError),
#[error(transparent)]
AbsoluteFilePath(#[from] AbsoluteFilePathError),
}
impl From<ParseEditWarrenHttpRequestError> for ApiError {
fn from(value: ParseEditWarrenHttpRequestError) -> Self {
match value {
ParseEditWarrenHttpRequestError::WarrenName(err) => match err {
WarrenNameError::Empty => {
Self::BadRequest("The warren name must not be empty".to_string())
}
},
ParseEditWarrenHttpRequestError::FilePath(err) => match err {
FilePathError::InvalidPath => Self::BadRequest("The path is invalid".to_string()),
},
ParseEditWarrenHttpRequestError::AbsoluteFilePath(err) => match err {
AbsoluteFilePathError::NotAbsolute => {
Self::BadRequest("The path must be absolute".to_string())
}
},
}
}
}
#[derive(Debug, Clone, Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub(super) struct EditWarrenHttpRequestBody {
id: Uuid,
name: String,
path: String,
}
impl EditWarrenHttpRequestBody {
fn try_into_domain(self) -> Result<EditWarrenRequest, ParseEditWarrenHttpRequestError> {
let name = WarrenName::new(&self.name)?;
let path = FilePath::new(&self.path)?.try_into()?;
Ok(EditWarrenRequest::new(self.id, name, path))
}
}
pub async fn edit_warren<WS: WarrenService, AS: AuthService>(
State(state): State<AppState<WS, AS>>,
SessionIdHeader(session): SessionIdHeader,
Json(request): Json<EditWarrenHttpRequestBody>,
) -> Result<ApiSuccess<AdminWarrenData>, ApiError> {
let domain_request = request.try_into_domain()?;
state
.auth_service
.edit_warren(
AuthRequest::new(session, domain_request),
state.warren_service.as_ref(),
)
.await
.map(|warren| ApiSuccess::new(StatusCode::CREATED, warren.into()))
.map_err(ApiError::from)
}

9
backend/src/lib/inbound/http/handlers/admin/mod.rs
View File

@@ -1,18 +1,24 @@
mod create_user;
mod create_user_warren;
mod create_warren;
mod delete_user;
mod delete_user_warren;
mod delete_warren;
mod edit_user;
mod edit_user_warren;
mod edit_warren;
mod list_all_users_and_warrens;
mod list_users;
use create_user::create_user;
use create_user_warren::create_user_warren;
use create_warren::create_warren;
use delete_user::delete_user;
use delete_user_warren::delete_user_warren;
use delete_warren::delete_warren;
use edit_user::edit_user;
use edit_user_warren::edit_user_warren;
use edit_warren::edit_warren;
use list_all_users_and_warrens::list_all_users_and_warrens;
use list_users::list_users;
@@ -33,6 +39,9 @@ pub fn routes<WS: WarrenService, AS: AuthService>() -> Router<AppState<WS, AS>>
.route("/users", post(create_user))
.route("/users", patch(edit_user))
.route("/users", delete(delete_user))
.route("/warrens", post(create_warren))
.route("/warrens", patch(edit_warren))
.route("/warrens", delete(delete_warren))
.route("/user-warrens", post(create_user_warren))
.route("/user-warrens", patch(edit_user_warren))
.route("/user-warrens", delete(delete_user_warren))

42
backend/src/lib/outbound/metrics_debug_logger.rs
View File

@@ -10,6 +10,27 @@ impl MetricsDebugLogger {
}
impl WarrenMetrics for MetricsDebugLogger {
async fn record_warren_creation_success(&self) {
tracing::debug!("[Metrics] Warren creation succeeded");
}
async fn record_warren_creation_failure(&self) {
tracing::debug!("[Metrics] Warren creation failed");
}
async fn record_warren_edit_success(&self) {
tracing::debug!("[Metrics] Warren edit succeeded");
}
async fn record_warren_edit_failure(&self) {
tracing::debug!("[Metrics] Warren edit failed");
}
async fn record_warren_deletion_success(&self) {
tracing::debug!("[Metrics] Warren deletion succeeded");
}
async fn record_warren_deletion_failure(&self) {
tracing::debug!("[Metrics] Warren deletion failed");
}
async fn record_warren_list_success(&self) {
tracing::debug!("[Metrics] Warren list succeeded");
}
@@ -129,6 +150,27 @@ impl FileSystemMetrics for MetricsDebugLogger {
}
impl AuthMetrics for MetricsDebugLogger {
async fn record_auth_warren_creation_success(&self) {
tracing::debug!("[Metrics] Warren creation by admin succeeded");
}
async fn record_auth_warren_creation_failure(&self) {
tracing::debug!("[Metrics] Warren creation by admin failed");
}
async fn record_auth_warren_edit_success(&self) -> () {
tracing::debug!("[Metrics] Warren edit by admin succeeded");
}
async fn record_auth_warren_edit_failure(&self) -> () {
tracing::debug!("[Metrics] Warren edit by admin failed");
}
async fn record_auth_warren_deletion_success(&self) -> () {
tracing::debug!("[Metrics] Warren deletion by admin succeeded");
}
async fn record_auth_warren_deletion_failure(&self) -> () {
tracing::debug!("[Metrics] Warren deletion by admin failed");
}
async fn record_user_registration_success(&self) {
tracing::debug!("[Metrics] User registration succeeded");
}

32
backend/src/lib/outbound/notifier_debug_logger.rs
View File

@@ -24,6 +24,16 @@ impl NotifierDebugLogger {
}
impl WarrenNotifier for NotifierDebugLogger {
async fn warren_created(&self, warren: &Warren) {
tracing::debug!("[Notifier] Created warren: {}", warren.name());
}
async fn warren_edited(&self, warren: &Warren) {
tracing::debug!("[Notifier] Edited warren: {}", warren.name());
}
async fn warren_deleted(&self, warren: &Warren) {
tracing::debug!("[Notifier] Deleted warren: {}", warren.name());
}
async fn warrens_fetched(&self, warrens: &Vec<Warren>) {
tracing::debug!("[Notifier] Fetched {} warren(s)", warrens.len());
}
@@ -121,6 +131,28 @@ impl FileSystemNotifier for NotifierDebugLogger {
}
impl AuthNotifier for NotifierDebugLogger {
async fn auth_warren_created(&self, creator: &User, warren: &Warren) {
tracing::debug!(
"[Notifier] Admin {} created warren: {}",
creator.id(),
warren.name()
);
}
async fn auth_warren_edited(&self, editor: &User, warren: &Warren) {
tracing::debug!(
"[Notifier] Admin {} edited warren: {}",
editor.id(),
warren.name()
);
}
async fn auth_warren_deleted(&self, deleter: &User, warren: &Warren) {
tracing::debug!(
"[Notifier] Admin {} deleted warren: {}",
deleter.id(),
warren.name()
);
}
async fn user_registered(&self, user: &User) {
tracing::debug!("[Notifier] Registered user {}", user.name());
}

159
backend/src/lib/outbound/postgres/warrens.rs
View File

@@ -1,11 +1,16 @@
use anyhow::{Context as _, anyhow};
use sqlx::PgConnection;
use sqlx::{Acquire as _, PgConnection};
use uuid::Uuid;
use crate::domain::warren::{
models::warren::{
FetchWarrenError, FetchWarrenRequest, FetchWarrensError, FetchWarrensRequest,
ListWarrensError, ListWarrensRequest, Warren,
models::{
file::AbsoluteFilePath,
warren::{
CreateWarrenError, CreateWarrenRequest, DeleteWarrenError, DeleteWarrenRequest,
EditWarrenError, EditWarrenRequest, FetchWarrenError, FetchWarrenRequest,
FetchWarrensError, FetchWarrensRequest, ListWarrensError, ListWarrensRequest, Warren,
WarrenName,
},
},
ports::WarrenRepository,
};
@@ -13,6 +18,62 @@ use crate::domain::warren::{
use super::{Postgres, is_not_found_error};
impl WarrenRepository for Postgres {
async fn create_warren(
&self,
request: CreateWarrenRequest,
) -> Result<Warren, CreateWarrenError> {
let mut connection = self
.pool
.acquire()
.await
.context("Failed to get a PostgreSQL connection")?;
let warren = self
.create_warren(&mut connection, request.name(), request.path())
.await
.context("Failed to create new warren")?;
Ok(warren)
}
async fn edit_warren(&self, request: EditWarrenRequest) -> Result<Warren, EditWarrenError> {
let mut connection = self
.pool
.acquire()
.await
.context("Failed to get a PostgreSQL connection")?;
let warren = self
.edit_warren(
&mut connection,
request.id(),
request.name(),
request.path(),
)
.await
.context("Failed to edit existing warren")?;
Ok(warren)
}
async fn delete_warren(
&self,
request: DeleteWarrenRequest,
) -> Result<Warren, DeleteWarrenError> {
let mut connection = self
.pool
.acquire()
.await
.context("Failed to get a PostgreSQL connection")?;
let warren = self
.delete_warren(&mut connection, request.id())
.await
.context("Failed to delete existing warren")?;
Ok(warren)
}
async fn fetch_warrens(
&self,
request: FetchWarrensRequest,
@@ -74,6 +135,96 @@ impl WarrenRepository for Postgres {
}
impl Postgres {
async fn create_warren(
&self,
connection: &mut PgConnection,
name: &WarrenName,
path: &AbsoluteFilePath,
) -> Result<Warren, sqlx::Error> {
let mut tx = connection.begin().await?;
let warren: Warren = sqlx::query_as(
"
INSERT INTO warrens (
name,
path
) VALUES (
$1,
$2
)
RETURNING
*
",
)
.bind(name)
.bind(path)
.fetch_one(&mut *tx)
.await?;
tx.commit().await?;
Ok(warren)
}
async fn edit_warren(
&self,
connection: &mut PgConnection,
id: &Uuid,
name: &WarrenName,
path: &AbsoluteFilePath,
) -> Result<Warren, sqlx::Error> {
let mut tx = connection.begin().await?;
let warren: Warren = sqlx::query_as(
"
UPDATE
warrens
SET
name = $2,
path = $3
WHERE
id = $1
RETURNING
*
",
)
.bind(id)
.bind(name)
.bind(path)
.fetch_one(&mut *tx)
.await?;
tx.commit().await?;
Ok(warren)
}
async fn delete_warren(
&self,
connection: &mut PgConnection,
id: &Uuid,
) -> Result<Warren, sqlx::Error> {
let mut tx = connection.begin().await?;
let warren: Warren = sqlx::query_as(
"
DELETE FROM
warrens
WHERE
id = $1
RETURNING
*
",
)
.bind(id)
.fetch_one(&mut *tx)
.await?;
tx.commit().await?;
Ok(warren)
}
async fn get_warren(
&self,
connection: &mut PgConnection,