Debian Codegraph @

examples/resource/resource_user.go

raw
1 package resource
2
3 import (
4 "errors"
5 "net/http"
6 "sort"
7 "strconv"
8
9 "github.com/manyminds/api2go"
10 "github.com/manyminds/api2go/examples/model"
11 "github.com/manyminds/api2go/examples/storage"
12 )
13
14 // UserResource for api2go routes
15 type UserResource struct {
16 ChocStorage *storage.ChocolateStorage
17 UserStorage *storage.UserStorage
18 }
19
20 // FindAll to satisfy api2go data source interface
21 func (s UserResource) FindAll(r api2go.Request) (api2go.Responder, error) {
22 var result []model.User
23 users := s.UserStorage.GetAll()
24
25 for _, user := range users {
26 // get all sweets for the user
27 user.Chocolates = []*model.Chocolate{}
28 for _, chocolateID := range user.ChocolatesIDs {
29 choc, err := s.ChocStorage.GetOne(chocolateID)
30 if err != nil {
31 return &Response{}, err
32 }
33 user.Chocolates = append(user.Chocolates, &choc)
34 }
35 result = append(result, *user)
36 }
37
38 return &Response{Res: result}, nil
39 }
40
41 // PaginatedFindAll can be used to load users in chunks
42 func (s UserResource) PaginatedFindAll(r api2go.Request) (uint, api2go.Responder, error) {
43 var (
44 result []model.User
45 number, size, offset, limit string
46 keys []int
47 )
48 users := s.UserStorage.GetAll()
49
50 for k := range users {
51 i, err := strconv.ParseInt(k, 10, 64)
52 if err != nil {
53 return 0, &Response{}, err
54 }
55
56 keys = append(keys, int(i))
57 }
58 sort.Ints(keys)
59
60 numberQuery, ok := r.QueryParams["page[number]"]
61 if ok {
62 number = numberQuery[0]
63 }
64 sizeQuery, ok := r.QueryParams["page[size]"]
65 if ok {
66 size = sizeQuery[0]
67 }
68 offsetQuery, ok := r.QueryParams["page[offset]"]
69 if ok {
70 offset = offsetQuery[0]
71 }
72 limitQuery, ok := r.QueryParams["page[limit]"]
73 if ok {
74 limit = limitQuery[0]
75 }
76
77 if size != "" {
78 sizeI, err := strconv.ParseUint(size, 10, 64)
79 if err != nil {
80 return 0, &Response{}, err
81 }
82
83 numberI, err := strconv.ParseUint(number, 10, 64)
84 if err != nil {
85 return 0, &Response{}, err
86 }
87
88 start := sizeI * (numberI - 1)
89 for i := start; i < start+sizeI; i++ {
90 if i >= uint64(len(users)) {
91 break
92 }
93 result = append(result, *users[strconv.FormatInt(int64(keys[i]), 10)])
94 }
95 } else {
96 limitI, err := strconv.ParseUint(limit, 10, 64)
97 if err != nil {
98 return 0, &Response{}, err
99 }
100
101 offsetI, err := strconv.ParseUint(offset, 10, 64)
102 if err != nil {
103 return 0, &Response{}, err
104 }
105
106 for i := offsetI; i < offsetI+limitI; i++ {
107 if i >= uint64(len(users)) {
108 break
109 }
110 result = append(result, *users[strconv.FormatInt(int64(keys[i]), 10)])
111 }
112 }
113
114 return uint(len(users)), &Response{Res: result}, nil
115 }
116
117 // FindOne to satisfy `api2go.DataSource` interface
118 // this method should return the user with the given ID, otherwise an error
119 func (s UserResource) FindOne(ID string, r api2go.Request) (api2go.Responder, error) {
120 user, err := s.UserStorage.GetOne(ID)
121 if err != nil {
122 return &Response{}, api2go.NewHTTPError(err, err.Error(), http.StatusNotFound)
123 }
124
125 user.Chocolates = []*model.Chocolate{}
126 for _, chocolateID := range user.ChocolatesIDs {
127 choc, err := s.ChocStorage.GetOne(chocolateID)
128 if err != nil {
129 return &Response{}, err
130 }
131 user.Chocolates = append(user.Chocolates, &choc)
132 }
133 return &Response{Res: user}, nil
134 }
135
136 // Create method to satisfy `api2go.DataSource` interface
137 func (s UserResource) Create(obj interface{}, r api2go.Request) (api2go.Responder, error) {
138 user, ok := obj.(model.User)
139 if !ok {
140 return &Response{}, api2go.NewHTTPError(errors.New("Invalid instance given"), "Invalid instance given", http.StatusBadRequest)
141 }
142
143 id := s.UserStorage.Insert(user)
144 user.ID = id
145
146 return &Response{Res: user, Code: http.StatusCreated}, nil
147 }
148
149 // Delete to satisfy `api2go.DataSource` interface
150 func (s UserResource) Delete(id string, r api2go.Request) (api2go.Responder, error) {
151 err := s.UserStorage.Delete(id)
152 return &Response{Code: http.StatusNoContent}, err
153 }
154
155 //Update stores all changes on the user
156 func (s UserResource) Update(obj interface{}, r api2go.Request) (api2go.Responder, error) {
157 user, ok := obj.(model.User)
158 if !ok {
159 return &Response{}, api2go.NewHTTPError(errors.New("Invalid instance given"), "Invalid instance given", http.StatusBadRequest)
160 }
161
162 err := s.UserStorage.Update(user)
163 return &Response{Res: user, Code: http.StatusNoContent}, err
164 }