swap error

crates/schema/public/enums/src/by_table/staff_audit_logs/staff_audit_action.rs

@@ -28,6 +28,14 @@ pub enum StaffAuditAction {
   /// Staff unbanned a user.
   #[serde(rename = "unban_user")]
   UnbanUser,
+
+  /// Staff added banked balance to a wallet.
+  #[serde(rename = "add_wallet_banked_balance")]
+  AddWalletBankedBalance,
+
+  /// Staff sent a manual alert via the pager system.
+  #[serde(rename = "send_alert")]
+  SendAlert,
 }
 
 impl_enum_display_and_debug_using_to_str!(StaffAuditAction);
@@ -41,6 +49,8 @@ impl StaffAuditAction {
       Self::ImpersonateUserRedeem => "impersonate_user_redeem",
       Self::BanUser => "ban_user",
       Self::UnbanUser => "unban_user",
+      Self::AddWalletBankedBalance => "add_wallet_banked_balance",
+      Self::SendAlert => "send_alert",
     }
   }
 
@@ -50,6 +60,8 @@ impl StaffAuditAction {
       "impersonate_user_redeem" => Ok(Self::ImpersonateUserRedeem),
       "ban_user" => Ok(Self::BanUser),
       "unban_user" => Ok(Self::UnbanUser),
+      "add_wallet_banked_balance" => Ok(Self::AddWalletBankedBalance),
+      "send_alert" => Ok(Self::SendAlert),
       _ => Err(format!("invalid StaffAuditAction value: {:?}", value)),
     }
   }
@@ -60,6 +72,8 @@ impl StaffAuditAction {
       Self::ImpersonateUserRedeem,
       Self::BanUser,
       Self::UnbanUser,
+      Self::AddWalletBankedBalance,
+      Self::SendAlert,
     ])
   }
 }
@@ -78,6 +92,8 @@ mod tests {
       assert_serialization(StaffAuditAction::ImpersonateUserRedeem, "impersonate_user_redeem");
       assert_serialization(StaffAuditAction::BanUser, "ban_user");
       assert_serialization(StaffAuditAction::UnbanUser, "unban_user");
+      assert_serialization(StaffAuditAction::AddWalletBankedBalance, "add_wallet_banked_balance");
+      assert_serialization(StaffAuditAction::SendAlert, "send_alert");
     }
 
     #[test]
@@ -86,6 +102,8 @@ mod tests {
       assert_eq!(StaffAuditAction::ImpersonateUserRedeem.to_str(), "impersonate_user_redeem");
       assert_eq!(StaffAuditAction::BanUser.to_str(), "ban_user");
       assert_eq!(StaffAuditAction::UnbanUser.to_str(), "unban_user");
+      assert_eq!(StaffAuditAction::AddWalletBankedBalance.to_str(), "add_wallet_banked_balance");
+      assert_eq!(StaffAuditAction::SendAlert.to_str(), "send_alert");
     }
 
     #[test]
@@ -94,12 +112,14 @@ mod tests {
       assert_eq!(StaffAuditAction::from_str("impersonate_user_redeem").unwrap(), StaffAuditAction::ImpersonateUserRedeem);
       assert_eq!(StaffAuditAction::from_str("ban_user").unwrap(), StaffAuditAction::BanUser);
       assert_eq!(StaffAuditAction::from_str("unban_user").unwrap(), StaffAuditAction::UnbanUser);
+      assert_eq!(StaffAuditAction::from_str("add_wallet_banked_balance").unwrap(), StaffAuditAction::AddWalletBankedBalance);
+      assert_eq!(StaffAuditAction::from_str("send_alert").unwrap(), StaffAuditAction::SendAlert);
       assert!(StaffAuditAction::from_str("invalid").is_err());
     }
 
     #[test]
     fn all_variants() {
-      const EXPECTED_COUNT: usize = 4;
+      const EXPECTED_COUNT: usize = 6;
       assert_eq!(StaffAuditAction::all_variants().len(), EXPECTED_COUNT);
     }
   }

crates/schema/public/enums/src/by_table/staff_audit_logs/staff_audit_entity_type.rs

@@ -16,6 +16,10 @@ pub enum StaffAuditEntityType {
   /// A user account.
   #[serde(rename = "user")]
   User,
+
+  /// A wallet.
+  #[serde(rename = "wallet")]
+  Wallet,
 }
 
 impl_enum_display_and_debug_using_to_str!(StaffAuditEntityType);
@@ -26,12 +30,14 @@ impl StaffAuditEntityType {
   pub fn to_str(&self) -> &'static str {
     match self {
       Self::User => "user",
+      Self::Wallet => "wallet",
     }
   }
 
   pub fn from_str(value: &str) -> Result<Self, String> {
     match value {
       "user" => Ok(Self::User),
+      "wallet" => Ok(Self::Wallet),
       _ => Err(format!("invalid StaffAuditEntityType value: {:?}", value)),
     }
   }
