/
solrResultJSONFacets.go
118 lines (108 loc) · 2.91 KB
/
solrResultJSONFacets.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
110
111
112
113
114
115
116
117
118
package search
import (
"fmt"
"github.com/pkg/errors"
)
type SolrResultJSONFacetBucket struct {
Count int64 `json:"count"`
Val string `json:"val"`
}
func NewSolrResultJSONFacetBucket() (*SolrResultJSONFacetBucket, error) {
return &SolrResultJSONFacetBucket{}, nil
}
func (fb *SolrResultJSONFacetBucket) Init(data interface{}) error {
eIntList, ok := data.(map[string]interface{})
if !ok {
return fmt.Errorf("invalid bucket type: %T", data)
}
for name, v := range eIntList {
switch name {
case "count":
cnt, ok := v.(float64)
if !ok {
return fmt.Errorf("wrong type for bucket field count: %T", v)
}
fb.Count = int64(cnt)
case "val":
str, ok := v.(string)
if !ok {
return fmt.Errorf("wrong type for bucket field val: %T", v)
}
fb.Val = str
default:
return fmt.Errorf("unknown bucket field: %s", name)
}
}
return nil
}
type SolrResultJSONFacetElement struct {
//Name string `json:"Name"`
Buckets []*SolrResultJSONFacetBucket `json:"buckets"`
}
func NewSolrResultJSONFacetElement() (*SolrResultJSONFacetElement, error) {
return &SolrResultJSONFacetElement{}, nil
}
func (fe *SolrResultJSONFacetElement) Init(data interface{}) error {
eIntList, ok := data.(map[string]interface{})
if !ok {
return fmt.Errorf("invalid type for data: %T", data)
}
for name, d := range eIntList {
if name != "buckets" {
return fmt.Errorf("cannot handle element field %s", name)
}
switch t := d.(type) {
case []interface{}:
for _, val := range t {
bucket, err := NewSolrResultJSONFacetBucket()
if err != nil {
return errors.Wrap(err, "cannot create new bucket")
}
if err := bucket.Init(val); err != nil {
return errors.Wrapf(err, "cannot initialize bucket with %v", val)
}
fe.Buckets = append(fe.Buckets, bucket)
}
default:
return fmt.Errorf("invalid type %T for buckets", t)
}
}
return nil
}
type SolrResultJSONFacets struct {
Count int64 `json:"count"`
Elements map[string]*SolrResultJSONFacetElement `json:"elements"`
}
func NewSolrResultJSONFacets() (*SolrResultJSONFacets, error) {
facets := &SolrResultJSONFacets{
Count: 0,
Elements: make(map[string]*SolrResultJSONFacetElement),
}
return facets, nil
}
func (fa *SolrResultJSONFacets) Init(data interface{}) error {
eIntList, ok := data.(map[string]interface{})
if !ok {
return fmt.Errorf("invalid type for data: %T", data)
}
for name, val := range eIntList {
switch t := val.(type) {
case float64:
if name != "count" {
return fmt.Errorf("invalid Name for number type: %s", name)
}
fa.Count = int64(t)
default:
if name == "count" {
return fmt.Errorf("invalid type for count: %T", t)
}
var err error
fa.Elements[name], err = NewSolrResultJSONFacetElement()
if err != nil {
return errors.Wrapf(err, "cannot parse facet element of %s", name)
}
fa.Elements[name].Init(t)
}
}
return nil
}