aries-cli 0.1.1

A simple Aries Cloudagent Controller
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

use super::register::Module;
use crate::agent::agents::Agent;
use async_trait::async_trait;
use clap::ArgMatches;
use serde::{Deserialize, Serialize};

/// Type of the received connections list
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Connections {
    /// List of the current connections
    pub results: Vec<Connection>,
}

/// Type of the connections configuration as received by the cli
#[derive(Debug)]
pub struct ConnectionsConfig {
    /// Filter based on the alias
    pub alias: Option<String>,

    /// Get a connection by this id
    pub connection_id: Option<String>,

    /// Filter based on the invitation key
    pub invitation_key: Option<String>,

    /// Filter based on your did
    pub my_did: Option<String>,

    /// Filter based on their did
    pub their_did: Option<String>,

    // TODO: enum
    /// Filter based on the state
    pub state: Option<String>,

    /// Filter based on their role
    pub their_role: Option<String>,
}

/// Type of a single received connection
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Connection {
    /// Invitation mode
    pub invitation_mode: String,

    /// Aries rfc23 state
    pub rfc23_state: String,

    /// Key of the invitation
    pub invitation_key: String,

    /// Their label
    pub their_label: Option<String>,

    /// Auto acceptance
    pub accept: String,

    /// Their did
    pub their_did: Option<String>,

    /// Timestamp of when the connection was created
    pub created_at: String,

    /// Their role in the invitation process
    pub their_role: String,

    /// When the connection was updated
    pub updated_at: String,

    /// State of the routing
    pub routing_state: String,

    /// The id of the connection
    pub connection_id: String,

    /// Your own did used for this connection
    pub my_did: Option<String>,

    /// State of the connection
    pub state: String,

    /// Alias given for this connection
    pub alias: Option<String>,
}

/// Connections module for the agent
pub struct ConnectionsModule;

/// Implementation of a module for connections
#[async_trait(?Send)]
impl Module<ConnectionsConfig> for ConnectionsModule {
    async fn run(agent: &dyn Agent, config: ConnectionsConfig) {
        let logger = agent.logger();
        match config.connection_id {
            Some(id) => {
                let connection = agent.get_connection_by_id(id).await;
                logger.log_pretty(connection);
            }
            None => {
                let connections = agent.get_connections(config).await.results;
                logger.log_pretty(connections);
            }
        };
    }

    async fn register<'a>(agent: &dyn Agent, matches: &ArgMatches<'a>) {
        if let Some(matches_connections) = matches.subcommand_matches("connections") {
            let connection_id = matches_connections
                .value_of("connection-id")
                .map(|x| x.to_string());

            let alias = matches_connections.value_of("alias").map(|x| x.to_string());

            let invitation_key = matches_connections
                .value_of("invitation-key")
                .map(|x| x.to_string());

            let my_did = matches_connections
                .value_of("my-did")
                .map(|x| x.to_string());

            let their_did = matches_connections
                .value_of("their-did")
                .map(|x| x.to_string());

            let their_role = matches_connections
                .value_of("their_role")
                .map(|x| x.to_string());

            let state = matches_connections.value_of("state").map(|x| x.to_string());

            let config = ConnectionsConfig {
                connection_id,
                alias,
                invitation_key,
                my_did,
                their_did,
                state,
                their_role,
            };

            ConnectionsModule::run(agent, config).await;
        }
    }
}