Repository navigation
Expand file tree
/
Copy pathemulator.go
More file actions
124 lines (103 loc) · 2.93 KB
/
Copy pathemulator.go
File metadata and controls
124 lines (103 loc) · 2.93 KB
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
package main
import (
"net/http"
"strings"
"sync"
)
type gateway struct {
PhoneNumber string
PhoneAPIKey string
PhoneID string
}
type notificationRecord struct {
GatewayID string `json:"gateway_id"`
Data map[string]string `json:"data"`
MessageID string `json:"message_id,omitempty"`
Kind string `json:"kind"`
Processed bool `json:"processed"`
Error string `json:"error,omitempty"`
Authorization string `json:"authorization,omitempty"`
}
type emulator struct {
apiBaseURL string
client *http.Client
mu sync.RWMutex
gateways map[string]gateway
records []*notificationRecord
}
func newEmulator(apiBaseURL string, client *http.Client) *emulator {
return &emulator{
apiBaseURL: strings.TrimRight(apiBaseURL, "/"),
client: client,
gateways: make(map[string]gateway),
}
}
func (instance *emulator) registerGateway(gatewayID string, registration gatewayRegistration) {
instance.mu.Lock()
defer instance.mu.Unlock()
instance.gateways[gatewayID] = gateway{
PhoneNumber: registration.PhoneNumber,
PhoneAPIKey: registration.PhoneAPIKey,
PhoneID: registration.PhoneID,
}
}
func (instance *emulator) loadGateway(gatewayID string) (gateway, bool) {
instance.mu.RLock()
defer instance.mu.RUnlock()
registeredGateway, ok := instance.gateways[gatewayID]
return registeredGateway, ok
}
func (instance *emulator) recordNotification(
gatewayID string,
data map[string]string,
kind string,
messageID string,
authorization string,
) *notificationRecord {
instance.mu.Lock()
defer instance.mu.Unlock()
record := ¬ificationRecord{
GatewayID: gatewayID,
Data: copyStringMap(data),
MessageID: messageID,
Kind: kind,
Authorization: authorization,
}
instance.records = append(instance.records, record)
return record
}
func (instance *emulator) markNotificationProcessed(record *notificationRecord) {
instance.mu.Lock()
defer instance.mu.Unlock()
record.Processed = true
record.Error = ""
}
func (instance *emulator) markNotificationFailed(record *notificationRecord, err error) {
instance.mu.Lock()
defer instance.mu.Unlock()
record.Processed = false
record.Error = err.Error()
}
func (instance *emulator) listGatewayRecords(gatewayID string) []notificationRecord {
instance.mu.RLock()
defer instance.mu.RUnlock()
records := make([]notificationRecord, 0)
for _, record := range instance.records {
if record.GatewayID == gatewayID {
records = append(records, *copyNotificationRecord(record))
}
}
return records
}
func copyNotificationRecord(record *notificationRecord) *notificationRecord {
copied := *record
copied.Data = copyStringMap(record.Data)
return &copied
}
func copyStringMap(values map[string]string) map[string]string {
copied := make(map[string]string, len(values))
for key, value := range values {
copied[key] = value
}
return copied
}