siera-cloudagent-python 0.2.0

Hyperledger Aries Cloudagent Python controller.
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
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

use crate::agent::CloudAgentPython;
use crate::fill_query;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use serde_json::json;
use siera_agent::error::Result;
use siera_agent::modules::connection::{
    Connection, ConnectionCreateInvitationOptions, ConnectionGetAllOptions, ConnectionModule,
    ConnectionReceiveInvitationOptions, Invitation,
};

/// Response from the server when all connections are requested
#[derive(Debug, Serialize, Deserialize)]
pub struct ConnectionGetAllResponse {
    /// List of all the connections returned by the cloudagent
    /// these connections are already filtered on
    pub results: Vec<Connection>,
}

#[async_trait]
impl ConnectionModule for CloudAgentPython {
    async fn get_all(&self, options: ConnectionGetAllOptions) -> Result<Vec<Connection>> {
        let url = self.create_url(&["connections"])?;

        let query = fill_query!(
            options,
            alias,
            connection_protocol,
            invitation_key,
            my_did,
            state,
            their_did,
            their_role
        );

        let connections: ConnectionGetAllResponse = self.get(url, Some(query)).await?;

        Ok(connections.results)
    }

    async fn get_by_id(&self, id: String) -> Result<Connection> {
        let url = self.create_url(&["connections", &id])?;
        self.get::<Connection>(url, None).await
    }

    async fn create_invitation(
        &self,
        options: ConnectionCreateInvitationOptions,
    ) -> Result<Invitation> {
        let url = self.create_url(&["connections", "create-invitation"])?;
        let mut query: Vec<(&str, String)> = vec![];

        let body = if options.toolbox {
            query.push(("multi_use", false.to_string()));
            query.push(("auto_accept", true.to_string()));
            query.push(("alias", String::from("toolbox")));

            Some(json!({
                "metadata": {
                    "group": "admin"
                }
            }))
        } else {
            if options.multi_use {
                query.push(("multi_use", true.to_string()));
            }
            if options.auto_accept {
                query.push(("auto_accept", true.to_string()));
            }
            if let Some(alias) = &options.alias {
                query.push(("alias", alias.clone()));
            }
            None
        };
        self.post::<Invitation>(url, Some(query), body).await
    }
    async fn receive_invitation(
        &self,
        invitation: ConnectionReceiveInvitationOptions,
    ) -> Result<Connection> {
        let url = self.create_url(&["connections", "receive-invitation"])?;

        self.post(url, None, Some(serde_json::to_value(invitation)?))
            .await
    }
}