bucketwarden-server 0.1.0

use super::*;

pub(super) fn inventory_table_configuration_result_xml(
    result: &InventoryTableConfigurationResult,
) -> String {
    let error = result
        .error
        .as_ref()
        .map(metadata_configuration_error_xml)
        .unwrap_or_default();
    format!(
        "<InventoryTableConfigurationResult><ConfigurationState>{}</ConfigurationState>{error}<TableArn>{}</TableArn><TableName>{}</TableName><TableStatus>{}</TableStatus></InventoryTableConfigurationResult>",
        xml_escape(&result.configuration_state),
        xml_escape(&result.table_arn),
        xml_escape(&result.table_name),
        xml_escape(&result.table_status),
    )
}

pub(super) fn journal_table_configuration_result_xml(
    result: &JournalTableConfigurationResult,
) -> String {
    let error = result
        .error
        .as_ref()
        .map(metadata_configuration_error_xml)
        .unwrap_or_default();
    format!(
        "<JournalTableConfigurationResult>{error}{}<TableArn>{}</TableArn><TableName>{}</TableName><TableStatus>{}</TableStatus></JournalTableConfigurationResult>",
        record_expiration_xml(&result.record_expiration),
        xml_escape(&result.table_arn),
        xml_escape(&result.table_name),
        xml_escape(&result.table_status),
    )
}

pub(super) fn metadata_configuration_error_xml(
    error: &MetadataConfigurationErrorDetails,
) -> String {
    format!(
        "<Error><ErrorCode>{}</ErrorCode><ErrorMessage>{}</ErrorMessage></Error>",
        xml_escape(&error.error_code),
        xml_escape(&error.error_message),
    )
}

pub(super) fn record_expiration_xml(result: &RecordExpiration) -> String {
    let days = result
        .days
        .map(|value| format!("<Days>{value}</Days>"))
        .unwrap_or_default();
    format!(
        "<RecordExpiration>{days}<Expiration>{}</Expiration></RecordExpiration>",
        xml_escape(&result.expiration)
    )
}

pub(super) fn metrics_filter_xml(filter: &MetricsFilter) -> String {
    let access_point_arn = filter
        .access_point_arn
        .as_ref()
        .map(|value| format!("<AccessPointArn>{}</AccessPointArn>", xml_escape(value)))
        .unwrap_or_default();
    let prefix = filter
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    let tag = filter.tag.as_ref().map(metrics_tag_xml).unwrap_or_default();
    let and = filter.and.as_ref().map(metrics_and_xml).unwrap_or_default();
    format!("<Filter>{access_point_arn}{prefix}{tag}{and}</Filter>")
}

pub(super) fn metrics_and_xml(and: &MetricsAndOperator) -> String {
    let access_point_arn = and
        .access_point_arn
        .as_ref()
        .map(|value| format!("<AccessPointArn>{}</AccessPointArn>", xml_escape(value)))
        .unwrap_or_default();
    let prefix = and
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    let tags = and.tags.iter().map(metrics_tag_xml).collect::<String>();
    format!("<And>{access_point_arn}{prefix}{tags}</And>")
}

pub(super) fn metrics_tag_xml(tag: &MetricsTag) -> String {
    format!(
        "<Tag><Key>{}</Key><Value>{}</Value></Tag>",
        xml_escape(&tag.key),
        xml_escape(&tag.value)
    )
}

pub(super) fn analytics_filter_xml(filter: &AnalyticsFilter) -> String {
    let prefix = filter
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    let tag = filter
        .tag
        .as_ref()
        .map(analytics_tag_xml)
        .unwrap_or_default();
    let and = filter
        .and
        .as_ref()
        .map(analytics_and_xml)
        .unwrap_or_default();
    format!("<Filter>{prefix}{tag}{and}</Filter>")
}

pub(super) fn analytics_and_xml(and: &AnalyticsAndOperator) -> String {
    let prefix = and
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    let tags = and.tags.iter().map(analytics_tag_xml).collect::<String>();
    format!("<And>{prefix}{tags}</And>")
}

pub(super) fn analytics_tag_xml(tag: &AnalyticsTag) -> String {
    format!(
        "<Tag><Key>{}</Key><Value>{}</Value></Tag>",
        xml_escape(&tag.key),
        xml_escape(&tag.value)
    )
}

pub(super) fn storage_class_analysis_data_export_xml(
    export: &StorageClassAnalysisDataExport,
) -> String {
    let destination = &export.destination.s3_bucket_destination;
    let prefix = destination
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    format!(
        "<DataExport><OutputSchemaVersion>{}</OutputSchemaVersion><Destination><S3BucketDestination><Bucket>{}</Bucket><Format>{}</Format>{prefix}</S3BucketDestination></Destination></DataExport>",
        xml_escape(&export.output_schema_version),
        xml_escape(&destination.bucket_arn),
        xml_escape(&destination.format)
    )
}

pub(super) fn inventory_destination_xml(destination: &InventoryDestination) -> String {
    let s3_bucket_destination = &destination.s3_bucket_destination;
    let account_id = s3_bucket_destination
        .account_id
        .as_ref()
        .map(|value| format!("<AccountId>{}</AccountId>", xml_escape(value)))
        .unwrap_or_default();
    let prefix = s3_bucket_destination
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    let encryption = s3_bucket_destination
        .encryption
        .as_ref()
        .map(inventory_encryption_xml)
        .unwrap_or_default();
    format!(
        "<Destination><S3BucketDestination><Bucket>{}</Bucket>{account_id}<Format>{}</Format>{prefix}{encryption}</S3BucketDestination></Destination>",
        xml_escape(&s3_bucket_destination.bucket_arn),
        xml_escape(&s3_bucket_destination.format),
    )
}

pub(super) fn inventory_encryption_xml(encryption: &InventoryEncryption) -> String {
    if encryption.sse_s3 {
        "<Encryption><SSE-S3/></Encryption>".to_string()
    } else {
        let key_id = encryption
            .kms_key_id
            .as_ref()
            .map(|value| format!("<KeyId>{}</KeyId>", xml_escape(value)))
            .unwrap_or_default();
        format!("<Encryption><SSE-KMS>{key_id}</SSE-KMS></Encryption>")
    }
}

pub(super) fn intelligent_tiering_filter_xml(filter: &IntelligentTieringFilter) -> String {
    let prefix = filter
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    let tag = filter
        .tag
        .as_ref()
        .map(intelligent_tiering_tag_xml)
        .unwrap_or_default();
    let and = filter
        .and
        .as_ref()
        .map(intelligent_tiering_and_xml)
        .unwrap_or_default();
    format!("<Filter>{prefix}{tag}{and}</Filter>")
}

pub(super) fn intelligent_tiering_and_xml(and: &IntelligentTieringAndOperator) -> String {
    let prefix = and
        .prefix
        .as_ref()
        .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
        .unwrap_or_default();
    let tags = and
        .tags
        .iter()
        .map(intelligent_tiering_tag_xml)
        .collect::<String>();
    format!("<And>{prefix}{tags}</And>")
}

pub(super) fn intelligent_tiering_tag_xml(tag: &IntelligentTieringTag) -> String {
    format!(
        "<Tag><Key>{}</Key><Value>{}</Value></Tag>",
        xml_escape(&tag.key),
        xml_escape(&tag.value)
    )
}

pub(super) fn tiering_xml(tiering: &Tiering) -> String {
    format!(
        "<Tiering><AccessTier>{}</AccessTier><Days>{}</Days></Tiering>",
        xml_escape(&tiering.access_tier),
        tiering.days
    )
}