package wopi import ( "errors" "fmt" model "github.com/cloudreve/Cloudreve/v3/models" "github.com/cloudreve/Cloudreve/v3/pkg/cache" "github.com/cloudreve/Cloudreve/v3/pkg/hashid" "github.com/cloudreve/Cloudreve/v3/pkg/request" "github.com/cloudreve/Cloudreve/v3/pkg/util" "github.com/gofrs/uuid" "net/url" "path" "strings" "sync" "time" ) type Client interface { // NewSession creates a new document session with access token. NewSession(user *model.User, file *model.File, action ActonType) (*Session, error) // AvailableExts returns a list of file extensions that are supported by WOPI. AvailableExts() []string } var ( ErrActionNotSupported = errors.New("action not supported by current wopi endpoint") Default Client DefaultMu sync.Mutex queryPlaceholders = map[string]string{ "BUSINESS_USER": "", "DC_LLCC": "lng", "DISABLE_ASYNC": "", "DISABLE_CHAT": "", "EMBEDDED": "true", "FULLSCREEN": "true", "HOST_SESSION_ID": "", "SESSION_CONTEXT": "", "RECORDING": "", "THEME_ID": "darkmode", "UI_LLCC": "lng", "VALIDATOR_TEST_CATEGORY": "", } ) const ( SessionCachePrefix = "wopi_session_" AccessTokenQuery = "access_token" OverwriteHeader = wopiHeaderPrefix + "Override" ServerErrorHeader = wopiHeaderPrefix + "ServerError" RenameRequestHeader = wopiHeaderPrefix + "RequestedName" MethodLock = "LOCK" MethodUnlock = "UNLOCK" MethodRefreshLock = "REFRESH_LOCK" MethodRename = "RENAME_FILE" wopiSrcPlaceholder = "WOPI_SOURCE" wopiSrcParamDefault = "WOPISrc" sessionExpiresPadding = 10 wopiHeaderPrefix = "X-WOPI-" ) // Init initializes a new global WOPI client. func Init() { settings := model.GetSettingByNames("wopi_endpoint", "wopi_enabled") if !model.IsTrueVal(settings["wopi_enabled"]) { DefaultMu.Lock() Default = nil DefaultMu.Unlock() return } cache.Deletes([]string{DiscoverResponseCacheKey}, "") wopiClient, err := NewClient(settings["wopi_endpoint"], cache.Store, request.NewClient()) if err != nil { util.Log().Error("Failed to initialize WOPI client: %s", err) return } DefaultMu.Lock() Default = wopiClient DefaultMu.Unlock() } type client struct { cache cache.Driver http request.Client mu sync.RWMutex discovery *WopiDiscovery actions map[string]map[string]Action config } type config struct { discoveryEndpoint *url.URL } func NewClient(endpoint string, cache cache.Driver, http request.Client) (Client, error) { endpointUrl, err := url.Parse(endpoint) if err != nil { return nil, fmt.Errorf("failed to parse WOPI endpoint: %s", err) } return &client{ cache: cache, http: http, config: config{ discoveryEndpoint: endpointUrl, }, }, nil } func (c *client) NewSession(user *model.User, file *model.File, action ActonType) (*Session, error) { if err := c.checkDiscovery(); err != nil { return nil, err } c.mu.RLock() defer c.mu.RUnlock() ext := path.Ext(file.Name) availableActions, ok := c.actions[ext] if !ok { return nil, ErrActionNotSupported } var ( actionConfig Action ) fallbackOrder := []ActonType{action, ActionPreview, ActionPreviewFallback, ActionEdit} for _, a := range fallbackOrder { if actionConfig, ok = availableActions[string(a)]; ok { break } } if actionConfig.Urlsrc == "" { return nil, ErrActionNotSupported } // Generate WOPI REST endpoint for given file baseURL := model.GetSiteURL() linkPath, err := url.Parse(fmt.Sprintf("/api/v3/wopi/files/%s", hashid.HashID(file.ID, hashid.FileID))) if err != nil { return nil, err } actionUrl, err := generateActionUrl(actionConfig.Urlsrc, baseURL.ResolveReference(linkPath).String()) if err != nil { return nil, err } // Create document session sessionID := uuid.Must(uuid.NewV4()) token := util.RandStringRunes(64) ttl := model.GetIntSetting("wopi_session_timeout", 36000) session := &SessionCache{ AccessToken: fmt.Sprintf("%s.%s", sessionID, token), FileID: file.ID, UserID: user.ID, Action: action, } err = c.cache.Set(SessionCachePrefix+sessionID.String(), *session, ttl) if err != nil { return nil, fmt.Errorf("failed to create document session: %w", err) } sessionRes := &Session{ AccessToken: session.AccessToken, ActionURL: actionUrl, AccessTokenTTL: time.Now().Add(time.Duration(ttl-sessionExpiresPadding) * time.Second).UnixMilli(), } return sessionRes, nil } // Replace query parameters in action URL template. Some placeholders need to be replaced // at the frontend, e.g. `THEME_ID`. func generateActionUrl(src string, fileSrc string) (*url.URL, error) { src = strings.ReplaceAll(src, "<", "") src = strings.ReplaceAll(src, ">", "") actionUrl, err := url.Parse(src) if err != nil { return nil, fmt.Errorf("failed to parse action url: %s", err) } queries := actionUrl.Query() srcReplaced := false queryReplaced := url.Values{} for k := range queries { if placeholder, ok := queryPlaceholders[queries.Get(k)]; ok { if placeholder != "" { queryReplaced.Set(k, placeholder) } continue } if queries.Get(k) == wopiSrcPlaceholder { queryReplaced.Set(k, fileSrc) srcReplaced = true continue } queryReplaced.Set(k, queries.Get(k)) } if !srcReplaced { queryReplaced.Set(wopiSrcParamDefault, fileSrc) } actionUrl.RawQuery = queryReplaced.Encode() return actionUrl, nil }