Skip to main content

shared/models/
system_backup_policy_database_agent_host.rs

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}