Skip to main content

shared/models/
system_backup_policy_run.rs

1use crate::{
2    models::{
3        server_backup::ServerBackupKind, system_backup_policy::SystemBackupPolicy,
4        system_backup_policy_run_target::SystemBackupPolicyRunTargetReason,
5    },
6    prelude::*,
7};
8use serde::{Deserialize, Serialize};
9use sqlx::{Row, postgres::PgRow};
10use std::{collections::BTreeMap, sync::LazyLock};
11
12const PROGRESS_JOIN: &str = r#"
13    LEFT JOIN LATERAL (
14        SELECT
15            COUNT(*) FILTER (
16                WHERE system_backup_policy_run_targets.status = 'PENDING'
17            ) AS pending_targets,
18            COUNT(*) FILTER (
19                WHERE system_backup_policy_run_targets.status = 'DISPATCHED'
20                AND COALESCE(
21                    server_backups.completed IS NULL
22                    AND server_backups.deleted IS NULL
23                    AND server_backups.created >= NOW() - INTERVAL '1 day',
24                    FALSE
25                )
26            ) AS running_targets,
27            COUNT(*) FILTER (
28                WHERE system_backup_policy_run_targets.status = 'DISPATCHED'
29                AND server_backups.successful
30            ) AS successful_targets,
31            COUNT(*) FILTER (
32                WHERE system_backup_policy_run_targets.status = 'FAILED'
33                OR (
34                    system_backup_policy_run_targets.status = 'DISPATCHED'
35                    AND NOT COALESCE(server_backups.successful, FALSE)
36                    AND NOT COALESCE(
37                        server_backups.completed IS NULL
38                        AND server_backups.deleted IS NULL
39                        AND server_backups.created >= NOW() - INTERVAL '1 day',
40                        FALSE
41                    )
42                )
43            ) AS failed_targets,
44            COUNT(*) FILTER (
45                WHERE system_backup_policy_run_targets.status = 'SKIPPED'
46            ) AS skipped_targets
47        FROM system_backup_policy_run_targets
48        LEFT JOIN server_backups ON server_backups.uuid = system_backup_policy_run_targets.server_backup_uuid
49        WHERE
50            system_backup_policy_run_targets.system_backup_policy_run_uuid = system_backup_policy_runs.uuid
51            AND system_backup_policy_runs.completed IS NULL
52    ) AS system_backup_policy_run_progress ON TRUE
53"#;
54
55#[derive(Serialize, Deserialize, Clone)]
56pub struct SystemBackupPolicyRun {
57    pub uuid: uuid::Uuid,
58    pub system_backup_policy: Fetchable<SystemBackupPolicy>,
59
60    pub manual: bool,
61    pub occurrence: chrono::NaiveDateTime,
62
63    pub total_targets: i64,
64    pub pending_targets: i64,
65    pub running_targets: i64,
66    pub successful_targets: i64,
67    pub failed_targets: i64,
68    pub skipped_targets: i64,
69
70    pub cancelled: Option<chrono::NaiveDateTime>,
71    pub completed: Option<chrono::NaiveDateTime>,
72    pub created: chrono::NaiveDateTime,
73
74    extension_data: super::ModelExtensionData,
75}
76
77impl BaseModel for SystemBackupPolicyRun {
78    const NAME: &'static str = "system_backup_policy_run";
79
80    fn get_extension_list() -> &'static super::ModelExtensionList {
81        static EXTENSIONS: LazyLock<super::ModelExtensionList> =
82            LazyLock::new(|| parking_lot::RwLock::new(Vec::new()));
83
84        &EXTENSIONS
85    }
86
87    fn get_extension_data(&self) -> &super::ModelExtensionData {
88        &self.extension_data
89    }
90
91    #[inline]
92    fn base_columns(prefix: Option<&str>) -> BTreeMap<&'static str, compact_str::CompactString> {
93        let prefix = prefix.unwrap_or_default();
94
95        BTreeMap::from([
96            (
97                "system_backup_policy_runs.uuid",
98                compact_str::format_compact!("{prefix}uuid"),
99            ),
100            (
101                "system_backup_policy_runs.system_backup_policy_uuid",
102                compact_str::format_compact!("{prefix}system_backup_policy_uuid"),
103            ),
104            (
105                "system_backup_policy_runs.manual",
106                compact_str::format_compact!("{prefix}manual"),
107            ),
108            (
109                "system_backup_policy_runs.occurrence",
110                compact_str::format_compact!("{prefix}occurrence"),
111            ),
112            (
113                "system_backup_policy_runs.total_targets::int8",
114                compact_str::format_compact!("{prefix}total_targets"),
115            ),
116            (
117                "COALESCE(system_backup_policy_run_progress.pending_targets, 0)",
118                compact_str::format_compact!("{prefix}pending_targets"),
119            ),
120            (
121                "COALESCE(system_backup_policy_run_progress.running_targets, 0)",
122                compact_str::format_compact!("{prefix}running_targets"),
123            ),
124            (
125                "CASE WHEN system_backup_policy_runs.completed IS NULL THEN system_backup_policy_run_progress.successful_targets ELSE system_backup_policy_runs.successful_targets END",
126                compact_str::format_compact!("{prefix}successful_targets"),
127            ),
128            (
129                "CASE WHEN system_backup_policy_runs.completed IS NULL THEN system_backup_policy_run_progress.failed_targets ELSE system_backup_policy_runs.failed_targets END",
130                compact_str::format_compact!("{prefix}failed_targets"),
131            ),
132            (
133                "CASE WHEN system_backup_policy_runs.completed IS NULL THEN system_backup_policy_run_progress.skipped_targets ELSE system_backup_policy_runs.skipped_targets END",
134                compact_str::format_compact!("{prefix}skipped_targets"),
135            ),
136            (
137                "system_backup_policy_runs.cancelled",
138                compact_str::format_compact!("{prefix}cancelled"),
139            ),
140            (
141                "system_backup_policy_runs.completed",
142                compact_str::format_compact!("{prefix}completed"),
143            ),
144            (
145                "system_backup_policy_runs.created",
146                compact_str::format_compact!("{prefix}created"),
147            ),
148        ])
149    }
150
151    #[inline]
152    fn map(prefix: Option<&str>, row: &PgRow) -> Result<Self, crate::database::DatabaseError> {
153        let prefix = prefix.unwrap_or_default();
154
155        Ok(Self {
156            uuid: row.try_get(compact_str::format_compact!("{prefix}uuid").as_str())?,
157            system_backup_policy: SystemBackupPolicy::get_fetchable(row.try_get(
158                compact_str::format_compact!("{prefix}system_backup_policy_uuid").as_str(),
159            )?),
160            manual: row.try_get(compact_str::format_compact!("{prefix}manual").as_str())?,
161            occurrence: row.try_get(compact_str::format_compact!("{prefix}occurrence").as_str())?,
162            total_targets: row
163                .try_get(compact_str::format_compact!("{prefix}total_targets").as_str())?,
164            pending_targets: row
165                .try_get(compact_str::format_compact!("{prefix}pending_targets").as_str())?,
166            running_targets: row
167                .try_get(compact_str::format_compact!("{prefix}running_targets").as_str())?,
168            successful_targets: row
169                .try_get(compact_str::format_compact!("{prefix}successful_targets").as_str())?,
170            failed_targets: row
171                .try_get(compact_str::format_compact!("{prefix}failed_targets").as_str())?,
172            skipped_targets: row
173                .try_get(compact_str::format_compact!("{prefix}skipped_targets").as_str())?,
174            cancelled: row.try_get(compact_str::format_compact!("{prefix}cancelled").as_str())?,
175            completed: row.try_get(compact_str::format_compact!("{prefix}completed").as_str())?,
176            created: row.try_get(compact_str::format_compact!("{prefix}created").as_str())?,
177            extension_data: Self::map_extensions(prefix, row)?,
178        })
179    }
180}
181
182impl SystemBackupPolicyRun {
183    pub async fn by_system_backup_policy_uuid_with_pagination(
184        database: &crate::database::Database,
185        system_backup_policy_uuid: uuid::Uuid,
186        page: i64,
187        per_page: i64,
188    ) -> Result<super::Pagination<Self>, crate::database::DatabaseError> {
189        super::PaginatedQueryBuilder::new(
190            Self::columns_sql(None),
191            format!(
192                r#"
193                FROM system_backup_policy_runs
194                {PROGRESS_JOIN}
195                WHERE system_backup_policy_runs.system_backup_policy_uuid = $1
196                "#
197            ),
198            "system_backup_policy_runs.created DESC, system_backup_policy_runs.uuid DESC",
199        )
200        .bind(system_backup_policy_uuid)
201        .fetch(database, page, per_page)
202        .await
203    }
204
205    pub async fn by_system_backup_policy_uuid_uuid(
206        database: &crate::database::Database,
207        system_backup_policy_uuid: uuid::Uuid,
208        uuid: uuid::Uuid,
209    ) -> Result<Option<Self>, crate::database::DatabaseError> {
210        let row = sqlx::query(sqlx::AssertSqlSafe(format!(
211            r#"
212            SELECT {}
213            FROM system_backup_policy_runs
214            {PROGRESS_JOIN}
215            WHERE
216                system_backup_policy_runs.system_backup_policy_uuid = $1
217                AND system_backup_policy_runs.uuid = $2
218            "#,
219            Self::columns_sql(None)
220        )))
221        .bind(system_backup_policy_uuid)
222        .bind(uuid)
223        .fetch_optional(database.read())
224        .await?;
225
226        row.try_map(|row| Self::map(None, &row))
227    }
228
229    pub async fn all_latest(
230        database: &crate::database::Database,
231    ) -> Result<Vec<Self>, crate::database::DatabaseError> {
232        let rows = sqlx::query(sqlx::AssertSqlSafe(format!(
233            r#"
234            SELECT {}
235            FROM (
236                SELECT DISTINCT ON (system_backup_policy_runs.system_backup_policy_uuid)
237                    system_backup_policy_runs.*
238                FROM system_backup_policy_runs
239                ORDER BY
240                    system_backup_policy_runs.system_backup_policy_uuid,
241                    system_backup_policy_runs.created DESC,
242                    system_backup_policy_runs.uuid DESC
243            ) AS system_backup_policy_runs
244            {PROGRESS_JOIN}
245            "#,
246            Self::columns_sql(None)
247        )))
248        .fetch_all(database.read())
249        .await?;
250
251        rows.into_iter()
252            .map(|row| Self::map(None, &row))
253            .try_collect_vec()
254    }
255
256    pub async fn open_by_system_backup_policy_uuid(
257        database: &crate::database::Database,
258        system_backup_policy_uuid: uuid::Uuid,
259    ) -> Result<Vec<Self>, crate::database::DatabaseError> {
260        let rows = sqlx::query(sqlx::AssertSqlSafe(format!(
261            r#"
262            SELECT {}
263            FROM system_backup_policy_runs
264            {PROGRESS_JOIN}
265            WHERE
266                system_backup_policy_runs.system_backup_policy_uuid = $1
267                AND system_backup_policy_runs.completed IS NULL
268            ORDER BY system_backup_policy_runs.created, system_backup_policy_runs.uuid
269            "#,
270            Self::columns_sql(None)
271        )))
272        .bind(system_backup_policy_uuid)
273        .fetch_all(database.write())
274        .await?;
275
276        rows.into_iter()
277            .map(|row| Self::map(None, &row))
278            .try_collect_vec()
279    }
280
281    pub async fn has_pending_by_system_backup_policy_uuid(
282        database: &crate::database::Database,
283        system_backup_policy_uuid: uuid::Uuid,
284    ) -> Result<bool, sqlx::Error> {
285        let exists = sqlx::query_scalar!(
286            r#"
287            SELECT EXISTS (
288                SELECT 1
289                FROM system_backup_policy_run_targets
290                JOIN system_backup_policy_runs ON system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
291                WHERE
292                    system_backup_policy_runs.system_backup_policy_uuid = $1
293                    AND system_backup_policy_runs.completed IS NULL
294                    AND system_backup_policy_run_targets.status = 'PENDING'
295            ) AS "exists!"
296            "#,
297            system_backup_policy_uuid,
298        )
299        .fetch_one(database.write())
300        .await?;
301
302        Ok(exists)
303    }
304
305    pub async fn create(
306        database: &crate::database::Database,
307        policy: &SystemBackupPolicy,
308        manual: bool,
309        occurrence: chrono::NaiveDateTime,
310    ) -> Result<Option<uuid::Uuid>, sqlx::Error> {
311        let mut transaction = database.write().begin().await?;
312
313        let run_uuid = sqlx::query_scalar!(
314            r#"
315            INSERT INTO system_backup_policy_runs (system_backup_policy_uuid, manual, occurrence)
316            SELECT $1, $2, $3
317            WHERE $2 OR NOT EXISTS (
318                SELECT 1
319                FROM system_backup_policy_runs
320                WHERE
321                    system_backup_policy_runs.system_backup_policy_uuid = $1
322                    AND NOT system_backup_policy_runs.manual
323                    AND system_backup_policy_runs.occurrence >= $3
324            )
325            ON CONFLICT DO NOTHING
326            RETURNING system_backup_policy_runs.uuid
327            "#,
328            policy.uuid,
329            manual,
330            occurrence,
331        )
332        .fetch_optional(&mut *transaction)
333        .await?;
334
335        let Some(run_uuid) = run_uuid else {
336            return Ok(None);
337        };
338
339        sqlx::query!(
340            r#"
341            UPDATE system_backup_policy_run_targets
342            SET
343                status = 'SKIPPED',
344                reason = COALESCE(system_backup_policy_run_targets.reason, 'SUPERSEDED'),
345                updated = NOW()
346            FROM system_backup_policy_runs
347            WHERE
348                system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
349                AND system_backup_policy_runs.system_backup_policy_uuid = $1
350                AND system_backup_policy_runs.uuid != $2
351                AND system_backup_policy_runs.completed IS NULL
352                AND system_backup_policy_run_targets.status = 'PENDING'
353            "#,
354            policy.uuid,
355            run_uuid,
356        )
357        .execute(&mut *transaction)
358        .await?;
359
360        let total_targets = match policy.kind {
361            ServerBackupKind::Server => {
362                sqlx::query!(
363                    r#"
364                    INSERT INTO system_backup_policy_run_targets (system_backup_policy_run_uuid, server_uuid, last_attempt)
365                    SELECT $2, servers.uuid, attempts.last_attempt
366                    FROM servers
367                    JOIN nodes ON nodes.uuid = servers.node_uuid
368                    LEFT JOIN LATERAL (
369                        SELECT MIN(scopes.created) AS attached
370                        FROM (
371                            SELECT system_backup_policy_nodes.created
372                            FROM system_backup_policy_nodes
373                            WHERE
374                                system_backup_policy_nodes.system_backup_policy_uuid = $1
375                                AND system_backup_policy_nodes.node_uuid = servers.node_uuid
376                            UNION ALL
377                            SELECT system_backup_policy_locations.created
378                            FROM system_backup_policy_locations
379                            WHERE
380                                system_backup_policy_locations.system_backup_policy_uuid = $1
381                                AND system_backup_policy_locations.location_uuid = nodes.location_uuid
382                            UNION ALL
383                            SELECT system_backup_policy_servers.created
384                            FROM system_backup_policy_servers
385                            WHERE
386                                system_backup_policy_servers.system_backup_policy_uuid = $1
387                                AND system_backup_policy_servers.server_uuid = servers.uuid
388                        ) AS scopes
389                    ) AS coverage ON TRUE
390                    LEFT JOIN LATERAL (
391                        SELECT
392                            MAX(server_backups.created) AS last_attempt,
393                            BOOL_OR(
394                                server_backups.completed IS NULL
395                                AND server_backups.deleted IS NULL
396                                AND server_backups.created >= NOW() - INTERVAL '1 day'
397                            ) AS in_flight
398                        FROM server_backups
399                        WHERE
400                            server_backups.system_backup_policy_uuid = $1
401                            AND server_backups.server_uuid = servers.uuid
402                    ) AS attempts ON TRUE
403                    WHERE
404                        coverage.attached IS NOT NULL
405                        AND ($3 OR GREATEST(servers.created, coverage.attached) < $4)
406                        AND (attempts.last_attempt IS NULL OR attempts.last_attempt < $4)
407                        AND NOT COALESCE(attempts.in_flight, FALSE)
408                    "#,
409                    policy.uuid,
410                    run_uuid,
411                    manual,
412                    occurrence,
413                )
414                .execute(&mut *transaction)
415                .await?
416                .rows_affected()
417            }
418            ServerBackupKind::DatabaseInstance => {
419                sqlx::query!(
420                    r#"
421                    INSERT INTO system_backup_policy_run_targets (system_backup_policy_run_uuid, server_uuid, database_instance_uuid, last_attempt)
422                    SELECT $2, server_database_instances.server_uuid, server_database_instances.uuid, attempts.last_attempt
423                    FROM server_database_instances
424                    LEFT JOIN LATERAL (
425                        SELECT MIN(scopes.created) AS attached
426                        FROM (
427                            SELECT system_backup_policy_database_agent_hosts.created
428                            FROM system_backup_policy_database_agent_hosts
429                            WHERE
430                                system_backup_policy_database_agent_hosts.system_backup_policy_uuid = $1
431                                AND system_backup_policy_database_agent_hosts.database_agent_host_uuid = server_database_instances.database_agent_host_uuid
432                            UNION ALL
433                            SELECT system_backup_policy_locations.created
434                            FROM system_backup_policy_locations
435                            JOIN location_database_agent_hosts ON location_database_agent_hosts.location_uuid = system_backup_policy_locations.location_uuid
436                            WHERE
437                                system_backup_policy_locations.system_backup_policy_uuid = $1
438                                AND location_database_agent_hosts.database_agent_host_uuid = server_database_instances.database_agent_host_uuid
439                            UNION ALL
440                            SELECT system_backup_policy_servers.created
441                            FROM system_backup_policy_servers
442                            WHERE
443                                system_backup_policy_servers.system_backup_policy_uuid = $1
444                                AND system_backup_policy_servers.server_uuid = server_database_instances.server_uuid
445                        ) AS scopes
446                    ) AS coverage ON TRUE
447                    LEFT JOIN LATERAL (
448                        SELECT
449                            MAX(server_backups.created) AS last_attempt,
450                            BOOL_OR(
451                                server_backups.completed IS NULL
452                                AND server_backups.deleted IS NULL
453                                AND server_backups.created >= NOW() - INTERVAL '1 day'
454                            ) AS in_flight
455                        FROM server_backups
456                        WHERE
457                            server_backups.system_backup_policy_uuid = $1
458                            AND server_backups.database_instance_uuid = server_database_instances.uuid
459                    ) AS attempts ON TRUE
460                    WHERE
461                        coverage.attached IS NOT NULL
462                        AND ($3 OR GREATEST(server_database_instances.created, coverage.attached) < $4)
463                        AND (attempts.last_attempt IS NULL OR attempts.last_attempt < $4)
464                        AND NOT COALESCE(attempts.in_flight, FALSE)
465                    "#,
466                    policy.uuid,
467                    run_uuid,
468                    manual,
469                    occurrence,
470                )
471                .execute(&mut *transaction)
472                .await?
473                .rows_affected()
474            }
475        };
476
477        sqlx::query!(
478            "UPDATE system_backup_policy_runs
479            SET total_targets = $2
480            WHERE system_backup_policy_runs.uuid = $1",
481            run_uuid,
482            total_targets as i32,
483        )
484        .execute(&mut *transaction)
485        .await?;
486
487        transaction.commit().await?;
488
489        Ok(Some(run_uuid))
490    }
491
492    pub async fn skip_pending_scheduled_by_system_backup_policy_uuid(
493        database: &crate::database::Database,
494        system_backup_policy_uuid: uuid::Uuid,
495        reason: SystemBackupPolicyRunTargetReason,
496    ) -> Result<u64, sqlx::Error> {
497        Ok(sqlx::query!(
498            r#"
499            UPDATE system_backup_policy_run_targets
500            SET status = 'SKIPPED', reason = $2, updated = NOW()
501            FROM system_backup_policy_runs
502            WHERE
503                system_backup_policy_runs.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
504                AND system_backup_policy_runs.system_backup_policy_uuid = $1
505                AND NOT system_backup_policy_runs.manual
506                AND system_backup_policy_runs.completed IS NULL
507                AND system_backup_policy_run_targets.status = 'PENDING'
508            "#,
509            system_backup_policy_uuid,
510            reason as SystemBackupPolicyRunTargetReason,
511        )
512        .execute(database.write())
513        .await?
514        .rows_affected())
515    }
516
517    pub async fn cancel(
518        database: &crate::database::Database,
519        system_backup_policy_uuid: uuid::Uuid,
520        uuid: uuid::Uuid,
521    ) -> Result<bool, sqlx::Error> {
522        let row = sqlx::query!(
523            r#"
524            WITH cancelled_run AS (
525                UPDATE system_backup_policy_runs
526                SET cancelled = NOW()
527                WHERE
528                    system_backup_policy_runs.uuid = $2
529                    AND system_backup_policy_runs.system_backup_policy_uuid = $1
530                    AND system_backup_policy_runs.completed IS NULL
531                    AND system_backup_policy_runs.cancelled IS NULL
532                RETURNING system_backup_policy_runs.uuid
533            ), skipped_targets AS (
534                UPDATE system_backup_policy_run_targets
535                SET status = 'SKIPPED', reason = 'CANCELLED', not_before = NULL, updated = NOW()
536                FROM cancelled_run
537                WHERE
538                    system_backup_policy_run_targets.system_backup_policy_run_uuid = cancelled_run.uuid
539                    AND system_backup_policy_run_targets.status = 'PENDING'
540            )
541            SELECT uuid FROM cancelled_run
542            "#,
543            system_backup_policy_uuid,
544            uuid,
545        )
546        .fetch_optional(database.write())
547        .await?;
548
549        Ok(row.is_some())
550    }
551
552    pub async fn complete(&self, database: &crate::database::Database) -> Result<(), sqlx::Error> {
553        sqlx::query!(
554            "UPDATE system_backup_policy_runs
555            SET
556                completed = NOW(),
557                successful_targets = $2,
558                failed_targets = $3,
559                skipped_targets = $4
560            WHERE system_backup_policy_runs.uuid = $1 AND system_backup_policy_runs.completed IS NULL",
561            self.uuid,
562            self.successful_targets as i32,
563            self.failed_targets as i32,
564            self.skipped_targets as i32,
565        )
566        .execute(database.write())
567        .await?;
568
569        Ok(())
570    }
571
572    pub async fn prune(
573        database: &crate::database::Database,
574        keep_runs: i64,
575        keep_targets: i64,
576    ) -> Result<u64, sqlx::Error> {
577        sqlx::query!(
578            r#"
579            DELETE FROM system_backup_policy_run_targets
580            USING (
581                SELECT
582                    system_backup_policy_runs.uuid,
583                    ROW_NUMBER() OVER (
584                        PARTITION BY system_backup_policy_runs.system_backup_policy_uuid
585                        ORDER BY system_backup_policy_runs.created DESC, system_backup_policy_runs.uuid DESC
586                    ) AS position
587                FROM system_backup_policy_runs
588                WHERE system_backup_policy_runs.completed IS NOT NULL
589            ) AS ranked
590            WHERE
591                ranked.uuid = system_backup_policy_run_targets.system_backup_policy_run_uuid
592                AND ranked.position > $1
593            "#,
594            keep_targets,
595        )
596        .execute(database.write())
597        .await?;
598
599        Ok(sqlx::query!(
600            r#"
601            DELETE FROM system_backup_policy_runs
602            USING (
603                SELECT
604                    system_backup_policy_runs.uuid,
605                    ROW_NUMBER() OVER (
606                        PARTITION BY system_backup_policy_runs.system_backup_policy_uuid
607                        ORDER BY system_backup_policy_runs.created DESC, system_backup_policy_runs.uuid DESC
608                    ) AS position
609                FROM system_backup_policy_runs
610                WHERE system_backup_policy_runs.completed IS NOT NULL
611            ) AS ranked
612            WHERE
613                ranked.uuid = system_backup_policy_runs.uuid
614                AND ranked.position > $1
615            "#,
616            keep_runs,
617        )
618        .execute(database.write())
619        .await?
620        .rows_affected())
621    }
622}
623
624#[async_trait::async_trait]
625impl IntoAdminApiObject for SystemBackupPolicyRun {
626    type AdminApiObject = AdminApiSystemBackupPolicyRun;
627    type ExtraArgs<'a> = ();
628
629    async fn into_admin_api_object<'a>(
630        self,
631        state: &crate::State,
632        _args: Self::ExtraArgs<'a>,
633    ) -> Result<Self::AdminApiObject, crate::database::DatabaseError> {
634        let api_object = AdminApiSystemBackupPolicyRun::init_hooks(&self, state).await?;
635
636        let api_object = finish_extendible!(
637            AdminApiSystemBackupPolicyRun {
638                uuid: self.uuid,
639                manual: self.manual,
640                occurrence: self.occurrence.and_utc(),
641                total_targets: self.total_targets,
642                pending_targets: self.pending_targets,
643                running_targets: self.running_targets,
644                successful_targets: self.successful_targets,
645                failed_targets: self.failed_targets,
646                skipped_targets: self.skipped_targets,
647                cancelled: self.cancelled.map(|dt| dt.and_utc()),
648                completed: self.completed.map(|dt| dt.and_utc()),
649                created: self.created.and_utc(),
650            },
651            api_object,
652            state
653        )?;
654
655        Ok(api_object)
656    }
657}
658
659#[schema_extension_derive::extendible]
660#[init_args(SystemBackupPolicyRun, crate::State)]
661#[hook_args(crate::State)]
662#[derive(ToSchema, Serialize)]
663#[schema(title = "SystemBackupPolicyRun")]
664pub struct AdminApiSystemBackupPolicyRun {
665    pub uuid: uuid::Uuid,
666
667    pub manual: bool,
668    pub occurrence: chrono::DateTime<chrono::Utc>,
669
670    pub total_targets: i64,
671    pub pending_targets: i64,
672    pub running_targets: i64,
673    pub successful_targets: i64,
674    pub failed_targets: i64,
675    pub skipped_targets: i64,
676
677    pub cancelled: Option<chrono::DateTime<chrono::Utc>>,
678    pub completed: Option<chrono::DateTime<chrono::Utc>>,
679    pub created: chrono::DateTime<chrono::Utc>,
680}