-
Notifications
You must be signed in to change notification settings - Fork 0
/
retrieval.go
140 lines (117 loc) · 3.55 KB
/
retrieval.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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package rethink
import (
"math/rand"
r "gopkg.in/gorethink/gorethink.v4"
)
// RetrievalResult is a specific type of error object used for tracking
// the result of a database retrieval operation
type RetrievalResult struct {
Success bool
SoftDeleted bool
Message string
}
func (rr RetrievalResult) Error() string {
return rr.Message
}
// GetSingle returns a single object from the current table via a filter key
func (c *Connection) GetSingle(filter map[string]interface{}, table string) (interface{}, error) {
res, err := r.Table(table).Filter(filter).Run(c.Session)
if err != nil {
return nil, err
}
var response interface{}
res.One(&response)
if response == nil {
return response, nil
}
// Probably want retrieval logic to be pure and not deal with any of these
// checks
// if response.(map[string]interface{})["deletedAt"].(float64) != 0 {
// // Don't include anything that has a non-zero deletedAt (soft deleted)
// return response, RetrievalResult{true, true, "Requested object is soft-deleted"}
// }
return response, nil
}
// GetByUUID returns a single object from the current table via the uuid
func (c *Connection) GetByUUID(uuid string, table string) (interface{}, error) {
res, err := r.Table(table).Get(uuid).Run(c.Session)
defer res.Close()
if err != nil {
return nil, err
}
var response interface{}
res.One(&response)
if response.(map[string]interface{})["deletedAt"].(float64) != 0 {
// Don't include anything that has a non-zero deletedAt (soft deleted)
return response, RetrievalResult{true, true, "Requested UUID is soft-deleted"}
}
return response, nil
}
// GetAll returns all the record in a table, a wrapper around GetMultiple
func (c *Connection) GetAll(table string) ([]interface{}, error) {
response, err := c.GetMultiple(table, 0) // 0 means all
if err != nil {
return nil, err
}
return response, nil
}
// GetMultiple returns multiple records from a table
func (c *Connection) GetMultiple(table string, limit int) ([]interface{}, error) {
query := r.Table(table)
if limit > 0 {
query = r.Table(table).Limit(limit)
}
res, err := query.Run(c.Session)
defer res.Close()
if err != nil {
return nil, err
}
var fromDB []interface{}
var response []interface{}
res.All(&fromDB)
for _, val := range fromDB {
if val.(map[string]interface{})["deletedAt"].(float64) != 0 {
// Don't include anything that has a non-zero deletedAt (soft deleted)
continue
}
response = append(response, val)
}
return response, nil
}
// GetByFilter is like GetMultiple, except it has the ability to filter the results first
func (c *Connection) GetByFilter(table string, filter map[string]interface{}, limit int) ([]interface{}, error) {
query := r.Table(table)
if len(filter) > 0 {
query = query.Filter(filter)
}
if limit > 0 {
query = query.Limit(limit)
}
res, err := query.Run(c.Session)
defer res.Close()
if err != nil {
return nil, err
}
var fromDB []interface{}
var response []interface{}
res.All(&fromDB)
for _, val := range fromDB {
if val.(map[string]interface{})["deletedAt"].(float64) != 0 {
// Don't include anything that has a non-zero deletedAt (soft deleted)
continue
}
response = append(response, val)
}
return response, nil
}
// GetRandom retrieves a single random record from the table given the filter
func (c *Connection) GetRandom(table string, filter map[string]interface{}) (interface{}, error) {
response, err := c.GetByFilter(table, filter, 0)
if err != nil {
return nil, err
}
if len(response) == 0 {
return nil, nil
}
return response[rand.Intn(len(response))], nil
}