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 repoKnotAndId(r *http.Request) (string, string, identity.Identity, error) {
179 repoName := chi.URLParam(r, "repo")
180 knot, ok := r.Context().Value("knot").(string)
181 if !ok {
182 log.Println("malformed middleware")
183 return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")
184 }
185 id, ok := r.Context().Value("resolvedId").(identity.Identity)
186 if !ok {
187 log.Println("malformed middleware")
188 return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")
189 }
190
191 return repoName, knot, id, nil
192}