daml-grpc 0.3.0

Daml Ledger GRPC API
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
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
146
147

use std::collections::HashMap;

use crate::grpc_protobuf::com::daml::ledger::api::v2::admin::{ObjectMeta, PartyDetails};

/// The participant-side view of a Daml party.
///
/// v2 dropped `display_name` from the wire shape (`reserved 2` in the
/// proto) and added participant-local metadata plus an identity-provider
/// id. Modifiable fields can be updated via
/// `PartyManagementService.UpdatePartyDetails`.
#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlPartyDetails {
    /// Stable unique identifier of the party. Not modifiable.
    pub party: String,
    /// `true` iff the party is hosted by *this* participant and shares
    /// the same identity provider as the user issuing the request.
    /// Not modifiable.
    pub is_local: bool,
    /// Participant-local annotations + concurrency token. Modifiable.
    pub local_metadata: Option<DamlObjectMeta>,
    /// `Identity Provider` this party is assigned to. Empty string means
    /// the default IDP. Updatable via `UpdatePartyIdentityProviderId`, not
    /// `UpdatePartyDetails`.
    pub identity_provider_id: String,
}

impl From<PartyDetails> for DamlPartyDetails {
    fn from(d: PartyDetails) -> Self {
        Self {
            party: d.party,
            is_local: d.is_local,
            local_metadata: d.local_metadata.map(DamlObjectMeta::from),
            identity_provider_id: d.identity_provider_id,
        }
    }
}

impl From<DamlPartyDetails> for PartyDetails {
    fn from(d: DamlPartyDetails) -> Self {
        Self {
            party: d.party,
            is_local: d.is_local,
            local_metadata: d.local_metadata.map(Into::into),
            identity_provider_id: d.identity_provider_id,
        }
    }
}

/// Kubernetes-style metadata attached to participant-local resources
/// (parties, users, …).
///
/// `resource_version` is an opaque server-managed concurrency token: on
/// reads it carries the current version; on updates you echo it back to
/// have the server reject the update if anyone else has modified the
/// resource since you last read it. Leave it empty when creating a new
/// resource — the server populates it on success.
#[derive(Debug, Eq, PartialEq, Clone, Default)]
pub struct DamlObjectMeta {
    pub resource_version: String,
    pub annotations: HashMap<String, String>,
}

impl From<ObjectMeta> for DamlObjectMeta {
    fn from(m: ObjectMeta) -> Self {
        Self {
            resource_version: m.resource_version,
            annotations: m.annotations,
        }
    }
}

impl From<DamlObjectMeta> for ObjectMeta {
    fn from(m: DamlObjectMeta) -> Self {
        Self {
            resource_version: m.resource_version,
            annotations: m.annotations,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    fn sample_meta() -> DamlObjectMeta {
        DamlObjectMeta {
            resource_version: "v42".to_owned(),
            annotations: [("k".to_owned(), "v".to_owned()), ("other".to_owned(), "value".to_owned())]
                .into_iter()
                .collect(),
        }
    }

    fn sample_party() -> DamlPartyDetails {
        DamlPartyDetails {
            party: "Alice::participant".to_owned(),
            is_local: true,
            local_metadata: Some(sample_meta()),
            identity_provider_id: "idp-1".to_owned(),
        }
    }

    #[test]
    fn party_details_roundtrip() {
        let dto = sample_party();
        let proto: PartyDetails = dto.clone().into();
        let back: DamlPartyDetails = proto.into();
        assert_eq!(back, dto);
    }

    #[test]
    fn party_details_default_roundtrip() {
        let dto = DamlPartyDetails::default();
        let proto: PartyDetails = dto.clone().into();
        let back: DamlPartyDetails = proto.into();
        assert_eq!(back, dto);
    }

    #[test]
    fn party_details_without_metadata_roundtrip() {
        let dto = DamlPartyDetails {
            party: "Bob".to_owned(),
            is_local: false,
            local_metadata: None,
            identity_provider_id: String::new(),
        };
        let proto: PartyDetails = dto.clone().into();
        let back: DamlPartyDetails = proto.into();
        assert_eq!(back, dto);
    }

    #[test]
    fn object_meta_roundtrip() {
        let dto = sample_meta();
        let proto: ObjectMeta = dto.clone().into();
        let back: DamlObjectMeta = proto.into();
        assert_eq!(back, dto);
    }

    #[test]
    fn object_meta_empty_roundtrip() {
        let dto = DamlObjectMeta::default();
        let proto: ObjectMeta = dto.clone().into();
        let back: DamlObjectMeta = proto.into();
        assert_eq!(back, dto);
    }
}