/
get.go
115 lines (102 loc) · 2.44 KB
/
get.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
package watchers
import (
"encoding/json"
"github.com/jawr/dns/database/connection"
"github.com/jawr/dns/database/models/domains"
"github.com/jawr/dns/database/models/users"
"github.com/jawr/dns/database/models/watchers/intervals"
)
const (
SELECT string = "SELECT * FROM watcher "
)
type Result struct {
One func() (Watcher, error)
List func() ([]Watcher, error)
}
func newResult(query string, args ...interface{}) Result {
return Result{
func() (Watcher, error) {
return Get(query, args...)
},
func() ([]Watcher, error) {
return GetList(query, args...)
},
}
}
func GetAll() Result {
return newResult(SELECT)
}
func GetByUser(user users.User) Result {
return newResult(SELECT+"WHERE users@> '[$1]'", user.ID)
}
func GetByID(id int32) Result {
return newResult(SELECT+"WHERE id = $1", id)
}
func GetByInterval(interval intervals.Interval) Result {
return newResult(SELECT+"WHERE interval = $1", interval.ID)
}
func GetByDomainUUID(uuid string) Result {
return newResult(SELECT+"WHERE domain = $1", uuid)
}
func GetByDomain(domain domains.Domain) Result {
return GetByDomainUUID(domain.UUID.String())
}
func parseRow(row connection.Row) (Watcher, error) {
w := Watcher{}
var intervalID int32
var uuid string
var usersBuf, logs []byte
err := row.Scan(&w.ID, &uuid, &w.Added, &w.Updated, &intervalID, &logs, &usersBuf)
err = json.Unmarshal(logs, &w.Logs)
if err != nil {
return w, err
}
var usersArr []int
err = json.Unmarshal(usersBuf, &usersArr)
if err != nil {
return w, err
}
for _, u := range usersArr {
user, err := users.GetByID(u).One()
if err != nil {
continue
}
w.Users = append(w.Users, user)
}
w.Domain, err = domains.GetByUUID(uuid).One()
if err != nil {
return w, err
}
w.Interval, err = intervals.GetByID(intervalID).One()
return w, err
}
func Get(query string, args ...interface{}) (Watcher, error) {
var result Watcher
conn, err := connection.Get()
if err != nil {
return Watcher{}, err
}
row := conn.QueryRow(query, args...)
result, err = parseRow(row)
return result, err
}
func GetList(query string, args ...interface{}) ([]Watcher, error) {
conn, err := connection.Get()
if err != nil {
return []Watcher{}, err
}
rows, err := conn.Query(query, args...)
defer rows.Close()
if err != nil {
return []Watcher{}, err
}
var list []Watcher
for rows.Next() {
rt, err := parseRow(rows)
if err != nil {
return list, err
}
list = append(list, rt)
}
return list, rows.Err()
}