/
sneakerReferencePipeHTTP.go
109 lines (94 loc) · 2.85 KB
/
sneakerReferencePipeHTTP.go
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
package REST
import (
"fmt"
"net/url"
"path"
"strconv"
"strings"
"github.com/fatih/structs"
"go.kicksware.com/api/service-common/api/rest"
"go.kicksware.com/api/service-common/config"
"go.kicksware.com/api/service-common/core"
"go.kicksware.com/api/reference-service/core/model"
"go.kicksware.com/api/service-common/core/meta"
"go.kicksware.com/api/search-service/core/pipe"
)
type referencePipe struct {
config config.CommonConfig
communicator core.InnerCommunicator
fetchResource string
}
func NewSneakerReferencePipe(auth core.AuthService, config config.CommonConfig) pipe.SneakerReferencePipe {
return &referencePipe{
config,
rest.NewCommunicator(auth, config),
"sneaker/references",
}
}
func (p *referencePipe) FetchOne(code string) (ref *model.SneakerReference, err error) {
err = p.communicator.GetMessage(p.requestEndpoint(code), ref)
return
}
func (p *referencePipe) Fetch(codes []string, params *meta.RequestParams) (refs []*model.SneakerReference, err error) {
values := url.Values{}
for _, code := range codes {
values.Add("referenceId", code)
}
if paramValues := requestParamValues(params); paramValues != nil && len(paramValues) != 0 {
for key, param := range paramValues {
values.Add(key, param[0])
}
}
err = p.communicator.GetMessage(p.requestEndpoint("?", values.Encode()), &refs)
return
}
func (p *referencePipe) FetchAll(params *meta.RequestParams) (refs []*model.SneakerReference, err error) {
if paramValues := requestParamValues(params); paramValues != nil && len(paramValues) != 0 {
err = p.communicator.GetMessage(p.requestEndpoint("?", paramValues.Encode()), &refs)
return
}
err = p.communicator.GetMessage(p.requestEndpoint(), &refs)
return
}
func (p *referencePipe) FetchQuery(query meta.RequestQuery, params *meta.RequestParams) (refs []*model.SneakerReference, err error) {
resource := p.requestEndpoint("query")
if paramValues := requestParamValues(params); paramValues != nil && len(paramValues) != 0 {
resource = p.requestEndpoint("query", "?", paramValues.Encode())
}
err = p.communicator.PostMessage(resource, query, &refs)
return
}
func (p *referencePipe) requestEndpoint(res ...string) string {
return path.Join(p.fetchResource, strings.Join(res, ""))
}
func requestParamValues(params *meta.RequestParams) url.Values {
if params == nil {
return nil
}
values := url.Values{}
properties := structs.Map(params)
for prop := range properties {
val := properties[prop]
switch v := val.(type) {
case nil:
continue
case string:
if v != "" {
values.Add("referenceId", v)
}
case int:
if v != 0 {
values.Add("referenceId", strconv.Itoa(v))
}
case float32, float64:
if v != 0 {
values.Add("referenceId", fmt.Sprint(v))
}
case bool:
values.Add("referenceId", strconv.FormatBool(v))
default:
values.Add("referenceId", fmt.Sprint(v))
}
}
return values
}