@@ -39,6 +45,7 @@ impl StaffAuditEntityType {
   pub fn all_variants() -> BTreeSet<Self> {
     BTreeSet::from([
       Self::User,
+      Self::Wallet,
     ])
   }
 }
@@ -54,22 +61,25 @@ mod tests {
     #[test]
     fn test_serialization() {
       assert_serialization(StaffAuditEntityType::User, "user");
+      assert_serialization(StaffAuditEntityType::Wallet, "wallet");
     }
 
     #[test]
     fn to_str() {
       assert_eq!(StaffAuditEntityType::User.to_str(), "user");
+      assert_eq!(StaffAuditEntityType::Wallet.to_str(), "wallet");
     }
 
     #[test]
     fn from_str() {
       assert_eq!(StaffAuditEntityType::from_str("user").unwrap(), StaffAuditEntityType::User);
+      assert_eq!(StaffAuditEntityType::from_str("wallet").unwrap(), StaffAuditEntityType::Wallet);
       assert!(StaffAuditEntityType::from_str("invalid").is_err());
     }
 
     #[test]
     fn all_variants() {
-      const EXPECTED_COUNT: usize = 1;
+      const EXPECTED_COUNT: usize = 2;
       assert_eq!(StaffAuditEntityType::all_variants().len(), EXPECTED_COUNT);
     }
   }

crates/service/web/storyteller_web/src/http_server/endpoints/moderation/alerts/moderation_send_alert_handler.rs

@@ -1,3 +1,4 @@
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 use actix_web::web::Json;
@@ -5,11 +6,14 @@ use actix_web::{web, HttpRequest};
 use log::warn;
 
 use artcraft_api_defs::moderation::alerts::moderation_send_alert::{ModerationSendAlertRequest, ModerationSendAlertResponse, ModerationSendAlertUrgency};
-use pager::client::pager::Pager;
-use pager::notification::notification_details::NotificationDetails;
+use enums::by_table::staff_audit_logs::staff_audit_action::StaffAuditAction;
+use http_server_common::request::get_request_ip::get_request_ip;
+use mysql_queries::queries::staff_audit_logs::insert_staff_audit_log::{
+  insert_staff_audit_log, InsertStaffAuditLogArgs,
+};
 use pager::notification::notification_details_builder::NotificationDetailsBuilder;
 use pager::notification::notification_urgency::NotificationUrgency;
-use crate::http_server::common_responses::common_web_error::CommonWebError;
+use crate::http_server::common_responses::advanced_common_web_error::AdvancedCommonWebError;
 use crate::http_server::web_utils::user_session::require_moderator::{require_moderator, UseDatabase};
 use crate::state::server_state::ServerState;
 
