add open-with-web endpoint

changelog/unreleased/enhancement-add-open-with-web-endpoint.md

@@ -0,0 +1,7 @@
+Enhancement: Add /app/open-with-web endpoint
+
+We've added an /app/open-with-web endpoint to the app provider, so that
+clients that are no browser or have only limited browser access can also open apps with the help of a Web URL.
+
+https://github.com/cs3org/reva/pull/3143
+https://github.com/owncloud/ocis/pull/4376

internal/http/services/appprovider/appprovider.go

@@ -21,6 +21,7 @@ package appprovider
 import (
 	"encoding/json"
 	"net/http"
+	"net/url"
 	"path"
 
 	appregistry "github.com/cs3org/go-cs3apis/cs3/app/registry/v1beta1"
@@ -52,6 +53,14 @@ type Config struct {
 	Prefix     string `mapstructure:"prefix"`
 	GatewaySvc string `mapstructure:"gatewaysvc"`
 	Insecure   bool   `mapstructure:"insecure"`
+	WebBaseURI string `mapstructure:"webbaseuri"`
+	Web        Web    `mapstructure:"web"`
+}
+
+// Web holds the config options for the URL parameters for Web
+type Web struct {
+	URLParamsMapping map[string]string `mapstructure:"urlparamsmapping"`
+	StaticURLParams  map[string]string `mapstructure:"staticurlparams"`
 }
 
 func (c *Config) init() {
@@ -88,10 +97,16 @@ func New(m map[string]interface{}, log *zerolog.Logger) (global.Service, error)
 	return s, nil
 }
 
+const (
+	openModeNormal = iota
+	openModeWeb
+)
+
 func (s *svc) routerInit() error {
 	s.router.Get("/list", s.handleList)
 	s.router.Post("/new", s.handleNew)
-	s.router.Post("/open", s.handleOpen)
+	s.router.Post("/open", s.handleOpen(openModeNormal))
+	s.router.Post("/open-with-web", s.handleOpen(openModeWeb))
 	return nil
 }
 
@@ -324,97 +339,164 @@ func (s *svc) handleList(w http.ResponseWriter, r *http.Request) {
 	}
 }
 
