swift_mt_message/plugin/
validate.rs

1use crate::{ParseError, SwiftParser, SwiftValidationError};
2use async_trait::async_trait;
3use dataflow_rs::engine::error::DataflowError;
4use dataflow_rs::engine::{
5    AsyncFunctionHandler, FunctionConfig,
6    error::Result,
7    message::{Change, Message},
8};
9use datalogic_rs::DataLogic;
10use serde_json::{Value, json};
11use std::sync::Arc;
12use tracing::{debug, instrument};
13
14pub struct Validate;
15
16#[async_trait]
17impl AsyncFunctionHandler for Validate {
18    #[instrument(skip(self, message, config, _datalogic))]
19    async fn execute(
20        &self,
21        message: &mut Message,
22        config: &FunctionConfig,
23        _datalogic: Arc<DataLogic>,
24    ) -> Result<(usize, Vec<Change>)> {
25        debug!("Starting MT message validation");
26
27        // Extract custom configuration
28        let input = match config {
29            FunctionConfig::Custom { input, .. } => input,
30            _ => {
31                return Err(DataflowError::Validation(
32                    "Invalid configuration type".to_string(),
33                ));
34            }
35        };
36
37        let source_field = input.get("source").and_then(Value::as_str).ok_or_else(|| {
38            DataflowError::Validation("'source' parameter is required".to_string())
39        })?;
40
41        let target_field = input.get("target").and_then(Value::as_str).ok_or_else(|| {
42            DataflowError::Validation("'target' parameter is required".to_string())
43        })?;
44
45        // Get the MT message to validate
46        let mt_content = if source_field == "payload" {
47            // Extract string value from the payload JSON
48            if let Some(s) = message.payload.as_str() {
49                s.to_string()
50            } else {
51                // If it's not a string directly, try to convert
52                message.payload.to_string().trim_matches('"').to_string()
53            }
54        } else {
55            // Check if the field contains an object with mt_message (from generate_mt output)
56            let field_value = message.data().get(source_field).ok_or_else(|| {
57                DataflowError::Validation(format!(
58                    "MT message field '{}' not found in message data",
59                    source_field
60                ))
61            })?;
62
63            // If it's an object with mt_message field, extract that
64            if let Some(mt_msg) = field_value.get("mt_message").and_then(Value::as_str) {
65                mt_msg.to_string()
66            } else if let Some(s) = field_value.as_str() {
67                // If it's a direct string, use it
68                s.to_string()
69            } else {
70                return Err(DataflowError::Validation(format!(
71                    "Field '{}' does not contain a valid MT message",
72                    source_field
73                )));
74            }
75        };
76
77        debug!(
78            source_field = %source_field,
79            target_field = %target_field,
80            "Validating MT message"
81        );
82
83        // Perform validation
84        let validation_result = self.validate_mt_message(&mt_content)?;
85
86        // Store validation result
87        message
88            .data_mut()
89            .as_object_mut()
90            .unwrap()
91            .insert(target_field.to_string(), validation_result.clone());
92
93        // Update metadata with validation summary
94        message.metadata_mut().as_object_mut().unwrap().insert(
95            "validation".to_string(),
96            json!({
97                "validated": true,
98                "timestamp": chrono::Utc::now().to_rfc3339(),
99            }),
100        );
101
102        message.invalidate_context_cache();
103
104        Ok((
105            200,
106            vec![Change {
107                path: Arc::from(format!("data.{}", target_field)),
108                old_value: Arc::new(Value::Null),
109                new_value: Arc::new(validation_result),
110            }],
111        ))
112    }
113}
114
115impl Validate {
116    fn validate_mt_message(&self, mt_content: &str) -> Result<Value> {
117        let mut errors = Vec::new();
118
119        // Try to parse the message
120        match SwiftParser::parse_auto(mt_content) {
121            Ok(parsed_message) => {
122                // Use the new network validation rules from SwiftMessageBody trait
123                let validation_errors = self.validate_network_rules(&parsed_message);
124
125                if !validation_errors.is_empty() {
126                    // Convert SwiftValidationError instances to formatted error strings
127                    for validation_error in validation_errors {
128                        errors.push(self.format_validation_error(&validation_error));
129                    }
130                }
131            }
132            Err(parse_error) => {
133                // Accumulate parse errors - the Display trait already provides good error messages
134                errors.push(format!("Parse error: {}", parse_error));
135
136                // Add more specific error details for certain error types
137                match &parse_error {
138                    ParseError::InvalidFieldFormat(e) => {
139                        errors.push(format!(
140                            "Field {} - {}: Invalid value '{}', expected format: {}",
141                            e.field_tag, e.component_name, e.value, e.format_spec
142                        ));
143                    }
144                    ParseError::MissingRequiredField {
145                        field_tag,
146                        field_name,
147                        ..
148                    } => {
149                        errors.push(format!(
150                            "Missing required field: {} ({})",
151                            field_tag, field_name
152                        ));
153                    }
154                    ParseError::InvalidFormat { message } => {
155                        errors.push(format!("Invalid message format: {}", message));
156                    }
157                    ParseError::ValidationFailed {
158                        errors: validation_errors,
159                    } => {
160                        for validation_error in validation_errors {
161                            errors.push(validation_error.to_string());
162                        }
163                    }
164                    _ => {
165                        // Other error types are already covered by the Display trait
166                    }
167                }
168            }
169        }
170
171        let is_valid = errors.is_empty();
172
173        Ok(json!({
174            "valid": is_valid,
175            "errors": errors,
176            "timestamp": chrono::Utc::now().to_rfc3339(),
177        }))
178    }
179
180    /// Validate network rules on parsed message using the SwiftMessageBody trait
181    fn validate_network_rules(
182        &self,
183        parsed_message: &crate::parsed_message::ParsedSwiftMessage,
184    ) -> Vec<SwiftValidationError> {
185        use crate::parsed_message::ParsedSwiftMessage;
186
187        // Call validate_network_rules on the message body (stop_on_first_error = false to get all errors)
188        match parsed_message {
189            ParsedSwiftMessage::MT101(msg) => msg.fields.validate_network_rules(false),
190            ParsedSwiftMessage::MT103(msg) => msg.fields.validate_network_rules(false),
191            ParsedSwiftMessage::MT104(msg) => msg.fields.validate_network_rules(false),
192            ParsedSwiftMessage::MT107(msg) => msg.fields.validate_network_rules(false),
193            ParsedSwiftMessage::MT110(msg) => msg.fields.validate_network_rules(false),
194            ParsedSwiftMessage::MT111(msg) => msg.fields.validate_network_rules(false),
195            ParsedSwiftMessage::MT112(msg) => msg.fields.validate_network_rules(false),
196            ParsedSwiftMessage::MT190(msg) => msg.fields.validate_network_rules(false),
197            ParsedSwiftMessage::MT191(msg) => msg.fields.validate_network_rules(false),
198            ParsedSwiftMessage::MT192(msg) => msg.fields.validate_network_rules(false),
199            ParsedSwiftMessage::MT196(msg) => msg.fields.validate_network_rules(false),
200            ParsedSwiftMessage::MT199(msg) => msg.fields.validate_network_rules(false),
201            ParsedSwiftMessage::MT200(msg) => msg.fields.validate_network_rules(false),
202            ParsedSwiftMessage::MT202(msg) => msg.fields.validate_network_rules(false),
203            ParsedSwiftMessage::MT204(msg) => msg.fields.validate_network_rules(false),
204            ParsedSwiftMessage::MT205(msg) => msg.fields.validate_network_rules(false),
205            ParsedSwiftMessage::MT210(msg) => msg.fields.validate_network_rules(false),
206            ParsedSwiftMessage::MT290(msg) => msg.fields.validate_network_rules(false),
207            ParsedSwiftMessage::MT291(msg) => msg.fields.validate_network_rules(false),
208            ParsedSwiftMessage::MT292(msg) => msg.fields.validate_network_rules(false),
209            ParsedSwiftMessage::MT296(msg) => msg.fields.validate_network_rules(false),
210            ParsedSwiftMessage::MT299(msg) => msg.fields.validate_network_rules(false),
211            ParsedSwiftMessage::MT900(msg) => msg.fields.validate_network_rules(false),
212            ParsedSwiftMessage::MT910(msg) => msg.fields.validate_network_rules(false),
213            ParsedSwiftMessage::MT920(msg) => msg.fields.validate_network_rules(false),
214            ParsedSwiftMessage::MT935(msg) => msg.fields.validate_network_rules(false),
215            ParsedSwiftMessage::MT940(msg) => msg.fields.validate_network_rules(false),
216            ParsedSwiftMessage::MT941(msg) => msg.fields.validate_network_rules(false),
217            ParsedSwiftMessage::MT942(msg) => msg.fields.validate_network_rules(false),
218            ParsedSwiftMessage::MT950(msg) => msg.fields.validate_network_rules(false),
219        }
220    }
221
222    /// Format a SwiftValidationError into a human-readable string
223    fn format_validation_error(&self, error: &SwiftValidationError) -> String {
224        use crate::errors::SwiftValidationError;
225
226        match error {
227            SwiftValidationError::Format(err) => {
228                format!(
229                    "[{}] Field {}: {} - Invalid value '{}' (expected: {})",
230                    err.code, err.field, err.message, err.value, err.expected
231                )
232            }
233            SwiftValidationError::Content(err) => {
234                format!(
235                    "[{}] Field {}: {} - Content '{}' violates requirement: {}",
236                    err.code, err.field, err.message, err.content, err.requirements
237                )
238            }
239            SwiftValidationError::Relation(err) => {
240                let related = if !err.related_fields.is_empty() {
241                    format!(" (related: {})", err.related_fields.join(", "))
242                } else {
243                    String::new()
244                };
245                let instruction = err
246                    .instruction_context
247                    .as_ref()
248                    .map(|ctx| format!(" [{}]", ctx))
249                    .unwrap_or_default();
250                format!(
251                    "[{}] Field {}: {}{}{}",
252                    err.code, err.field, err.message, related, instruction
253                )
254            }
255            SwiftValidationError::Business(err) => {
256                let related = if !err.related_fields.is_empty() {
257                    format!(" (related: {})", err.related_fields.join(", "))
258                } else {
259                    String::new()
260                };
261                format!(
262                    "[{}] Field {}: {} - Rule: {}{}",
263                    err.code, err.field, err.message, err.rule_description, related
264                )
265            }
266            SwiftValidationError::General(err) => {
267                let category = err
268                    .category
269                    .as_ref()
270                    .map(|c| format!(" [{}]", c))
271                    .unwrap_or_default();
272                format!(
273                    "[{}] Field {}: {} - Value '{}'{}",
274                    err.code, err.field, err.message, err.value, category
275                )
276            }
277        }
278    }
279}
swift_mt_message/plugin/validate.rs

swift_mt_message/plugin/
validate.rs
