@sync-in/server 1.9.6 → 1.10.1

package/server/applications/files/modules/collabora-online/collabora-online-manager.service.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../backend/src/applications/files/modules/collabora-online/collabora-online-manager.service.ts"],"sourcesContent":["/*\n * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>\n * This file is part of Sync-in | The open source file sync and share solution\n * See the LICENSE file for licensing details\n */\n\nimport { HttpException, HttpStatus, Injectable, Logger } from '@nestjs/common'\nimport { JwtService } from '@nestjs/jwt'\nimport { FastifyReply } from 'fastify'\nimport fs from 'node:fs/promises'\nimport os from 'node:os'\nimport path from 'node:path'\nimport { convertHumanTimeToSeconds } from '../../../../common/functions'\nimport { configuration } from '../../../../configuration/config.environment'\nimport { ContextManager } from '../../../../infrastructure/context/services/context-manager.service'\nimport { SPACE_OPERATION } from '../../../spaces/constants/spaces'\nimport type { SpaceEnv } from '../../../spaces/models/space-env.model'\nimport { haveSpaceEnvPermissions } from '../../../spaces/utils/permissions'\nimport type { UserModel } from '../../../users/models/user.model'\nimport { getAvatarBase64 } from '../../../users/utils/avatar'\nimport { DEPTH, LOCK_SCOPE } from '../../../webdav/constants/webdav'\nimport { FILE_MODE } from '../../constants/operations'\nimport { FileLockOptions } from '../../interfaces/file-lock.interface'\nimport { FileLockProps } from '../../interfaces/file-props.interface'\nimport { LockConflict } from '../../models/file-lock-error'\nimport { FilesLockManager } from '../../services/files-lock-manager.service'\nimport {\n  copyFileContent,\n  fileName,\n  fileSize,\n  genEtag,\n  genUniqHashFromFileDBProps,\n  isPathExists,\n  isPathIsDir,\n  removeFiles,\n  uniqueFilePathFromDir,\n  writeFromStream\n} from '../../utils/files'\nimport {\n  COLLABORA_APP_LOCK,\n  COLLABORA_HEADERS,\n  COLLABORA_LOCK_ACTION,\n  COLLABORA_ONLINE_EXTENSIONS,\n  COLLABORA_TOKEN_QUERY_PARAM_NAME,\n  COLLABORA_URI,\n  COLLABORA_WOPI_SRC_QUERY_PARAM_NAME\n} from './collabora-online.constants'\nimport { CollaboraOnlineReqDto, CollaboraSaveDocumentDto } from './collabora-online.dtos'\nimport { CollaboraOnlineCheckFileInfo, FastifyCollaboraOnlineSpaceRequest, JwtCollaboraOnlinePayload } from './collabora-online.interface'\nimport { API_COLLABORA_ONLINE_FILES } from './collabora-online.routes'\n\n@Injectable()\nexport class CollaboraOnlineManager {\n  private logger = new Logger(CollaboraOnlineManager.name)\n  private readonly externalCollaboraOnlineServer = configuration.applications.files.collabora.externalServer || null\n  private readonly expiration = convertHumanTimeToSeconds(configuration.auth.token.refresh.expiration)\n\n  constructor(\n    private readonly contextManager: ContextManager,\n    private readonly jwt: JwtService,\n    private readonly filesLockManager: FilesLockManager\n  ) {}\n\n  async getSettings(user: UserModel, space: SpaceEnv): Promise<CollaboraOnlineReqDto> {\n    await this.checkSpace(space)\n    const fileExtension = path.extname(space.realPath).slice(1)\n    if (!COLLABORA_ONLINE_EXTENSIONS.has(fileExtension)) {\n      throw new HttpException('Document not supported', HttpStatus.BAD_REQUEST)\n    }\n    let hasLock: false | FileLockProps = false\n    let mode: FILE_MODE = haveSpaceEnvPermissions(space, SPACE_OPERATION.MODIFY) ? FILE_MODE.EDIT : FILE_MODE.VIEW\n    if (mode === FILE_MODE.EDIT) {\n      // Check lock conflicts\n      try {\n        await this.filesLockManager.checkConflicts(space.dbFile, DEPTH.RESOURCE, {\n          userId: user.id,\n          app: COLLABORA_APP_LOCK,\n          lockScope: LOCK_SCOPE.SHARED\n        })\n      } catch (e) {\n        if (e instanceof LockConflict) {\n          hasLock = this.filesLockManager.convertLockToFileLockProps(e.lock)\n          mode = FILE_MODE.VIEW\n        } else {\n          this.logger.error(`${this.getSettings.name} - ${e}`)\n          throw new HttpException('Unable to check file lock', HttpStatus.INTERNAL_SERVER_ERROR)\n        }\n      }\n    }\n    const dbFileHash = genUniqHashFromFileDBProps(space.dbFile)\n    const authToken: string = await this.genAuthToken(user, space, dbFileHash)\n    return { documentServerUrl: this.getDocumentUrl(dbFileHash, authToken), mode: mode, hasLock: hasLock }\n  }\n\n  async checkFileInfo(req: FastifyCollaboraOnlineSpaceRequest): Promise<CollaboraOnlineCheckFileInfo> {\n    const fStats = await fs.stat(req.space.realPath)\n    return {\n      BaseFileName: fileName(req.space.realPath),\n      Version: genEtag(null, req.space.realPath, false),\n      OwnerId: `${req.space.dbFile.ownerId || req.user.id}`,\n      Size: fStats.size,\n      LastModifiedTime: fStats.mtime.toISOString(),\n      UserId: `${req.user.id}`,\n      UserFriendlyName: `${req.user.fullName} (${req.user.email})`,\n      ReadOnly: false,\n      UserExtraInfo: { avatar: await getAvatarBase64(req.user.login) },\n      UserCanNotWriteRelative: true,\n      UserCanWrite: haveSpaceEnvPermissions(req.space, SPACE_OPERATION.MODIFY),\n      UserCanRename: false,\n      SupportsUpdate: true,\n      SupportsRename: false,\n      SupportsExport: true,\n      SupportsCoauth: true,\n      SupportsLocks: true,\n      SupportsGetLock: true\n    } satisfies CollaboraOnlineCheckFileInfo\n  }\n\n  async saveDocument(req: FastifyCollaboraOnlineSpaceRequest): Promise<CollaboraSaveDocumentDto> {\n    await this.checkSpace(req.space)\n    await this.checkTimeStampFromHeaders(req)\n    const tmpFilePath = await uniqueFilePathFromDir(path.join(os.tmpdir(), fileName(req.space.realPath)))\n    try {\n      await writeFromStream(tmpFilePath, req.raw)\n    } catch (e) {\n      throw new Error(`unable to save document : ${e.message}`)\n    }\n    // try to verify the downloaded size\n    const contentLength = parseInt(req.headers['content-length'], 10)\n    if (!isNaN(contentLength) && contentLength !== 0) {\n      const tmpFileSize = await fileSize(tmpFilePath)\n      if (tmpFileSize !== contentLength) {\n        this.logger.error(`${this.saveDocument.name} - document size differs (${tmpFileSize} != ${contentLength})`)\n        throw new HttpException('Size Mismatch', HttpStatus.BAD_REQUEST)\n      }\n    } else if (contentLength === 0) {\n      this.logger.warn(`${this.saveDocument.name} - content length is 0 : ${req.space.url}`)\n    }\n    // copy contents to avoid inode changes (dbFileHash in some cases)\n    try {\n      // todo: versioning\n      await copyFileContent(tmpFilePath, req.space.realPath)\n      await removeFiles(tmpFilePath)\n      const fStats = await fs.stat(req.space.realPath)\n      return { LastModifiedTime: fStats.mtime.toISOString() } satisfies CollaboraSaveDocumentDto\n    } catch (e) {\n      this.logger.error(`${this.saveDocument.name} - unable to save document: ${e}`)\n      throw new HttpException('Unable to save document', HttpStatus.INTERNAL_SERVER_ERROR)\n    }\n  }\n\n  async manageLock(req: FastifyCollaboraOnlineSpaceRequest, res: FastifyReply) {\n    const lockAction = req.headers[COLLABORA_HEADERS.Action] as COLLABORA_LOCK_ACTION\n    switch (lockAction) {\n      case COLLABORA_LOCK_ACTION.LOCK: {\n        const reqLockToken = this.lockTokenFromHeaders(req)\n        const currentLock = await this.filesLockManager.isLockedWithToken(reqLockToken, req.space.dbFile.path)\n        if (currentLock) {\n          await this.filesLockManager.refreshLockTimeout(currentLock, this.expiration)\n          break\n        }\n        const [ok, fileLock] = await this.filesLockManager.create(\n          req.user,\n          req.space.dbFile,\n          COLLABORA_APP_LOCK,\n          DEPTH.RESOURCE,\n          {\n            lockRoot: null,\n            lockToken: reqLockToken,\n            lockScope: LOCK_SCOPE.SHARED // Collabora uses one lock for the session\n          } satisfies FileLockOptions,\n          this.expiration\n        )\n        if (!ok) {\n          this.lockConflict(res, fileLock.options.lockToken)\n          return\n        }\n        break\n      }\n      case COLLABORA_LOCK_ACTION.UNLOCK: {\n        const reqLockToken = this.lockTokenFromHeaders(req)\n        const currentLock = await this.filesLockManager.isLockedWithToken(reqLockToken, req.space.dbFile.path)\n        if (currentLock) {\n          await this.filesLockManager.removeLock(currentLock.key)\n        } else {\n          throw new HttpException('Lock not found', HttpStatus.CONFLICT)\n        }\n        break\n      }\n      case COLLABORA_LOCK_ACTION.GET_LOCK: {\n        const lock = await this.filesLockManager.getLocksByPath(req.space.dbFile)\n        if (lock.length) {\n          res.header(COLLABORA_HEADERS.LockToken, lock[0].options.lockToken)\n        }\n        break\n      }\n      case COLLABORA_LOCK_ACTION.REFRESH_LOCK: {\n        const reqLockToken = this.lockTokenFromHeaders(req)\n        const currentLock = await this.filesLockManager.isLockedWithToken(reqLockToken, req.space.dbFile.path)\n        if (currentLock) {\n          await this.filesLockManager.refreshLockTimeout(currentLock, this.expiration)\n        } else {\n          throw new HttpException('Lock not found', HttpStatus.CONFLICT)\n        }\n        break\n      }\n      default:\n        this.logger.warn(`${this.manageLock.name} - Unknown lock action: ${lockAction}`)\n        throw new HttpException('Unknown lock action', HttpStatus.BAD_REQUEST)\n    }\n  }\n\n  private getDocumentUrl(dbFileHash: string, token: string): string {\n    const collaboraBase = this.externalCollaboraOnlineServer || this.contextManager.headerOriginUrl()\n    // Example:\n    // - external: https://collabora.domain.com\n    // - internal (via nginx proxy): https://domain.com/*\n\n    const editorUrl = new URL(COLLABORA_URI, collaboraBase)\n    // → /browser/dist/cool.html\n\n    const wopiSrcUrl = new URL(`${API_COLLABORA_ONLINE_FILES}/${dbFileHash}`, this.contextManager.headerOriginUrl())\n    // → https://domain.com/wopi/files/888\n\n    editorUrl.searchParams.set(COLLABORA_WOPI_SRC_QUERY_PARAM_NAME, wopiSrcUrl.toString())\n    editorUrl.searchParams.set(COLLABORA_TOKEN_QUERY_PARAM_NAME, token)\n\n    return editorUrl.toString()\n  }\n\n  private genAuthToken(user: UserModel, space: SpaceEnv, dbFileHash: string): Promise<string> {\n    // use refresh expiration to allow long sessions\n    return this.jwt.signAsync(\n      {\n        identity: {\n          id: user.id,\n          login: user.login,\n          email: user.email,\n          fullName: user.fullName,\n          language: user.language,\n          role: user.role,\n          applications: user.applications,\n          spaceUrl: space.url,\n          dbFileHash: dbFileHash\n        } satisfies JwtCollaboraOnlinePayload\n      },\n      {\n        secret: configuration.auth.token.access.secret,\n        expiresIn: this.expiration\n      }\n    )\n  }\n\n  private lockTokenFromHeaders(req: FastifyCollaboraOnlineSpaceRequest): string {\n    const lockToken = req.headers[COLLABORA_HEADERS.LockToken] as string\n    if (!lockToken) {\n      throw new HttpException('Lock token is required', HttpStatus.CONFLICT)\n    }\n    return lockToken\n  }\n\n  private lockConflict(res: FastifyReply, currentLockToken: string) {\n    res.header(COLLABORA_HEADERS.LockToken, currentLockToken)\n    throw new HttpException('The file is locked', HttpStatus.CONFLICT)\n  }\n\n  private async checkTimeStampFromHeaders(req: FastifyCollaboraOnlineSpaceRequest) {\n    const timestamp = req.headers[COLLABORA_HEADERS.Timestamp] as string\n    if (!timestamp) {\n      return\n    }\n    const fStats = await fs.stat(req.space.realPath)\n    if (fStats.mtime.toISOString() !== timestamp) {\n      throw new HttpException({ LOOLStatusCode: 1010 }, HttpStatus.CONFLICT)\n    }\n  }\n\n  private async checkSpace(space: SpaceEnv) {\n    if (!(await isPathExists(space.realPath))) {\n      throw new HttpException('Document not found', HttpStatus.NOT_FOUND)\n    }\n    if (await isPathIsDir(space.realPath)) {\n      throw new HttpException('Document must be a file', HttpStatus.BAD_REQUEST)\n    }\n  }\n}\n"],"names":["CollaboraOnlineManager","getSettings","user","space","checkSpace","fileExtension","path","extname","realPath","slice","COLLABORA_ONLINE_EXTENSIONS","has","HttpException","HttpStatus","BAD_REQUEST","hasLock","mode","haveSpaceEnvPermissions","SPACE_OPERATION","MODIFY","FILE_MODE","EDIT","VIEW","filesLockManager","checkConflicts","dbFile","DEPTH","RESOURCE","userId","id","app","COLLABORA_APP_LOCK","lockScope","LOCK_SCOPE","SHARED","e","LockConflict","convertLockToFileLockProps","lock","logger","error","name","INTERNAL_SERVER_ERROR","dbFileHash","genUniqHashFromFileDBProps","authToken","genAuthToken","documentServerUrl","getDocumentUrl","checkFileInfo","req","fStats","fs","stat","BaseFileName","fileName","Version","genEtag","OwnerId","ownerId","Size","size","LastModifiedTime","mtime","toISOString","UserId","UserFriendlyName","fullName","email","ReadOnly","UserExtraInfo","avatar","getAvatarBase64","login","UserCanNotWriteRelative","UserCanWrite","UserCanRename","SupportsUpdate","SupportsRename","SupportsExport","SupportsCoauth","SupportsLocks","SupportsGetLock","saveDocument","checkTimeStampFromHeaders","tmpFilePath","uniqueFilePathFromDir","join","os","tmpdir","writeFromStream","raw","Error","message","contentLength","parseInt","headers","isNaN","tmpFileSize","fileSize","warn","url","copyFileContent","removeFiles","manageLock","res","lockAction","COLLABORA_HEADERS","Action","COLLABORA_LOCK_ACTION","LOCK","reqLockToken","lockTokenFromHeaders","currentLock","isLockedWithToken","refreshLockTimeout","expiration","ok","fileLock","create","lockRoot","lockToken","lockConflict","options","UNLOCK","removeLock","key","CONFLICT","GET_LOCK","getLocksByPath","length","header","LockToken","REFRESH_LOCK","token","collaboraBase","externalCollaboraOnlineServer","contextManager","headerOriginUrl","editorUrl","URL","COLLABORA_URI","wopiSrcUrl","API_COLLABORA_ONLINE_FILES","searchParams","set","COLLABORA_WOPI_SRC_QUERY_PARAM_NAME","toString","COLLABORA_TOKEN_QUERY_PARAM_NAME","jwt","signAsync","identity","language","role","applications","spaceUrl","secret","configuration","auth","access","expiresIn","currentLockToken","timestamp","Timestamp","LOOLStatusCode","isPathExists","NOT_FOUND","isPathIsDir","Logger","files","collabora","externalServer","convertHumanTimeToSeconds","refresh"],"mappings":"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"}

package/server/applications/files/modules/collabora-online/collabora-online-manager.service.spec.js

@@ -0,0 +1,552 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _common = require("@nestjs/common");
+const _jwt = require("@nestjs/jwt");
+const _testing = require("@nestjs/testing");
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodestream = require("node:stream");
+const _contextmanagerservice = require("../../../../infrastructure/context/services/context-manager.service");
+const _spaces = require("../../../spaces/constants/spaces");
+const _webdav = require("../../../webdav/constants/webdav");
+const _operations = require("../../constants/operations");
+const _filelockerror = require("../../models/file-lock-error");
+const _fileslockmanagerservice = require("../../services/files-lock-manager.service");
+const _files = /*#__PURE__*/ _interop_require_wildcard(require("../../utils/files"));
+const _collaboraonlinemanagerservice = require("./collabora-online-manager.service");
+const _collaboraonlineconstants = require("./collabora-online.constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+jest.mock('../../utils/files');
+jest.mock('node:fs/promises');
+jest.mock('../../../users/utils/avatar');
+describe(_collaboraonlinemanagerservice.CollaboraOnlineManager.name, ()=>{
+    let service;
+    let filesLockManager;
+    const mockUser = {
+        id: 1,
+        login: 'testuser',
+        email: 'test@example.com',
+        fullName: 'Test User',
+        language: 'en',
+        role: 1,
+        applications: []
+    };
+    const mockSpace = {
+        realPath: '/path/to/document.docx',
+        url: '/files/document.docx',
+        envPermissions: '',
+        dbFile: {
+            id: 1,
+            path: '/document.docx',
+            ownerId: 1,
+            name: 'document.docx'
+        }
+    };
+    beforeEach(async ()=>{
+        const module = await _testing.Test.createTestingModule({
+            providers: [
+                _collaboraonlinemanagerservice.CollaboraOnlineManager,
+                {
+                    provide: _contextmanagerservice.ContextManager,
+                    useValue: {
+                        headerOriginUrl: jest.fn().mockReturnValue('https://domain.com')
+                    }
+                },
+                {
+                    provide: _jwt.JwtService,
+                    useValue: {
+                        signAsync: jest.fn().mockResolvedValue('mock-jwt-token')
+                    }
+                },
+                {
+                    provide: _fileslockmanagerservice.FilesLockManager,
+                    useValue: {
+                        checkConflicts: jest.fn(),
+                        convertLockToFileLockProps: jest.fn(),
+                        create: jest.fn(),
+                        removeLock: jest.fn(),
+                        getLocksByPath: jest.fn(),
+                        isLockedWithToken: jest.fn(),
+                        refreshLockTimeout: jest.fn()
+                    }
+                }
+            ]
+        }).compile();
+        module.useLogger([
+            'fatal'
+        ]);
+        service = module.get(_collaboraonlinemanagerservice.CollaboraOnlineManager);
+        filesLockManager = module.get(_fileslockmanagerservice.FilesLockManager);
+    });
+    afterEach(()=>{
+        jest.clearAllMocks();
+    });
+    it('should be defined', ()=>{
+        expect(service).toBeDefined();
+    });
+    describe('getSettings', ()=>{
+        beforeEach(()=>{
+            jest.spyOn(_files, 'isPathExists').mockResolvedValue(true);
+            jest.spyOn(_files, 'isPathIsDir').mockResolvedValue(false);
+            jest.spyOn(_files, 'genUniqHashFromFileDBProps').mockReturnValue('file-hash-123');
+        });
+        it('should return settings with edit mode when user has modify permissions and no lock conflicts', async ()=>{
+            const spaceWithPermissions = {
+                ...mockSpace,
+                envPermissions: _spaces.SPACE_OPERATION.MODIFY
+            };
+            jest.spyOn(filesLockManager, 'checkConflicts').mockResolvedValue(undefined);
+            const result = await service.getSettings(mockUser, spaceWithPermissions);
+            expect(result).toEqual({
+                documentServerUrl: expect.stringContaining('file-hash-123'),
+                mode: _operations.FILE_MODE.EDIT,
+                hasLock: false
+            });
+            expect(filesLockManager.checkConflicts).toHaveBeenCalledWith(mockSpace.dbFile, _webdav.DEPTH.RESOURCE, expect.objectContaining({
+                userId: mockUser.id,
+                app: _collaboraonlineconstants.COLLABORA_APP_LOCK,
+                lockScope: _webdav.LOCK_SCOPE.SHARED
+            }));
+        });
+        it('should return settings with view mode when lock conflict exists', async ()=>{
+            const spaceWithPermissions = {
+                ...mockSpace,
+                envPermissions: _spaces.SPACE_OPERATION.MODIFY
+            };
+            const mockLock = {
+                userId: 2,
+                options: {
+                    lockToken: 'token-123'
+                }
+            };
+            const mockFileLockProps = {
+                owner: {
+                    id: 2,
+                    login: 'otheruser',
+                    email: 'other@example.com',
+                    fullName: 'Other User'
+                },
+                app: _collaboraonlineconstants.COLLABORA_APP_LOCK,
+                isExclusive: false
+            };
+            jest.spyOn(filesLockManager, 'checkConflicts').mockRejectedValue(new _filelockerror.LockConflict(mockLock, 'conflict'));
+            jest.spyOn(filesLockManager, 'convertLockToFileLockProps').mockReturnValue(mockFileLockProps);
+            const result = await service.getSettings(mockUser, spaceWithPermissions);
+            expect(result.mode).toBe(_operations.FILE_MODE.VIEW);
+            expect(result.hasLock).toEqual(mockFileLockProps);
+        });
+        it('should return view mode when user does not have modify permissions', async ()=>{
+            const spaceWithoutPermissions = {
+                ...mockSpace,
+                envPermissions: ''
+            };
+            const result = await service.getSettings(mockUser, spaceWithoutPermissions);
+            expect(result.mode).toBe(_operations.FILE_MODE.VIEW);
+            expect(filesLockManager.checkConflicts).not.toHaveBeenCalled();
+        });
+        it('should throw error when document extension is not supported', async ()=>{
+            const spaceWithUnsupportedFile = {
+                ...mockSpace,
+                realPath: '/path/to/document.xyz'
+            };
+            jest.spyOn(_files, 'isPathExists').mockResolvedValue(true);
+            jest.spyOn(_files, 'isPathIsDir').mockResolvedValue(false);
+            await expect(service.getSettings(mockUser, spaceWithUnsupportedFile)).rejects.toThrow(new _common.HttpException('Document not supported', _common.HttpStatus.BAD_REQUEST));
+        });
+        it('should throw error when document does not exist', async ()=>{
+            jest.spyOn(_files, 'isPathExists').mockResolvedValue(false);
+            await expect(service.getSettings(mockUser, mockSpace)).rejects.toThrow(new _common.HttpException('Document not found', _common.HttpStatus.NOT_FOUND));
+        });
+        it('should throw error when path is a directory', async ()=>{
+            jest.spyOn(_files, 'isPathExists').mockResolvedValue(true);
+            jest.spyOn(_files, 'isPathIsDir').mockResolvedValue(true);
+            await expect(service.getSettings(mockUser, mockSpace)).rejects.toThrow(new _common.HttpException('Document must be a file', _common.HttpStatus.BAD_REQUEST));
+        });
+    });
+    describe('checkFileInfo', ()=>{
+        it('should return file information', async ()=>{
+            const mockStats = {
+                size: 1024,
+                mtime: new Date('2024-01-01T10:00:00Z')
+            };
+            const mockRequest = {
+                user: mockUser,
+                space: {
+                    ...mockSpace,
+                    envPermissions: _spaces.SPACE_OPERATION.MODIFY
+                }
+            };
+            jest.spyOn(_promises.default, 'stat').mockResolvedValue(mockStats);
+            jest.spyOn(_files, 'fileName').mockReturnValue('document.docx');
+            jest.spyOn(_files, 'genEtag').mockReturnValue('etag-123');
+            const { getAvatarBase64 } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../../../users/utils/avatar")));
+            getAvatarBase64.mockResolvedValue('base64-avatar');
+            const result = await service.checkFileInfo(mockRequest);
+            expect(result).toEqual({
+                BaseFileName: 'document.docx',
+                Version: 'etag-123',
+                OwnerId: '1',
+                Size: 1024,
+                LastModifiedTime: '2024-01-01T10:00:00.000Z',
+                UserId: '1',
+                UserFriendlyName: 'Test User (test@example.com)',
+                ReadOnly: false,
+                UserExtraInfo: {
+                    avatar: 'base64-avatar'
+                },
+                UserCanNotWriteRelative: true,
+                UserCanWrite: true,
+                UserCanRename: false,
+                SupportsUpdate: true,
+                SupportsRename: false,
+                SupportsExport: true,
+                SupportsCoauth: true,
+                SupportsLocks: true,
+                SupportsGetLock: true
+            });
+        });
+        it('should set UserCanWrite to false when user does not have modify permissions', async ()=>{
+            const mockStats = {
+                size: 1024,
+                mtime: new Date('2024-01-01T10:00:00Z')
+            };
+            const mockRequest = {
+                user: mockUser,
+                space: {
+                    ...mockSpace,
+                    envPermissions: ''
+                }
+            };
+            jest.spyOn(_promises.default, 'stat').mockResolvedValue(mockStats);
+            jest.spyOn(_files, 'fileName').mockReturnValue('document.docx');
+            jest.spyOn(_files, 'genEtag').mockReturnValue('etag-123');
+            const { getAvatarBase64 } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("../../../users/utils/avatar")));
+            getAvatarBase64.mockResolvedValue('base64-avatar');
+            const result = await service.checkFileInfo(mockRequest);
+            expect(result.UserCanWrite).toBe(false);
+        });
+    });
+    describe('saveDocument', ()=>{
+        beforeEach(()=>{
+            jest.spyOn(_files, 'isPathExists').mockResolvedValue(true);
+            jest.spyOn(_files, 'isPathIsDir').mockResolvedValue(false);
+            jest.spyOn(_files, 'fileName').mockReturnValue('document.docx');
+            jest.spyOn(_files, 'uniqueFilePathFromDir').mockResolvedValue('/tmp/document-unique.docx');
+            jest.spyOn(_files, 'writeFromStream').mockResolvedValue(undefined);
+            jest.spyOn(_files, 'copyFileContent').mockResolvedValue(undefined);
+            jest.spyOn(_files, 'removeFiles').mockResolvedValue(undefined);
+        });
+        it('should save document successfully', async ()=>{
+            const mockStats = {
+                mtime: new Date('2024-01-01T11:00:00Z')
+            };
+            const mockRequest = {
+                user: mockUser,
+                space: mockSpace,
+                headers: {
+                    'content-length': '1024'
+                },
+                raw: new _nodestream.Readable()
+            };
+            jest.spyOn(_promises.default, 'stat').mockResolvedValue(mockStats);
+            jest.spyOn(_files, 'fileSize').mockResolvedValue(1024);
+            const result = await service.saveDocument(mockRequest);
+            expect(result).toEqual({
+                LastModifiedTime: '2024-01-01T11:00:00.000Z'
+            });
+            expect(_files.writeFromStream).toHaveBeenCalledWith('/tmp/document-unique.docx', mockRequest.raw);
+            expect(_files.copyFileContent).toHaveBeenCalledWith('/tmp/document-unique.docx', mockSpace.realPath);
+            expect(_files.removeFiles).toHaveBeenCalledWith('/tmp/document-unique.docx');
+        });
+        it('should throw error when document size mismatch', async ()=>{
+            const mockRequest = {
+                user: mockUser,
+                space: mockSpace,
+                headers: {
+                    'content-length': '1024',
+                    [_collaboraonlineconstants.COLLABORA_HEADERS.Timestamp]: '2024-01-01T10:00:00.000Z'
+                },
+                raw: new _nodestream.Readable()
+            };
+            jest.spyOn(_files, 'fileSize').mockResolvedValue(512);
+            jest.spyOn(_promises.default, 'stat').mockResolvedValue({
+                mtime: new Date('2024-01-01T10:00:00.000Z')
+            });
+            await expect(service.saveDocument(mockRequest)).rejects.toThrow(new _common.HttpException('Size Mismatch', _common.HttpStatus.BAD_REQUEST));
+        });
+        it('should throw error when timestamp mismatch', async ()=>{
+            const mockRequest = {
+                user: mockUser,
+                space: mockSpace,
+                headers: {
+                    'content-length': '1024',
+                    [_collaboraonlineconstants.COLLABORA_HEADERS.Timestamp]: '2024-01-01T10:00:00.000Z'
+                },
+                raw: new _nodestream.Readable()
+            };
+            jest.spyOn(_promises.default, 'stat').mockResolvedValue({
+                mtime: new Date('2024-01-01T11:00:00.000Z')
+            });
+            await expect(service.saveDocument(mockRequest)).rejects.toThrow(new _common.HttpException({
+                LOOLStatusCode: 1010
+            }, _common.HttpStatus.CONFLICT));
+        });
+        it('should throw error when document does not exist', async ()=>{
+            const mockRequest = {
+                user: mockUser,
+                space: mockSpace,
+                headers: {
+                    'content-length': '1024'
+                },
+                raw: new _nodestream.Readable()
+            };
+            jest.spyOn(_files, 'isPathExists').mockResolvedValue(false);
+            await expect(service.saveDocument(mockRequest)).rejects.toThrow(new _common.HttpException('Document not found', _common.HttpStatus.NOT_FOUND));
+        });
+    });
+    describe('manageLock', ()=>{
+        const mockReply = {
+            header: jest.fn().mockReturnThis()
+        };
+        describe('LOCK action', ()=>{
+            it('should create a new lock', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.LOCK,
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.LockToken]: 'new-lock-token'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'isLockedWithToken').mockResolvedValue(null);
+                jest.spyOn(filesLockManager, 'create').mockResolvedValue([
+                    true,
+                    {}
+                ]);
+                await service.manageLock(mockRequest, mockReply);
+                expect(filesLockManager.create).toHaveBeenCalledWith(mockUser, mockSpace.dbFile, _collaboraonlineconstants.COLLABORA_APP_LOCK, _webdav.DEPTH.RESOURCE, expect.objectContaining({
+                    lockToken: 'new-lock-token',
+                    lockScope: _webdav.LOCK_SCOPE.SHARED
+                }), expect.any(Number));
+            });
+            it('should refresh existing lock', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.LOCK,
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.LockToken]: 'existing-lock-token'
+                    }
+                };
+                const existingLock = {
+                    key: 'lock-key',
+                    options: {
+                        lockToken: 'existing-lock-token'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'isLockedWithToken').mockResolvedValue(existingLock);
+                jest.spyOn(filesLockManager, 'refreshLockTimeout').mockResolvedValue(undefined);
+                await service.manageLock(mockRequest, mockReply);
+                expect(filesLockManager.refreshLockTimeout).toHaveBeenCalledWith(existingLock, expect.any(Number));
+                expect(filesLockManager.create).not.toHaveBeenCalled();
+            });
+            it('should throw conflict when lock creation fails', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.LOCK,
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.LockToken]: 'new-lock-token'
+                    }
+                };
+                const conflictingLock = {
+                    options: {
+                        lockToken: 'conflicting-token'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'isLockedWithToken').mockResolvedValue(null);
+                jest.spyOn(filesLockManager, 'create').mockResolvedValue([
+                    false,
+                    conflictingLock
+                ]);
+                await expect(service.manageLock(mockRequest, mockReply)).rejects.toThrow(new _common.HttpException('The file is locked', _common.HttpStatus.CONFLICT));
+                expect(mockReply.header).toHaveBeenCalledWith(_collaboraonlineconstants.COLLABORA_HEADERS.LockToken, 'conflicting-token');
+            });
+            it('should throw error when lock token is missing', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.LOCK
+                    }
+                };
+                await expect(service.manageLock(mockRequest, mockReply)).rejects.toThrow(new _common.HttpException('Lock token is required', _common.HttpStatus.CONFLICT));
+            });
+        });
+        describe('UNLOCK action', ()=>{
+            it('should remove existing lock', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.UNLOCK,
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.LockToken]: 'lock-token-to-remove'
+                    }
+                };
+                const existingLock = {
+                    key: 'lock-key',
+                    options: {
+                        lockToken: 'lock-token-to-remove'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'isLockedWithToken').mockResolvedValue(existingLock);
+                jest.spyOn(filesLockManager, 'removeLock').mockResolvedValue(undefined);
+                await service.manageLock(mockRequest, mockReply);
+                expect(filesLockManager.removeLock).toHaveBeenCalledWith('lock-key');
+            });
+            it('should throw error when lock does not exist', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.UNLOCK,
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.LockToken]: 'non-existent-token'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'isLockedWithToken').mockResolvedValue(null);
+                await expect(service.manageLock(mockRequest, mockReply)).rejects.toThrow(new _common.HttpException('Lock not found', _common.HttpStatus.CONFLICT));
+            });
+        });
+        describe('GET_LOCK action', ()=>{
+            it('should return lock token when lock exists', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.GET_LOCK
+                    }
+                };
+                const existingLock = {
+                    options: {
+                        lockToken: 'existing-lock-token'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'getLocksByPath').mockResolvedValue([
+                    existingLock
+                ]);
+                await service.manageLock(mockRequest, mockReply);
+                expect(mockReply.header).toHaveBeenCalledWith(_collaboraonlineconstants.COLLABORA_HEADERS.LockToken, 'existing-lock-token');
+            });
+            it('should not set header when no lock exists', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.GET_LOCK
+                    }
+                };
+                jest.spyOn(filesLockManager, 'getLocksByPath').mockResolvedValue([]);
+                await service.manageLock(mockRequest, mockReply);
+                expect(mockReply.header).not.toHaveBeenCalled();
+            });
+        });
+        describe('REFRESH_LOCK action', ()=>{
+            it('should refresh existing lock', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.REFRESH_LOCK,
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.LockToken]: 'lock-token-to-refresh'
+                    }
+                };
+                const existingLock = {
+                    key: 'lock-key',
+                    options: {
+                        lockToken: 'lock-token-to-refresh'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'isLockedWithToken').mockResolvedValue(existingLock);
+                jest.spyOn(filesLockManager, 'refreshLockTimeout').mockResolvedValue(undefined);
+                await service.manageLock(mockRequest, mockReply);
+                expect(filesLockManager.refreshLockTimeout).toHaveBeenCalledWith(existingLock, expect.any(Number));
+            });
+            it('should throw error when lock does not exist', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: _collaboraonlineconstants.COLLABORA_LOCK_ACTION.REFRESH_LOCK,
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.LockToken]: 'non-existent-token'
+                    }
+                };
+                jest.spyOn(filesLockManager, 'isLockedWithToken').mockResolvedValue(null);
+                await expect(service.manageLock(mockRequest, mockReply)).rejects.toThrow(new _common.HttpException('Lock not found', _common.HttpStatus.CONFLICT));
+            });
+        });
+        describe('Unknown action', ()=>{
+            it('should throw error for unknown lock action', async ()=>{
+                const mockRequest = {
+                    user: mockUser,
+                    space: mockSpace,
+                    headers: {
+                        [_collaboraonlineconstants.COLLABORA_HEADERS.Action]: 'UNKNOWN_ACTION'
+                    }
+                };
+                await expect(service.manageLock(mockRequest, mockReply)).rejects.toThrow(new _common.HttpException('Unknown lock action', _common.HttpStatus.BAD_REQUEST));
+            });
+        });
+    });
+});
+
+//# sourceMappingURL=collabora-online-manager.service.spec.js.map