1use crate::{State, models::InsertQueryBuilder, prelude::*};
2use compact_str::ToCompactString;
3use garde::Validate;
4use serde::{Deserialize, Serialize};
5use sqlx::{Row, postgres::PgRow};
6use std::{
7 collections::BTreeMap,
8 sync::{Arc, LazyLock},
9};
10use utoipa::ToSchema;
11
12pub type GetAdminActivityLogger = crate::extract::ConsumingExtension<AdminActivityLogger>;
13
14#[derive(Clone)]
15pub struct AdminActivityLogger {
16 pub state: State,
17 pub user_uuid: uuid::Uuid,
18 pub impersonator_uuid: Option<uuid::Uuid>,
19 pub api_key_uuid: Option<uuid::Uuid>,
20 pub ip: std::net::IpAddr,
21}
22
23impl AdminActivityLogger {
24 pub async fn log(&self, event: impl Into<compact_str::CompactString>, data: serde_json::Value) {
25 let options = CreateAdminActivityOptions {
26 user_uuid: Some(self.user_uuid),
27 impersonator_uuid: self.impersonator_uuid,
28 api_key_uuid: self.api_key_uuid,
29 event: event.into(),
30 ip: Some(self.ip.into()),
31 data,
32 created: None,
33 };
34 if let Err(err) = AdminActivity::create(&self.state, options).await {
35 tracing::warn!(
36 user = %self.user_uuid,
37 "failed to log admin activity: {:#?}",
38 err
39 );
40 }
41 }
42}
43
44#[derive(Serialize, Deserialize)]
45pub struct AdminActivity {
46 pub user: Option<super::user::User>,
47 pub impersonator: Option<Fetchable<super::user::User>>,
48 pub api_key: Option<Fetchable<super::user_api_key::UserApiKey>>,
49
50 pub event: compact_str::CompactString,
51 pub ip: Option<sqlx::types::ipnetwork::IpNetwork>,
52 pub data: serde_json::Value,
53
54 pub created: chrono::NaiveDateTime,
55
56 extension_data: super::ModelExtensionData,
57}
58
59impl BaseModel for AdminActivity {
60 const NAME: &'static str = "admin_activity";
61
62 fn get_extension_list() -> &'static super::ModelExtensionList {
63 static EXTENSIONS: LazyLock<super::ModelExtensionList> =
64 LazyLock::new(|| parking_lot::RwLock::new(Vec::new()));
65
66 &EXTENSIONS
67 }
68
69 fn get_extension_data(&self) -> &super::ModelExtensionData {
70 &self.extension_data
71 }
72
73 #[inline]
74 fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, compact_str::CompactString> {
75 let prefix = prefix.unwrap_or_default();
76
77 let mut columns = BTreeMap::from([
78 (
79 "admin_activities.impersonator_uuid",
80 compact_str::format_compact!("{prefix}impersonator_uuid"),
81 ),
82 (
83 "admin_activities.api_key_uuid",
84 compact_str::format_compact!("{prefix}api_key_uuid"),
85 ),
86 (
87 "admin_activities.event",
88 compact_str::format_compact!("{prefix}event"),
89 ),
90 (
91 "admin_activities.ip",
92 compact_str::format_compact!("{prefix}ip"),
93 ),
94 (
95 "admin_activities.data",
96 compact_str::format_compact!("{prefix}data"),
97 ),
98 (
99 "admin_activities.created",
100 compact_str::format_compact!("{prefix}created"),
101 ),
102 ]);
103
104 columns.extend(super::user::User::base_columns(Some("user_")));
105
106 columns
107 }
108
109 #[inline]
110 fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, crate::database::DatabaseError> {
111 let prefix = prefix.unwrap_or_default();
112
113 Ok(Self {
114 user: if row
115 .try_get::<uuid::Uuid, _>("user_uuid".to_string().as_str())
116 .is_ok()
117 {
118 Some(super::user::User::map(Some("user_"), row)?)
119 } else {
120 None
121 },
122 impersonator: super::user::User::get_fetchable_from_row(
123 row,
124 compact_str::format_compact!("{prefix}impersonator_uuid"),
125 ),
126 api_key: super::user_api_key::UserApiKey::get_fetchable_from_row(
127 row,
128 compact_str::format_compact!("{prefix}api_key_uuid").as_str(),
129 ),
130 event: row.try_get(compact_str::format_compact!("{prefix}event").as_str())?,
131 ip: row.try_get(compact_str::format_compact!("{prefix}ip").as_str())?,
132 data: row.try_get(compact_str::format_compact!("{prefix}data").as_str())?,
133 created: row.try_get(compact_str::format_compact!("{prefix}created").as_str())?,
134 extension_data: Self::map_extensions(prefix, row)?,
135 })
136 }
137}
138
139impl AdminActivity {
140 pub async fn all_with_pagination(
141 database: &crate::database::Database,
142 page: i64,
143 per_page: i64,
144 search: Option<&str>,
145 ) -> Result<super::Pagination<Self>, crate::database::DatabaseError> {
146 super::PaginatedQueryBuilder::new(
147 Self::columns_sql(None),
148 r#"
149 FROM admin_activities
150 LEFT JOIN users ON users.uuid = admin_activities.user_uuid
151 LEFT JOIN roles ON roles.uuid = users.role_uuid
152 WHERE ($1 IS NULL OR admin_activities.event ILIKE '%' || $1 || '%' OR users.username ILIKE '%' || $1 || '%')
153 "#,
154 "admin_activities.created DESC",
155 )
156 .bind(search)
157 .fetch(database, page, per_page)
158 .await
159 }
160
161 pub async fn by_user_uuid_with_pagination(
162 database: &crate::database::Database,
163 user_uuid: uuid::Uuid,
164 page: i64,
165 per_page: i64,
166 search: Option<&str>,
167 ) -> Result<super::Pagination<Self>, crate::database::DatabaseError> {
168 super::PaginatedQueryBuilder::new(
169 Self::columns_sql(None),
170 r#"
171 FROM admin_activities
172 LEFT JOIN users ON users.uuid = admin_activities.user_uuid
173 LEFT JOIN roles ON roles.uuid = users.role_uuid
174 WHERE admin_activities.user_uuid = $1 AND ($2 IS NULL OR admin_activities.event ILIKE '%' || $2 || '%' OR users.username ILIKE '%' || $2 || '%')
175 "#,
176 "admin_activities.created DESC",
177 )
178 .bind(user_uuid)
179 .bind(search)
180 .fetch(database, page, per_page)
181 .await
182 }
183
184 pub async fn delete_older_than(
185 database: &crate::database::Database,
186 cutoff: chrono::DateTime<chrono::Utc>,
187 ) -> Result<u64, crate::database::DatabaseError> {
188 let result = sqlx::query(
189 r#"
190 DELETE FROM admin_activities
191 WHERE admin_activities.created < $1
192 "#,
193 )
194 .bind(cutoff.naive_utc())
195 .execute(database.write())
196 .await?;
197
198 Ok(result.rows_affected())
199 }
200
201 pub async fn retain_latest_logs(
202 database: &crate::database::Database,
203 keep_count: i64,
204 ) -> Result<u64, crate::database::DatabaseError> {
205 let result = sqlx::query(
206 r#"
207 DELETE FROM admin_activities
208 WHERE ctid IN (
209 SELECT ctid
210 FROM admin_activities
211 ORDER BY admin_activities.created DESC
212 OFFSET $1
213 )
214 "#,
215 )
216 .bind(keep_count)
217 .execute(database.write())
218 .await?;
219
220 Ok(result.rows_affected())
221 }
222}
223
224#[async_trait::async_trait]
225impl IntoAdminApiObject for AdminActivity {
226 type AdminApiObject = AdminApiAdminActivity;
227 type ExtraArgs<'a> = &'a crate::storage::StorageUrlRetriever<'a>;
228
229 async fn into_admin_api_object<'a>(
230 self,
231 state: &crate::State,
232 storage_url_retriever: Self::ExtraArgs<'a>,
233 ) -> Result<Self::AdminApiObject, crate::database::DatabaseError> {
234 let api_object = AdminApiAdminActivity::init_hooks(&self, state).await?;
235
236 let user = if let Some(user) = self.user {
237 Some(user.into_api_object(state, storage_url_retriever).await?)
238 } else {
239 None
240 };
241
242 let impersonator = if let Some(impersonator) = self.impersonator {
243 Some(
244 impersonator
245 .fetch_cached(&state.database)
246 .await?
247 .into_api_object(state, storage_url_retriever)
248 .await?,
249 )
250 } else {
251 None
252 };
253
254 let api_object = finish_extendible!(
255 AdminApiAdminActivity {
256 user,
257 impersonator,
258 event: self.event,
259 ip: self.ip.map(|ip| ip.ip().to_compact_string()),
260 data: self.data,
261 is_api: self.api_key.is_some(),
262 created: self.created.and_utc(),
263 },
264 api_object,
265 state
266 )?;
267
268 Ok(api_object)
269 }
270}
271
272#[derive(ToSchema, Deserialize, Validate)]
273pub struct CreateAdminActivityOptions {
274 #[garde(skip)]
275 pub user_uuid: Option<uuid::Uuid>,
276 #[garde(skip)]
277 pub impersonator_uuid: Option<uuid::Uuid>,
278 #[garde(skip)]
279 pub api_key_uuid: Option<uuid::Uuid>,
280 #[garde(length(chars, min = 1, max = 255))]
281 #[schema(min_length = 1, max_length = 255)]
282 pub event: compact_str::CompactString,
283 #[garde(skip)]
284 #[schema(value_type = Option<String>)]
285 pub ip: Option<sqlx::types::ipnetwork::IpNetwork>,
286 #[garde(skip)]
287 pub data: serde_json::Value,
288 #[garde(skip)]
289 pub created: Option<chrono::NaiveDateTime>,
290}
291
292#[async_trait::async_trait]
293impl CreatableModel for AdminActivity {
294 type CreateOptions<'a> = CreateAdminActivityOptions;
295 type CreateResult = ();
296
297 fn get_create_handlers() -> &'static LazyLock<CreateListenerList<Self>> {
298 static CREATE_LISTENERS: LazyLock<CreateListenerList<AdminActivity>> =
299 LazyLock::new(|| Arc::new(ModelHandlerList::default()));
300
301 &CREATE_LISTENERS
302 }
303
304 async fn create_with_transaction(
305 state: &crate::State,
306 mut options: Self::CreateOptions<'_>,
307 transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
308 ) -> Result<Self::CreateResult, crate::database::DatabaseError> {
309 options.validate()?;
310
311 let mut query_builder = InsertQueryBuilder::new("admin_activities");
312
313 Self::run_create_handlers(&mut options, &mut query_builder, state, transaction).await?;
314
315 query_builder
316 .set("user_uuid", options.user_uuid)
317 .set("impersonator_uuid", options.impersonator_uuid)
318 .set("api_key_uuid", options.api_key_uuid)
319 .set("event", &options.event)
320 .set("ip", options.ip)
321 .set("data", &options.data);
322
323 if let Some(created) = options.created {
324 query_builder.set("created", created);
325 }
326
327 query_builder.execute(&mut **transaction).await?;
328
329 let mut result = ();
330
331 Self::run_after_create_handlers(&mut result, &options, state, transaction).await?;
332
333 Ok(result)
334 }
335}
336
337#[schema_extension_derive::extendible]
338#[init_args(AdminActivity, crate::State)]
339#[hook_args(crate::State)]
340#[derive(ToSchema, Serialize)]
341#[schema(title = "AdminAdminActivity")]
342pub struct AdminApiAdminActivity {
343 pub user: Option<super::user::ApiUser>,
344 pub impersonator: Option<super::user::ApiUser>,
345
346 pub event: compact_str::CompactString,
347 pub ip: Option<compact_str::CompactString>,
348 pub data: serde_json::Value,
349
350 pub is_api: bool,
351
352 pub created: chrono::DateTime<chrono::Utc>,
353}