Merge pull request #143 from icann/andy_dev

Multiple Issues

Author: anewton1998

LICENSE-APACHE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2025 Internet Corporation for Assigned Names and Numbers (ICANN)
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

LICENSE-MIT

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2014-2016 Ning Sun and tojson_macros contributors
+Copyright (c) 2025 Internet Corporation for Assigned Names and Numbers (ICANN)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

icann-rdap-client/src/md/types.rs

@@ -344,12 +344,13 @@ pub(crate) fn events_to_table(
 ) -> MultiPartTable {
     table = table.header_ref(&header_name.replace_md_chars());
     for event in events {
+        let raw_event_date = event.event_date.to_owned().unwrap_or_default();
         let event_date = &event
             .event_date
             .to_owned()
             .unwrap_or("????".to_string())
             .format_date_time(params)
-            .unwrap_or_default();
+            .unwrap_or(format!("UKN FMT: {raw_event_date}"));
         let mut ul: Vec<&String> = vec![event_date];
         if let Some(event_actor) = &event.event_actor {
             ul.push(event_actor);

icann-rdap-common/src/contact/mod.rs

@@ -76,7 +76,11 @@
 //! ]"#;
 //!
 //! let data: Vec<Value> = serde_json::from_str(json).unwrap();
-//! let contact = Contact::from_vcard(&data);
+//! let contact = Contact::from_vcard(&data).unwrap();
+//!
+//! // use the getter functions to access the data.
+//! let kind = contact.kind();
+//! let email_addr = contact.emails().first().unwrap().email();
 //! ```
 
 mod from_vcard;
@@ -249,6 +253,71 @@ impl Contact {
         self.postal_addresses = Some(vec![postal_address]);
         self
     }
+
+    /// Get the langs.
+    pub fn langs(&self) -> &[Lang] {
+        self.langs.as_deref().unwrap_or_default()
+    }
+
+    /// Get the kind.
+    pub fn kind(&self) -> Option<&str> {
+        self.kind.as_deref()
+    }
+
+    /// Get the full name.
+    pub fn full_name(&self) -> Option<&str> {
+        self.full_name.as_deref()
+    }
+
+    /// Get the name parts.
+    pub fn name_parts(&self) -> Option<&NameParts> {
+        self.name_parts.as_ref()
+    }
+
+    /// Get the nick names.
+    pub fn nick_names(&self) -> &[String] {
+        self.nick_names.as_deref().unwrap_or_default()
+    }
+
+    /// Get the titles.
+    pub fn titles(&self) -> &[String] {
+        self.titles.as_deref().unwrap_or_default()
+    }
+
+    /// Get the organizational roles.
+    pub fn roles(&self) -> &[String] {
+        self.roles.as_deref().unwrap_or_default()
+    }
+
+    /// Get the organizational names.
+    pub fn organizational_names(&self) -> &[String] {
+        self.organization_names.as_deref().unwrap_or_default()
+    }
+
+    /// Get the postal addresses.
+    pub fn postal_addresses(&self) -> &[PostalAddress] {
+        self.postal_addresses.as_deref().unwrap_or_default()
+    }
+
+    /// Get the emails.
+    pub fn emails(&self) -> &[Email] {
+        self.emails.as_deref().unwrap_or_default()
+    }
+
+    /// Get the phones.
+    pub fn phones(&self) -> &[Phone] {
+        self.phones.as_deref().unwrap_or_default()
+    }
+
+    /// Get the contact uris.
+    pub fn contact_uris(&self) -> &[String] {
+        self.contact_uris.as_deref().unwrap_or_default()
+    }
+
+    /// Get the URLs.
+    pub fn urls(&self) -> &[String] {
+        self.urls.as_deref().unwrap_or_default()
+    }
 }
 
 /// The language preference of the contact.
@@ -261,6 +330,18 @@ pub struct Lang {
     pub tag: String,
 }
 
+impl Lang {
+    /// Get the preference.
+    pub fn preference(&self) -> Option<u64> {
+        self.preference
+    }
+
+    /// Get the RFC 5646 language tag.
+    pub fn tag(&self) -> &str {
+        self.tag.as_str()
+    }
+}
+
 impl Display for Lang {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(pref) = self.preference {
@@ -308,6 +389,31 @@ impl NameParts {
             suffixes: to_opt_vec(suffixes),
         }
     }
+
+    /// Get the name prefixes.
+    pub fn prefixes(&self) -> &[String] {
+        self.prefixes.as_deref().unwrap_or_default()
+    }
+
+    /// Get the sur names.
+    pub fn surnames(&self) -> &[String] {
+        self.surnames.as_deref().unwrap_or_default()
+    }
+
+    /// Get the middle names.
+    pub fn middle_names(&self) -> &[String] {
+        self.middle_names.as_deref().unwrap_or_default()
+    }
+
+    /// Get the given names.
+    pub fn given_names(&self) -> &[String] {
+        self.given_names.as_deref().unwrap_or_default()
+    }
+
+    /// Get the suffixes.
+    pub fn suffixes(&self) -> &[String] {
+        self.suffixes.as_deref().unwrap_or_default()
+    }
 }
 
 /// A postal address.
@@ -382,6 +488,68 @@ impl PostalAddress {
             postal_code,
         }
     }
+
+    /// Get the preference.
+    pub fn preference(&self) -> Option<u64> {
+        self.preference
+    }
+
+    /// Get the contexts.
+    pub fn contexts(&self) -> &[String] {
+        self.contexts.as_deref().unwrap_or_default()
+    }
+
+    /// Get the full address.
+    ///
+    /// An unstructured address. An unstructured postal address is
+    /// usually the complete postal address. That is, this string
+    /// would contain the street address, country, region, postal code, etc...
+    ///
+    /// Depending on how the postal address is given, it can either
+    /// be structured or unstructured. If it is given as unstructured,
+    /// then this value is populated.
+    ///
+    /// It is possible that a single postal address is given as both,
+    /// in which case this value is populated along with the other
+    /// values of the postal address.   
+    pub fn full_address(&self) -> Option<&str> {
+        self.full_address.as_deref()
+    }
+
+    /// Get the street parts.
+    pub fn street_parts(&self) -> &[String] {
+        self.street_parts.as_deref().unwrap_or_default()
+    }
+
+    /// Get the locality.
+    pub fn locality(&self) -> Option<&str> {
+        self.locality.as_deref()
+    }
+
+    /// Get the region name.
+    pub fn region_name(&self) -> Option<&str> {
+        self.region_name.as_deref()
+    }
+
+    /// Get the region code.
+    pub fn region_code(&self) -> Option<&str> {
+        self.region_code.as_deref()
+    }
+
+    /// Get the country name.
+    pub fn country_name(&self) -> Option<&str> {
+        self.country_name.as_deref()
+    }
+
+    /// Get the country code.
+    pub fn country_code(&self) -> Option<&str> {
+        self.country_code.as_deref()
+    }
+
+    /// Get the postal code.
+    pub fn postal_code(&self) -> Option<&str> {
+        self.postal_code.as_deref()
+    }
 }
 
 /// Represents an email address.
