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 Description: result.Description,
52 },
53 RepoIndexResponse: result,
54 })
55
56 return
57}
58
59func (s *State) RepoLog(w http.ResponseWriter, r *http.Request) {
60 repoName, knot, id, err := repoKnotAndId(r)
61 if err != nil {
62 log.Println("failed to get repo and knot", err)
63 return
64 }
65
66 ref := chi.URLParam(r, "ref")
67 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/log/%s", knot, id.DID.String(), repoName, ref))
68 if err != nil {
69 log.Println("failed to reach knotserver", err)
70 return
71 }
72
73 body, err := io.ReadAll(resp.Body)
74 if err != nil {
75 log.Fatalf("Error reading response body: %v", err)
76 return
77 }
78
79 var result types.RepoLogResponse
80 err = json.Unmarshal(body, &result)
81 if err != nil {
82 log.Println("failed to parse json response", err)
83 return
84 }
85
86 s.pages.RepoLog(w, pages.RepoLogParams{
87 LoggedInUser: s.auth.GetUser(r),
88 RepoInfo: pages.RepoInfo{
89 OwnerDid: id.DID.String(),
90 OwnerHandle: id.Handle.String(),
91 Name: repoName,
92 Description: result.Description,
93 },
94 RepoLogResponse: result,
95 })
96 return
97}
98
99func (s *State) RepoCommit(w http.ResponseWriter, r *http.Request) {
100 repoName, knot, id, err := repoKnotAndId(r)
101 if err != nil {
102 log.Println("failed to get repo and knot", err)
103 return
104 }
105
106 ref := chi.URLParam(r, "ref")
107 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/commit/%s", knot, id.DID.String(), repoName, ref))
108 if err != nil {
109 log.Println("failed to reach knotserver", err)
110 return
111 }
112
113 body, err := io.ReadAll(resp.Body)
114 if err != nil {
115 log.Fatalf("Error reading response body: %v", err)
116 return
117 }
118
119 var result types.RepoCommitResponse
120 err = json.Unmarshal(body, &result)
121 if err != nil {
122 log.Println("failed to parse response:", err)
123 return
124 }
125
126 s.pages.RepoCommit(w, pages.RepoCommitParams{
127 LoggedInUser: s.auth.GetUser(r),
128 RepoInfo: pages.RepoInfo{
129 OwnerDid: id.DID.String(),
130 OwnerHandle: id.Handle.String(),
131 Name: repoName,
132 },
133 RepoCommitResponse: result,
134 })
135 return
136}
137
138func (s *State) RepoTree(w http.ResponseWriter, r *http.Request) {
139 repoName, knot, id, err := repoKnotAndId(r)
140 if err != nil {
141 log.Println("failed to get repo and knot", err)
142 return
143 }
144
145 ref := chi.URLParam(r, "ref")
146 treePath := chi.URLParam(r, "*")
147 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/tree/%s/%s", knot, id.DID.String(), repoName, ref, treePath))
148 if err != nil {
149 log.Println("failed to reach knotserver", err)
150 return
151 }
152
153 body, err := io.ReadAll(resp.Body)
154 if err != nil {
155 log.Fatalf("Error reading response body: %v", err)
156 return
157 }
158
159 var result types.RepoTreeResponse
160 err = json.Unmarshal(body, &result)
161 if err != nil {
162 log.Println("failed to parse response:", err)
163 return
164 }
165
166 log.Println(result)
167
168 s.pages.RepoTree(w, pages.RepoTreeParams{
169 LoggedInUser: s.auth.GetUser(r),
170 RepoInfo: pages.RepoInfo{
171 OwnerDid: id.DID.String(),
172 OwnerHandle: id.Handle.String(),
173 Name: repoName,
174 Description: result.Description,
175 },
176 RepoTreeResponse: result,
177 })
178 return
179}
180
181func (s *State) RepoTags(w http.ResponseWriter, r *http.Request) {
182 repoName, knot, id, err := repoKnotAndId(r)
183 if err != nil {
184 log.Println("failed to get repo and knot", err)
185 return
186 }
187
188 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/tags", knot, id.DID.String(), repoName))
189 if err != nil {
190 log.Println("failed to reach knotserver", err)
191 return
192 }
193
194 body, err := io.ReadAll(resp.Body)
195 if err != nil {
196 log.Fatalf("Error reading response body: %v", err)
197 return
198 }
199
200 var result types.RepoTagsResponse
201 err = json.Unmarshal(body, &result)
202 if err != nil {
203 log.Println("failed to parse response:", err)
204 return
205 }
206
207 s.pages.RepoTags(w, pages.RepoTagsParams{
208 LoggedInUser: s.auth.GetUser(r),
209 RepoInfo: pages.RepoInfo{
210 OwnerDid: id.DID.String(),
211 OwnerHandle: id.Handle.String(),
212 Name: repoName,
213 },
214 RepoTagsResponse: result,
215 })
216 return
217}
218
219func (s *State) RepoBranches(w http.ResponseWriter, r *http.Request) {
220 repoName, knot, id, err := repoKnotAndId(r)
221 if err != nil {
222 log.Println("failed to get repo and knot", err)
223 return
224 }
225
226 resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/branches", knot, id.DID.String(), repoName))
227 if err != nil {
228 log.Println("failed to reach knotserver", err)
229 return
230 }
231
232 body, err := io.ReadAll(resp.Body)
233 if err != nil {
234 log.Fatalf("Error reading response body: %v", err)
235 return
236 }
237
238 var result types.RepoBranchesResponse
239 err = json.Unmarshal(body, &result)
240 if err != nil {
241 log.Println("failed to parse response:", err)
242 return
243 }
244
245 s.pages.RepoBranches(w, pages.RepoBranchesParams{
246 LoggedInUser: s.auth.GetUser(r),
247 RepoInfo: pages.RepoInfo{
248 OwnerDid: id.DID.String(),
249 OwnerHandle: id.Handle.String(),
250 Name: repoName,
251 },
252 RepoBranchesResponse: result,
253 })
254 return
255}
256
257func repoKnotAndId(r *http.Request) (string, string, identity.Identity, error) {
258 repoName := chi.URLParam(r, "repo")
259 knot, ok := r.Context().Value("knot").(string)
260 if !ok {
261 log.Println("malformed middleware")
262 return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")
263 }
264 id, ok := r.Context().Value("resolvedId").(identity.Identity)
265 if !ok {
266 log.Println("malformed middleware")
267 return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")
268 }
269
270 return repoName, knot, id, nil
271}