descriptions.go 4.31 KB
Newer Older
1
2
3
4
5
package irmago

import (
	"encoding/xml"

6
	"errors"
7
8
9
10
)

// SchemeManager describes a scheme manager.
type SchemeManager struct {
11
12
	ID                string           `xml:"Id"`
	Name              TranslatedString `xml:"Name"`
13
14
15
16
17
18
19
20
21
22
23
	URL               string           `xml:"Contact"`
	Description       TranslatedString
	KeyshareServer    string
	KeyshareWebsite   string
	KeyshareAttribute string
	XMLVersion        int      `xml:"version,attr"`
	XMLName           xml.Name `xml:"SchemeManager"`
}

// Issuer describes an issuer.
type Issuer struct {
24
25
26
27
28
29
30
31
	ID              string           `xml:"ID"`
	Name            TranslatedString `xml:"Name"`
	ShortName       TranslatedString `xml:"ShortName"`
	SchemeManagerID string           `xml:"SchemeManager"`
	ContactAddress  string
	ContactEMail    string
	URL             string `xml:"baseURL"`
	XMLVersion      int    `xml:"version,attr"`
32
33
34
35
}

// CredentialType is a description of a credential type, specifying (a.o.) its name, issuer, and attributes.
type CredentialType struct {
36
37
38
39
40
41
42
43
44
45
	ID              string           `xml:"CredentialID"`
	Name            TranslatedString `xml:"Name"`
	ShortName       TranslatedString `xml:"ShortName"`
	IssuerID        string           `xml:"IssuerID"`
	SchemeManagerID string           `xml:"SchemeManager"`
	IsSingleton     bool             `xml:"ShouldBeSingleton"`
	Description     TranslatedString
	Attributes      []AttributeDescription `xml:"Attributes>Attribute"`
	XMLVersion      int                    `xml:"version,attr"`
	XMLName         xml.Name               `xml:"IssueSpecification"`
46
47
}

48
49
// ContainsAttribute tests whether the specified attribute is contained in this
// credentialtype.
50
func (ct *CredentialType) ContainsAttribute(ai AttributeTypeIdentifier) bool {
51
	if ai.CredentialTypeIdentifier().String() != ct.Identifier().String() {
52
53
54
55
56
57
58
59
60
61
		return false
	}
	for _, desc := range ct.Attributes {
		if desc.ID == ai.Name() {
			return true
		}
	}
	return false
}

62
63
64
65
66
67
68
// AttributeDescription is a description of an attribute within a credential type.
type AttributeDescription struct {
	ID          string `xml:"id,attr"`
	Name        TranslatedString
	Description TranslatedString
}

Sietse Ringers's avatar
Sietse Ringers committed
69
70
// IndexOf returns the index of the specified attribute if present,
// or an error (and -1) if not present.
71
72
73
74
75
76
77
78
79
80
81
82
func (ct CredentialType) IndexOf(ai AttributeTypeIdentifier) (int, error) {
	if ai.CredentialTypeIdentifier() != ct.Identifier() {
		return -1, errors.New("Wrong credential type")
	}
	for i, description := range ct.Attributes {
		if description.ID == ai.Name() {
			return i, nil
		}
	}
	return -1, errors.New("Attribute identifier not found")
}

Sietse Ringers's avatar
Sietse Ringers committed
83
84
// TranslatedString is a map of translated strings.
type TranslatedString map[string]string
85

Sietse Ringers's avatar
Sietse Ringers committed
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
// UnmarshalXML unmarshals an XML tag containing a string translated to multiple languages,
// for example: <Foo><en>Hello world</en><nl>Hallo wereld</nl></Foo>
// into a TranslatedString: { "en": "Hello world" , "nl": "Hallo wereld" }
func (ts *TranslatedString) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	if map[string]string(*ts) == nil {
		*ts = TranslatedString(make(map[string]string))
	}
	temp := &struct {
		Translations []struct {
			XMLName xml.Name
			Text    string `xml:",chardata"`
		} `xml:",any"`
	}{}
	if err := d.DecodeElement(temp, &start); err != nil {
		return err
	}
	for _, translation := range temp.Translations {
		(*ts)[translation.XMLName.Local] = translation.Text
104
	}
Sietse Ringers's avatar
Sietse Ringers committed
105
	return nil
106
107
108
}

// Identifier returns the identifier of the specified credential type.
109
110
func (ct *CredentialType) Identifier() CredentialTypeIdentifier {
	return NewCredentialTypeIdentifier(ct.SchemeManagerID + "." + ct.IssuerID + "." + ct.ID)
111
112
113
}

// IssuerIdentifier returns the issuer identifier of the specified credential type.
114
115
func (ct *CredentialType) IssuerIdentifier() IssuerIdentifier {
	return NewIssuerIdentifier(ct.SchemeManagerID + "." + ct.IssuerID)
116
117
118
}

// Identifier returns the identifier of the specified issuer description.
119
120
121
122
123
124
125
func (id *Issuer) Identifier() IssuerIdentifier {
	return NewIssuerIdentifier(id.SchemeManagerID + "." + id.ID)
}

// Identifier returns the identifier of the specified scheme manager.
func (sm *SchemeManager) Identifier() SchemeManagerIdentifier {
	return NewSchemeManagerIdentifier(sm.ID)
126
127
}

128
// Distributed indicates if this scheme manager uses a keyshare server.
Sietse Ringers's avatar
Sietse Ringers committed
129
130
131
func (sm *SchemeManager) Distributed() bool {
	return len(sm.KeyshareServer) > 0
}