-func (s *svc) handleOpen(w http.ResponseWriter, r *http.Request) {
-	ctx := r.Context()
+func (s *svc) handleOpen(openMode int) http.HandlerFunc {
 
-	client, err := pool.GetGatewayServiceClient(s.conf.GatewaySvc)
-	if err != nil {
-		writeError(w, r, appErrorServerError, "Internal error with the gateway, please try again later", err)
-		return
-	}
+	return func(w http.ResponseWriter, r *http.Request) {
+		ctx := r.Context()
 
-	err = r.ParseForm()
-	if err != nil {
-		writeError(w, r, appErrorInvalidParameter, "parameters could not be parsed", nil)
-	}
+		client, err := pool.GetGatewayServiceClient(s.conf.GatewaySvc)
+		if err != nil {
+			writeError(w, r, appErrorServerError, "Internal error with the gateway, please try again later", err)
+			return
+		}
 
-	fileID := r.Form.Get("file_id")
+		err = r.ParseForm()
+		if err != nil {
+			writeError(w, r, appErrorInvalidParameter, "parameters could not be parsed", nil)
+		}
 
-	if fileID == "" {
-		writeError(w, r, appErrorInvalidParameter, "missing file ID", nil)
-		return
-	}
+		fileID := r.Form.Get("file_id")
 
-	resourceID, err := storagespace.ParseID(fileID)
-	if err != nil {
-		writeError(w, r, appErrorInvalidParameter, "invalid file ID", nil)
-		return
-	}
+		if fileID == "" {
+			writeError(w, r, appErrorInvalidParameter, "missing file ID", nil)
+			return
+		}
 
-	fileRef := &provider.Reference{
-		ResourceId: &resourceID,
-		Path:       ".",
-	}
+		resourceID, err := storagespace.ParseID(fileID)
+		if err != nil {
+			writeError(w, r, appErrorInvalidParameter, "invalid file ID", nil)
+			return
+		}
 
-	statRes, err := client.Stat(ctx, &provider.StatRequest{Ref: fileRef})
-	if err != nil {
-		writeError(w, r, appErrorServerError, "Internal error accessing the file, please try again later", err)
-		return
-	}
+		fileRef := &provider.Reference{
+			ResourceId: &resourceID,
+			Path:       ".",
+		}
 
-	if statRes.Status.Code == rpc.Code_CODE_NOT_FOUND {
-		writeError(w, r, appErrorNotFound, "file does not exist", nil)
-		return
-	} else if statRes.Status.Code != rpc.Code_CODE_OK {
-		writeError(w, r, appErrorServerError, "failed to stat the file", nil)
-		return
-	}
+		statRes, err := client.Stat(ctx, &provider.StatRequest{Ref: fileRef})
+		if err != nil {
+			writeError(w, r, appErrorServerError, "Internal error accessing the file, please try again later", err)
+			return
+		}
 
-	if statRes.Info.Type != provider.ResourceType_RESOURCE_TYPE_FILE {
-		writeError(w, r, appErrorInvalidParameter, "the given file id does not point to a file", nil)
-		return
-	}
+		if statRes.Status.Code == rpc.Code_CODE_NOT_FOUND {
+			writeError(w, r, appErrorNotFound, "file does not exist", nil)
+			return
+		} else if statRes.Status.Code != rpc.Code_CODE_OK {
+			writeError(w, r, appErrorServerError, "failed to stat the file", nil)
+			return
+		}
 
-	viewMode := getViewMode(statRes.Info, r.Form.Get("view_mode"))
-	if viewMode == gateway.OpenInAppRequest_VIEW_MODE_INVALID {
-		writeError(w, r, appErrorInvalidParameter, "invalid view mode", err)
-		return
-	}
+		if statRes.Info.Type != provider.ResourceType_RESOURCE_TYPE_FILE {
+			writeError(w, r, appErrorInvalidParameter, "the given file id does not point to a file", nil)
+			return
+		}
 
-	openReq := gateway.OpenInAppRequest{
-		Ref:      fileRef,
-		ViewMode: viewMode,
-		App:      r.Form.Get("app_name"),
-	}
-	openRes, err := client.OpenInApp(ctx, &openReq)
-	if err != nil {
-		writeError(w, r, appErrorServerError,
-			"Error contacting the requested application, please use a different one or try again later", err)
-		return
-	}
-	if openRes.Status.Code != rpc.Code_CODE_OK {
-		if openRes.Status.Code == rpc.Code_CODE_NOT_FOUND {
-			writeError(w, r, appErrorNotFound, openRes.Status.Message, nil)
+		viewMode := getViewMode(statRes.Info, r.Form.Get("view_mode"))
+		if viewMode == gateway.OpenInAppRequest_VIEW_MODE_INVALID {
+			writeError(w, r, appErrorInvalidParameter, "invalid view mode", err)
+			return
+		}
+
+		openReq := gateway.OpenInAppRequest{
+			Ref:      fileRef,
+			ViewMode: viewMode,
+			App:      r.Form.Get("app_name"),
+		}
+		openRes, err := client.OpenInApp(ctx, &openReq)
+		if err != nil {
+			writeError(w, r, appErrorServerError,
+				"Error contacting the requested application, please use a different one or try again later", err)
+			return
+		}
+		if openRes.Status.Code != rpc.Code_CODE_OK {
+			if openRes.Status.Code == rpc.Code_CODE_NOT_FOUND {
+				writeError(w, r, appErrorNotFound, openRes.Status.Message, nil)
+				return
+			}
+			writeError(w, r, appErrorServerError, openRes.Status.Message,
+				status.NewErrorFromCode(openRes.Status.Code, "error calling OpenInApp"))
+			return
+		}
+
+		var payload interface{}
+
+		switch openMode {
+		case openModeNormal:
+			payload = openRes.AppUrl
+
+		case openModeWeb:
+			payload, err = newOpenInWebResponse(s.conf.WebBaseURI, s.conf.Web.URLParamsMapping, s.conf.Web.StaticURLParams, fileID, r.Form.Get("app_name"), r.Form.Get("view_mode"))
+			if err != nil {
+				writeError(w, r, appErrorServerError, "Internal error",
+					errors.Wrap(err, "error building OpenInWeb response"))
+				return
+			}
+
+		default:
+			writeError(w, r, appErrorServerError, "Internal error with the open mode",
+				errors.New("unknown open mode"))
+			return
+
+		}
+
+		js, err := json.Marshal(payload)
+		if err != nil {
+			writeError(w, r, appErrorServerError, "Internal error with JSON payload",
+				errors.Wrap(err, "error marshalling JSON response"))
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		if _, err = w.Write(js); err != nil {
+			writeError(w, r, appErrorServerError, "Internal error with JSON payload",
+				errors.Wrap(err, "error writing JSON response"))
 			return
 		}
-		writeError(w, r, appErrorServerError, openRes.Status.Message,
-			status.NewErrorFromCode(openRes.Status.Code, "error calling OpenInApp"))
-		return
 	}
+}
+
+type openInWebResponse struct {
+	URI string `json:"uri"`
+}
+
+func newOpenInWebResponse(baseURI string, params, staticParams map[string]string, fileID, appName, viewMode string) (openInWebResponse, error) {
 
-	js, err := json.Marshal(openRes.AppUrl)
+	uri, err := url.Parse(baseURI)
 	if err != nil {
-		writeError(w, r, appErrorServerError, "Internal error with JSON payload",
-			errors.Wrap(err, "error marshalling JSON response"))
-		return
+		return openInWebResponse{}, err
 	}
 
-	w.Header().Set("Content-Type", "application/json")
-	if _, err = w.Write(js); err != nil {
-		writeError(w, r, appErrorServerError, "Internal error with JSON payload",
-			errors.Wrap(err, "error writing JSON response"))
-		return
+	query := uri.Query()
+
+	for key, val := range params {
+
+		switch val {
+		case "fileid":
+			if fileID != "" {
+				query.Add(key, fileID)
+			}
+		case "appname":
+			if appName != "" {
+				query.Add(key, appName)
+			}
+		case "viewmode":
+			if viewMode != "" {
+				query.Add(key, viewMode)
+			}
+		default:
+			return openInWebResponse{}, errors.New("unknown parameter mapper")
+		}
+
+	}
+
+	for key, val := range staticParams {
+		query.Add(key, val)
 	}
+
+	uri.RawQuery = query.Encode()
+
+	return openInWebResponse{URI: uri.String()}, nil
 }
 
 func filterAppsByUserAgent(mimeTypes []*appregistry.MimeTypeInfo, userAgent string) []*appregistry.MimeTypeInfo {

internal/http/services/owncloud/ocs/data/capabilities.go

@@ -117,11 +117,12 @@ type CapabilitiesArchiver struct {
 
 // CapabilitiesAppProvider holds available app provider information
 type CapabilitiesAppProvider struct {
-	Enabled bool   `json:"enabled" xml:"enabled" mapstructure:"enabled"`
-	Version string `json:"version" xml:"version" mapstructure:"version"`
-	AppsURL string `json:"apps_url" xml:"apps_url" mapstructure:"apps_url"`
-	OpenURL string `json:"open_url" xml:"open_url" mapstructure:"open_url"`
-	NewURL  string `json:"new_url" xml:"new_url" mapstructure:"new_url"`
+	Enabled    bool   `json:"enabled" xml:"enabled" mapstructure:"enabled"`
+	Version    string `json:"version" xml:"version" mapstructure:"version"`
+	AppsURL    string `json:"apps_url" xml:"apps_url" mapstructure:"apps_url"`
+	OpenURL    string `json:"open_url" xml:"open_url" mapstructure:"open_url"`
+	OpenWebURL string `json:"open_web_url" xml:"open_web_url" mapstructure:"open_web_url"`
+	NewURL     string `json:"new_url" xml:"new_url" mapstructure:"new_url"`
 }
 
 // CapabilitiesFiles TODO this is storage specific, not global. What effect do these options have on the clients?