bucketwarden-server 0.1.0

use super::metadata_helpers::*;
use super::*;

pub(crate) fn bucket_metadata_configuration_xml(result: &MetadataConfigurationResult) -> String {
    let destination = format!(
        "<DestinationResult><TableBucketArn>{}</TableBucketArn><TableBucketType>{}</TableBucketType><TableNamespace>{}</TableNamespace></DestinationResult>",
        xml_escape(&result.destination_result.table_bucket_arn),
        xml_escape(&result.destination_result.table_bucket_type),
        xml_escape(&result.destination_result.table_namespace)
    );
    let inventory = result
        .inventory_table_configuration_result
        .as_ref()
        .map(inventory_table_configuration_result_xml)
        .unwrap_or_default();
    let journal =
        journal_table_configuration_result_xml(&result.journal_table_configuration_result);
    format!(
        "<GetBucketMetadataConfigurationResult><MetadataConfigurationResult>{destination}{inventory}{journal}</MetadataConfigurationResult></GetBucketMetadataConfigurationResult>"
    )
}

pub(crate) fn bucket_metadata_table_configuration_xml(
    result: &GetBucketMetadataTableConfigurationResult,
) -> String {
    let destination = &result
        .metadata_table_configuration_result
        .s3_tables_destination_result;
    let error = result
        .error
        .as_ref()
        .map(metadata_configuration_error_xml)
        .unwrap_or_default();
    format!(
        "<GetBucketMetadataTableConfigurationResult><MetadataTableConfigurationResult><S3TablesDestinationResult><TableArn>{}</TableArn><TableBucketArn>{}</TableBucketArn><TableName>{}</TableName><TableNamespace>{}</TableNamespace></S3TablesDestinationResult></MetadataTableConfigurationResult><Status>{}</Status>{error}</GetBucketMetadataTableConfigurationResult>",
        xml_escape(&destination.table_arn),
        xml_escape(&destination.table_bucket_arn),
        xml_escape(&destination.table_name),
        xml_escape(&destination.table_namespace),
        xml_escape(&result.status),
    )
}

pub(crate) fn bucket_metrics_configuration_xml(result: &MetricsConfiguration) -> String {
    let filter = result
        .filter
        .as_ref()
        .map(metrics_filter_xml)
        .unwrap_or_default();
    format!(
        "<MetricsConfiguration><Id>{}</Id>{filter}</MetricsConfiguration>",
        xml_escape(&result.id)
    )
}

pub(crate) fn list_bucket_metrics_configurations_xml(
    result: &ListMetricsConfigurationsResult,
) -> String {
    let continuation_token = result
        .continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<ContinuationToken>{}</ContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let next_continuation_token = result
        .next_continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<NextContinuationToken>{}</NextContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let configurations = result
        .metrics_configurations
        .iter()
        .map(bucket_metrics_configuration_xml)
        .collect::<String>();
    format!(
        "<ListMetricsConfigurationsResult>{continuation_token}<IsTruncated>{}</IsTruncated>{next_continuation_token}{configurations}</ListMetricsConfigurationsResult>",
        if result.is_truncated { "true" } else { "false" }
    )
}

pub(crate) fn bucket_analytics_configuration_xml(result: &AnalyticsConfiguration) -> String {
    let filter = result
        .filter
        .as_ref()
        .map(analytics_filter_xml)
        .unwrap_or_default();
    let data_export = result
        .storage_class_analysis
        .data_export
        .as_ref()
        .map(storage_class_analysis_data_export_xml)
        .unwrap_or_default();
    format!(
        "<AnalyticsConfiguration><Id>{}</Id>{filter}<StorageClassAnalysis>{data_export}</StorageClassAnalysis></AnalyticsConfiguration>",
        xml_escape(&result.id)
    )
}

