versa 1.9.0-rc2

Versa types and utilities for developing Versa client applications in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

use std::future::Future;

use crate::protocol::{CheckRegistryResponse, TransactionHandles};

use super::{ClientError, VersaClient};

/// **DEPRECATED**: This trait is deprecated and will be removed in a future version.
///
/// This trait was used to provide a `check_registry` method for querying the registry
/// about receiver configurations. It is being deprecated as part of API simplification.

#[deprecated(
  since = "1.2.0",
  note = "The CheckRegistry trait is deprecated and will be removed in a future version"
)]
pub trait CheckRegistry {
  #[deprecated(
    since = "1.2.0",
    note = "The check_registry method is deprecated and will be removed in a future version; please use query_receivers instead"
  )]
  fn check_registry(
    &self,
    handles: TransactionHandles,
  ) -> impl Future<Output = Result<CheckRegistryResponse, ClientError>> + Send;
}

impl CheckRegistry for VersaClient {
  async fn check_registry(
    &self,
    handles: TransactionHandles,
  ) -> Result<CheckRegistryResponse, ClientError> {
    let credential = self.authorization_header_val();
    let url = format!("{}/check_registry", self.registry_url);
    let payload_json = serde_json::to_string(&handles).unwrap();

    let client = reqwest::Client::new();
    let response_result = client
      .post(url)
      .header("Accept", "application/json")
      .header("Authorization", credential)
      .header("Content-Type", "application/json")
      .body(payload_json)
      .send()
      .await;

    match response_result {
      Ok(response) => {
        if response.status().is_success() {
          let response: CheckRegistryResponse = match response.json().await {
            Ok(response) => response,
            Err(e) => return Err(ClientError::DeserializationError(e)),
          };
          Ok(response)
        } else {
          Err(ClientError::RegistryError(
            response.status(),
            response.text().await.unwrap(),
          ))
        }
      }
      Err(e) => Err(ClientError::NetworkError(e)),
    }
  }
}