ddex-parser 0.4.5

High-performance DDEX XML parser with SIMD optimization (40+ MB/s)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

// core/src/transform/version_adapter.rs
//! Version-specific transformation and adaptation

use crate::error::ParseError;
use ddex_core::models::graph::ERNMessage;
use ddex_core::models::versions::ERNVersion;
use ddex_core::models::versions::VersionDifferences;

pub struct VersionAdapter {
    _version: ERNVersion,
    _differences: VersionDifferences,
}

impl VersionAdapter {
    pub fn new(version: ERNVersion) -> Self {
        Self {
            _version: version,
            _differences: VersionDifferences::for_version(version),
        }
    }

    /// Transform version-specific MessageHeader to common model
    pub fn adapt_message_header(
        &self,
        _xml_data: &[u8],
    ) -> Result<ddex_core::models::graph::MessageHeader, ParseError> {
        // Placeholder implementation
        use ddex_core::models::graph::{
            MessageHeader, MessageRecipient, MessageSender, MessageType,
        };

        Ok(MessageHeader {
            message_id: "PLACEHOLDER".to_string(),
            message_type: MessageType::NewReleaseMessage,
            message_created_date_time: chrono::Utc::now(),
            message_sender: MessageSender {
                party_id: Vec::new(),
                party_name: Vec::new(),
                trading_name: None,
                extensions: None,
                attributes: None,
                comments: None,
            },
            message_recipient: MessageRecipient {
                party_id: Vec::new(),
                party_name: Vec::new(),
                trading_name: None,
                extensions: None,
                attributes: None,
                comments: None,
            },
            message_control_type: None,
            message_thread_id: None,
            extensions: None,
            attributes: None,
            comments: None,
        })
    }

    /// Adapt DealTerms based on version
    pub fn adapt_deal_terms(
        &self,
        _xml_data: &[u8],
    ) -> Result<ddex_core::models::graph::DealTerms, ParseError> {
        // Placeholder implementation
        use ddex_core::models::graph::DealTerms;

        Ok(DealTerms {
            validity_period: None,
            start_date: None,
            end_date: None,
            territory_code: Vec::new(),
            excluded_territory_code: Vec::new(),
            distribution_channel: Vec::new(),
            excluded_distribution_channel: Vec::new(),
            commercial_model_type: Vec::new(),
            use_type: Vec::new(),
            price_information: Vec::new(),
            wholesale_price: Vec::new(),
            suggested_retail_price: Vec::new(),
            pre_order_date: None,
            pre_order_preview_date: None,
            instant_gratification_date: None,
            takedown_date: None,
        })
    }
}

/// Migration helper to upgrade between versions
pub struct VersionMigrator;

impl VersionMigrator {
    /// Migrate from 3.8.2 to 4.2
    pub fn migrate_382_to_42(message: &ERNMessage) -> Result<ERNMessage, ParseError> {
        let mut migrated = message.clone();
        migrated.version = ERNVersion::V4_2;

        // Add empty audit trail if not present
        if migrated.message_audit_trail.is_none() {
            migrated.message_audit_trail = Some(ddex_core::models::graph::MessageAuditTrail {
                audit_trail_events: Vec::new(),
                extensions: None,
                attributes: None,
                comments: None,
            });
        }

        Ok(migrated)
    }

    /// Migrate from 4.2 to 4.3
    pub fn migrate_42_to_43(message: &ERNMessage) -> Result<ERNMessage, ParseError> {
        let mut migrated = message.clone();
        migrated.version = ERNVersion::V4_3;
        Ok(migrated)
    }

    /// Downgrade from 4.3 to 4.2 (with data loss warnings)
    pub fn downgrade_43_to_42(
        message: &ERNMessage,
    ) -> Result<(ERNMessage, Vec<String>), ParseError> {
        let mut downgraded = message.clone();
        downgraded.version = ERNVersion::V4_2;

        let mut warnings = Vec::new();

        if downgraded.profile.is_some() {
            warnings.push("Profile information will be lost in 4.2".to_string());
            downgraded.profile = None;
        }

        Ok((downgraded, warnings))
    }
}