1use crate::{models::InsertQueryBuilder, prelude::*};
2use garde::Validate;
3use serde::{Deserialize, Serialize};
4use sqlx::{Row, postgres::PgRow};
5use std::{
6 collections::BTreeMap,
7 sync::{Arc, LazyLock},
8};
9use utoipa::ToSchema;
10
11#[derive(Serialize, Deserialize)]
12pub struct SystemBackupPolicyDatabaseAgentHost {
13 pub system_backup_policy: Fetchable<super::system_backup_policy::SystemBackupPolicy>,
14 pub database_agent_host: Fetchable<super::database_agent_host::DatabaseAgentHost>,
15
16 pub created: chrono::NaiveDateTime,
17
18 extension_data: super::ModelExtensionData,
19}
20
21impl BaseModel for SystemBackupPolicyDatabaseAgentHost {
22 const NAME: &'static str = "system_backup_policy_database_agent_host";
23
24 fn get_extension_list() -> &'static super::ModelExtensionList {
25 static EXTENSIONS: LazyLock<super::ModelExtensionList> =
26 LazyLock::new(|| parking_lot::RwLock::new(Vec::new()));
27
28 &EXTENSIONS
29 }
30
31 fn get_extension_data(&self) -> &super::ModelExtensionData {
32 &self.extension_data
33 }
34
35 #[inline]
36 fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, compact_str::CompactString> {
37 let prefix = prefix.unwrap_or_default();
38
39 BTreeMap::from([
40 (
41 "system_backup_policy_database_agent_hosts.system_backup_policy_uuid",
42 compact_str::format_compact!("{prefix}system_backup_policy_uuid"),
43 ),
44 (
45 "system_backup_policy_database_agent_hosts.database_agent_host_uuid",
46 compact_str::format_compact!("{prefix}database_agent_host_uuid"),
47 ),
48 (
49 "system_backup_policy_database_agent_hosts.created",
50 compact_str::format_compact!("{prefix}created"),
51 ),
52 ])
53 }
54
55 #[inline]
56 fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, crate::database::DatabaseError> {
57 let prefix = prefix.unwrap_or_default();
58
59 Ok(Self {
60 system_backup_policy: super::system_backup_policy::SystemBackupPolicy::get_fetchable(
61 row.try_get(
62 compact_str::format_compact!("{prefix}system_backup_policy_uuid").as_str(),
63 )?,
64 ),
65 database_agent_host: super::database_agent_host::DatabaseAgentHost::get_fetchable(
66 row.try_get(
67 compact_str::format_compact!("{prefix}database_agent_host_uuid").as_str(),
68 )?,
69 ),
70 created: row.try_get(compact_str::format_compact!("{prefix}created").as_str())?,
71 extension_data: Self::map_extensions(prefix, row)?,
72 })
73 }
74}
75
76impl SystemBackupPolicyDatabaseAgentHost {
77 pub async fn by_system_backup_policy_uuid_database_agent_host_uuid(
78 database: &crate::database::Database,
79 system_backup_policy_uuid: uuid::Uuid,
80 database_agent_host_uuid: uuid::Uuid,
81 ) -> Result<Option<Self>, crate::database::DatabaseError> {
82 let row = sqlx::query(sqlx::AssertSqlSafe(format!(
83 r#"
84 SELECT {}
85 FROM system_backup_policy_database_agent_hosts
86 WHERE
87 system_backup_policy_database_agent_hosts.system_backup_policy_uuid = $1
88 AND system_backup_policy_database_agent_hosts.database_agent_host_uuid = $2
89 "#,
90 Self::columns_sql(None)
91 )))
92 .bind(system_backup_policy_uuid)
93 .bind(database_agent_host_uuid)
94 .fetch_optional(database.read())
95 .await?;
96
97 row.try_map(|row| Self::map(None, &row))
98 }
99
100 pub async fn by_system_backup_policy_uuid_with_pagination(
101 database: &crate::database::Database,
102 system_backup_policy_uuid: uuid::Uuid,
103 page: i64,
104 per_page: i64,
105 search: Option<&str>,
106 ) -> Result<super::Pagination<Self>, crate::database::DatabaseError> {
107 super::PaginatedQueryBuilder::new(
108 Self::columns_sql(None),
109 format!(
110 r#"
111 FROM system_backup_policy_database_agent_hosts
112 JOIN database_agent_hosts ON database_agent_hosts.uuid = system_backup_policy_database_agent_hosts.database_agent_host_uuid
113 WHERE
114 system_backup_policy_database_agent_hosts.system_backup_policy_uuid = $1
115 AND {search}
116 "#,
117 search = super::search_sql(2, &["database_agent_hosts.name"], &["database_agent_hosts.uuid"]),
118 ),
119 "system_backup_policy_database_agent_hosts.created, system_backup_policy_database_agent_hosts.system_backup_policy_uuid, system_backup_policy_database_agent_hosts.database_agent_host_uuid",
120 )
121 .bind(system_backup_policy_uuid)
122 .bind(search)
123 .fetch(database, page, per_page)
124 .await
125 }
126}
127
128#[async_trait::async_trait]
129impl IntoAdminApiObject for SystemBackupPolicyDatabaseAgentHost {
130 type AdminApiObject = AdminApiSystemBackupPolicyDatabaseAgentHost;
131 type ExtraArgs<'a> = ();
132
133 async fn into_admin_api_object<'a>(
134 self,
135 state: &crate::State,
136 _args: Self::ExtraArgs<'a>,
137 ) -> Result<Self::AdminApiObject, crate::database::DatabaseError> {
138 let api_object =
139 AdminApiSystemBackupPolicyDatabaseAgentHost::init_hooks(&self, state).await?;
140
141 let api_object = finish_extendible!(
142 AdminApiSystemBackupPolicyDatabaseAgentHost {
143 database_agent_host: self
144 .database_agent_host
145 .fetch_cached(&state.database)
146 .await?
147 .into_admin_api_object(state, ())
148 .await?,
149 created: self.created.and_utc(),
150 },
151 api_object,
152 state
153 )?;
154
155 Ok(api_object)
156 }
157}
158
159#[derive(ToSchema, Deserialize, Validate)]
160pub struct CreateSystemBackupPolicyDatabaseAgentHostOptions {
161 #[garde(skip)]
162 pub system_backup_policy_uuid: uuid::Uuid,
163 #[garde(skip)]
164 pub database_agent_host_uuid: uuid::Uuid,
165}
166
167#[async_trait::async_trait]
168impl CreatableModel for SystemBackupPolicyDatabaseAgentHost {
169 type CreateOptions<'a> = CreateSystemBackupPolicyDatabaseAgentHostOptions;
170 type CreateResult = Self;
171
172 fn get_create_handlers() -> &'static LazyLock<CreateListenerList<Self>> {
173 static CREATE_LISTENERS: LazyLock<CreateListenerList<SystemBackupPolicyDatabaseAgentHost>> =
174 LazyLock::new(|| Arc::new(ModelHandlerList::default()));
175
176 &CREATE_LISTENERS
177 }
178
179 async fn create_with_transaction(
180 state: &crate::State,
181 mut options: Self::CreateOptions<'_>,
182 transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
183 ) -> Result<Self, crate::database::DatabaseError> {
184 options.validate()?;
185
186 super::database_agent_host::DatabaseAgentHost::by_uuid_optional_cached(
187 &state.database,
188 options.database_agent_host_uuid,
189 )
190 .await?
191 .ok_or(crate::database::InvalidRelationError("database_agent_host"))?;
192
193 let mut query_builder =
194 InsertQueryBuilder::new("system_backup_policy_database_agent_hosts");
195
196 Self::run_create_handlers(&mut options, &mut query_builder, state, transaction).await?;
197
198 query_builder
199 .set(
200 "system_backup_policy_uuid",
201 options.system_backup_policy_uuid,
202 )
203 .set("database_agent_host_uuid", options.database_agent_host_uuid);
204
205 let row = query_builder
206 .returning(&Self::columns_sql(None))
207 .fetch_one(&mut **transaction)
208 .await?;
209 let mut policy_database_agent_host = Self::map(None, &row)?;
210
211 Self::run_after_create_handlers(
212 &mut policy_database_agent_host,
213 &options,
214 state,
215 transaction,
216 )
217 .await?;
218
219 Ok(policy_database_agent_host)
220 }
221}
222
223#[async_trait::async_trait]
224impl DeletableModel for SystemBackupPolicyDatabaseAgentHost {
225 type DeleteOptions = ();
226
227 fn get_delete_handlers() -> &'static LazyLock<DeleteHandlerList<Self>> {
228 static DELETE_LISTENERS: LazyLock<DeleteHandlerList<SystemBackupPolicyDatabaseAgentHost>> =
229 LazyLock::new(|| Arc::new(ModelHandlerList::default()));
230
231 &DELETE_LISTENERS
232 }
233
234 async fn delete_with_transaction(
235 &self,
236 state: &crate::State,
237 options: Self::DeleteOptions,
238 transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
239 ) -> Result<(), anyhow::Error> {
240 self.run_delete_handlers(&options, state, transaction)
241 .await?;
242
243 sqlx::query(
244 r#"
245 DELETE FROM system_backup_policy_database_agent_hosts
246 WHERE
247 system_backup_policy_database_agent_hosts.system_backup_policy_uuid = $1
248 AND system_backup_policy_database_agent_hosts.database_agent_host_uuid = $2
249 "#,
250 )
251 .bind(self.system_backup_policy.uuid)
252 .bind(self.database_agent_host.uuid)
253 .execute(&mut **transaction)
254 .await?;
255
256 self.run_after_delete_handlers(&options, state, transaction)
257 .await?;
258
259 Ok(())
260 }
261}
262
263#[schema_extension_derive::extendible]
264#[init_args(SystemBackupPolicyDatabaseAgentHost, crate::State)]
265#[hook_args(crate::State)]
266#[derive(ToSchema, Serialize)]
267#[schema(title = "SystemBackupPolicyDatabaseAgentHost")]
268pub struct AdminApiSystemBackupPolicyDatabaseAgentHost {
269 pub database_agent_host: super::database_agent_host::AdminApiDatabaseAgentHost,
270
271 pub created: chrono::DateTime<chrono::Utc>,
272}