1 package authservice
2
3 import (
4 "encoding/json"
5 "errors"
6 "strings"
7
8 "edge-infra.dev/pkg/sds/emergencyaccess/eaconst"
9 )
10
11 type userError struct {
12 err error
13 userErr string
14 }
15
16 func (err userError) Error() string {
17 return err.err.Error()
18 }
19
20 func (err userError) userError() string {
21 return err.userErr
22 }
23
24 type ValidationError []userError
25
26 func (myerr ValidationError) Error() string {
27 var msg []string
28 for _, err := range myerr {
29 msg = append(msg, err.Error())
30 }
31 return strings.Join(msg, ", ")
32 }
33
34 func (myerr ValidationError) UserError() []string {
35 var msg []string
36 for _, err := range myerr {
37 msg = append(msg, err.userError())
38 }
39 return msg
40 }
41
42
43 type RulesEngineCommand struct {
44 Name string `json:"name"`
45 Type eaconst.RequestType `json:"type"`
46 }
47
48 type RulesEnginePayload struct {
49 Identity identity `json:"identity"`
50 Command RulesEngineCommand `json:"command"`
51 Target Target `json:"target"`
52 }
53
54 type CommandAuthPayload struct {
55 Command string `json:"command"`
56 Target Target `json:"target"`
57 AuthDetails AuthDetails `json:"authDetails"`
58 }
59
60 func (ca CommandAuthPayload) Validate() error {
61 errs := ValidationError{}
62 if len(ca.Command) == 0 {
63 errs = append(errs, userError{
64 errors.New("command was nil"),
65 "Payload missing command"})
66 }
67 if len(ca.Target.BannerID) == 0 {
68 errs = append(errs, userError{
69 errors.New("banner id was nil"),
70 "Payload missing banner ID"})
71 }
72 if len(errs) != 0 {
73 return errs
74 }
75 return nil
76 }
77
78 type AuthorizeRequestPayload struct {
79 Request Request `json:"request"`
80 Target Target `json:"target"`
81 }
82
83 func (arp AuthorizeRequestPayload) Validate() error {
84 errs := ValidationError{}
85 if _, err := json.Marshal(arp.Request.Data); err != nil {
86 errs = append(errs, userError{
87 errors.New("request data could not be marshaled"),
88 "Payload has invalid request data"})
89 } else if arp.Request.Data == nil {
90 errs = append(errs, userError{
91 errors.New("request data is nil"),
92 "Payload has invalid request data"})
93 }
94 if tErr := arp.Target.Validate(); tErr != nil {
95 errs = append(errs, userError{tErr,
96 "Payload has invalid target"})
97 }
98 if len(errs) != 0 {
99 return errs
100 }
101 return nil
102 }
103
104 type AuthorizeTargetPayload struct {
105 Target Target `json:"target"`
106 }
107
108 func (atp AuthorizeTargetPayload) Validate() error {
109 return atp.Target.Validate()
110 }
111
112 type ResolveTargetPayload struct {
113 Target Target `json:"target"`
114 }
115
116 func (tap ResolveTargetPayload) Validate() error {
117 return tap.Target.Validate()
118 }
119
120 type Target struct {
121 ProjectID string `json:"projectid,omitempty"`
122 BannerID string `json:"bannerid"`
123 StoreID string `json:"storeid,omitempty"`
124 TerminalID string `json:"terminalid,omitempty"`
125 }
126
127 func (tgt Target) Validate() error {
128 errs := ValidationError{}
129 if tgt.BannerID == "" {
130 errs = append(errs, userError{
131 errors.New("banner id was nil"),
132 "Payload missing banner ID"})
133 }
134 if tgt.StoreID == "" {
135 errs = append(errs, userError{
136 errors.New("store id was nil"),
137 "Payload missing store ID"})
138 }
139 if tgt.TerminalID == "" {
140 errs = append(errs, userError{
141 errors.New("terminal id was nil"),
142 "Payload missing terminal ID"})
143 }
144 if len(errs) != 0 {
145 return errs
146 }
147 return nil
148 }
149
150 type AuthDetails struct {
151 DarkMode bool `json:"darkmode"`
152 }
153
154 type identity struct {
155 UserID string `json:"userid"`
156 EAroles []string `json:"earoles"`
157 }
158
159 type Request struct {
160 Data json.RawMessage `json:"data"`
161 Attributes map[string]string `json:"attributes"`
162 }
163
164 type Response struct {
165 Valid bool `json:"valid"`
166 }
167
View as plain text