instant-labs
/
instant-epp
mirror of https://github.com/instant-labs/instant-epp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Migrate commands to new API

This commit is contained in:
Nicholas Rempel 2021-11-26 14:21:38 -08:00 committed by masalachai
parent aa54c14972
commit 31fc61f4b0
25 changed files with 1351 additions and 1050 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
epp-client/src/connection/client.rs
View File

@ -7,8 +7,9 @@
//!
//! use epp_client::config::{EppClientConfig, EppClientConnection};
//! use epp_client::EppClient;
//! use epp_client::domain::check::{EppDomainCheck, EppDomainCheckResponse};
//! use epp_client::domain::check::DomainCheck;
//! use epp_client::generate_client_tr_id;
//! use epp_client::common::NoExtension;
//!
//! #[tokio::main]
//! async fn main() {
@ -39,8 +40,8 @@
//! println!("{:?}", greeting);
//!
//! // Execute an EPP Command against the registry with distinct request and response objects
//! let domain_check = EppDomainCheck::new(vec!["eppdev.com", "eppdev.net"], generate_client_tr_id(&client).as_str());
//! let response = client.transact::<_, EppDomainCheckResponse>(&domain_check).await.unwrap();
//! let domain_check = DomainCheck::<NoExtension>::new(vec!["eppdev.com", "eppdev.net"]);
//! let response = client.transact_new(domain_check, generate_client_tr_id(&client).as_str()).await.unwrap();
//! println!("{:?}", response);
//!
//! }
@ -49,14 +50,18 @@
use std::time::SystemTime;
use std::{error::Error, fmt::Debug};
use crate::common::{EppObject, NoExtension};
use crate::config::EppClientConfig;
use crate::connection::registry::{epp_connect, EppConnection};
use crate::error;
use crate::hello::{EppGreeting, EppHello};
use crate::login::{EppLogin, EppLoginResponse};
use crate::logout::{EppLogout, EppLogoutResponse};
use crate::login::Login;
use crate::logout::Logout;
use crate::request::{generate_client_tr_id, EppExtension, EppRequest};
use crate::response::{CommandResponseWithExtension, EppCommandResponse, EppCommandResponseError};
use crate::response::{
CommandResponseStatus, CommandResponseWithExtension, EppCommandResponse,
EppCommandResponseError,
};
use crate::xml::EppXml;
/// Instances of the EppClient type are used to transact with the registry.
/// Once initialized, the EppClient instance can serialize EPP requests to XML and send them
@ -110,19 +115,17 @@ impl EppClient {
connection,
credentials,
ext_uris,
// client_tr_id_fn: Arc::new(default_client_tr_id_fn),
};
let client_tr_id = generate_client_tr_id(&client.credentials.0)?;
let login_request = EppLogin::new(
let login_request = Login::<NoExtension>::new(
&client.credentials.0,
&client.credentials.1,
&client.ext_uris,
client_tr_id.as_str(),
);
client
.transact::<_, EppLoginResponse>(&login_request)
.transact_new(login_request, client_tr_id.as_str())
.await?;
Ok(client)
@ -197,11 +200,16 @@ impl EppClient {
}
/// Sends the EPP Logout command to log out of the EPP session
pub async fn logout(&mut self) -> Result<EppLogoutResponse, error::Error> {
pub async fn logout(
&mut self,
) -> Result<
CommandResponseWithExtension<EppObject<CommandResponseStatus>, NoExtension>,
error::Error,
> {
let client_tr_id = generate_client_tr_id(&self.credentials.0).unwrap();
let epp_logout = EppLogout::new(client_tr_id.as_str());
let epp_logout = Logout::<NoExtension>::new();
let response = self.transact::<_, EppLogoutResponse>(&epp_logout).await?;
let response = self.transact_new(epp_logout, client_tr_id.as_str()).await?;
self.connection.shutdown().await?;

67
epp-client/src/contact/check.rs
View File

@ -1,12 +1,28 @@
use std::fmt::Debug;
/// Types for EPP contact check request
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, StringValue};
use crate::common::{ElementName, NoExtension, StringValue};
use crate::contact::EPP_CONTACT_XMLNS;
use crate::request::Command;
use crate::response::CommandResponse;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct ContactCheck<E> {
request: ContactCheckRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for ContactCheck<E> {
type Input = ContactCheckRequest;
type Output = ContactCheckResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for contact &lt;check&gt; command
///
/// ## Usage
@ -16,8 +32,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::contact::check::{EppContactCheck, EppContactCheckResponse};
/// use epp_client::contact::check::ContactCheck;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -42,47 +59,45 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppContactCheck instance
/// let contact_check = EppContactCheck::new(
/// &["epp-client-c1", "epp-client-c2"],
/// generate_client_tr_id(&client).as_str()
/// // Create an ContactCheck instance
/// let contact_check = ContactCheck::<NoExtension>::new(
/// &["epp-client-c1", "epp-client-c2"]
/// );
///
/// // send it to the registry and receive a response of type EppContactCheckResponse
/// let response = client.transact::<_, EppContactCheckResponse>(&contact_check).await.unwrap();
/// // send it to the registry and receive a response of type ContactCheckResponse
///
/// let response = client.transact_new(contact_check, generate_client_tr_id(&client).as_str()).await.unwrap();
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppContactCheck = EppObject<Command<ContactCheckRequest>>;
impl EppContactCheck {
/// Creates an EppObject corresponding to the &lt;epp&gt; tag with data for a contact check request
pub fn new(contact_ids: &[&str], client_tr_id: &str) -> EppContactCheck {
impl<E: EppExtension> ContactCheck<E> {
pub fn new(contact_ids: &[&str]) -> ContactCheck<NoExtension> {
let contact_ids = contact_ids
.iter()
.map(|&d| d.into())
.collect::<Vec<StringValue>>();
let contact_check = ContactCheckRequest {
ContactCheck {
request: ContactCheckRequest {
list: ContactList {
xmlns: EPP_CONTACT_XMLNS.to_string(),
contact_ids,
},
};
},
extension: None,
}
}
EppObject::build(Command::<ContactCheckRequest>::new(
contact_check,
client_tr_id,
))
pub fn with_extension<F: EppExtension>(self, extension: F) -> ContactCheck<F> {
ContactCheck {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML contact check response
pub type EppContactCheckResponse = EppObject<CommandResponse<ContactCheckResponse>>;
// Request
/// Type that represents the &lt;check&gt; command for contact transactions
@ -109,7 +124,7 @@ pub struct ContactCheckRequest {
/// Type that represents the &lt;id&gt; tag for contact check response
#[derive(Serialize, Deserialize, Debug)]
pub struct ContactCheck {
pub struct ContactAvailable {
/// The text of the &lt;id&gt; tag
#[serde(rename = "$value")]
pub id: StringValue,
@ -123,7 +138,7 @@ pub struct ContactCheck {
pub struct ContactCheckResponseDataItem {
/// Data under the &lt;id&gt; tag
#[serde(rename = "id")]
pub contact: ContactCheck,
pub contact: ContactAvailable,
/// The reason for (un)availability
pub reason: Option<StringValue>,
}

66
epp-client/src/contact/create.rs
View File

@ -2,12 +2,26 @@
use epp_client_macros::*;
use crate::common::{ContactAuthInfo, ElementName, EppObject, Phone, PostalInfo, StringValue};
use crate::common::{ContactAuthInfo, ElementName, NoExtension, Phone, PostalInfo, StringValue};
use crate::contact::EPP_CONTACT_XMLNS;
use crate::request::Command;
use crate::response::CommandResponse;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct ContactCreate<E> {
request: ContactCreateRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for ContactCreate<E> {
type Input = ContactCreateRequest;
type Output = ContactCreateResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for contact &lt;create&gt; command
///
/// ## Usage
@ -18,8 +32,9 @@ use serde::{Deserialize, Serialize};
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::common::{Address, Phone, PostalInfo};
/// use epp_client::contact::create::{EppContactCreate, EppContactCreateResponse};
/// use epp_client::contact::create::ContactCreate;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -53,38 +68,34 @@ use serde::{Deserialize, Serialize};
/// let mut fax = Phone::new("+1.86698799");
/// fax.set_extension("677");
///
/// // Create an EppContactCreate instance
/// let mut contact_create = EppContactCreate::new(
/// // Create an ContactCreate instance
/// let mut contact_create = ContactCreate::<NoExtension>::new(
/// "eppdev-contact-100",
/// "contact@eppdev.net",
/// postal_info,
/// voice,
/// "epP4uthd#v",
/// generate_client_tr_id(&client).as_str()
/// "epP4uthd#v"
/// );
/// contact_create.set_fax(fax);
///
/// // send it to the registry and receive a response of type EppContactCreateResponse
/// let response = client.transact::<_, EppContactCreateResponse>(&contact_create).await.unwrap();
/// // send it to the registry and receive a response of type ContactCreateResponse
/// let response = client.transact_new(contact_create, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppContactCreate = EppObject<Command<ContactCreateRequest>>;
impl EppContactCreate {
/// Creates a new EppObject for contact create corresponding to the &lt;epp&gt; tag in EPP XML
impl<E: EppExtension> ContactCreate<E> {
pub fn new(
id: &str,
email: &str,
postal_info: PostalInfo,
voice: Phone,
auth_password: &str,
client_tr_id: &str,
) -> EppContactCreate {
let contact_create = ContactCreateRequest {
) -> ContactCreate<NoExtension> {
ContactCreate {
request: ContactCreateRequest {
contact: Contact {
xmlns: EPP_CONTACT_XMLNS.to_string(),
id: id.into(),
@ -94,23 +105,24 @@ impl EppContactCreate {
email: email.into(),
auth_info: ContactAuthInfo::new(auth_password),
},
};
},
extension: None,
}
}
EppObject::build(Command::<ContactCreateRequest>::new(
contact_create,
client_tr_id,
))
pub fn with_extension<F: EppExtension>(self, extension: F) -> ContactCreate<F> {
ContactCreate {
request: self.request,
extension: Some(extension),
}
}
/// Sets the &lt;fax&gt; data for the request
pub fn set_fax(&mut self, fax: Phone) {
self.data.command.contact.fax = Some(fax);
self.request.contact.fax = Some(fax);
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML contact create response
pub type EppContactCreateResponse = EppObject<CommandResponse<ContactCreateResult>>;
// Request
/// Type for elements under the contact &lt;create&gt; tag
@ -165,7 +177,7 @@ pub struct ContactCreateData {
/// Type that represents the &lt;resData&gt; tag for contact create response
#[derive(Serialize, Deserialize, Debug)]
pub struct ContactCreateResult {
pub struct ContactCreateResponse {
/// Data under the &lt;creData&gt; tag
#[serde(rename = "creData")]
pub create_data: ContactCreateData,

60
epp-client/src/contact/delete.rs
View File

@ -2,12 +2,27 @@
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, StringValue};
use crate::common::{ElementName, NoExtension, StringValue};
use crate::contact::EPP_CONTACT_XMLNS;
use crate::request::Command;
use crate::request::{EppExtension, EppRequest};
use crate::response::EppCommandResponse;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct ContactDelete<E> {
request: ContactDeleteRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for ContactDelete<E> {
type Input = ContactDeleteRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type for the &lt;epp&gt; request for contact &lt;delete&gt; command
///
/// ## Usage
@ -17,8 +32,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::contact::delete::{EppContactDelete, EppContactDeleteResponse};
/// use epp_client::contact::delete::ContactDelete;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -43,42 +59,40 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppContactDelete instance
/// let contact_delete = EppContactDelete::new(
/// "eppdev-contact-100",
/// generate_client_tr_id(&client).as_str()
/// // Create an ContactDelete instance
/// let contact_delete = ContactDelete::<NoExtension>::new(
/// "eppdev-contact-100"
/// );
///
/// // send it to the registry and receive a response of type EppContactDeleteResponse
/// let response = client.transact::<_, EppContactDeleteResponse>(&contact_delete).await.unwrap();
/// // send it to the registry and receive a response of type ContactDeleteResponse
/// let response = client.transact_new(contact_delete, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppContactDelete = EppObject<Command<ContactDeleteRequest>>;
impl EppContactDelete {
/// Creates a new EppObject for contact delete corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(id: &str, client_tr_id: &str) -> EppContactDelete {
let contact_delete = ContactDeleteRequest {
impl<E: EppExtension> ContactDelete<E> {
pub fn new(id: &str) -> ContactDelete<NoExtension> {
ContactDelete {
request: ContactDeleteRequest {
contact: ContactDeleteRequestData {
xmlns: EPP_CONTACT_XMLNS.to_string(),
id: id.into(),
},
};
},
extension: None,
}
}
EppObject::build(Command::<ContactDeleteRequest>::new(
contact_delete,
client_tr_id,
))
pub fn with_extension<F: EppExtension>(self, extension: F) -> ContactDelete<F> {
ContactDelete {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML contact delete response
pub type EppContactDeleteResponse = EppCommandResponse;
/// Type containing the data for the &lt;delete&gt; tag for contacts
#[derive(Serialize, Deserialize, Debug)]
pub struct ContactDeleteRequestData {

61
epp-client/src/contact/info.rs
View File

@ -3,13 +3,27 @@
use epp_client_macros::*;
use crate::common::{
ContactAuthInfo, ContactStatus, ElementName, EppObject, Phone, PostalInfo, StringValue,
ContactAuthInfo, ContactStatus, ElementName, NoExtension, Phone, PostalInfo, StringValue,
};
use crate::contact::EPP_CONTACT_XMLNS;
use crate::request::Command;
use crate::response::CommandResponse;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct ContactInfo<E> {
request: ContactInfoRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for ContactInfo<E> {
type Input = ContactInfoRequest;
type Output = ContactInfoResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type for the &lt;epp&gt; request for contact &lt;info&gt; command
///
/// ## Usage
@ -19,8 +33,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::contact::info::{EppContactInfo, EppContactInfoResponse};
/// use epp_client::contact::info::ContactInfo;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -45,44 +60,42 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppContactInfo instance
/// let contact_info = EppContactInfo::new(
/// // Create an ContactInfo instance
/// let contact_info = ContactInfo::<NoExtension>::new(
/// "eppdev-contact-100",
/// "epP4uthd#v",
/// generate_client_tr_id(&client).as_str()
/// "epP4uthd#v"
/// );
///
/// // send it to the registry and receive a response of type EppContactInfoResponse
/// let response = client.transact::<_, EppContactInfoResponse>(&contact_info).await.unwrap();
/// // send it to the registry and receive a response of type ContactInfoResponse
/// let response = client.transact_new(contact_info, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppContactInfo = EppObject<Command<ContactInfoRequest>>;
impl EppContactInfo {
/// Creates a new EppObject for contact info corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(id: &str, auth_password: &str, client_tr_id: &str) -> EppContactInfo {
let contact_info = ContactInfoRequest {
impl<E: EppExtension> ContactInfo<E> {
pub fn new(id: &str, auth_password: &str) -> ContactInfo<NoExtension> {
ContactInfo {
request: ContactInfoRequest {
info: ContactInfoRequestData {
xmlns: EPP_CONTACT_XMLNS.to_string(),
id: id.into(),
auth_info: ContactAuthInfo::new(auth_password),
},
};
},
extension: None,
}
}
EppObject::build(Command::<ContactInfoRequest>::new(
contact_info,
client_tr_id,
))
pub fn with_extension<F: EppExtension>(self, extension: F) -> ContactInfo<F> {
ContactInfo {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML contact info response
pub type EppContactInfoResponse = EppObject<CommandResponse<ContactInfoResponse>>;
// Request
/// Type for elements under the contact &lt;info&gt; tag

93
epp-client/src/contact/update.rs
View File

@ -3,15 +3,28 @@
use epp_client_macros::*;
use crate::common::{
ContactAuthInfo, ContactStatus, ElementName, EppObject, Phone, PostalInfo, StringValue,
ContactAuthInfo, ContactStatus, ElementName, NoExtension, Phone, PostalInfo, StringValue,
};
use crate::contact::info::EppContactInfoResponse;
use crate::contact::EPP_CONTACT_XMLNS;
use crate::error;
use crate::request::Command;
use crate::request::{EppExtension, EppRequest};
use crate::response::EppCommandResponse;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct ContactUpdate<E> {
request: ContactUpdateRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for ContactUpdate<E> {
type Input = ContactUpdateRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for contact &lt;update&gt; command
///
/// ## Usage
@ -21,9 +34,10 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::contact::update::{EppContactUpdate, EppContactUpdateResponse};
/// use epp_client::contact::update::ContactUpdate;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::ContactStatus;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -48,10 +62,9 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppContactUpdate instance
/// let mut contact_update = EppContactUpdate::new(
/// "eppdev-contact-100",
/// generate_client_tr_id(&client).as_str()
/// // Create an ContactUpdate instance
/// let mut contact_update = ContactUpdate::<NoExtension>::new(
/// "eppdev-contact-100"
/// );
///
/// let add_statuses = vec![
@ -62,20 +75,18 @@ use serde::{Deserialize, Serialize};
///
/// contact_update.add(add_statuses);
///
/// // send it to the registry and receive a response of type EppContactUpdateResponse
/// let response = client.transact::<_, EppContactUpdateResponse>(&contact_update).await.unwrap();
/// // send it to the registry and receive a response of type ContactUpdateResponse
/// let response = client.transact_new(contact_update, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppContactUpdate = EppObject<Command<ContactUpdateRequest>>;
impl EppContactUpdate {
/// Creates a new EppObject for contact update corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(id: &str, client_tr_id: &str) -> EppContactUpdate {
let contact_update = ContactUpdateRequest {
impl<E: EppExtension> ContactUpdate<E> {
pub fn new(id: &str) -> ContactUpdate<NoExtension> {
ContactUpdate {
request: ContactUpdateRequest {
contact: ContactUpdateRequestData {
xmlns: EPP_CONTACT_XMLNS.to_string(),
id: id.into(),
@ -83,11 +94,16 @@ impl EppContactUpdate {
remove_statuses: None,
change_info: None,
},
};
EppObject::build(Command::<ContactUpdateRequest>::new(
contact_update,
client_tr_id,
))
},
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> ContactUpdate<F> {
ContactUpdate {
request: self.request,
extension: Some(extension),
}
}
/// Sets the data for the &lt;chg&gt; tag for the contact update request
@ -98,7 +114,7 @@ impl EppContactUpdate {
voice: Phone,
auth_password: &str,
) {
self.data.command.contact.change_info = Some(ContactChangeInfo {
self.request.contact.change_info = Some(ContactChangeInfo {
email: Some(email.into()),
postal_info: Some(postal_info),
voice: Some(voice),
@ -109,47 +125,22 @@ impl EppContactUpdate {
/// Sets the data for the &lt;fax&gt; tag under &lt;chg&gt; for the contact update request
pub fn set_fax(&mut self, fax: Phone) {
if let Some(info) = &mut self.data.command.contact.change_info {
if let Some(info) = &mut self.request.contact.change_info {
info.fax = Some(fax)
}
}
/// Sets the data for the &lt;add&gt; tag for the contact update request
pub fn add(&mut self, statuses: Vec<ContactStatus>) {
self.data.command.contact.add_statuses = Some(StatusList { status: statuses });
self.request.contact.add_statuses = Some(StatusList { status: statuses });
}
/// Sets the data for the &lt;rem&gt; tag for the contact update request
pub fn remove(&mut self, statuses: Vec<ContactStatus>) {
self.data.command.contact.remove_statuses = Some(StatusList { status: statuses });
}
/// Loads data into the &lt;chg&gt; tag from an existing EppContactInfoResponse object
pub fn load_from_epp_contact_info(
&mut self,
contact_info: EppContactInfoResponse,
) -> Result<(), error::Error> {
match contact_info.data.res_data {
Some(res_data) => {
self.data.command.contact.change_info = Some(ContactChangeInfo {
email: Some(res_data.info_data.email.clone()),
postal_info: Some(res_data.info_data.postal_info.clone()),
voice: Some(res_data.info_data.voice.clone()),
fax: res_data.info_data.fax,
auth_info: None,
});
Ok(())
}
None => Err(error::Error::Other(
"No res_data in EppContactInfoResponse object".to_string(),
)),
}
self.request.contact.remove_statuses = Some(StatusList { status: statuses });
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML contact update response
pub type EppContactUpdateResponse = EppCommandResponse;
/// Type for elements under the &lt;chg&gt; tag for contact update request
#[derive(Serialize, Deserialize, Debug)]
pub struct ContactChangeInfo {

64
epp-client/src/domain/check.rs
View File

@ -3,11 +3,25 @@
use epp_client_macros::*;
use super::EPP_DOMAIN_XMLNS;
use crate::common::{ElementName, EppObject, StringValue};
use crate::request::Command;
use crate::response::CommandResponse;
use crate::common::{ElementName, NoExtension, StringValue};
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct DomainCheck<E> {
request: DomainCheckRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainCheck<E> {
type Input = DomainCheckRequest;
type Output = DomainCheckResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for domain &lt;check&gt; command
///
/// ## Usage
@ -17,8 +31,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::check::{EppDomainCheck, EppDomainCheckResponse};
/// use epp_client::domain::check::DomainCheck;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -43,44 +58,43 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainCheck instance
/// let domain_check = EppDomainCheck::new(
/// // Create an DomainCheck instance
/// let domain_check = DomainCheck::<NoExtension>::new(
/// vec!["eppdev-100.com", "eppdev-100.net"],
/// generate_client_tr_id(&client).as_str()
/// );
///
/// // send it to the registry and receive a response of type EppDomainCheckResponse
/// let response = client.transact::<_, EppDomainCheckResponse>(&domain_check).await.unwrap();
/// let response = client.transact_new(domain_check, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainCheck = EppObject<Command<DomainCheckRequest>>;
impl EppDomainCheck {
/// Creates a new EppObject for domain check corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(domains: Vec<&str>, client_tr_id: &str) -> EppDomainCheck {
let domains = domains.into_iter().map(|d| d.into()).collect();
let domain_check = DomainCheckRequest {
impl<E: EppExtension> DomainCheck<E> {
pub fn new(domains: Vec<&str>) -> DomainCheck<NoExtension> {
DomainCheck {
request: DomainCheckRequest {
list: DomainList {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
domains,
domains: domains
.into_iter()
.map(|d| d.into())
.collect::<Vec<StringValue>>(),
},
};
},
extension: None,
}
}
EppObject::build(Command::<DomainCheckRequest>::new(
domain_check,
client_tr_id,
))
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainCheck<F> {
DomainCheck {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain check response
pub type EppDomainCheckResponse = EppObject<CommandResponse<DomainCheckResponse>>;
// Request
/// Type for &lt;name&gt; elements under the domain &lt;check&gt; tag

193
epp-client/src/domain/create.rs
View File

@ -4,13 +4,26 @@ use epp_client_macros::*;
use super::EPP_DOMAIN_XMLNS;
use crate::common::{
DomainAuthInfo, DomainContact, ElementName, EppObject, HostAttr, HostAttrList, HostList,
HostObjList, Period, StringValue,
DomainAuthInfo, DomainContact, ElementName, HostList, NoExtension, Period, StringValue,
};
use crate::request::Command;
use crate::response::CommandResponse;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct DomainCreate<E> {
request: DomainCreateRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainCreate<E> {
type Input = DomainCreateRequest;
type Output = DomainCreateResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for domain &lt;create&gt; command
/// with &lt;hostObj&gt; elements in the request for &lt;ns&gt; list
///
@ -22,9 +35,13 @@ use serde::{Deserialize, Serialize};
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::common::DomainContact;
/// use epp_client::domain::create::{EppDomainCreate, EppDomainCreateResponse};
/// use epp_client::domain::create::DomainCreate;
/// use epp_client::generate_client_tr_id;
///
/// use epp_client::common::NoExtension;
/// use epp_client::common::HostAttrList;
/// use epp_client::common::HostList;
/// use epp_client::common::HostObjList;
/// #[tokio::main]
/// async fn main() {
/// // Create a config
@ -48,154 +65,78 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// /// Create a vector of existing domain contact IDs
/// let contacts = vec![
/// DomainContact {
/// contact_type: "admin".to_string(),
/// id: "eppdev-contact-2".to_string()
/// id: "eppdev-contact-3".to_string(),
/// },
/// DomainContact {
/// contact_type: "tech".to_string(),
/// id: "eppdev-contact-2".to_string()
/// id: "eppdev-contact-3".to_string(),
/// },
/// DomainContact {
/// contact_type: "billing".to_string(),
/// id: "eppdev-contact-2".to_string()
/// }
/// id: "eppdev-contact-3".to_string(),
/// },
/// ];
///
/// // Create an EppDomainCreate instance
/// let domain_create = EppDomainCreate::new(
/// "eppdev-100.com", 1, "eppdev-contact-2", "epP4uthd#v", contacts, generate_client_tr_id(&client).as_str()
/// let ns = Some(HostList::HostObjList(HostObjList {
/// hosts: vec!["ns1.test.com".into(), "ns2.test.com".into()],
/// }));
/// let domain_create = DomainCreate::<NoExtension>::new(
/// "eppdev-1.com",
/// 1,
/// ns,
/// Some("eppdev-contact-3"),
/// "epP4uthd#v",
/// Some(contacts),
/// );
///
/// // send it to the registry and receive a response of type EppDomainCreateResponse
/// let response = client.transact::<_, EppDomainCreateResponse>(&domain_create).await.unwrap();
/// let response = client.transact_new(domain_create, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainCreate = EppObject<Command<DomainCreateRequest>>;
impl EppDomainCreate {
/// Creates a new EppObject for domain create corresponding to the &lt;epp&gt; tag in EPP XML
/// with the &lt;ns&gt; tag containing &lt;hostObj&gt; tags
pub fn new_with_ns(
name: &str,
period: u16,
ns: &[&str],
registrant_id: &str,
auth_password: &str,
contacts: Vec<DomainContact>,
client_tr_id: &str,
) -> EppDomainCreate {
let ns_list = ns.iter().map(|&n| n.into()).collect();
let domain_create = DomainCreateRequest {
domain: DomainCreateRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: Period::new(period),
ns: Some(HostList::HostObjList(HostObjList { hosts: ns_list })),
registrant: Some(registrant_id.into()),
auth_info: DomainAuthInfo::new(auth_password),
contacts: Some(contacts),
},
};
EppObject::build(Command::<DomainCreateRequest>::new(
domain_create,
client_tr_id,
))
}
/// Creates a new EppObject for domain create corresponding to the &lt;epp&gt; tag in EPP XML
/// without any nameservers
impl<E: EppExtension> DomainCreate<E> {
pub fn new(
name: &str,
period: u16,
registrant_id: &str,
ns: Option<HostList>,
registrant_id: Option<&str>,
auth_password: &str,
contacts: Vec<DomainContact>,
client_tr_id: &str,
) -> EppDomainCreate {
contacts: Option<Vec<DomainContact>>,
) -> DomainCreate<NoExtension> {
let registrant = registrant_id.map(|id| id.into());
let domain_create = DomainCreateRequest {
domain: DomainCreateRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: Period::new(period),
ns: None,
registrant: Some(registrant_id.into()),
ns,
registrant,
auth_info: DomainAuthInfo::new(auth_password),
contacts: Some(contacts),
contacts,
},
};
EppObject::build(Command::<DomainCreateRequest>::new(
domain_create,
client_tr_id,
))
DomainCreate {
request: domain_create,
extension: None,
}
}
/// Creates a new EppObject for domain create corresponding to the &lt;epp&gt; tag in EPP XML
/// without any contacts
pub fn new_without_contacts(
name: &str,
period: u16,
auth_password: &str,
client_tr_id: &str,
) -> EppDomainCreate {
let domain_create = DomainCreateRequest {
domain: DomainCreateRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: Period::new(period),
ns: None,
registrant: None,
auth_info: DomainAuthInfo::new(auth_password),
contacts: None,
},
};
EppObject::build(Command::<DomainCreateRequest>::new(
domain_create,
client_tr_id,
))
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainCreate<F> {
DomainCreate {
request: self.request,
extension: Some(extension),
}
/// Creates a new EppObject for domain create corresponding to the &lt;epp&gt; tag in EPP XML
/// with the &lt;ns&gt; tag containing &lt;hostAttr&gt; tags
pub fn new_with_host_attr(
name: &str,
period: u16,
ns: Vec<HostAttr>,
registrant_id: &str,
auth_password: &str,
contacts: Vec<DomainContact>,
client_tr_id: &str,
) -> EppDomainCreate {
let domain_create = DomainCreateRequest {
domain: DomainCreateRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: Period::new(period),
ns: Some(HostList::HostAttrList(HostAttrList { hosts: ns })),
registrant: Some(registrant_id.into()),
auth_info: DomainAuthInfo::new(auth_password),
contacts: Some(contacts),
},
};
EppObject::build(Command::<DomainCreateRequest>::new(
domain_create,
client_tr_id,
))
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain create response
pub type EppDomainCreateResponse = EppObject<CommandResponse<DomainCreateResponse>>;
// Request
/// Type for elements under the domain &lt;create&gt; tag
@ -203,26 +144,26 @@ pub type EppDomainCreateResponse = EppObject<CommandResponse<DomainCreateRespons
pub struct DomainCreateRequestData {
/// XML namespace for domain commands
#[serde(rename = "xmlns:domain", alias = "xmlns")]
xmlns: String,
pub xmlns: String,
/// The domain name
#[serde(rename = "domain:name", alias = "name")]
name: StringValue,
pub name: StringValue,
/// The period of registration
#[serde(rename = "domain:period", alias = "period")]
period: Period,
pub period: Period,
/// The list of nameserver hosts
/// either of type `HostObjList` or `HostAttrList`
#[serde(rename = "domain:ns", alias = "ns")]
ns: Option<HostList>,
pub ns: Option<HostList>,
/// The domain registrant
#[serde(rename = "domain:registrant", alias = "registrant")]
registrant: Option<StringValue>,
pub registrant: Option<StringValue>,
/// The list of contacts for the domain
#[serde(rename = "domain:contact", alias = "contact")]
contacts: Option<Vec<DomainContact>>,
pub contacts: Option<Vec<DomainContact>>,
/// The auth info for the domain
#[serde(rename = "domain:authInfo", alias = "authInfo")]
auth_info: DomainAuthInfo,
pub auth_info: DomainAuthInfo,
}
#[derive(Serialize, Deserialize, Debug, ElementName)]
@ -233,7 +174,7 @@ pub struct DomainCreateRequest {
/// T being the type of nameserver list (`HostObjList` or `HostAttrList`)
/// to be supplied
#[serde(rename = "domain:create", alias = "create")]
domain: DomainCreateRequestData,
pub domain: DomainCreateRequestData,
}
// Response
@ -243,7 +184,7 @@ pub struct DomainCreateRequest {
pub struct DomainCreateResponseData {
/// XML namespace for domain response data
#[serde(rename = "xmlns:domain")]
xmlns: String,
pub xmlns: String,
/// The domain name
pub name: StringValue,
/// The creation date

55
epp-client/src/domain/delete.rs
View File

@ -3,11 +3,26 @@
use epp_client_macros::*;
use super::EPP_DOMAIN_XMLNS;
use crate::common::{ElementName, EppObject, StringValue};
use crate::request::Command;
use crate::common::{ElementName, NoExtension, StringValue};
use crate::request::{EppExtension, EppRequest};
use crate::response::EppCommandResponse;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct DomainDelete<E> {
request: DomainDeleteRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainDelete<E> {
type Input = DomainDeleteRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for domain &lt;delete&gt; command
///
/// ## Usage
@ -17,8 +32,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::delete::{EppDomainDelete, EppDomainDeleteResponse};
/// use epp_client::domain::delete::DomainDelete;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -43,37 +59,38 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainDelete instance
/// let mut domain_delete = EppDomainDelete::new("eppdev-100.com", generate_client_tr_id(&client).as_str());
/// // Create an DomainDelete instance
/// let mut domain_delete = DomainDelete::<NoExtension>::new("eppdev-100.com");
///
/// // send it to the registry and receive a response of type EppDomainDeleteResponse
/// let response = client.transact::<_, EppDomainDeleteResponse>(&domain_delete).await.unwrap();
/// // send it to the registry and receive a response of type DomainDeleteResponse
/// let response = client.transact_new(domain_delete, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainDelete = EppObject<Command<DomainDeleteRequest>>;
impl EppDomainDelete {
/// Creates a new EppObject for domain delete corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(name: &str, client_tr_id: &str) -> EppDomainDelete {
EppObject::build(Command::<DomainDeleteRequest>::new(
DomainDeleteRequest {
impl<E: EppExtension> DomainDelete<E> {
pub fn new(name: &str) -> DomainDelete<NoExtension> {
DomainDelete {
request: DomainDeleteRequest {
domain: DomainDeleteRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
},
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainDelete<F> {
DomainDelete {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain delete response
pub type EppDomainDeleteResponse = EppCommandResponse;
/// Type for &lt;name&gt; element under the domain &lt;delete&gt; tag
#[derive(Serialize, Deserialize, Debug)]
pub struct DomainDeleteRequestData {

58
epp-client/src/domain/info.rs
View File

@ -4,13 +4,26 @@ use epp_client_macros::*;
use super::EPP_DOMAIN_XMLNS;
use crate::common::{
DomainAuthInfo, DomainContact, DomainStatus, ElementName, EppObject, HostAttr, StringValue,
DomainAuthInfo, DomainContact, DomainStatus, ElementName, HostAttr, NoExtension, StringValue,
};
use crate::domain::rgp::request::RgpRequestResponse;
use crate::request::Command;
use crate::response::CommandResponseWithExtension;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct DomainInfo<E> {
request: DomainInfoRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainInfo<E> {
type Input = DomainInfoRequest;
type Output = DomainInfoResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for domain &lt;info&gt; command
///
/// ## Usage
@ -20,8 +33,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::info::{EppDomainInfo, EppDomainInfoResponse};
/// use epp_client::domain::info::DomainInfo;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -46,24 +60,21 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainInfo instance
/// let domain_info = EppDomainInfo::new("eppdev-100.com", generate_client_tr_id(&client).as_str());
/// // Create an DomainInfo instance
/// let domain_info = DomainInfo::<NoExtension>::new("eppdev-100.com");
///
/// // send it to the registry and receive a response of type EppDomainInfoResponse
/// let response = client.transact::<_, EppDomainInfoResponse>(&domain_info).await.unwrap();
/// // send it to the registry and receive a response of type DomainInfoResponse
/// let response = client.transact_new(domain_info, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainInfo = EppObject<Command<DomainInfoRequest>>;
impl EppDomainInfo {
/// Creates a new EppObject for domain info corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(name: &str, client_tr_id: &str) -> EppDomainInfo {
EppObject::build(Command::<DomainInfoRequest>::new(
DomainInfoRequest {
impl<E: EppExtension> DomainInfo<E> {
pub fn new(name: &str) -> DomainInfo<NoExtension> {
DomainInfo {
request: DomainInfoRequest {
info: DomainInfoRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
domain: Domain {
@ -72,15 +83,18 @@ impl EppDomainInfo {
},
},
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainInfo<F> {
DomainInfo {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain info response
pub type EppDomainInfoResponse =
EppObject<CommandResponseWithExtension<DomainInfoResponse, RgpRequestResponse>>;
// Request
/// Type for data under the &lt;name&gt; element tag for the domain &lt;info&gt; tag

62
epp-client/src/domain/renew.rs
View File

@ -3,12 +3,26 @@
use epp_client_macros::*;
use super::EPP_DOMAIN_XMLNS;
use crate::common::{ElementName, EppObject, Period, StringValue};
use crate::request::Command;
use crate::response::CommandResponse;
use crate::common::{ElementName, NoExtension, Period, StringValue};
use crate::request::{EppExtension, EppRequest};
use chrono::NaiveDate;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct DomainRenew<E> {
request: DomainRenewRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainRenew<E> {
type Input = DomainRenewRequest;
type Output = DomainRenewResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for domain &lt;renew&gt; command
///
/// ## Usage
@ -20,8 +34,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::renew::{EppDomainRenew, EppDomainRenewResponse};
/// use epp_client::domain::renew::DomainRenew;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -49,31 +64,22 @@ use serde::{Deserialize, Serialize};
/// // Create a date object to set the current expiry date
/// let exp_date = NaiveDate::from_ymd(2022, 7, 27);
///
/// // Create an EppDomainRenew instance
/// let domain_renew = EppDomainRenew::new("eppdev-100.com", exp_date, 1, generate_client_tr_id(&client).as_str());
/// // Create an DomainRenew instance
/// let domain_renew = DomainRenew::<NoExtension>::new("eppdev-100.com", exp_date, 1);
///
/// // send it to the registry and receive a response of type EppDomainRenewResponse
/// let response = client.transact::<_, EppDomainRenewResponse>(&domain_renew).await.unwrap();
/// // send it to the registry and receive a response of type DomainRenewResponse
/// let response = client.transact_new(domain_renew, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainRenew = EppObject<Command<DomainRenewRequest>>;
impl EppDomainRenew {
/// Creates a new EppObject for domain renew corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(
name: &str,
current_expiry_date: NaiveDate,
years: u16,
client_tr_id: &str,
) -> EppDomainRenew {
impl<E: EppExtension> DomainRenew<E> {
pub fn new(name: &str, current_expiry_date: NaiveDate, years: u16) -> DomainRenew<NoExtension> {
let exp_date_str = current_expiry_date.format("%Y-%m-%d").to_string().into();
EppObject::build(Command::<DomainRenewRequest>::new(
DomainRenewRequest {
DomainRenew {
request: DomainRenewRequest {
domain: DomainRenewRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
@ -81,18 +87,18 @@ impl EppDomainRenew {
period: Period::new(years),
},
},
client_tr_id,
))
extension: None,
}
}
pub fn set_period(&mut self, period: Period) {
self.data.command.domain.period = period;
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainRenew<F> {
DomainRenew {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain renew response
pub type EppDomainRenewResponse = EppObject<CommandResponse<DomainRenewResponse>>;
// Request
/// Type for data under the domain &lt;renew&gt; tag

365
epp-client/src/domain/transfer.rs
View File

@ -3,11 +3,86 @@
use epp_client_macros::*;
use super::EPP_DOMAIN_XMLNS;
use crate::common::{DomainAuthInfo, ElementName, EppObject, Period, StringValue};
use crate::request::Command;
use crate::response::{CommandResponse, EppCommandResponse};
use crate::common::{DomainAuthInfo, ElementName, NoExtension, Period, StringValue};
use crate::request::{EppExtension, EppRequest};
use crate::response::EppCommandResponse;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct DomainTransferRequest<E> {
request: DomainTransferReq,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainTransferRequest<E> {
type Input = DomainTransferReq;
type Output = DomainTransferResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
#[derive(Debug)]
pub struct DomainTransferApprove<E> {
request: DomainTransferReq,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainTransferApprove<E> {
type Input = DomainTransferReq;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
#[derive(Debug)]
pub struct DomainTransferReject<E> {
request: DomainTransferReq,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainTransferReject<E> {
type Input = DomainTransferReq;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
#[derive(Debug)]
pub struct DomainTransferCancel<E> {
request: DomainTransferReq,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainTransferCancel<E> {
type Input = DomainTransferReq;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
#[derive(Debug)]
pub struct DomainTransferQuery<E> {
request: DomainTransferReq,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainTransferQuery<E> {
type Input = DomainTransferReq;
type Output = DomainTransferResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for transfer request for domain
///
/// ## Usage
@ -17,8 +92,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::transfer::{EppDomainTransferRequest, EppDomainTransferRequestResponse};
/// use epp_client::domain::transfer::DomainTransferRequest;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -43,20 +119,42 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainTransferRequest instance
/// let domain_transfer_request = EppDomainTransferRequest::request(
/// "eppdev-100.net", 1, "epP4uthd#v", generate_client_tr_id(&client).as_str()
/// // Create an DomainTransferRequest instance
/// let domain_transfer_request = DomainTransferRequest::<NoExtension>::new(
/// "eppdev-100.net", 1, "epP4uthd#v"
/// );
///
/// // send it to the registry and receive a response of type EppDomainTransferRequestResponse
/// let response = client.transact::<_, EppDomainTransferRequestResponse>(&domain_transfer_request).await.unwrap();
/// // send it to the registry and receive a response of type DomainTransferRequestResponse
/// let response = client.transact_new(domain_transfer_request, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainTransferRequest = EppObject<Command<DomainTransferRequest>>;
impl<E: EppExtension> DomainTransferRequest<E> {
pub fn new(name: &str, years: u16, auth_password: &str) -> DomainTransferRequest<NoExtension> {
DomainTransferRequest {
request: DomainTransferReq {
operation: "request".to_string(),
domain: DomainTransferReqData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: Some(Period::new(years)),
auth_info: Some(DomainAuthInfo::new(auth_password)),
},
},
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainTransferRequest<F> {
DomainTransferRequest {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; request for transfer approval for domains
///
@ -67,8 +165,9 @@ pub type EppDomainTransferRequest = EppObject<Command<DomainTransferRequest>>;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::transfer::{EppDomainTransferApprove, EppDomainTransferApproveResponse};
/// use epp_client::domain::transfer::DomainTransferApprove;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -93,20 +192,42 @@ pub type EppDomainTransferRequest = EppObject<Command<DomainTransferRequest>>;
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainTransferApprove instance
/// let domain_transfer_approve = EppDomainTransferApprove::approve(
/// "eppdev-100.net", generate_client_tr_id(&client).as_str()
/// // Create an DomainTransferApprove instance
/// let domain_transfer_approve = DomainTransferApprove::<NoExtension>::new(
/// "eppdev-100.net"
/// );
///
/// // send it to the registry and receive a response of type EppDomainTransferApproveResponse
/// let response = client.transact::<_, EppDomainTransferApproveResponse>(&domain_transfer_approve).await.unwrap();
/// // send it to the registry and receive a response of type DomainTransferApproveResponse
/// let response = client.transact_new(domain_transfer_approve, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainTransferApprove = EppObject<Command<DomainTransferRequest>>;
impl<E: EppExtension> DomainTransferApprove<E> {
pub fn new(name: &str) -> DomainTransferApprove<NoExtension> {
DomainTransferApprove {
request: DomainTransferReq {
operation: "approve".to_string(),
domain: DomainTransferReqData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: None,
auth_info: None,
},
},
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainTransferApprove<F> {
DomainTransferApprove {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; request for transfer rejection for domains
///
@ -117,8 +238,9 @@ pub type EppDomainTransferApprove = EppObject<Command<DomainTransferRequest>>;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::transfer::{EppDomainTransferReject, EppDomainTransferRejectResponse};
/// use epp_client::domain::transfer::DomainTransferReject;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -143,20 +265,42 @@ pub type EppDomainTransferApprove = EppObject<Command<DomainTransferRequest>>;
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainTransferReject instance
/// let domain_transfer_reject = EppDomainTransferReject::reject(
/// "eppdev-100.net", generate_client_tr_id(&client).as_str()
/// // Create an DomainTransferReject instance
/// let domain_transfer_reject = DomainTransferReject::<NoExtension>::new(
/// "eppdev-100.net"
/// );
///
/// // send it to the registry and receive a response of type EppDomainTransferRejectResponse
/// let response = client.transact::<_, EppDomainTransferRejectResponse>(&domain_transfer_reject).await.unwrap();
/// // send it to the registry and receive a response of type DomainTransferRejectResponse
/// let response = client.transact_new(domain_transfer_reject, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainTransferReject = EppObject<Command<DomainTransferRequest>>;
impl<E: EppExtension> DomainTransferReject<E> {
pub fn new(name: &str) -> DomainTransferReject<NoExtension> {
DomainTransferReject {
request: DomainTransferReq {
operation: "reject".to_string(),
domain: DomainTransferReqData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: None,
auth_info: None,
},
},
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainTransferReject<F> {
DomainTransferReject {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; request for transfer request cancellation for domains
///
@ -167,8 +311,9 @@ pub type EppDomainTransferReject = EppObject<Command<DomainTransferRequest>>;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::transfer::{EppDomainTransferCancel, EppDomainTransferCancelResponse};
/// use epp_client::domain::transfer::DomainTransferCancel;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -193,20 +338,42 @@ pub type EppDomainTransferReject = EppObject<Command<DomainTransferRequest>>;
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainTransferCancel instance
/// let domain_transfer_cancel = EppDomainTransferCancel::cancel(
/// "eppdev-100.net", generate_client_tr_id(&client).as_str()
/// // Create an DomainTransferCancel instance
/// let domain_transfer_cancel = DomainTransferCancel::<NoExtension>::new(
/// "eppdev-100.net"
/// );
///
/// // send it to the registry and receive a response of type EppDomainTransferCancelResponse
/// let response = client.transact::<_, EppDomainTransferCancelResponse>(&domain_transfer_cancel).await.unwrap();
/// // send it to the registry and receive a response of type DomainTransferCancelResponse
/// let response = client.transact_new(domain_transfer_cancel, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainTransferCancel = EppObject<Command<DomainTransferRequest>>;
impl<E: EppExtension> DomainTransferCancel<E> {
pub fn new(name: &str) -> DomainTransferCancel<NoExtension> {
DomainTransferCancel {
request: DomainTransferReq {
operation: "cancel".to_string(),
domain: DomainTransferReqData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: None,
auth_info: None,
},
},
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainTransferCancel<F> {
DomainTransferCancel {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; request for transfer request query for domains
///
@ -217,8 +384,9 @@ pub type EppDomainTransferCancel = EppObject<Command<DomainTransferRequest>>;
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::domain::transfer::{EppDomainTransferQuery, EppDomainTransferQueryResponse};
/// use epp_client::domain::transfer::DomainTransferQuery;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -243,137 +411,48 @@ pub type EppDomainTransferCancel = EppObject<Command<DomainTransferRequest>>;
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainTransferQuery instance
/// let domain_transfer_query = EppDomainTransferQuery::query(
/// "eppdev-100.net", "epP4uthd#v", generate_client_tr_id(&client).as_str()
/// // Create an DomainTransferQuery instance
/// let domain_transfer_query = DomainTransferQuery::<NoExtension>::new(
/// "eppdev-100.net", "epP4uthd#v"
/// );
///
/// // send it to the registry and receive a response of type EppDomainTransferQueryResponse
/// let response = client.transact::<_, EppDomainTransferQueryResponse>(&domain_transfer_query).await.unwrap();
/// // send it to the registry and receive a response of type DomainTransferQueryResponse
/// let response = client.transact_new(domain_transfer_query, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainTransferQuery = EppObject<Command<DomainTransferRequest>>;
impl EppDomainTransferRequest {
/// Creates a new EppObject for domain transfer request corresponding to the &lt;epp&gt; tag in EPP XML
pub fn request(
name: &str,
years: u16,
auth_password: &str,
client_tr_id: &str,
) -> EppDomainTransferRequest {
EppObject::build(Command::<DomainTransferRequest>::new(
DomainTransferRequest {
operation: "request".to_string(),
domain: DomainTransferRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: Some(Period::new(years)),
auth_info: Some(DomainAuthInfo::new(auth_password)),
},
},
client_tr_id,
))
}
/// Sets the period for renewal in case of a successful transfer
pub fn set_period(&mut self, period: Period) {
self.data.command.domain.period = Some(period);
}
}
impl EppDomainTransferApprove {
/// Creates a new EppObject for domain transfer approval corresponding to the &lt;epp&gt; tag in EPP XML
pub fn approve(name: &str, client_tr_id: &str) -> EppDomainTransferApprove {
EppObject::build(Command::<DomainTransferRequest>::new(
DomainTransferRequest {
operation: "approve".to_string(),
domain: DomainTransferRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: None,
auth_info: None,
},
},
client_tr_id,
))
}
}
impl EppDomainTransferCancel {
/// Creates a new EppObject for domain transfer request cancellation corresponding to the &lt;epp&gt; tag in EPP XML
pub fn cancel(name: &str, client_tr_id: &str) -> EppDomainTransferCancel {
EppObject::build(Command::<DomainTransferRequest>::new(
DomainTransferRequest {
operation: "cancel".to_string(),
domain: DomainTransferRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: None,
auth_info: None,
},
},
client_tr_id,
))
}
}
impl EppDomainTransferReject {
/// Creates a new EppObject for domain transfer rejection corresponding to the &lt;epp&gt; tag in EPP XML
pub fn reject(name: &str, client_tr_id: &str) -> EppDomainTransferReject {
EppObject::build(Command::<DomainTransferRequest>::new(
DomainTransferRequest {
operation: "reject".to_string(),
domain: DomainTransferRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: None,
auth_info: None,
},
},
client_tr_id,
))
}
}
impl EppDomainTransferQuery {
/// Creates a new EppObject for domain transfer request query corresponding to the &lt;epp&gt; tag in EPP XML
pub fn query(name: &str, auth_password: &str, client_tr_id: &str) -> EppDomainTransferQuery {
EppObject::build(Command::<DomainTransferRequest>::new(
DomainTransferRequest {
impl<E: EppExtension> DomainTransferQuery<E> {
pub fn new(name: &str, auth_password: &str) -> DomainTransferQuery<NoExtension> {
DomainTransferQuery {
request: DomainTransferReq {
operation: "query".to_string(),
domain: DomainTransferRequestData {
domain: DomainTransferReqData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
period: None,
auth_info: Some(DomainAuthInfo::new(auth_password)),
},
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainTransferQuery<F> {
DomainTransferQuery {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain transfer request response
pub type EppDomainTransferRequestResponse = EppObject<CommandResponse<DomainTransferResponse>>;
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain transfer approval response
pub type EppDomainTransferApproveResponse = EppCommandResponse;
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain transfer rejection response
pub type EppDomainTransferRejectResponse = EppCommandResponse;
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain transfer cancellation response
pub type EppDomainTransferCancelResponse = EppCommandResponse;
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain transfer query response
pub type EppDomainTransferQueryResponse = EppObject<CommandResponse<DomainTransferResponse>>;
// Request
/// Type for elements under the domain &lt;transfer&gt; tag
#[derive(Serialize, Deserialize, Debug)]
pub struct DomainTransferRequestData {
pub struct DomainTransferReqData {
/// XML namespace for domain commands
#[serde(rename = "xmlns:domain")]
xmlns: String,
@ -393,14 +472,14 @@ pub struct DomainTransferRequestData {
#[derive(Serialize, Deserialize, Debug, ElementName)]
#[element_name(name = "transfer")]
/// Type for EPP XML &lt;transfer&gt; command for domains
pub struct DomainTransferRequest {
pub struct DomainTransferReq {
/// The transfer operation to perform indicated by the 'op' attr
/// The values are one of transfer, approve, reject, cancel, or query
#[serde(rename = "op")]
operation: String,
/// The data under the &lt;transfer&gt; tag in the transfer request
#[serde(rename = "domain:transfer")]
domain: DomainTransferRequestData,
domain: DomainTransferReqData,
}
// Response

66
epp-client/src/domain/update.rs
View File

@ -2,15 +2,34 @@
use epp_client_macros::*;
use crate::common::{
DomainAuthInfo, DomainContact, DomainStatus, ElementName, EppObject, HostList, StringValue,
use crate::{
common::{
DomainAuthInfo, DomainContact, DomainStatus, ElementName, HostList, NoExtension,
StringValue,
},
request::{EppExtension, EppRequest},
};
use super::EPP_DOMAIN_XMLNS;
use crate::request::Command;
use crate::response::EppCommandResponse;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct DomainUpdate<E> {
request: DomainUpdateRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for DomainUpdate<E> {
type Input = DomainUpdateRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for domain &lt;update&gt; command
/// with &lt;hostObj&gt; elements in the request for &lt;ns&gt; list
///
@ -22,8 +41,9 @@ use serde::{Deserialize, Serialize};
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::common::{DomainStatus, DomainContact};
/// use epp_client::domain::update::{EppDomainUpdate, EppDomainUpdateResponse, DomainAddRemove};
/// use epp_client::domain::update::{DomainUpdate, DomainAddRemove};
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -48,8 +68,8 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppDomainUpdate instance
/// let mut domain_update = EppDomainUpdate::new("eppdev-100.com", generate_client_tr_id(&client).as_str());
/// // Create an DomainUpdate instance
/// let mut domain_update = DomainUpdate::<NoExtension>::new("eppdev-100.com");
///
/// let add = DomainAddRemove {
/// ns: None,
@ -76,21 +96,17 @@ use serde::{Deserialize, Serialize};
/// domain_update.remove(remove);
///
/// // send it to the registry and receive a response of type EppDomainUpdateResponse
/// let response = client.transact::<_, EppDomainUpdateResponse>(&domain_update).await.unwrap();
/// let response = client.transact_new(domain_update, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppDomainUpdate = EppObject<Command<DomainUpdateRequest>>;
impl EppDomainUpdate {
/// Creates a new EppObject for domain update corresponding to the &lt;epp&gt; tag in EPP XML
/// with the &lt;ns&gt; tag containing &lt;hostObj&gt; tags
pub fn new(name: &str, client_tr_id: &str) -> EppDomainUpdate {
EppObject::build(Command::<DomainUpdateRequest>::new(
DomainUpdateRequest {
impl<E: EppExtension> DomainUpdate<E> {
pub fn new(name: &str) -> DomainUpdate<NoExtension> {
DomainUpdate {
request: DomainUpdateRequest {
domain: DomainUpdateRequestData {
xmlns: EPP_DOMAIN_XMLNS.to_string(),
name: name.into(),
@ -99,29 +115,33 @@ impl EppDomainUpdate {
change_info: None,
},
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> DomainUpdate<F> {
DomainUpdate {
request: self.request,
extension: Some(extension),
}
}
/// Sets the data for the &lt;chg&gt; tag
pub fn info(&mut self, info: DomainChangeInfo) {
self.data.command.domain.change_info = Some(info);
self.request.domain.change_info = Some(info);
}
/// Sets the data for the &lt;add&gt; tag
pub fn add(&mut self, add: DomainAddRemove) {
self.data.command.domain.add = Some(add);
self.request.domain.add = Some(add);
}
/// Sets the data for the &lt;rem&gt; tag
pub fn remove(&mut self, remove: DomainAddRemove) {
self.data.command.domain.remove = Some(remove);
self.request.domain.remove = Some(remove);
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML domain update response
pub type EppDomainUpdateResponse = EppCommandResponse;
/// Type for elements under the &lt;chg&gt; tag for domain update
#[derive(Serialize, Deserialize, Debug)]
pub struct DomainChangeInfo {

66
epp-client/src/host/check.rs
View File

@ -1,13 +1,29 @@
//! Types for EPP host check request
use std::fmt::Debug;
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, StringValue};
use crate::common::{ElementName, NoExtension, StringValue};
use crate::host::EPP_HOST_XMLNS;
use crate::request::Command;
use crate::response::CommandResponse;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct HostCheck<E> {
request: HostCheckRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for HostCheck<E> {
type Input = HostCheckRequest;
type Output = HostCheckResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for host &lt;check&gt; command
///
/// ## Usage
@ -17,8 +33,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::host::check::{EppHostCheck, EppHostCheckResponse};
/// use epp_client::host::check::HostCheck;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -43,41 +60,42 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppHostCheck instance
/// let host_check = EppHostCheck::new(
/// &["ns1.eppdev-101.com", "ns2.eppdev-101.com"],
/// generate_client_tr_id(&client).as_str()
/// // Create an HostCheck instance
/// let host_check = HostCheck::<NoExtension>::new(
/// &["ns1.eppdev-101.com", "ns2.eppdev-101.com"]
/// );
///
/// // send it to the registry and receive a response of type EppHostCheckResponse
/// let response = client.transact::<_, EppHostCheckResponse>(&host_check).await.unwrap();
/// // send it to the registry and receive a response of type HostCheckResponse
/// let response = client.transact_new(host_check, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppHostCheck = EppObject<Command<HostCheckRequest>>;
impl EppHostCheck {
/// Creates a new EppObject for host check corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(hosts: &[&str], client_tr_id: &str) -> EppHostCheck {
impl<E: EppExtension> HostCheck<E> {
pub fn new(hosts: &[&str]) -> HostCheck<NoExtension> {
let hosts = hosts.iter().map(|&d| d.into()).collect();
let host_check = HostCheckRequest {
HostCheck {
request: HostCheckRequest {
list: HostList {
xmlns: EPP_HOST_XMLNS.to_string(),
hosts,
},
};
},
extension: None,
}
}
EppObject::build(Command::<HostCheckRequest>::new(host_check, client_tr_id))
pub fn with_extension<F: EppExtension>(self, extension: F) -> HostCheck<F> {
HostCheck {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML host check response
pub type EppHostCheckResponse = EppObject<CommandResponse<HostCheckResult>>;
// Request
/// Type for data under the host &lt;check&gt; tag
@ -104,7 +122,7 @@ pub struct HostCheckRequest {
/// Type that represents the &lt;name&gt; tag for host check response
#[derive(Serialize, Deserialize, Debug)]
pub struct HostCheck {
pub struct HostAvailable {
/// The host name
#[serde(rename = "$value")]
pub name: StringValue,
@ -118,7 +136,7 @@ pub struct HostCheck {
pub struct HostCheckDataItem {
/// Data under the &lt;name&gt; tag
#[serde(rename = "name")]
pub host: HostCheck,
pub host: HostAvailable,
/// The reason for (un)availability
pub reason: Option<StringValue>,
}
@ -136,7 +154,7 @@ pub struct HostCheckData {
/// Type that represents the &lt;resData&gt; tag for host check response
#[derive(Serialize, Deserialize, Debug)]
pub struct HostCheckResult {
pub struct HostCheckResponse {
/// Data under the &lt;chkData&gt; tag
#[serde(rename = "chkData")]
pub check_data: HostCheckData,

55
epp-client/src/host/create.rs
View File

@ -2,12 +2,26 @@
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, HostAddr, StringValue};
use crate::common::{ElementName, HostAddr, NoExtension, StringValue};
use crate::host::EPP_HOST_XMLNS;
use crate::request::Command;
use crate::response::CommandResponse;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct HostCreate<E> {
request: HostCreateRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for HostCreate<E> {
type Input = HostCreateRequest;
type Output = HostCreateResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for host &lt;create&gt; command
///
/// ## Usage
@ -18,8 +32,9 @@ use serde::{Deserialize, Serialize};
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::common::HostAddr;
/// use epp_client::host::create::{EppHostCreate, EppHostCreateResponse};
/// use epp_client::host::create::HostCreate;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -50,37 +65,39 @@ use serde::{Deserialize, Serialize};
/// HostAddr::new("v6", "2404:6800:4001:801::200e"),
/// ];
///
/// // Create an EppHostCreate instance
/// let host_create = EppHostCreate::new("ns1.eppdev-101.com", addresses, generate_client_tr_id(&client).as_str());
/// // Create an HostCreate instance
/// let host_create = HostCreate::<NoExtension>::new("ns1.eppdev-101.com", addresses);
///
/// // send it to the registry and receive a response of type EppHostCreateResponse
/// let response = client.transact::<_, EppHostCreateResponse>(&host_create).await.unwrap();
/// // send it to the registry and receive a response of type HostCreateResponse
/// let response = client.transact_new(host_create, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppHostCreate = EppObject<Command<HostCreateRequest>>;
impl EppHostCreate {
/// Creates a new EppObject for host create corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(host: &str, addresses: Vec<HostAddr>, client_tr_id: &str) -> EppHostCreate {
let host_create = HostCreateRequest {
impl<E: EppExtension> HostCreate<E> {
pub fn new(host: &str, addresses: Vec<HostAddr>) -> HostCreate<NoExtension> {
HostCreate {
request: HostCreateRequest {
host: HostCreateRequestData {
xmlns: EPP_HOST_XMLNS.to_string(),
name: host.into(),
addresses: Some(addresses),
},
};
},
extension: None,
}
}
EppObject::build(Command::<HostCreateRequest>::new(host_create, client_tr_id))
pub fn with_extension<F: EppExtension>(self, extension: F) -> HostCreate<F> {
HostCreate {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML host create response
pub type EppHostCreateResponse = EppObject<CommandResponse<HostCreateResponse>>;
// Request
/// Type for data under the host &lt;create&gt; tag

55
epp-client/src/host/delete.rs
View File

@ -2,12 +2,27 @@
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, StringValue};
use crate::common::{ElementName, NoExtension, StringValue};
use crate::host::EPP_HOST_XMLNS;
use crate::request::Command;
use crate::request::{EppExtension, EppRequest};
use crate::response::EppCommandResponse;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct HostDelete<E> {
request: HostDeleteRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for HostDelete<E> {
type Input = HostDeleteRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for host &lt;delete&gt; command
///
/// ## Usage
@ -17,8 +32,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::host::delete::{EppHostDelete, EppHostDeleteResponse};
/// use epp_client::host::delete::HostDelete;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -43,37 +59,38 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppHostDelete instance
/// let host_delete = EppHostDelete::new("ns2.eppdev-101.com", generate_client_tr_id(&client).as_str());
/// // Create an HostDelete instance
/// let host_delete = HostDelete::<NoExtension>::new("ns2.eppdev-101.com");
///
/// // send it to the registry and receive a response of type EppHostDeleteResponse
/// let response = client.transact::<_, EppHostDeleteResponse>(&host_delete).await.unwrap();
/// // send it to the registry and receive a response of type HostDeleteResponse
/// let response = client.transact_new(host_delete, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppHostDelete = EppObject<Command<HostDeleteRequest>>;
impl EppHostDelete {
/// Creates a new EppObject for host delete corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(name: &str, client_tr_id: &str) -> EppHostDelete {
EppObject::build(Command::<HostDeleteRequest>::new(
HostDeleteRequest {
impl<E: EppExtension> HostDelete<E> {
pub fn new(name: &str) -> HostDelete<NoExtension> {
HostDelete {
request: HostDeleteRequest {
host: HostDeleteRequestData {
xmlns: EPP_HOST_XMLNS.to_string(),
name: name.into(),
},
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> HostDelete<F> {
HostDelete {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML host delete response
pub type EppHostDeleteResponse = EppCommandResponse;
/// Type for data under the host &lt;delete&gt; tag
#[derive(Serialize, Deserialize, Debug)]
pub struct HostDeleteRequestData {

56
epp-client/src/host/info.rs
View File

@ -2,12 +2,26 @@
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, HostAddr, HostStatus, StringValue};
use crate::common::{ElementName, HostAddr, HostStatus, NoExtension, StringValue};
use crate::host::EPP_HOST_XMLNS;
use crate::request::Command;
use crate::response::CommandResponse;
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct HostInfo<E> {
request: HostInfoRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for HostInfo<E> {
type Input = HostInfoRequest;
type Output = HostInfoResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for host &lt;info&gt; command
///
/// ## Usage
@ -17,8 +31,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::host::info::{EppHostInfo, EppHostInfoResponse};
/// use epp_client::host::info::HostInfo;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -43,37 +58,38 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppHostCreate instance
/// let host_info = EppHostInfo::new("ns2.eppdev-101.com", generate_client_tr_id(&client).as_str());
/// // Create an HostInfo instance
/// let host_info = HostInfo::<NoExtension>::new("ns2.eppdev-101.com");
///
/// // send it to the registry and receive a response of type EppHostInfoResponse
/// let response = client.transact::<_, EppHostInfoResponse>(&host_info).await.unwrap();
/// // send it to the registry and receive a response of type HostInfoResponse
/// let response = client.transact_new(host_info, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppHostInfo = EppObject<Command<HostInfoRequest>>;
impl EppHostInfo {
/// Creates a new EppObject for host info corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(name: &str, client_tr_id: &str) -> EppHostInfo {
EppObject::build(Command::<HostInfoRequest>::new(
HostInfoRequest {
impl<E: EppExtension> HostInfo<E> {
pub fn new(name: &str) -> HostInfo<NoExtension> {
HostInfo {
request: HostInfoRequest {
info: HostInfoRequestData {
xmlns: EPP_HOST_XMLNS.to_string(),
name: name.into(),
},
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> HostInfo<F> {
HostInfo {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML host info response
pub type EppHostInfoResponse = EppObject<CommandResponse<HostInfoResponse>>;
// Request
/// Type for data under the host &lt;info&gt; tag

61
epp-client/src/host/update.rs
View File

@ -2,12 +2,27 @@
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, HostAddr, HostStatus, StringValue};
use crate::common::{ElementName, HostAddr, HostStatus, NoExtension, StringValue};
use crate::host::EPP_HOST_XMLNS;
use crate::request::Command;
use crate::request::{EppExtension, EppRequest};
use crate::response::EppCommandResponse;
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct HostUpdate<E> {
request: HostUpdateRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for HostUpdate<E> {
type Input = HostUpdateRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for host &lt;update&gt; command
///
/// ## Usage
@ -18,8 +33,9 @@ use serde::{Deserialize, Serialize};
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::common::{HostAddr, HostStatus};
/// use epp_client::host::update::{EppHostUpdate, EppHostUpdateResponse, HostAddRemove, HostChangeInfo};
/// use epp_client::host::update::{HostUpdate, HostAddRemove, HostChangeInfo};
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -44,8 +60,8 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppHostUpdate instance
/// let mut host_update = EppHostUpdate::new("ns1.eppdev-101.com", generate_client_tr_id(&client).as_str());
/// // Create an HostUpdate instance
/// let mut host_update = HostUpdate::<NoExtension>::new("ns1.eppdev-101.com");
///
/// /// Prepare the add and remove sections for the update
/// let add = HostAddRemove {
@ -68,21 +84,18 @@ use serde::{Deserialize, Serialize};
/// // Send a &lt;chg&gt; section as well
/// host_update.info(HostChangeInfo { name: "ns2.eppdev-101.com".into() });
///
/// // send it to the registry and receive a response of type EppHostUpdateResponse
/// let response = client.transact::<_, EppHostUpdateResponse>(&host_update).await.unwrap();
/// // send it to the registry and receive a response of type HostUpdateResponse
/// let response = client.transact_new(host_update, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppHostUpdate = EppObject<Command<HostUpdateRequest>>;
impl EppHostUpdate {
/// Creates a new EppObject for host update corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(name: &str, client_tr_id: &str) -> EppHostUpdate {
EppObject::build(Command::<HostUpdateRequest>::new(
HostUpdateRequest {
impl<E: EppExtension> HostUpdate<E> {
pub fn new(name: &str) -> HostUpdate<NoExtension> {
HostUpdate {
request: HostUpdateRequest {
host: HostUpdateRequestData {
xmlns: EPP_HOST_XMLNS.to_string(),
name: name.into(),
@ -91,29 +104,33 @@ impl EppHostUpdate {
change_info: None,
},
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> HostUpdate<F> {
HostUpdate {
request: self.request,
extension: Some(extension),
}
}
/// Sets the data for the &lt;chg&gt; element of the host update
pub fn info(&mut self, info: HostChangeInfo) {
self.data.command.host.change_info = Some(info);
self.request.host.change_info = Some(info);
}
/// Sets the data for the &lt;add&gt; element of the host update
pub fn add(&mut self, add: HostAddRemove) {
self.data.command.host.add = Some(add);
self.request.host.add = Some(add);
}
/// Sets the data for the &lt;rem&gt; element of the host update
pub fn remove(&mut self, remove: HostAddRemove) {
self.data.command.host.remove = Some(remove);
self.request.host.remove = Some(remove);
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML host update response
pub type EppHostUpdateResponse = EppCommandResponse;
/// Type for data under the &lt;chg&gt; tag
#[derive(Serialize, Deserialize, Debug)]
pub struct HostChangeInfo {

10
epp-client/src/lib.rs
View File

@ -43,8 +43,9 @@
//!
//! use epp_client::config::{EppClientConfig, EppClientConnection};
//! use epp_client::EppClient;
//! use epp_client::domain::check::{EppDomainCheck, EppDomainCheckResponse};
//! use epp_client::domain::check::DomainCheck;
//! use epp_client::generate_client_tr_id;
//! use epp_client::common::NoExtension;
//!
//! #[tokio::main]
//! async fn main() {
@ -72,15 +73,14 @@
//!
//! // Make a domain check call, which returns an object of type EppDomainCheckResponse
//! // that contains the result of the call
//! let domain_check = EppDomainCheck::new(
//! let domain_check = DomainCheck::<NoExtension>::new(
//! vec!["eppdev.com", "eppdev.net"],
//! generate_client_tr_id(&client).as_str()
//! );
//!
//! let response = client.transact::<_, EppDomainCheckResponse>(&domain_check).await.unwrap();
//! let response = client.transact_new(domain_check, generate_client_tr_id(&client).as_str()).await.unwrap();
//!
//! // print the availability results
//! response.data.res_data.unwrap().check_data.domain_list
//! response.res_data.unwrap().check_data.domain_list
//! .iter()
//! .for_each(|chk| println!("Domain: {}, Available: {}", chk.domain.name, chk.domain.available));
//!

53
epp-client/src/login.rs
View File

@ -4,30 +4,41 @@ use epp_client_macros::ElementName;
use serde::{Deserialize, Serialize};
use crate::{
common::{ElementName, EppObject, Options, ServiceExtension, Services, StringValue},
common::{ElementName, NoExtension, Options, ServiceExtension, Services, StringValue},
contact::EPP_CONTACT_XMLNS,
domain::EPP_DOMAIN_XMLNS,
host::EPP_HOST_XMLNS,
request::{Command, EPP_LANG, EPP_VERSION},
request::{EppExtension, EppRequest, EPP_LANG, EPP_VERSION},
response::EppCommandResponse,
};
/// The EPP Login Request
pub type EppLogin = EppObject<Command<Login>>;
#[derive(Debug)]
pub struct Login<E> {
request: LoginRequest,
extension: Option<E>,
}
impl EppLogin {
/// Creates a new EPP Login request
impl<E: EppExtension> EppRequest<E> for Login<E> {
type Input = LoginRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
impl<E: EppExtension> Login<E> {
pub fn new(
username: &str,
password: &str,
ext_uris: &Option<Vec<String>>,
client_tr_id: &str,
) -> EppLogin {
) -> Login<NoExtension> {
let ext_uris = ext_uris
.as_ref()
.map(|uris| uris.iter().map(|u| u.as_str().into()).collect());
let login = Login {
Login {
request: LoginRequest {
username: username.into(),
password: password.into(),
options: Options {
@ -42,33 +53,33 @@ impl EppLogin {
],
svc_ext: Some(ServiceExtension { ext_uris }),
},
};
EppObject::build(Command::<Login> {
command: login,
},
extension: None,
client_tr_id: client_tr_id.into(),
})
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> Login<F> {
Login {
request: self.request,
extension: Some(extension),
}
}
/// Sets the <options> tag data
pub fn options(&mut self, options: Options) {
self.data.command.options = options;
self.request.options = options;
}
/// Sets the <svcs> tag data
pub fn services(&mut self, services: Services) {
self.data.command.services = services;
self.request.services = services;
}
}
/// An alias of `EppCommandResponse` received in response to a successful login request
pub type EppLoginResponse = EppCommandResponse;
#[derive(Serialize, Deserialize, Debug, PartialEq, ElementName)]
#[element_name(name = "login")]
/// Type corresponding to the &lt;login&gt; tag in an EPP XML login request
pub struct Login {
pub struct LoginRequest {
/// The username to use for the login
#[serde(rename(serialize = "clID", deserialize = "clID"))]
username: StringValue,

44
epp-client/src/logout.rs
View File

@ -4,29 +4,43 @@ use epp_client_macros::ElementName;
use serde::{Deserialize, Serialize};
use crate::{
common::{ElementName, EppObject},
request::Command,
common::{ElementName, NoExtension},
request::{EppExtension, EppRequest},
response::EppCommandResponse,
};
/// The EPP Logout request
pub type EppLogout = EppObject<Command<Logout>>;
#[derive(Debug)]
pub struct Logout<E> {
request: LogoutRequest,
extension: Option<E>,
}
impl EppLogout {
/// Creates a new EPP Logout request
pub fn new(client_tr_id: &str) -> EppLogout {
EppObject::build(Command::<Logout> {
command: Logout,
extension: None,
client_tr_id: client_tr_id.into(),
})
impl<E: EppExtension> EppRequest<E> for Logout<E> {
type Input = LogoutRequest;
type Output = EppCommandResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// An alias of `EppCommandResponse` received in response to a successful logout request
pub type EppLogoutResponse = EppCommandResponse;
impl<E: EppExtension> Logout<E> {
pub fn new() -> Logout<NoExtension> {
Logout {
request: LogoutRequest {},
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> Logout<F> {
Logout {
request: self.request,
extension: Some(extension),
}
}
}
#[derive(Serialize, Deserialize, Debug, PartialEq, ElementName)]
#[element_name(name = "logout")]
/// Type corresponding to the &lt;logout&gt; tag in an EPP XML logout request
pub struct Logout;
pub struct LogoutRequest;

56
epp-client/src/message/ack.rs
View File

@ -2,11 +2,25 @@
use epp_client_macros::*;
use crate::common::{ElementName, EppObject};
use crate::request::Command;
use crate::response::CommandResponse;
use crate::common::{ElementName, NoExtension};
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct MessageAck<E> {
request: MessageAckRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for MessageAck<E> {
type Input = MessageAckRequest;
type Output = String;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for registry <poll op="ack"> command
/// ## Usage
///
@ -15,8 +29,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::message::ack::{EppMessageAck, EppMessageAckResponse};
/// use epp_client::message::ack::MessageAck;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -41,35 +56,36 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppMessageAck instance
/// let message_ack = EppMessageAck::new(12345, generate_client_tr_id(&client).as_str());
/// // Create an MessageAck instance
/// let message_ack = MessageAck::<NoExtension>::new(12345);
///
/// // send it to the registry and receive a response of type EppMessageAckResponse
/// let response = client.transact::<_, EppMessageAckResponse>(&message_ack).await.unwrap();
/// // send it to the registry and receive a response of type MessageAckResponse
/// let response = client.transact_new(message_ack, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppMessageAck = EppObject<Command<MessageAckRequest>>;
impl EppMessageAck {
/// Creates a new EppObject for &lt;poll&gt; ack corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(message_id: u32, client_tr_id: &str) -> EppMessageAck {
EppObject::build(Command::<MessageAckRequest>::new(
MessageAckRequest {
impl<E: EppExtension> MessageAck<E> {
pub fn new(message_id: u32) -> MessageAck<NoExtension> {
MessageAck {
request: MessageAckRequest {
op: "ack".to_string(),
message_id: message_id.to_string(),
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> MessageAck<F> {
MessageAck {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML message ack response
pub type EppMessageAckResponse = EppObject<CommandResponse<String>>;
#[derive(Serialize, Deserialize, Debug, ElementName)]
#[element_name(name = "poll")]
/// Type for EPP XML &lt;poll&gt; command for message ack

56
epp-client/src/message/poll.rs
View File

@ -2,11 +2,25 @@
use epp_client_macros::*;
use crate::common::{ElementName, EppObject, StringValue};
use crate::request::Command;
use crate::response::CommandResponse;
use crate::common::{ElementName, NoExtension, StringValue};
use crate::request::{EppExtension, EppRequest};
use serde::{Deserialize, Serialize};
#[derive(Debug)]
pub struct MessagePoll<E> {
request: MessagePollRequest,
extension: Option<E>,
}
impl<E: EppExtension> EppRequest<E> for MessagePoll<E> {
type Input = MessagePollRequest;
type Output = MessagePollResponse;
fn into_parts(self) -> (Self::Input, Option<E>) {
(self.request, self.extension)
}
}
/// Type that represents the &lt;epp&gt; request for registry <poll op="req"> command
///
/// ## Usage
@ -16,8 +30,9 @@ use serde::{Deserialize, Serialize};
///
/// use epp_client::config::{EppClientConfig, EppClientConnection};
/// use epp_client::EppClient;
/// use epp_client::message::poll::{EppMessagePoll, EppMessagePollResponse};
/// use epp_client::message::poll::MessagePoll;
/// use epp_client::generate_client_tr_id;
/// use epp_client::common::NoExtension;
///
/// #[tokio::main]
/// async fn main() {
@ -42,34 +57,35 @@ use serde::{Deserialize, Serialize};
/// Err(e) => panic!("Failed to create EppClient: {}", e)
/// };
///
/// // Create an EppMessagePoll instance
/// let message_poll = EppMessagePoll::new(generate_client_tr_id(&client).as_str());
/// // Create an MessagePoll instance
/// let message_poll = MessagePoll::<NoExtension>::new();
///
/// // send it to the registry and receive a response of type EppMessagePollResponse
/// let response = client.transact::<_, EppMessagePollResponse>(&message_poll).await.unwrap();
/// // send it to the registry and receive a response of type MessagePollResponse
/// let response = client.transact_new(message_poll, generate_client_tr_id(&client).as_str()).await.unwrap();
///
/// println!("{:?}", response);
///
/// client.logout().await.unwrap();
/// }
/// ```
pub type EppMessagePoll = EppObject<Command<MessagePollRequest>>;
impl EppMessagePoll {
/// Creates a new EppObject for &lt;poll&gt; req corresponding to the &lt;epp&gt; tag in EPP XML
pub fn new(client_tr_id: &str) -> EppMessagePoll {
EppObject::build(Command::<MessagePollRequest>::new(
MessagePollRequest {
impl<E: EppExtension> MessagePoll<E> {
pub fn new() -> MessagePoll<NoExtension> {
MessagePoll {
request: MessagePollRequest {
op: "req".to_string(),
},
client_tr_id,
))
extension: None,
}
}
pub fn with_extension<F: EppExtension>(self, extension: F) -> MessagePoll<F> {
MessagePoll {
request: self.request,
extension: Some(extension),
}
}
}
/// Type that represents the &lt;epp&gt; tag for the EPP XML message poll response
pub type EppMessagePollResponse = EppObject<CommandResponse<MessagePollResponse>>;
// Request
#[derive(Serialize, Deserialize, Debug, ElementName)]

335
epp-client/src/tests/de.rs
View File

@ -3,35 +3,37 @@
mod response {
use super::super::get_xml;
use super::super::CLTRID;
use crate::contact::check::EppContactCheckResponse;
use crate::contact::create::EppContactCreateResponse;
use crate::contact::delete::EppContactDeleteResponse;
use crate::contact::info::EppContactInfoResponse;
use crate::contact::update::EppContactUpdateResponse;
use crate::domain::check::EppDomainCheckResponse;
use crate::domain::create::EppDomainCreateResponse;
use crate::domain::delete::EppDomainDeleteResponse;
use crate::domain::info::EppDomainInfoResponse;
use crate::domain::renew::EppDomainRenewResponse;
use crate::common::NoExtension;
use crate::contact::check::ContactCheck;
use crate::contact::create::ContactCreate;
use crate::contact::delete::ContactDelete;
use crate::contact::info::ContactInfo;
use crate::contact::update::ContactUpdate;
use crate::domain::check::DomainCheck;
use crate::domain::create::DomainCreate;
use crate::domain::delete::DomainDelete;
use crate::domain::info::DomainInfo;
use crate::domain::renew::DomainRenew;
use crate::domain::rgp::request::EppDomainRgpRestoreRequestResponse;
use crate::domain::transfer::EppDomainTransferApproveResponse;
use crate::domain::transfer::EppDomainTransferCancelResponse;
use crate::domain::transfer::EppDomainTransferQueryResponse;
use crate::domain::transfer::EppDomainTransferRejectResponse;
use crate::domain::transfer::EppDomainTransferRequestResponse;
use crate::domain::update::EppDomainUpdateResponse;
use crate::domain::transfer::DomainTransferApprove;
use crate::domain::transfer::DomainTransferCancel;
use crate::domain::transfer::DomainTransferQuery;
use crate::domain::transfer::DomainTransferReject;
use crate::domain::transfer::DomainTransferRequest;
use crate::domain::update::DomainUpdate;
use crate::hello::EppGreeting;
use crate::hello::ExpiryType;
use crate::hello::Relative;
use crate::host::check::EppHostCheckResponse;
use crate::host::create::EppHostCreateResponse;
use crate::host::delete::EppHostDeleteResponse;
use crate::host::info::EppHostInfoResponse;
use crate::host::update::EppHostUpdateResponse;
use crate::login::EppLoginResponse;
use crate::logout::EppLogoutResponse;
use crate::message::ack::EppMessageAckResponse;
use crate::message::poll::EppMessagePollResponse;
use crate::host::check::HostCheck;
use crate::host::create::HostCreate;
use crate::host::delete::HostDelete;
use crate::host::info::HostInfo;
use crate::host::update::HostUpdate;
use crate::login::Login;
use crate::logout::Logout;
use crate::message::ack::MessageAck;
use crate::message::poll::MessagePoll;
use crate::request::EppRequest;
use crate::response::EppCommandResponseError;
use crate::xml::EppXml;
@ -87,37 +89,37 @@ mod response {
#[test]
fn login() {
let xml = get_xml("response/login.xml").unwrap();
let object = EppLoginResponse::deserialize(xml.as_str()).unwrap();
let object = Login::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn logout() {
let xml = get_xml("response/logout.xml").unwrap();
let object = EppLogoutResponse::deserialize(xml.as_str()).unwrap();
let object = Logout::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1500);
assert_eq!(object.result.code, 1500);
assert_eq!(
object.data.result.message,
object.result.message,
"Command completed successfully; ending session".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn contact_check() {
let xml = get_xml("response/contact/check.xml").unwrap();
let object = EppContactCheckResponse::deserialize(xml.as_str()).unwrap();
let object = ContactCheck::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let results = object.data.res_data().unwrap();
let results = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(
results.check_data.contact_list[0].contact.id,
"eppdev-contact-1".into()
@ -128,52 +130,52 @@ mod response {
"eppdev-contact-2".into()
);
assert_eq!(results.check_data.contact_list[1].contact.available, 1);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn contact_create() {
let xml = get_xml("response/contact/create.xml").unwrap();
let object = EppContactCreateResponse::deserialize(xml.as_str()).unwrap();
let object = ContactCreate::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let results = object.data.res_data().unwrap();
let results = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(results.create_data.id, "eppdev-contact-4".into());
assert_eq!(
results.create_data.created_at,
"2021-07-25T16:05:32.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn contact_delete() {
let xml = get_xml("response/contact/delete.xml").unwrap();
let object = EppContactDeleteResponse::deserialize(xml.as_str()).unwrap();
let object = ContactDelete::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn contact_info() {
let xml = get_xml("response/contact/info.xml").unwrap();
let object = EppContactInfoResponse::deserialize(xml.as_str()).unwrap();
let object = ContactInfo::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
let fax = result.info_data.fax.as_ref().unwrap();
let voice_ext = result.info_data.voice.extension.as_ref().unwrap();
let fax_ext = fax.extension.as_ref().unwrap();
let auth_info = result.info_data.auth_info.as_ref().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(result.info_data.id, "eppdev-contact-3".into());
assert_eq!(result.info_data.roid, "UNDEF-ROID".into());
assert_eq!(result.info_data.statuses[0].status, "ok".to_string());
@ -218,30 +220,30 @@ mod response {
"2021-07-23T13:09:09.0Z".into()
);
assert_eq!((*auth_info).password, "eppdev-387323".into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn contact_update() {
let xml = get_xml("response/contact/update.xml").unwrap();
let object = EppContactUpdateResponse::deserialize(xml.as_str()).unwrap();
let object = ContactUpdate::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_check() {
let xml = get_xml("response/domain/check.xml").unwrap();
let object = EppDomainCheckResponse::deserialize(xml.as_str()).unwrap();
let object = DomainCheck::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(
result.check_data.domain_list[0].domain.name,
"eppdev.com".into()
@ -252,19 +254,19 @@ mod response {
"eppdev.net".into()
);
assert_eq!(result.check_data.domain_list[1].domain.available, 0);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_create() {
let xml = get_xml("response/domain/create.xml").unwrap();
let object = EppDomainCreateResponse::deserialize(xml.as_str()).unwrap();
let object = DomainCreate::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(result.create_data.name, "eppdev-2.com".into());
assert_eq!(
result.create_data.created_at,
@ -274,34 +276,34 @@ mod response {
result.create_data.expiring_at,
"2022-07-25T18:11:34.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_delete() {
let xml = get_xml("response/domain/delete.xml").unwrap();
let object = EppDomainDeleteResponse::deserialize(xml.as_str()).unwrap();
let object = DomainDelete::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_info() {
let xml = get_xml("response/domain/info.xml").unwrap();
let object = EppDomainInfoResponse::deserialize(xml.as_str()).unwrap();
let object = DomainInfo::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
let auth_info = result.info_data.auth_info.as_ref().unwrap();
let ns_list = result.info_data.ns.as_ref().unwrap();
let ns = (*ns_list).host_obj.as_ref().unwrap();
let hosts = result.info_data.hosts.as_ref().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(result.info_data.name, "eppdev-1.com".into());
assert_eq!(result.info_data.roid, "125899511_DOMAIN_COM-VRSN".into());
assert_eq!(result.info_data.statuses[0].status, "ok".to_string());
@ -348,38 +350,39 @@ mod response {
"2023-07-23T15:31:20.0Z".into()
);
assert_eq!((*auth_info).password, "epP4uthd#v".into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_renew() {
let xml = get_xml("response/domain/renew.xml").unwrap();
let object = EppDomainRenewResponse::deserialize(xml.as_str()).unwrap();
let object = DomainRenew::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(result.renew_data.name, "eppdev-1.com".into());
assert_eq!(
result.renew_data.expiring_at,
"2024-07-23T15:31:20.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_transfer_request() {
let xml = get_xml("response/domain/transfer_request.xml").unwrap();
let object = EppDomainTransferRequestResponse::deserialize(xml.as_str()).unwrap();
let object =
DomainTransferRequest::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1001);
assert_eq!(object.result.code, 1001);
assert_eq!(
object.data.result.message,
object.result.message,
"Command completed successfully; action pending".into()
);
assert_eq!(result.transfer_data.name, "eppdev-transfer.com".into());
@ -395,52 +398,56 @@ mod response {
result.transfer_data.expiring_at,
"2022-07-02T14:53:19.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_transfer_approve() {
let xml = get_xml("response/domain/transfer_approve.xml").unwrap();
let object = EppDomainTransferApproveResponse::deserialize(xml.as_str()).unwrap();
let object =
DomainTransferApprove::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_transfer_reject() {
let xml = get_xml("response/domain/transfer_reject.xml").unwrap();
let object = EppDomainTransferRejectResponse::deserialize(xml.as_str()).unwrap();
let object =
DomainTransferReject::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_transfer_cancel() {
let xml = get_xml("response/domain/transfer_cancel.xml").unwrap();
let object = EppDomainTransferCancelResponse::deserialize(xml.as_str()).unwrap();
let object =
DomainTransferCancel::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_transfer_query() {
let xml = get_xml("response/domain/transfer_query.xml").unwrap();
let object = EppDomainTransferQueryResponse::deserialize(xml.as_str()).unwrap();
let object =
DomainTransferQuery::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(result.transfer_data.name, "eppdev-transfer.com".into());
assert_eq!(result.transfer_data.transfer_status, "pending".into());
assert_eq!(result.transfer_data.requester_id, "eppdev".into());
@ -454,30 +461,30 @@ mod response {
result.transfer_data.expiring_at,
"2022-07-02T14:53:19.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn domain_update() {
let xml = get_xml("response/domain/update.xml").unwrap();
let object = EppDomainUpdateResponse::deserialize(xml.as_str()).unwrap();
let object = DomainUpdate::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn host_check() {
let xml = get_xml("response/host/check.xml").unwrap();
let object = EppHostCheckResponse::deserialize(xml.as_str()).unwrap();
let object = HostCheck::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(
result.check_data.host_list[0].host.name,
"host1.eppdev-1.com".into()
@ -488,37 +495,37 @@ mod response {
"ns1.testing.com".into()
);
assert_eq!(result.check_data.host_list[1].host.available, 0);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn host_create() {
let xml = get_xml("response/host/create.xml").unwrap();
let object = EppHostCreateResponse::deserialize(xml.as_str()).unwrap();
let object = HostCreate::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(result.create_data.name, "host2.eppdev-1.com".into());
assert_eq!(
result.create_data.created_at,
"2021-07-26T05:28:55.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn host_info() {
let xml = get_xml("response/host/info.xml").unwrap();
let object = EppHostInfoResponse::deserialize(xml.as_str()).unwrap();
let object = HostInfo::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let result = object.res_data().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(result.info_data.name, "host2.eppdev-1.com".into());
assert_eq!(result.info_data.roid, "UNDEF-ROID".into());
assert_eq!(result.info_data.statuses[0].status, "ok".to_string());
@ -549,43 +556,43 @@ mod response {
*(result.info_data.updated_at.as_ref().unwrap()),
"2021-07-26T05:28:55.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn host_update() {
let xml = get_xml("response/host/update.xml").unwrap();
let object = EppHostUpdateResponse::deserialize(xml.as_str()).unwrap();
let object = HostUpdate::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn host_delete() {
let xml = get_xml("response/host/delete.xml").unwrap();
let object = EppHostDeleteResponse::deserialize(xml.as_str()).unwrap();
let object = HostDelete::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn message_poll() {
let xml = get_xml("response/message/poll.xml").unwrap();
let object = EppMessagePollResponse::deserialize(xml.as_str()).unwrap();
let object = MessagePoll::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let result = object.data.res_data().unwrap();
let msg = object.data.message_queue().unwrap();
let result = object.res_data().unwrap();
let msg = object.message_queue().unwrap();
assert_eq!(object.data.result.code, 1301);
assert_eq!(object.result.code, 1301);
assert_eq!(
object.data.result.message,
object.result.message,
"Command completed successfully; ack to dequeue".into()
);
assert_eq!(msg.count, 5);
@ -611,22 +618,22 @@ mod response {
result.message_data.expiring_at,
"2022-07-02T14:53:19.0Z".into()
);
assert_eq!(object.data.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.client_tr_id.unwrap(), CLTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]
fn message_ack() {
let xml = get_xml("response/message/ack.xml").unwrap();
let object = EppMessageAckResponse::deserialize(xml.as_str()).unwrap();
let object = MessageAck::<NoExtension>::deserialize_response(xml.as_str()).unwrap();
let msg = object.data.message_queue().unwrap();
let msg = object.message_queue().unwrap();
assert_eq!(object.data.result.code, 1000);
assert_eq!(object.data.result.message, SUCCESS_MSG.into());
assert_eq!(object.result.code, 1000);
assert_eq!(object.result.message, SUCCESS_MSG.into());
assert_eq!(msg.count, 4);
assert_eq!(msg.id, "12345".to_string());
assert_eq!(object.data.tr_ids.server_tr_id, SVTRID.into());
assert_eq!(object.tr_ids.server_tr_id, SVTRID.into());
}
#[test]

194
epp-client/src/tests/se.rs
View File

@ -3,42 +3,47 @@
mod request {
use super::super::get_xml;
use super::super::CLTRID;
use crate::common::HostAttrList;
use crate::common::HostList;
use crate::common::HostObjList;
use crate::common::NoExtension;
use crate::common::{
Address, ContactStatus, DomainAuthInfo, DomainContact, DomainStatus, HostAddr, HostAttr,
HostStatus, Phone, PostalInfo,
};
use crate::contact::check::EppContactCheck;
use crate::contact::create::EppContactCreate;
use crate::contact::delete::EppContactDelete;
use crate::contact::info::EppContactInfo;
use crate::contact::update::EppContactUpdate;
use crate::domain::check::EppDomainCheck;
use crate::domain::create::EppDomainCreate;
use crate::domain::delete::EppDomainDelete;
use crate::domain::info::EppDomainInfo;
use crate::domain::renew::EppDomainRenew;
use crate::contact::check::ContactCheck;
use crate::contact::create::ContactCreate;
use crate::contact::delete::ContactDelete;
use crate::contact::info::ContactInfo;
use crate::contact::update::ContactUpdate;
use crate::domain::check::DomainCheck;
use crate::domain::create::DomainCreate;
use crate::domain::delete::DomainDelete;
use crate::domain::info::DomainInfo;
use crate::domain::renew::DomainRenew;
use crate::domain::rgp::report::EppDomainRgpRestoreReport;
use crate::domain::rgp::request::EppDomainRgpRestoreRequest;
use crate::domain::transfer::EppDomainTransferApprove;
use crate::domain::transfer::EppDomainTransferCancel;
use crate::domain::transfer::EppDomainTransferQuery;
use crate::domain::transfer::EppDomainTransferReject;
use crate::domain::transfer::EppDomainTransferRequest;
use crate::domain::transfer::DomainTransferApprove;
use crate::domain::transfer::DomainTransferCancel;
use crate::domain::transfer::DomainTransferQuery;
use crate::domain::transfer::DomainTransferReject;
use crate::domain::transfer::DomainTransferRequest;
use crate::domain::update::DomainAddRemove;
use crate::domain::update::DomainChangeInfo;
use crate::domain::update::EppDomainUpdate;
use crate::domain::update::DomainUpdate;
use crate::hello::EppHello;
use crate::host::check::EppHostCheck;
use crate::host::create::EppHostCreate;
use crate::host::delete::EppHostDelete;
use crate::host::info::EppHostInfo;
use crate::host::update::EppHostUpdate;
use crate::host::check::HostCheck;
use crate::host::create::HostCreate;
use crate::host::delete::HostDelete;
use crate::host::info::HostInfo;
use crate::host::update::HostAddRemove;
use crate::host::update::HostChangeInfo;
use crate::login::EppLogin;
use crate::logout::EppLogout;
use crate::message::ack::EppMessageAck;
use crate::message::poll::EppMessagePoll;
use crate::host::update::HostUpdate;
use crate::login::Login;
use crate::logout::Logout;
use crate::message::ack::MessageAck;
use crate::message::poll::MessagePoll;
use crate::request::EppRequest;
use crate::xml::EppXml;
use chrono::{DateTime, NaiveDate};
use std::str::FromStr;
@ -59,8 +64,8 @@ mod request {
]);
let xml = get_xml("request/login.xml").unwrap();
let object = EppLogin::new("username", "password", &ext_uris, CLTRID);
let serialized = object.serialize().unwrap();
let object = Login::<NoExtension>::new("username", "password", &ext_uris);
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -68,8 +73,8 @@ mod request {
#[test]
fn logout() {
let xml = get_xml("request/logout.xml").unwrap();
let object = EppLogout::new(CLTRID);
let serialized = object.serialize().unwrap();
let object = Logout::<NoExtension>::new();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -77,8 +82,8 @@ mod request {
#[test]
fn contact_check() {
let xml = get_xml("request/contact/check.xml").unwrap();
let object = EppContactCheck::new(&["eppdev-contact-1", "eppdev-contact-2"], CLTRID);
let serialized = object.serialize().unwrap();
let object = ContactCheck::<NoExtension>::new(&["eppdev-contact-1", "eppdev-contact-2"]);
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -95,17 +100,16 @@ mod request {
let mut fax = Phone::new("+33.86698799");
fax.set_extension("677");
let mut object = EppContactCreate::new(
let mut object = ContactCreate::<NoExtension>::new(
"eppdev-contact-3",
"contact@eppdev.net",
postal_info,
voice,
"eppdev-387323",
CLTRID,
);
object.set_fax(fax);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -114,9 +118,9 @@ mod request {
fn contact_info() {
let xml = get_xml("request/contact/info.xml").unwrap();
let object = EppContactInfo::new("eppdev-contact-3", "eppdev-387323", CLTRID);
let object = ContactInfo::<NoExtension>::new("eppdev-contact-3", "eppdev-387323");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -125,7 +129,7 @@ mod request {
fn contact_update() {
let xml = get_xml("request/contact/update.xml").unwrap();
let mut object = EppContactUpdate::new("eppdev-contact-3", CLTRID);
let mut object = ContactUpdate::<NoExtension>::new("eppdev-contact-3");
let street = &["58", "Orchid Road"];
let address = Address::new(street, "Paris", "Paris", "392374", "FR");
@ -142,7 +146,7 @@ mod request {
}];
object.remove(remove_statuses);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -151,9 +155,9 @@ mod request {
fn contact_delete() {
let xml = get_xml("request/contact/delete.xml").unwrap();
let object = EppContactDelete::new("eppdev-contact-3", CLTRID);
let object = ContactDelete::<NoExtension>::new("eppdev-contact-3");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -162,9 +166,9 @@ mod request {
fn domain_check() {
let xml = get_xml("request/domain/check.xml").unwrap();
let object = EppDomainCheck::new(vec!["eppdev.com", "eppdev.net"], CLTRID);
let object = DomainCheck::<NoExtension>::new(vec!["eppdev.com", "eppdev.net"]);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -188,16 +192,16 @@ mod request {
},
];
let object = EppDomainCreate::new(
let object = DomainCreate::<NoExtension>::new(
"eppdev-1.com",
1,
"eppdev-contact-3",
None,
Some("eppdev-contact-3"),
"epP4uthd#v",
contacts,
CLTRID,
Some(contacts),
);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -221,17 +225,20 @@ mod request {
},
];
let object = EppDomainCreate::new_with_ns(
let ns = Some(HostList::HostObjList(HostObjList {
hosts: vec!["ns1.test.com".into(), "ns2.test.com".into()],
}));
let object = DomainCreate::<NoExtension>::new(
"eppdev-1.com",
1,
&["ns1.test.com", "ns2.test.com"],
"eppdev-contact-3",
ns,
Some("eppdev-contact-3"),
"epP4uthd#v",
contacts,
CLTRID,
Some(contacts),
);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -255,7 +262,8 @@ mod request {
},
];
let host_attr = vec![
let host_attr = HostList::HostAttrList(HostAttrList {
hosts: vec![
HostAttr {
name: "ns1.eppdev-1.com".into(),
addresses: None,
@ -267,19 +275,19 @@ mod request {
HostAddr::new_v6("2404:6800:4001:801::200e"),
]),
},
];
],
});
let object = EppDomainCreate::new_with_host_attr(
let object = DomainCreate::<NoExtension>::new(
"eppdev-2.com",
1,
host_attr,
"eppdev-contact-3",
Some(host_attr),
Some("eppdev-contact-3"),
"epP4uthd#v",
contacts,
CLTRID,
Some(contacts),
);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -288,9 +296,9 @@ mod request {
fn domain_info() {
let xml = get_xml("request/domain/info.xml").unwrap();
let object = EppDomainInfo::new("eppdev.com", CLTRID);
let object = DomainInfo::<NoExtension>::new("eppdev.com");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -299,7 +307,7 @@ mod request {
fn domain_update() {
let xml = get_xml("request/domain/update.xml").unwrap();
let mut object = EppDomainUpdate::new("eppdev.com", CLTRID);
let mut object = DomainUpdate::<NoExtension>::new("eppdev.com");
let add = DomainAddRemove {
ns: None,
@ -327,7 +335,7 @@ mod request {
object.remove(remove);
object.info(change_info);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -336,9 +344,9 @@ mod request {
fn domain_delete() {
let xml = get_xml("request/domain/delete.xml").unwrap();
let object = EppDomainDelete::new("eppdev.com", CLTRID);
let object = DomainDelete::<NoExtension>::new("eppdev.com");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -348,9 +356,9 @@ mod request {
let xml = get_xml("request/domain/renew.xml").unwrap();
let exp_date = NaiveDate::from_ymd(2022, 7, 23);
let object = EppDomainRenew::new("eppdev.com", exp_date, 1, CLTRID);
let object = DomainRenew::<NoExtension>::new("eppdev.com", exp_date, 1);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -359,9 +367,9 @@ mod request {
fn domain_transfer_request() {
let xml = get_xml("request/domain/transfer_request.xml").unwrap();
let object = EppDomainTransferRequest::request("testing.com", 1, "epP4uthd#v", CLTRID);
let object = DomainTransferRequest::<NoExtension>::new("testing.com", 1, "epP4uthd#v");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -370,9 +378,9 @@ mod request {
fn domain_transfer_approve() {
let xml = get_xml("request/domain/transfer_approve.xml").unwrap();
let object = EppDomainTransferApprove::approve("testing.com", CLTRID);
let object = DomainTransferApprove::<NoExtension>::new("testing.com");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -381,9 +389,9 @@ mod request {
fn domain_transfer_reject() {
let xml = get_xml("request/domain/transfer_reject.xml").unwrap();
let object = EppDomainTransferReject::reject("testing.com", CLTRID);
let object = DomainTransferReject::<NoExtension>::new("testing.com");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -392,9 +400,9 @@ mod request {
fn domain_transfer_cancel() {
let xml = get_xml("request/domain/transfer_cancel.xml").unwrap();
let object = EppDomainTransferCancel::cancel("testing.com", CLTRID);
let object = DomainTransferCancel::<NoExtension>::new("testing.com");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -403,9 +411,9 @@ mod request {
fn domain_transfer_query() {
let xml = get_xml("request/domain/transfer_query.xml").unwrap();
let object = EppDomainTransferQuery::query("testing.com", "epP4uthd#v", CLTRID);
let object = DomainTransferQuery::<NoExtension>::new("testing.com", "epP4uthd#v");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -414,9 +422,9 @@ mod request {
fn host_check() {
let xml = get_xml("request/host/check.xml").unwrap();
let object = EppHostCheck::new(&["ns1.eppdev-1.com", "host1.eppdev-1.com"], CLTRID);
let object = HostCheck::<NoExtension>::new(&["ns1.eppdev-1.com", "host1.eppdev-1.com"]);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -430,9 +438,9 @@ mod request {
HostAddr::new("v6", "2404:6800:4001:801::200e"),
];
let object = EppHostCreate::new("host1.eppdev-1.com", addresses, CLTRID);
let object = HostCreate::<NoExtension>::new("host1.eppdev-1.com", addresses);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -441,9 +449,9 @@ mod request {
fn host_info() {
let xml = get_xml("request/host/info.xml").unwrap();
let object = EppHostInfo::new("ns1.eppdev-1.com", CLTRID);
let object = HostInfo::<NoExtension>::new("ns1.eppdev-1.com");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -466,7 +474,7 @@ mod request {
}]),
};
let mut object = EppHostUpdate::new("host1.eppdev-1.com", CLTRID);
let mut object = HostUpdate::<NoExtension>::new("host1.eppdev-1.com");
object.add(add);
object.remove(remove);
@ -474,7 +482,7 @@ mod request {
name: "host2.eppdev-1.com".into(),
});
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -483,9 +491,9 @@ mod request {
fn host_delete() {
let xml = get_xml("request/host/delete.xml").unwrap();
let object = EppHostDelete::new("ns1.eppdev-1.com", CLTRID);
let object = HostDelete::<NoExtension>::new("ns1.eppdev-1.com");
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -494,9 +502,9 @@ mod request {
fn message_poll() {
let xml = get_xml("request/message/poll.xml").unwrap();
let object = EppMessagePoll::new(CLTRID);
let object = MessagePoll::<NoExtension>::new();
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}
@ -505,9 +513,9 @@ mod request {
fn message_ack() {
let xml = get_xml("request/message/ack.xml").unwrap();
let object = EppMessageAck::new(12345, CLTRID);
let object = MessageAck::<NoExtension>::new(12345);
let serialized = object.serialize().unwrap();
let serialized = object.serialize_request(CLTRID).unwrap();
assert_eq!(xml, serialized);
}