1
+ use regex:: { Match , Regex } ;
1
2
use serde:: { de, Deserialize , Deserializer , Serialize , Serializer } ;
2
3
use serde_json:: Value ;
3
4
4
- use agency_client :: message_type :: parse_message_type ;
5
+ use crate :: error :: { VcxError , VcxErrorKind , VcxResult } ;
5
6
use crate :: messages:: a2a:: message_family:: MessageFamilies ;
6
7
7
8
#[ derive( Debug , Clone , PartialEq , Default ) ]
8
9
pub struct MessageType {
9
- pub did : String ,
10
+ pub prefix : String ,
10
11
pub family : MessageFamilies ,
11
12
pub version : String ,
12
- pub type_ : String ,
13
+ pub msg_type : String ,
13
14
}
14
15
15
16
impl MessageType {
16
17
pub fn build ( family : MessageFamilies , name : & str ) -> MessageType {
17
18
MessageType {
18
- did : MessageFamilies :: DID . to_string ( ) ,
19
+ prefix : MessageFamilies :: ARIES_CORE_PREFIX . to_string ( ) ,
19
20
version : family. version ( ) . to_string ( ) ,
20
21
family,
21
- type_ : name. to_string ( ) ,
22
+ msg_type : name. to_string ( ) ,
22
23
}
23
24
}
24
25
}
25
26
26
-
27
27
impl < ' de > Deserialize < ' de > for MessageType {
28
28
fn deserialize < D > ( deserializer : D ) -> Result < Self , D :: Error > where D : Deserializer < ' de > {
29
29
let value = Value :: deserialize ( deserializer) . map_err ( de:: Error :: custom) ?;
30
30
31
31
match value. as_str ( ) {
32
32
Some ( type_) => {
33
- let ( did , family , version , type_ ) = parse_message_type ( type_) . map_err ( de :: Error :: custom ) ? ;
34
- Ok ( MessageType {
35
- did ,
36
- family : MessageFamilies :: from ( family ) ,
37
- version ,
38
- type_ ,
39
- } )
33
+ if let Some ( msg_type ) = parse_message_type_legacy ( type_) {
34
+ Ok ( msg_type )
35
+ } else if let Some ( msg_type ) = parse_message_type ( type_ ) {
36
+ Ok ( msg_type )
37
+ } else {
38
+ Err ( de :: Error :: custom ( "Unexpected @type field structure." ) )
39
+ }
40
40
}
41
41
_ => Err ( de:: Error :: custom ( "Unexpected @type field structure." ) )
42
42
}
@@ -52,6 +52,77 @@ impl Serialize for MessageType {
52
52
53
53
impl std:: string:: ToString for MessageType {
54
54
fn to_string ( & self ) -> String {
55
- format ! ( "{};spec/{}/{}/{}" , self . did, self . family. to_string( ) , self . version, self . type_)
55
+ if self . family == MessageFamilies :: Routing { // vcxagency-node only supports legacy format right now
56
+ format ! ( "{};spec/{}/{}/{}" , MessageFamilies :: DID_PREFIX . to_string( ) , self . family. to_string( ) , self . version, self . msg_type)
57
+ } else {
58
+ format ! ( "{}/{}/{}/{}" , self . prefix, self . family. to_string( ) , self . version, self . msg_type)
59
+ }
60
+ }
61
+ }
62
+
63
+
64
+ pub fn parse_message_type_legacy ( message_type : & str ) -> Option < MessageType > {
65
+ lazy_static ! {
66
+ static ref RE : Regex = Regex :: new( r"(?x)
67
+ (?P<did>[\d\w:]*);
68
+ (?P<spec>.*)/
69
+ (?P<family>.*)/
70
+ (?P<version>.*)/
71
+ (?P<type>.*)" ) . unwrap( ) ;
56
72
}
73
+
74
+ RE . captures ( message_type)
75
+ . and_then ( |cap| {
76
+ let did = cap. name ( "did" ) . as_ref ( ) . map ( Match :: as_str) ;
77
+ let family = cap. name ( "family" ) . as_ref ( ) . map ( Match :: as_str) ;
78
+ let version = cap. name ( "version" ) . as_ref ( ) . map ( Match :: as_str) ;
79
+ let msg_type = cap. name ( "type" ) . as_ref ( ) . map ( Match :: as_str) ;
80
+
81
+ match ( did, family, version, msg_type) {
82
+ ( Some ( did) , Some ( family) , Some ( version) , Some ( msg_type) ) => {
83
+ Some ( MessageType {
84
+ prefix : did. to_string ( ) ,
85
+ family : MessageFamilies :: from ( family. to_string ( ) ) ,
86
+ version : version. to_string ( ) ,
87
+ msg_type : msg_type. to_string ( ) ,
88
+ } )
89
+ }
90
+ _ => {
91
+ panic ! ( "Message type regex captures, but failed to map it onto MessageType structure." )
92
+ }
93
+ }
94
+ } )
95
+ }
96
+
97
+ pub fn parse_message_type ( message_type : & str ) -> Option < MessageType > {
98
+ lazy_static ! {
99
+ static ref RE : Regex = Regex :: new( r"(?x)
100
+ (?P<prefix>.+)/ # https://didcomm.org/
101
+ (?P<family>.+)/ # connections/
102
+ (?P<version>.+)/ # 1.0/
103
+ (?P<type>.+) # request
104
+ " ) . unwrap( ) ;
105
+ }
106
+
107
+ RE . captures ( message_type)
108
+ . and_then ( |cap| {
109
+ let prefix = cap. name ( "prefix" ) . as_ref ( ) . map ( Match :: as_str) ;
110
+ let family = cap. name ( "family" ) . as_ref ( ) . map ( Match :: as_str) ;
111
+ let version = cap. name ( "version" ) . as_ref ( ) . map ( Match :: as_str) ;
112
+ let msg_type = cap. name ( "type" ) . as_ref ( ) . map ( Match :: as_str) ;
113
+
114
+ match ( prefix, family, version, msg_type) {
115
+ ( Some ( prefix) , Some ( family) , Some ( version) , Some ( msg_type) ) => {
116
+ Some ( MessageType {
117
+ prefix : prefix. to_string ( ) ,
118
+ family : MessageFamilies :: from ( family. to_string ( ) ) ,
119
+ version : version. to_string ( ) ,
120
+ msg_type : msg_type. to_string ( ) ,
121
+ } )
122
+ }
123
+ _ => {
124
+ panic ! ( "Message type regex captures, but failed to map it onto MessageType structure." )
125
+ }
126
+ }
127
+ } )
57
128
}
0 commit comments