this repo has no description
tangled.org
1package state
2
3import (
4 "encoding/json"
5 "fmt"
6 "io"
7 "log"
8 "net/http"
9
10 "github.com/bluesky-social/indigo/atproto/identity"
11 "github.com/go-chi/chi/v5"
12 "github.com/sotangled/tangled/appview/pages"
13 "github.com/sotangled/tangled/types"
14)
15
16func (s *State) RepoIndex(w http.ResponseWriter, r *http.Request) {
17 repoName, knot, id, err := repoKnotAndId(r)
18 if err != nil {
19 log.Println("failed to get repo and knot", err)
20 return
21 }
22
23 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s", knot, id.DID.String(), repoName))
24 if err != nil {
25 log.Println("failed to reach knotserver", err)
26 return
27 }
28 defer resp.Body.Close()
29
30 body, err := io.ReadAll(resp.Body)
31 if err != nil {
32 log.Fatalf("Error reading response body: %v", err)
33 return
34 }
35
36 var result types.RepoIndexResponse
37 err = json.Unmarshal(body, &result)
38 if err != nil {
39 log.Fatalf("Error unmarshalling response body: %v", err)
40 return
41 }
42
43 log.Println(resp.Status, result)
44
45 s.pages.RepoIndexPage(w, pages.RepoIndexParams{
46 LoggedInUser: s.auth.GetUser(r),
47 RepoInfo: pages.RepoInfo{
48 OwnerDid: id.DID.String(),
49 OwnerHandle: id.Handle.String(),
50 Name: repoName,
51 },
52 RepoIndexResponse: result,
53 })
54
55 return
56}
57
58func (s *State) RepoLog(w http.ResponseWriter, r *http.Request) {
59 repoName, knot, id, err := repoKnotAndId(r)
60 if err != nil {
61 log.Println("failed to get repo and knot", err)
62 return
63 }
64
65 ref := chi.URLParam(r, "ref")
66 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/log/%s", knot, id.DID.String(), repoName, ref))
67 if err != nil {
68 log.Println("failed to reach knotserver", err)
69 return
70 }
71
72 body, err := io.ReadAll(resp.Body)
73 if err != nil {
74 log.Fatalf("Error reading response body: %v", err)
75 return
76 }
77
78 var result types.RepoLogResponse
79 err = json.Unmarshal(body, &result)
80 if err != nil {
81 log.Println("failed to parse json response", err)
82 return
83 }
84
85 s.pages.RepoLog(w, pages.RepoLogParams{
86 LoggedInUser: s.auth.GetUser(r),
87 RepoInfo: pages.RepoInfo{
88 OwnerDid: id.DID.String(),
89 OwnerHandle: id.Handle.String(),
90 Name: repoName,
91 },
92 RepoLogResponse: result,
93 })
94 return
95}
96
97func (s *State) RepoCommit(w http.ResponseWriter, r *http.Request) {
98 repoName, knot, id, err := repoKnotAndId(r)
99 if err != nil {
100 log.Println("failed to get repo and knot", err)
101 return
102 }
103
104 ref := chi.URLParam(r, "ref")
105 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/commit/%s", knot, id.DID.String(), repoName, ref))
106 if err != nil {
107 log.Println("failed to reach knotserver", err)
108 return
109 }
110
111 body, err := io.ReadAll(resp.Body)
112 if err != nil {
113 log.Fatalf("Error reading response body: %v", err)
114 return
115 }
116
117 var result types.RepoCommitResponse
118 err = json.Unmarshal(body, &result)
119 if err != nil {
120 log.Println("failed to parse response:", err)
121 return
122 }
123
124 s.pages.RepoCommit(w, pages.RepoCommitParams{
125 LoggedInUser: s.auth.GetUser(r),
126 RepoInfo: pages.RepoInfo{
127 OwnerDid: id.DID.String(),
128 OwnerHandle: id.Handle.String(),
129 Name: repoName,
130 },
131 RepoCommitResponse: result,
132 })
133 return
134}
135
136func (s *State) RepoTree(w http.ResponseWriter, r *http.Request) {
137 repoName, knot, id, err := repoKnotAndId(r)
138 if err != nil {
139 log.Println("failed to get repo and knot", err)
140 return
141 }
142
143 ref := chi.URLParam(r, "ref")
144 treePath := chi.URLParam(r, "*")
145 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/tree/%s/%s", knot, id.DID.String(), repoName, ref, treePath))
146 if err != nil {
147 log.Println("failed to reach knotserver", err)
148 return
149 }
150
151 body, err := io.ReadAll(resp.Body)
152 if err != nil {
153 log.Fatalf("Error reading response body: %v", err)
154 return
155 }
156
157 var result types.RepoTreeResponse
158 err = json.Unmarshal(body, &result)
159 if err != nil {
160 log.Println("failed to parse response:", err)
161 return
162 }
163
164 log.Println(result)
165
166 s.pages.RepoTree(w, pages.RepoTreeParams{
167 LoggedInUser: s.auth.GetUser(r),
168 RepoInfo: pages.RepoInfo{
169 OwnerDid: id.DID.String(),
170 OwnerHandle: id.Handle.String(),
171 Name: repoName,
172 },
173 RepoTreeResponse: result,
174 })
175 return
176}
177
178func (s *State) RepoTags(w http.ResponseWriter, r *http.Request) {
179 repoName, knot, id, err := repoKnotAndId(r)
180 if err != nil {
181 log.Println("failed to get repo and knot", err)
182 return
183 }
184
185 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/tags", knot, id.DID.String(), repoName))
186 if err != nil {
187 log.Println("failed to reach knotserver", err)
188 return
189 }
190
191 body, err := io.ReadAll(resp.Body)
192 if err != nil {
193 log.Fatalf("Error reading response body: %v", err)
194 return
195 }
196
197 var result types.RepoTagsResponse
198 err = json.Unmarshal(body, &result)
199 if err != nil {
200 log.Println("failed to parse response:", err)
201 return
202 }
203
204 s.pages.RepoTags(w, pages.RepoTagsParams{
205 LoggedInUser: s.auth.GetUser(r),
206 RepoInfo: pages.RepoInfo{
207 OwnerDid: id.DID.String(),
208 OwnerHandle: id.Handle.String(),
209 Name: repoName,
210 },
211 RepoTagsResponse: result,
212 })
213 return
214}
215
216func (s *State) RepoBranches(w http.ResponseWriter, r *http.Request) {
217 repoName, knot, id, err := repoKnotAndId(r)
218 if err != nil {
219 log.Println("failed to get repo and knot", err)
220 return
221 }
222
223 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/branches", knot, id.DID.String(), repoName))
224 if err != nil {
225 log.Println("failed to reach knotserver", err)
226 return
227 }
228
229 body, err := io.ReadAll(resp.Body)
230 if err != nil {
231 log.Fatalf("Error reading response body: %v", err)
232 return
233 }
234
235 var result types.RepoBranchesResponse
236 err = json.Unmarshal(body, &result)
237 if err != nil {
238 log.Println("failed to parse response:", err)
239 return
240 }
241
242 s.pages.RepoBranches(w, pages.RepoBranchesParams{
243 LoggedInUser: s.auth.GetUser(r),
244 RepoInfo: pages.RepoInfo{
245 OwnerDid: id.DID.String(),
246 OwnerHandle: id.Handle.String(),
247 Name: repoName,
248 },
249 RepoBranchesResponse: result,
250 })
251 return
252}
253
254func (s *State) RepoBlob(w http.ResponseWriter, r *http.Request) {
255 repoName, knot, id, err := repoKnotAndId(r)
256 if err != nil {
257 log.Println("failed to get repo and knot", err)
258 return
259 }
260
261 ref := chi.URLParam(r, "ref")
262 filePath := chi.URLParam(r, "*")
263 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/blob/%s/%s", knot, id.DID.String(), repoName, ref, filePath))
264 if err != nil {
265 log.Println("failed to reach knotserver", err)
266 return
267 }
268
269 body, err := io.ReadAll(resp.Body)
270 if err != nil {
271 log.Fatalf("Error reading response body: %v", err)
272 return
273 }
274
275 var result types.RepoBlobResponse
276 err = json.Unmarshal(body, &result)
277 if err != nil {
278 log.Println("failed to parse response:", err)
279 return
280 }
281
282 s.pages.RepoBlob(w, pages.RepoBlobParams{
283 LoggedInUser: s.auth.GetUser(r),
284 RepoInfo: pages.RepoInfo{
285 OwnerDid: id.DID.String(),
286 OwnerHandle: id.Handle.String(),
287 Name: repoName,
288 },
289 RepoBlobResponse: result,
290 })
291 return
292}
293
294func repoKnotAndId(r *http.Request) (string, string, identity.Identity, error) {
295 repoName := chi.URLParam(r, "repo")
296 knot, ok := r.Context().Value("knot").(string)
297 if !ok {
298 log.Println("malformed middleware")
299 return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")
300 }
301 id, ok := r.Context().Value("resolvedId").(identity.Identity)
302 if !ok {
303 log.Println("malformed middleware")
304 return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")
305 }
306
307 return repoName, knot, id, nil
308}