pub(crate) fn list_bucket_analytics_configurations_xml(
    result: &ListAnalyticsConfigurationsResult,
) -> String {
    let continuation_token = result
        .continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<ContinuationToken>{}</ContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let next_continuation_token = result
        .next_continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<NextContinuationToken>{}</NextContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let configurations = result
        .analytics_configurations
        .iter()
        .map(bucket_analytics_configuration_xml)
        .collect::<String>();
    format!(
        "<ListBucketAnalyticsConfigurationsResult>{continuation_token}<IsTruncated>{}</IsTruncated>{next_continuation_token}{configurations}</ListBucketAnalyticsConfigurationsResult>",
        if result.is_truncated { "true" } else { "false" }
    )
}

pub(crate) fn bucket_inventory_configuration_xml(result: &InventoryConfiguration) -> String {
    let destination = inventory_destination_xml(&result.destination);
    let schedule = format!(
        "<Schedule><Frequency>{}</Frequency></Schedule>",
        xml_escape(&result.schedule.frequency)
    );
    let filter = result
        .filter
        .as_ref()
        .map(|filter| {
            let prefix = filter
                .prefix
                .as_ref()
                .map(|value| format!("<Prefix>{}</Prefix>", xml_escape(value)))
                .unwrap_or_default();
            format!("<Filter>{prefix}</Filter>")
        })
        .unwrap_or_default();
    let optional_fields = if result.optional_fields.is_empty() {
        String::new()
    } else {
        let fields = result
            .optional_fields
            .iter()
            .map(|field| format!("<Field>{}</Field>", xml_escape(field)))
            .collect::<String>();
        format!("<OptionalFields>{fields}</OptionalFields>")
    };
    format!(
        "<InventoryConfiguration><Id>{}</Id><IsEnabled>{}</IsEnabled><IncludedObjectVersions>{}</IncludedObjectVersions>{destination}{schedule}{filter}{optional_fields}</InventoryConfiguration>",
        xml_escape(&result.id),
        if result.is_enabled { "true" } else { "false" },
        xml_escape(&result.included_object_versions),
    )
}

pub(crate) fn list_bucket_inventory_configurations_xml(
    result: &ListInventoryConfigurationsResult,
) -> String {
    let continuation_token = result
        .continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<ContinuationToken>{}</ContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let next_continuation_token = result
        .next_continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<NextContinuationToken>{}</NextContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let configurations = result
        .inventory_configurations
        .iter()
        .map(bucket_inventory_configuration_xml)
        .collect::<String>();
    format!(
        "<ListInventoryConfigurationsResult>{continuation_token}<IsTruncated>{}</IsTruncated>{next_continuation_token}{configurations}</ListInventoryConfigurationsResult>",
        if result.is_truncated { "true" } else { "false" }
    )
}

pub(crate) fn bucket_intelligent_tiering_configuration_xml(
    result: &IntelligentTieringConfiguration,
) -> String {
    let filter = result
        .filter
        .as_ref()
        .map(intelligent_tiering_filter_xml)
        .unwrap_or_default();
    let tierings = result.tierings.iter().map(tiering_xml).collect::<String>();
    format!(
        "<IntelligentTieringConfiguration><Id>{}</Id><Status>{}</Status>{filter}{tierings}</IntelligentTieringConfiguration>",
        xml_escape(&result.id),
        xml_escape(&result.status),
    )
}

pub(crate) fn list_bucket_intelligent_tiering_configurations_xml(
    result: &ListIntelligentTieringConfigurationsResult,
) -> String {
    let continuation_token = result
        .continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<ContinuationToken>{}</ContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let next_continuation_token = result
        .next_continuation_token
        .as_ref()
        .map(|value| {
            format!(
                "<NextContinuationToken>{}</NextContinuationToken>",
                xml_escape(value)
            )
        })
        .unwrap_or_default();
    let configurations = result
        .intelligent_tiering_configurations
        .iter()
        .map(bucket_intelligent_tiering_configuration_xml)
        .collect::<String>();
    format!(
        "<ListBucketIntelligentTieringConfigurationsResult>{continuation_token}<IsTruncated>{}</IsTruncated>{next_continuation_token}{configurations}</ListBucketIntelligentTieringConfigurationsResult>",
        if result.is_truncated { "true" } else { "false" }
    )
}