oppi.li
Signed-off-by: oppiliappan me@oppi.li
+1
-10
knotserver/xrpc/list_keys.go
+1
-10
knotserver/xrpc/list_keys.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
"strconv"
7
6
···
46
45
response.Cursor = &nextCursor
47
46
}
48
47
49
-
w.Header().Set("Content-Type", "application/json")
50
-
if err := json.NewEncoder(w).Encode(response); err != nil {
51
-
x.Logger.Error("failed to encode response", "error", err)
52
-
writeError(w, xrpcerr.NewXrpcError(
53
-
xrpcerr.WithTag("InternalServerError"),
54
-
xrpcerr.WithMessage("failed to encode response"),
55
-
), http.StatusInternalServerError)
56
-
return
57
-
}
48
+
writeJson(w, response)
58
49
}
+1
-10
knotserver/xrpc/owner.go
+1
-10
knotserver/xrpc/owner.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
7
6
"tangled.sh/tangled.sh/core/api/tangled"
···
19
18
Owner: owner,
20
19
}
21
20
22
-
w.Header().Set("Content-Type", "application/json")
23
-
if err := json.NewEncoder(w).Encode(response); err != nil {
24
-
x.Logger.Error("failed to encode response", "error", err)
25
-
writeError(w, xrpcerr.NewXrpcError(
26
-
xrpcerr.WithTag("InternalServerError"),
27
-
xrpcerr.WithMessage("failed to encode response"),
28
-
), http.StatusInternalServerError)
29
-
return
30
-
}
21
+
writeJson(w, response)
31
22
}
+1
-10
knotserver/xrpc/repo_blob.go
+1
-10
knotserver/xrpc/repo_blob.go
···
3
3
import (
4
4
"crypto/sha256"
5
5
"encoding/base64"
6
-
"encoding/json"
7
6
"fmt"
8
7
"net/http"
9
8
"path/filepath"
···
124
123
response.MimeType = &mimeType
125
124
}
126
125
127
-
w.Header().Set("Content-Type", "application/json")
128
-
if err := json.NewEncoder(w).Encode(response); err != nil {
129
-
x.Logger.Error("failed to encode response", "error", err)
130
-
writeError(w, xrpcerr.NewXrpcError(
131
-
xrpcerr.WithTag("InternalServerError"),
132
-
xrpcerr.WithMessage("failed to encode response"),
133
-
), http.StatusInternalServerError)
134
-
return
135
-
}
126
+
writeJson(w, response)
136
127
}
137
128
138
129
// isTextualMimeType returns true if the MIME type represents textual content
+1
-10
knotserver/xrpc/repo_branch.go
+1
-10
knotserver/xrpc/repo_branch.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
"net/url"
7
6
"time"
···
82
81
When: commit.Author.When.Format(time.RFC3339),
83
82
}
84
83
85
-
w.Header().Set("Content-Type", "application/json")
86
-
if err := json.NewEncoder(w).Encode(response); err != nil {
87
-
x.Logger.Error("failed to encode response", "error", err)
88
-
writeError(w, xrpcerr.NewXrpcError(
89
-
xrpcerr.WithTag("InternalServerError"),
90
-
xrpcerr.WithMessage("failed to encode response"),
91
-
), http.StatusInternalServerError)
92
-
return
93
-
}
84
+
writeJson(w, response)
94
85
}
+1
-11
knotserver/xrpc/repo_branches.go
+1
-11
knotserver/xrpc/repo_branches.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
"strconv"
7
6
···
53
52
Branches: paginatedBranches,
54
53
}
55
54
56
-
// Write JSON response directly
57
-
w.Header().Set("Content-Type", "application/json")
58
-
if err := json.NewEncoder(w).Encode(response); err != nil {
59
-
x.Logger.Error("failed to encode response", "error", err)
60
-
writeError(w, xrpcerr.NewXrpcError(
61
-
xrpcerr.WithTag("InternalServerError"),
62
-
xrpcerr.WithMessage("failed to encode response"),
63
-
), http.StatusInternalServerError)
64
-
return
65
-
}
55
+
writeJson(w, response)
66
56
}
+2
-11
knotserver/xrpc/repo_compare.go
+2
-11
knotserver/xrpc/repo_compare.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"fmt"
6
5
"net/http"
7
6
···
72
71
return
73
72
}
74
73
75
-
resp := types.RepoFormatPatchResponse{
74
+
response := types.RepoFormatPatchResponse{
76
75
Rev1: commit1.Hash.String(),
77
76
Rev2: commit2.Hash.String(),
78
77
FormatPatch: formatPatch,
79
78
Patch: rawPatch,
80
79
}
81
80
82
-
w.Header().Set("Content-Type", "application/json")
83
-
if err := json.NewEncoder(w).Encode(resp); err != nil {
84
-
x.Logger.Error("failed to encode response", "error", err)
85
-
writeError(w, xrpcerr.NewXrpcError(
86
-
xrpcerr.WithTag("InternalServerError"),
87
-
xrpcerr.WithMessage("failed to encode response"),
88
-
), http.StatusInternalServerError)
89
-
return
90
-
}
81
+
writeJson(w, response)
91
82
}
+2
-11
knotserver/xrpc/repo_diff.go
+2
-11
knotserver/xrpc/repo_diff.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
7
6
"tangled.sh/tangled.sh/core/knotserver/git"
···
33
32
return
34
33
}
35
34
36
-
resp := types.RepoCommitResponse{
35
+
response := types.RepoCommitResponse{
37
36
Ref: ref,
38
37
Diff: diff,
39
38
}
40
39
41
-
w.Header().Set("Content-Type", "application/json")
42
-
if err := json.NewEncoder(w).Encode(resp); err != nil {
43
-
x.Logger.Error("failed to encode response", "error", err)
44
-
writeError(w, xrpcerr.NewXrpcError(
45
-
xrpcerr.WithTag("InternalServerError"),
46
-
xrpcerr.WithMessage("failed to encode response"),
47
-
), http.StatusInternalServerError)
48
-
return
49
-
}
40
+
writeJson(w, response)
50
41
}
+1
-10
knotserver/xrpc/repo_get_default_branch.go
+1
-10
knotserver/xrpc/repo_get_default_branch.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
"time"
7
6
···
36
35
When: time.UnixMicro(0).Format(time.RFC3339),
37
36
}
38
37
39
-
w.Header().Set("Content-Type", "application/json")
40
-
if err := json.NewEncoder(w).Encode(response); err != nil {
41
-
x.Logger.Error("failed to encode response", "error", err)
42
-
writeError(w, xrpcerr.NewXrpcError(
43
-
xrpcerr.WithTag("InternalServerError"),
44
-
xrpcerr.WithMessage("failed to encode response"),
45
-
), http.StatusInternalServerError)
46
-
return
47
-
}
38
+
writeJson(w, response)
48
39
}
+1
-10
knotserver/xrpc/repo_languages.go
+1
-10
knotserver/xrpc/repo_languages.go
···
2
2
3
3
import (
4
4
"context"
5
-
"encoding/json"
6
5
"math"
7
6
"net/http"
8
7
"time"
···
73
72
response.TotalFiles = &totalFiles
74
73
}
75
74
76
-
w.Header().Set("Content-Type", "application/json")
77
-
if err := json.NewEncoder(w).Encode(response); err != nil {
78
-
x.Logger.Error("failed to encode response", "error", err)
79
-
writeError(w, xrpcerr.NewXrpcError(
80
-
xrpcerr.WithTag("InternalServerError"),
81
-
xrpcerr.WithMessage("failed to encode response"),
82
-
), http.StatusInternalServerError)
83
-
return
84
-
}
75
+
writeJson(w, response)
85
76
}
+1
-11
knotserver/xrpc/repo_log.go
+1
-11
knotserver/xrpc/repo_log.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
"strconv"
7
6
···
78
77
79
78
response.Log = true
80
79
81
-
// Write JSON response directly
82
-
w.Header().Set("Content-Type", "application/json")
83
-
if err := json.NewEncoder(w).Encode(response); err != nil {
84
-
x.Logger.Error("failed to encode response", "error", err)
85
-
writeError(w, xrpcerr.NewXrpcError(
86
-
xrpcerr.WithTag("InternalServerError"),
87
-
xrpcerr.WithMessage("failed to encode response"),
88
-
), http.StatusInternalServerError)
89
-
return
90
-
}
80
+
writeJson(w, response)
91
81
}
+1
-10
knotserver/xrpc/repo_tree.go
+1
-10
knotserver/xrpc/repo_tree.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"net/http"
6
5
"path/filepath"
7
6
"time"
···
86
85
Files: treeEntries,
87
86
}
88
87
89
-
w.Header().Set("Content-Type", "application/json")
90
-
if err := json.NewEncoder(w).Encode(response); err != nil {
91
-
x.Logger.Error("failed to encode response", "error", err)
92
-
writeError(w, xrpcerr.NewXrpcError(
93
-
xrpcerr.WithTag("InternalServerError"),
94
-
xrpcerr.WithMessage("failed to encode response"),
95
-
), http.StatusInternalServerError)
96
-
return
97
-
}
88
+
writeJson(w, response)
98
89
}
+1
-11
knotserver/xrpc/version.go
+1
-11
knotserver/xrpc/version.go
···
1
1
package xrpc
2
2
3
3
import (
4
-
"encoding/json"
5
4
"fmt"
6
5
"net/http"
7
6
"runtime/debug"
8
7
9
8
"tangled.sh/tangled.sh/core/api/tangled"
10
-
xrpcerr "tangled.sh/tangled.sh/core/xrpc/errors"
11
9
)
12
10
13
11
// version is set during build time.
···
58
56
Version: version,
59
57
}
60
58
61
-
w.Header().Set("Content-Type", "application/json")
62
-
if err := json.NewEncoder(w).Encode(response); err != nil {
63
-
x.Logger.Error("failed to encode response", "error", err)
64
-
writeError(w, xrpcerr.NewXrpcError(
65
-
xrpcerr.WithTag("InternalServerError"),
66
-
xrpcerr.WithMessage("failed to encode response"),
67
-
), http.StatusInternalServerError)
68
-
return
69
-
}
59
+
writeJson(w, response)
70
60
}
+8
knotserver/xrpc/xrpc.go
+8
knotserver/xrpc/xrpc.go
···
117
117
w.WriteHeader(status)
118
118
json.NewEncoder(w).Encode(e)
119
119
}
120
+
121
+
func writeJson(w http.ResponseWriter, response any) {
122
+
w.Header().Set("Content-Type", "application/json")
123
+
if err := json.NewEncoder(w).Encode(response); err != nil {
124
+
writeError(w, xrpcerr.GenericError(err), http.StatusInternalServerError)
125
+
return
126
+
}
127
+
}