Skip to content

Take control over your live stream video by running it yourself. Streaming + chat out of the box.

Rework utils/restendpointhelper to use the new chi router functionality (#3750)

mahmed2000e04d65e63d7b
diff --git a/controllers/admin/chat.go b/controllers/admin/chat.go
index 6c68b6dd4f..f63e12bf09 100644
--- a/controllers/admin/chat.go
+++ b/controllers/admin/chat.go
@@ -261,7 +261,7 @@ func SendSystemMessage(integration user.ExternalAPIUser, w http.ResponseWriter,
// SendSystemMessageToConnectedClient will handle incoming requests to send a single message to a single connected client by ID.
func SendSystemMessageToConnectedClient(integration user.ExternalAPIUser, w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
- clientIDText, err := utils.ReadRestURLParameter(r, "clientId")
+ clientIDText, err := utils.GetURLParam(r, "clientId")
if err != nil {
controllers.BadRequestHandler(w, err)
return
diff --git a/handler/integrations.go b/handler/integrations.go
index 1d5ddb09e8..89f93334a5 100644
--- a/handler/integrations.go
+++ b/handler/integrations.go
@@ -7,7 +7,6 @@ import (
"github.com/owncast/owncast/controllers/admin"
"github.com/owncast/owncast/core/user"
"github.com/owncast/owncast/router/middleware"
- "github.com/owncast/owncast/utils"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
@@ -20,8 +19,6 @@ func (*ServerInterfaceImpl) SendSystemMessageOptions(w http.ResponseWriter, r *h
}
func (*ServerInterfaceImpl) SendSystemMessageToConnectedClient(w http.ResponseWriter, r *http.Request, clientId int) {
- // doing this hack to make the new system work with the old system
- r.Header[utils.RestURLPatternHeaderKey] = []string{`/api/integrations/chat/system/client/{clientId}`}
middleware.RequireExternalAPIAccessToken(user.ScopeCanSendSystemMessages, admin.SendSystemMessageToConnectedClient)(w, r)
}
diff --git a/utils/restendpointhelper.go b/utils/restendpointhelper.go
index 0858c5d650..2c207c8ee9 100644
--- a/utils/restendpointhelper.go
+++ b/utils/restendpointhelper.go
@@ -2,68 +2,16 @@ package utils
import (
"errors"
- "fmt"
"net/http"
- "strings"
-)
-
-const RestURLPatternHeaderKey = "Owncast-Resturl-Pattern"
-
-// takes the segment pattern of an Url string and returns the segment before the first dynamic REST parameter.
-func getPatternForRestEndpoint(pattern string) string {
- firstIndex := strings.Index(pattern, "/{")
- if firstIndex == -1 {
- return pattern
- }
-
- return strings.TrimRight(pattern[:firstIndex], "/") + "/"
-}
-
-func zip2D(iterable1 *[]string, iterable2 *[]string) map[string]string {
- dict := make(map[string]string)
- for index, key := range *iterable1 {
- dict[key] = (*iterable2)[index]
- }
- return dict
-}
-
-func mapPatternWithRequestURL(pattern string, requestURL string) (map[string]string, error) {
- patternSplit := strings.Split(pattern, "/")
- requestURLSplit := strings.Split(requestURL, "/")
-
- if len(patternSplit) == len(requestURLSplit) {
- return zip2D(&patternSplit, &requestURLSplit), nil
- }
- return nil, errors.New("the length of pattern and request Url does not match")
-}
-
-func readParameter(pattern string, requestURL string, paramName string) (string, error) {
- all, err := mapPatternWithRequestURL(pattern, requestURL)
- if err != nil {
- return "", err
- }
- if value, exists := all[fmt.Sprintf("{%s}", paramName)]; exists {
- return value, nil
- }
- return "", fmt.Errorf("parameter with name %s not found", paramName)
-}
-
-// ReadRestURLParameter will return the parameter from the request of the requested name.
-func ReadRestURLParameter(r *http.Request, parameterName string) (string, error) {
- pattern, found := r.Header[RestURLPatternHeaderKey]
- if !found {
- return "", fmt.Errorf("this HandlerFunc is not marked as REST-Endpoint. Cannot read Parameter '%s' from Request", parameterName)
- }
-
- return readParameter(pattern[0], r.URL.Path, parameterName)
-}
+ "github.com/go-chi/chi/v5"
+)
-// RestEndpoint wraps a handler to use the rest endpoint helper.
-func RestEndpoint(pattern string, handler http.HandlerFunc) (string, http.HandlerFunc) {
- baseURL := getPatternForRestEndpoint(pattern)
- return baseURL, func(w http.ResponseWriter, r *http.Request) {
- r.Header[RestURLPatternHeaderKey] = []string{pattern}
- handler(w, r)
+// GetURLParam retrieves the specified URL param from a given request.
+func GetURLParam(r *http.Request, key string) (value string, err error) {
+ value = chi.URLParam(r, key)
+ if value == "" {
+ err = errors.New("Request does not contain requested URL param")
}
+ return
}
diff --git a/utils/restendpointhelper_test.go b/utils/restendpointhelper_test.go
deleted file mode 100644
index c9204f775a..0000000000
--- a/utils/restendpointhelper_test.go
+++ /dev/null
@@ -1,39 +0,0 @@
-package utils
-
-import (
- "strings"
- "testing"
-)
-
-func TestGetPatternForRestEndpoint(t *testing.T) {
- expected := "/hello/"
- endpoints := [...]string{"/hello/{param1}", "/hello/{param1}/{param2}", "/hello/{param1}/world/{param2}"}
- for _, endpoint := range endpoints {
- if ep := getPatternForRestEndpoint(endpoint); ep != expected {
- t.Errorf("%s p does not match expected %s", ep, expected)
- }
- }
-}
-
-func TestReadParameter(t *testing.T) {
- expected := "world"
- endpoints := [...]string{
- "/hello/{p1}",
- "/hello/cruel/{p1}",
- "/hello/{p1}/my/friend",
- "/hello/{p1}/{p2}/friend",
- "/hello/{p2}/{p3}/{p1}",
- "/{p1}/is/nice",
- "/{p1}/{p1}/{p1}",
- }
-
- for _, ep := range endpoints {
- v, err := readParameter(ep, strings.Replace(ep, "{p1}", expected, -1), "p1")
- if err != nil {
- t.Errorf("Unexpected error when reading parameter: %s", err.Error())
- }
- if v != expected {
- t.Errorf("'%s' should have returned %s", ep, expected)
- }
- }
-}