use super::form_address_address_format::{is_uk_family, lookup_country, trim_ascii, upper_ascii}; use super::funejson::Value; use super::text_pattern_match::matches_pattern; use super::validation_uk_postcode::validate_uk_postcode; const MAX_LENGTH: usize = 100; // "Enter postcode", but "Enter ZIP code" and "Enter Eircode": only the two // ordinary labels are common nouns. fn in_sentence(label: &str) -> String { if label == "Postcode" || label == "Postal code" { label.to_ascii_lowercase() } else { label.to_string() } } // Without a known format: 1 to 12 letters, digits, spaces and hyphens. fn plausible_postcode(value: &str) -> bool { (1..=12).contains(&value.chars().count()) && value.chars().all(|ch| ch.is_ascii_uppercase() || ch.is_ascii_digit() || ch == ' ' || ch == '-') } fn error(field: &str, message: String) -> AddressError { AddressError { field: field.to_string(), message } } /// A postal address checked field by field: the GOV.UK address pattern for /// the UK, the country's own postcode format and labels elsewhere. Never /// panics: an unknown country is the country field's error. pub fn validate_address(address: &Address) -> AddressCheck { let mut errors: Vec = Vec::new(); let row = lookup_country(&address.country); let region_label = row.map(|r| r.region_label).unwrap_or("Region"); let postcode_label = row.map(|r| r.postcode_label).unwrap_or("Postal code"); // Unicode code points, as in the other languages. let length = |s: &str| s.chars().count(); let line1 = trim_ascii(&address.line1); if line1.is_empty() { errors.push(error("line1", "Enter address line 1, typically the building and street".to_string())); } else if length(line1) > MAX_LENGTH { errors.push(error("line1", format!("Address line 1 must be {} characters or less", MAX_LENGTH))); } let line2 = trim_ascii(address.line2.as_deref().unwrap_or("")); if length(line2) > MAX_LENGTH { errors.push(error("line2", format!("Address line 2 must be {} characters or less", MAX_LENGTH))); } let town = trim_ascii(&address.town); if town.is_empty() { errors.push(error("town", "Enter town or city".to_string())); } else if length(town) > MAX_LENGTH { errors.push(error("town", format!("Town or city must be {} characters or less", MAX_LENGTH))); } let region = trim_ascii(address.region.as_deref().unwrap_or("")); if length(region) > MAX_LENGTH { errors.push(error("region", format!("{} must be {} characters or less", region_label, MAX_LENGTH))); } let typed = trim_ascii(address.postcode.as_deref().unwrap_or("")); let mut postcode: Option = None; if typed.is_empty() { if row.map(|r| r.postcode_required).unwrap_or(false) { errors.push(error("postcode", format!("Enter {}", in_sentence(postcode_label)))); } } else if row.map(|r| is_uk_family(r.code)).unwrap_or(false) { let uk = validate_uk_postcode(typed); if uk.valid { postcode = uk.normalised; } else { errors.push(error("postcode", format!("Enter a real {}", in_sentence(postcode_label)))); } } else { let upper = upper_ascii(typed); let ok = match row.and_then(|r| r.postcode_pattern) { Some(pattern) => matches_pattern(pattern, &upper), None => plausible_postcode(&upper), }; if ok { postcode = Some(upper); } else { errors.push(error("postcode", format!("Enter a real {}", in_sentence(postcode_label)))); } } let row = match row { Some(row) if errors.is_empty() => row, _ => { if row.is_none() { errors.push(error("country", "Select a country".to_string())); } return AddressCheck { valid: false, address: None, errors }; } }; let optional = |s: &str| if s.is_empty() { None } else { Some(s.to_string()) }; AddressCheck { valid: true, address: Some(Address { line1: line1.to_string(), line2: optional(line2), town: town.to_string(), region: optional(region), postcode, country: row.code.to_string(), }), errors: Vec::new(), } } pub fn address_from_value(v: &Value) -> Address { let text = |key: &str| match v.get(key) { Value::Str(s) => s.clone(), _ => panic!("address.{} must be a string", key), }; let optional = |key: &str| match v.get(key) { Value::Str(s) => Some(s.clone()), _ => None, }; Address { line1: text("line1"), line2: optional("line2"), town: text("town"), region: optional("region"), postcode: optional("postcode"), country: text("country"), } } pub fn address_to_value(a: &Address) -> Value { let text = |v: &Option| v.as_deref().map(Value::str).unwrap_or(Value::Null); Value::obj(vec![ ("line1", Value::str(&a.line1)), ("line2", text(&a.line2)), ("town", Value::str(&a.town)), ("region", text(&a.region)), ("postcode", text(&a.postcode)), ("country", Value::str(&a.country)), ]) } pub fn address_check_to_value(check: &AddressCheck) -> Value { Value::obj(vec![ ("valid", Value::Bool(check.valid)), ("address", check.address.as_ref().map(address_to_value).unwrap_or(Value::Null)), ( "errors", Value::Arr( check .errors .iter() .map(|e| Value::obj(vec![("field", Value::str(&e.field)), ("message", Value::str(&e.message))])) .collect(), ), ), ]) } pub fn fune_vector(args: &[Value]) -> Value { address_check_to_value(&validate_address(&address_from_value(&args[0]))) }