@@ -407,6 +575,21 @@ impl Email {
             email,
         }
     }
+
+    /// Get the preference.
+    pub fn preference(&self) -> Option<u64> {
+        self.preference
+    }
+
+    /// Get the contexts.
+    pub fn contexts(&self) -> &[String] {
+        self.contexts.as_deref().unwrap_or_default()
+    }
+
+    /// Get the email address.
+    pub fn email(&self) -> &str {
+        self.email.as_str()
+    }
 }
 
 impl Display for Email {
@@ -459,6 +642,26 @@ impl Phone {
             features: to_opt_vec(features),
         }
     }
+
+    /// Get the preference.
+    pub fn preference(&self) -> Option<u64> {
+        self.preference
+    }
+
+    /// Get the contexts.
+    pub fn contexts(&self) -> &[String] {
+        self.contexts.as_deref().unwrap_or_default()
+    }
+
+    /// Get the phone number.
+    pub fn phone(&self) -> &str {
+        self.phone.as_str()
+    }
+
+    /// Get the phone features.
+    pub fn features(&self) -> &[String] {
+        self.features.as_deref().unwrap_or_default()
+    }
 }
 
 impl Display for Phone {

icann-rdap-common/src/response/autnum.rs

@@ -42,6 +42,19 @@ use super::{
 ///   "endAutnum": 710
 /// }
 /// ```
+///
+/// Use the getter functions to get the autnum data.
+/// See [CommonFields] and [ObjectCommonFields] for common getter functions.
+/// ```rust
+/// # use icann_rdap_common::prelude::*;
+/// # let autnum = Autnum::builder()
+/// #  .autnum_range(700..710) // the range of autnums
+/// #  .handle("AS700-1")
+/// #  .build();
+/// let start_autnum = autnum.start_autnum();
+/// let end_autnum = autnum.end_autnum();
+/// let handle = autnum.handle();
+/// ```
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
 pub struct Autnum {
     #[serde(flatten)]
@@ -77,7 +90,7 @@ impl Autnum {
     /// use icann_rdap_common::prelude::*;
     ///
     /// let autnum = Autnum::builder()
-    ///   .autnum_range(700..710)
+    ///   .autnum_range(700..710)  //required for this builder
     ///   .handle("AS700-1")
     ///   .status("active")
     ///   .build();

icann-rdap-common/src/response/common.rs

@@ -26,26 +26,25 @@ impl Common {
     }
 }
 
-/// Empty Extensions.
-static EMPTY_EXTENSIONS: Vec<Extension> = vec![];
-/// Empty Notices.
-static EMPTY_NOTICES: Vec<Notice> = vec![];
-
 /// Convience methods for fields in  [Common].
 pub trait CommonFields {
     /// Getter for [Common].
     fn common(&self) -> &Common;
 
-    /// Getter for Vec of RDAP extensions.
-    fn extensions(&self) -> &Vec<Extension> {
+    /// Getter for the list of RDAP extensions.
+    ///
+    /// In valid RDAP, this only appears on the top most object.
+    fn extensions(&self) -> &[Extension] {
         self.common()
             .rdap_conformance
-            .as_ref()
-            .unwrap_or(&EMPTY_EXTENSIONS)
+            .as_deref()
+            .unwrap_or_default()
     }
 
-    /// Getter for Vec of Notices.
-    fn notices(&self) -> &Vec<Notice> {
-        self.common().notices.as_ref().unwrap_or(&EMPTY_NOTICES)
+    /// Getter for the Notices.
+    ///
+    /// In valid RDAP, this only appears on the top most object.
+    fn notices(&self) -> &[Notice] {
+        self.common().notices.as_deref().unwrap_or_default()
     }
 }