@@ -29,11 +33,16 @@ pub async fn moderation_send_alert_handler(
   http_request: HttpRequest,
   request: Json<ModerationSendAlertRequest>,
   server_state: web::Data<Arc<ServerState>>,
-) -> Result<Json<ModerationSendAlertResponse>, CommonWebError> {
+) -> Result<Json<ModerationSendAlertResponse>, AdvancedCommonWebError> {
 
   let user_session = require_moderator(&http_request, &server_state, UseDatabase::GrabNewConnection)
     .await
-    .map_err(|_| CommonWebError::NotAuthorized)?;
+    .map_err(|err| {
+      warn!("Moderator check failed: {:?}", err);
+      AdvancedCommonWebError::NotAuthorized
+    })?;
+
+  let ip_address = get_request_ip(&http_request);
 
   let title = request.title.clone()
     .unwrap_or_else(|| "Moderation Alert".to_string());
@@ -68,9 +77,23 @@ pub async fn moderation_send_alert_handler(
     .enqueue_page(notification)
     .map_err(|err| {
       warn!("moderation_send_alert error: {:?}", err);
-      CommonWebError::ServerError
+      AdvancedCommonWebError::from_error(err)
     })?;
 
+  // Insert staff audit log.
+  let _audit_token = insert_staff_audit_log(InsertStaffAuditLogArgs {
+    audit_action: StaffAuditAction::SendAlert,
+    maybe_entity_type: None,
+    maybe_entity_token: None,
+    staff_user_token: &user_session.user_token,
+    actor_ip_address: &ip_address,
+    mysql_executor: &server_state.mysql_pool,
+    phantom: PhantomData,
+  }).await.map_err(|err| {
+    warn!("Failed to insert staff audit log: {:?}", err);
+    AdvancedCommonWebError::from_error(err)
+  })?;
+
   Ok(Json(ModerationSendAlertResponse {
     success: true,
   }))

crates/service/web/storyteller_web/src/http_server/endpoints/moderation/wallets/moderator_add_banked_balance_to_wallet_handler.rs

@@ -1,19 +1,26 @@
+use std::marker::PhantomData;
 use std::sync::Arc;
 
 use actix_web::web::{Json, Path};
 use actix_web::{web, HttpRequest};
-use log::warn;
+use log::{info, warn};
 
 use artcraft_api_defs::moderation::wallets::moderator_add_banked_balance_to_wallet::{
   ModeratorAddBankedBalanceToWalletPathInfo,
   ModeratorAddBankedBalanceToWalletRequest,
   ModeratorAddBankedBalanceToWalletResponse,
 };
+use enums::by_table::staff_audit_logs::staff_audit_action::StaffAuditAction;
+use enums::by_table::staff_audit_logs::staff_audit_entity_type::StaffAuditEntityType;
 use enums::by_table::wallet_ledger_entries::wallet_ledger_entry_type::WalletLedgerEntryType;
+use http_server_common::request::get_request_ip::get_request_ip;
+use mysql_queries::queries::staff_audit_logs::insert_staff_audit_log::{
+  insert_staff_audit_log, InsertStaffAuditLogArgs,
+};
 use mysql_queries::queries::wallets::add_durable_banked_balance_to_wallet::add_durable_banked_balance_to_wallet;
 
 use tokens::tokens::wallets::WalletToken;
-use crate::http_server::common_responses::common_web_error::CommonWebError;
+use crate::http_server::common_responses::advanced_common_web_error::AdvancedCommonWebError;
 use crate::http_server::web_utils::user_session::require_moderator::{require_moderator, UseDatabase};
 use crate::state::server_state::ServerState;
 
@@ -37,17 +44,29 @@ pub async fn moderator_add_banked_balance_to_wallet_handler(
   path: Path<ModeratorAddBankedBalanceToWalletPathInfo>,
   request: Json<ModeratorAddBankedBalanceToWalletRequest>,
   server_state: web::Data<Arc<ServerState>>,
-) -> Result<Json<ModeratorAddBankedBalanceToWalletResponse>, CommonWebError> {
+) -> Result<Json<ModeratorAddBankedBalanceToWalletResponse>, AdvancedCommonWebError> {
 
-  let _user_session = require_moderator(&http_request, &server_state, UseDatabase::GrabNewConnection)
+  let user_session = require_moderator(&http_request, &server_state, UseDatabase::GrabNewConnection)
     .await
-    .map_err(|_| CommonWebError::NotAuthorized)?;
+    .map_err(|err| {
+      warn!("Moderator check failed: {:?}", err);
+      AdvancedCommonWebError::NotAuthorized
+    })?;
+
+  let ip_address = get_request_ip(&http_request);
+
+  info!(
+    "Moderator {} adding {} banked credits to wallet {}",
+    user_session.user_token.as_str(),
+    request.credits,
+    path.wallet_token.as_str(),
+  );
 
   let mut transaction = server_state.mysql_pool.begin()
     .await
     .map_err(|err| {
       warn!("moderator_add_banked_balance_to_wallet transaction begin error: {:?}", err);
-      CommonWebError::ServerError
+      AdvancedCommonWebError::from_error(err)
     })?;
 
   let _result = add_durable_banked_balance_to_wallet(
@@ -60,14 +79,28 @@ pub async fn moderator_add_banked_balance_to_wallet_handler(
     .await
     .map_err(|err| {
       warn!("moderator_add_banked_balance_to_wallet error: {:?}", err);
-      CommonWebError::ServerError
+      AdvancedCommonWebError::from_anyhow_error(err)
     })?;
 
+  // Insert staff audit log.
+  let _audit_token = insert_staff_audit_log(InsertStaffAuditLogArgs {
+    audit_action: StaffAuditAction::AddWalletBankedBalance,
+    maybe_entity_type: Some(StaffAuditEntityType::Wallet),
+    maybe_entity_token: Some(path.wallet_token.as_str()),
+    staff_user_token: &user_session.user_token,
+    actor_ip_address: &ip_address,
+    mysql_executor: &mut *transaction,
+    phantom: PhantomData,
+  }).await.map_err(|err| {
+    warn!("Failed to insert staff audit log: {:?}", err);
+    AdvancedCommonWebError::from_error(err)
+  })?;
+
   transaction.commit()
     .await
     .map_err(|err| {
       warn!("moderator_add_banked_balance_to_wallet commit error: {:?}", err);
-      CommonWebError::ServerError
+      AdvancedCommonWebError::from_error(err)
     })?;
 
   Ok(Json(ModeratorAddBankedBalanceToWalletResponse {