oci_api/services/object_storage/
models.rs

1use crate::error::Result;
2use crate::services::object_storage::client::Bucket;
3use serde::{Deserialize, Serialize};
4
5/// Object Storage Object
6#[derive(Clone, Debug, Serialize, Deserialize)]
7pub struct Object {
8    /// Object name
9    pub name: String,
10    /// Object content
11    pub value: String,
12}
13
14impl Object {
15    pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
16        Self {
17            name: name.into(),
18            value: value.into(),
19        }
20    }
21}
22
23/// Retention Rule Duration
24#[derive(Debug, Clone, Serialize, Deserialize)]
25#[serde(rename_all = "camelCase")]
26pub struct RetentionDuration {
27    /// Time amount
28    pub time_amount: u64,
29    /// Time unit (YEARS, DAYS)
30    pub time_unit: RetentionTimeUnit,
31}
32
33/// Retention Time Unit
34#[derive(Debug, Clone, Serialize, Deserialize)]
35#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
36pub enum RetentionTimeUnit {
37    Years,
38    Days,
39}
40
41/// Retention Rule
42#[derive(Debug, Clone, Serialize, Deserialize)]
43#[serde(rename_all = "camelCase")]
44pub struct RetentionRule {
45    /// Retention Rule ID
46    pub id: String,
47    /// Display name
48    pub display_name: String,
49    /// Duration
50    #[serde(skip_serializing_if = "Option::is_none")]
51    pub duration: Option<RetentionDuration>,
52    /// Time rule locked
53    #[serde(skip_serializing_if = "Option::is_none")]
54    pub time_rule_locked: Option<String>,
55    /// Time created
56    pub time_created: String,
57    /// Time modified
58    pub time_modified: String,
59    /// ETag
60    pub etag: String,
61}
62
63/// Retention Rule Details
64#[derive(Debug, Clone, Serialize, Deserialize, Default)]
65#[serde(rename_all = "camelCase")]
66pub struct RetentionRuleDetails {
67    /// Display name
68    #[serde(skip_serializing_if = "Option::is_none")]
69    pub display_name: Option<String>,
70    /// Duration
71    #[serde(skip_serializing_if = "Option::is_none")]
72    pub duration: Option<RetentionDuration>,
73    /// Time rule locked
74    #[serde(skip_serializing_if = "Option::is_none")]
75    pub time_rule_locked: Option<String>,
76}
77
78impl RetentionRule {
79    /// Delete this retention rule
80    pub async fn delete(&self, bucket: &Bucket) -> Result<()> {
81        bucket.delete_retention_rule(&self.id).await
82    }
83
84    /// Update this retention rule
85    pub async fn update(
86        &self,
87        bucket: &Bucket,
88        details: RetentionRuleDetails,
89    ) -> Result<RetentionRule> {
90        bucket.update_retention_rule(&self.id, details).await
91    }
92}