@xen-orchestra/rest-api 0.15.0 → 0.16.0

package/dist/proxies/proxy.controller.mjs

@@ -0,0 +1,61 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+import { provide } from 'inversify-binding-decorators';
+import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { partialProxies, proxy, proxyIds } from '../open-api/oa-examples/proxy.oa-example.mjs';
+import { XoController } from '../abstract-classes/xo-controller.mjs';
+let ProxyController = class ProxyController extends XoController {
+    getAllCollectionObjects() {
+        return this.restApi.xoApp.getAllProxies();
+    }
+    getCollectionObject(id) {
+        return this.restApi.xoApp.getProxy(id);
+    }
+    /**
+     * @example fields "vmUuid,id,name"
+     * @example filter "vmUuid?"
+     * @example limit 42
+     */
+    async getProxies(req, fields, ndjson, filter, limit) {
+        const proxies = Object.values(await this.getObjects({ filter, limit }));
+        return this.sendObjects(proxies, req);
+    }
+    /**
+     * @example id "e625ea0c-a876-405a-b838-109d762efe88"
+     */
+    getProxy(id) {
+        return this.getObject(id);
+    }
+};
+__decorate([
+    Example(proxyIds),
+    Example(partialProxies),
+    Get(''),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], ProxyController.prototype, "getProxies", null);
+__decorate([
+    Example(proxy),
+    Get('{id}'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], ProxyController.prototype, "getProxy", null);
+ProxyController = __decorate([
+    Route('proxies'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('proxies'),
+    provide(ProxyController)
+], ProxyController);
+export { ProxyController };

package/dist/rest-api/rest-api.mjs

@@ -1,3 +1,4 @@
+import * as CM from 'complex-matcher';
 import { createLogger } from '@xen-orchestra/log';
 import { invalidCredentials } from 'xo-common/api-errors.js';
 const log = createLogger('xo:rest-api:error-handler');
@@ -31,8 +32,11 @@ export class RestApi {
     getObject(id, type) {
         return this.#xoApp.getObject(id, type);
     }
-    getObjectsByType(type, opts) {
-        return this.#xoApp.getObjectsByType(type, opts);
+    getObjectsByType(type, { filter, ...opts } = {}) {
+        if (filter !== undefined && typeof filter === 'string') {
+            filter = CM.parse(filter).createPredicate();
+        }
+        return this.#xoApp.getObjectsByType(type, { filter, ...opts });
     }
     getXapiObject(maybeId, type) {
         return this.#xoApp.getXapiObject(maybeId, type);

package/dist/restore-logs/restore-log.controller.mjs

@@ -0,0 +1,144 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { createLogger } from '@xen-orchestra/log';
+import { Deprecated, Example, Get, Middlewares, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+import { inject } from 'inversify';
+import { noSuchObject } from 'xo-common/api-errors.js';
+import { provide } from 'inversify-binding-decorators';
+import { BackupLogService } from '../backup-logs/backup-log.service.mjs';
+import { RestApi } from '../rest-api/rest-api.mjs';
+import { unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { XoController } from '../abstract-classes/xo-controller.mjs';
+import { partialRestoreLogs, restoreLog, restoreLogIds } from '../open-api/oa-examples/restore-log.oa-example.mjs';
+const log = createLogger('xo:rest-api:restoreLog-controller');
+let RestoreLogController = class RestoreLogController extends XoController {
+    #backupLogService;
+    constructor(restApi, backupLogService) {
+        super(restApi);
+        this.#backupLogService = backupLogService;
+    }
+    getAllCollectionObjects() {
+        const filter = log => !this.#backupLogService.isBackupLog(log);
+        return this.restApi.xoApp.getBackupNgLogsSorted({ filter });
+    }
+    async getCollectionObject(id) {
+        const log = await this.restApi.xoApp.getBackupNgLogs(id);
+        if (this.#backupLogService.isBackupLog(log)) {
+            throw noSuchObject('restore-log');
+        }
+        return log;
+    }
+    /**
+     * @example fields "jobName,status,data"
+     * @example filter "status:success"
+     * @example limit 42
+     */
+    async getRestoreLogs(req, fields, ndjson, filter, limit) {
+        const restoreLogs = await this.getObjects({ filter, limit });
+        return this.sendObjects(Object.values(restoreLogs), req);
+    }
+    /**
+     * @example id "fo"
+     */
+    getRestoreLog(id) {
+        return this.getObject(id);
+    }
+};
+__decorate([
+    Example(restoreLogIds),
+    Example(partialRestoreLogs),
+    Get(''),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], RestoreLogController.prototype, "getRestoreLogs", null);
+__decorate([
+    Example(restoreLog),
+    Get('{id}'),
+    __param(0, Path())
+], RestoreLogController.prototype, "getRestoreLog", null);
+RestoreLogController = __decorate([
+    Route('restore-logs'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Tags('restore-logs'),
+    provide(RestoreLogController),
+    __param(0, inject(RestApi)),
+    __param(1, inject(BackupLogService))
+], RestoreLogController);
+export { RestoreLogController };
+// ----------- DEPRECATED TO BE REMOVED IN ONE YEAR  (09-12-2026)--------------------
+let DeprecatedRestoreController = class DeprecatedRestoreController extends XoController {
+    #backupLogService;
+    constructor(restApi, backupLogService) {
+        super(restApi);
+        this.#backupLogService = backupLogService;
+    }
+    getAllCollectionObjects() {
+        const filter = log => !this.#backupLogService.isBackupLog(log);
+        return this.restApi.xoApp.getBackupNgLogsSorted({ filter });
+    }
+    async getCollectionObject(id) {
+        const log = await this.restApi.xoApp.getBackupNgLogs(id);
+        if (this.#backupLogService.isBackupLog(log)) {
+            throw noSuchObject('restore-log');
+        }
+        return log;
+    }
+    /**
+     * @example fields "jobName,status,data"
+     * @example filter "status:success"
+     * @example limit 42
+     */
+    async getDeprecatedRestoreLogs(req, fields, ndjson, filter, limit) {
+        const restoreLogs = await this.getObjects({ filter, limit });
+        return this.sendObjects(Object.values(restoreLogs), req, 'restore-logs');
+    }
+    /**
+     * @example id "1758180544428"
+     */
+    getDeprecatedRestoreLog(id) {
+        return this.getObject(id);
+    }
+};
+__decorate([
+    Example(restoreLogIds),
+    Example(partialRestoreLogs),
+    Deprecated(),
+    Get(''),
+    __param(0, Request()),
+    __param(1, Query()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], DeprecatedRestoreController.prototype, "getDeprecatedRestoreLogs", null);
+__decorate([
+    Example(restoreLog),
+    Deprecated(),
+    Get('{id}'),
+    __param(0, Path())
+], DeprecatedRestoreController.prototype, "getDeprecatedRestoreLog", null);
+DeprecatedRestoreController = __decorate([
+    Route('restore/logs'),
+    Security('*'),
+    Response(unauthorizedResp.status, unauthorizedResp.description),
+    Middlewares((_req, _res, next) => {
+        log.warn('You are calling a deprecated route. It will be removed in the futur. Please use `/rest/v0/restore-logs` instead');
+        next();
+    }),
+    Tags('restore-logs'),
+    provide(DeprecatedRestoreController),
+    __param(0, inject(RestApi)),
+    __param(1, inject(BackupLogService))
+], DeprecatedRestoreController);
+export { DeprecatedRestoreController };
+// ----------- DEPRECATED TO BE REMOVED IN ONE YEAR  (09-12-2026)--------------------

package/dist/srs/sr.controller.mjs

@@ -7,14 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+import { Example, Get, Path, Post, Query, Request, Response, Route, Security, SuccessResponse, Tags } from 'tsoa';
 import { inject } from 'inversify';
 import { provide } from 'inversify-binding-decorators';
+import { SUPPORTED_VDI_FORMAT } from '@vates/types';
 import { AlarmService } from '../alarms/alarm.service.mjs';
+import { BASE_URL } from '../index.mjs';
 import { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
 import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
-import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { createdResp, notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { partialSrs, sr, srIds } from '../open-api/oa-examples/sr.oa-example.mjs';
+import { vdiId } from '../open-api/oa-examples/vdi.oa-example.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 let SrController = class SrController extends XapiXoController {
@@ -51,6 +54,28 @@ let SrController = class SrController extends XapiXoController {
         });
         return this.sendObjects(Object.values(alarms), req, 'alarms');
     }
+    /**
+     * Import an exported VDI
+     * @example id "c4284e12-37c9-7967-b9e8-83ef229c3e03"
+     * @example name_label "VDI_foo_import"
+     * @example name_description "VDI imported by the REST API"
+     * @example raw true
+     */
+    async srImportVdi(req, id, name_label, name_description, raw) {
+        const xapiSr = this.getXapiObject(id);
+        const xapi = xapiSr.$xapi;
+        if (req.headers['content-length'] !== undefined) {
+            req.length = +req.headers['content-length'];
+        }
+        const vdiRef = await xapi.SR_importVdi(xapiSr.$ref, req, {
+            format: raw ? SUPPORTED_VDI_FORMAT.raw : SUPPORTED_VDI_FORMAT.vhd,
+            name_label,
+            name_description,
+        });
+        const vdiId = await xapi.getField('VDI', vdiRef, 'uuid');
+        this.setHeader('Location', `${BASE_URL}/vdis/${vdiId}`);
+        return { id: vdiId };
+    }
 };
 __decorate([
     Example(srIds),
@@ -80,6 +105,18 @@ __decorate([
     __param(4, Query()),
     __param(5, Query())
 ], SrController.prototype, "getSrAlarms", null);
+__decorate([
+    Example(vdiId),
+    Post('{id}/vdis'),
+    Tags('vdis'),
+    SuccessResponse(createdResp.status, 'VDI imported'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query())
+], SrController.prototype, "srImportVdi", null);
 SrController = __decorate([
     Route('srs'),
     Security('*'),

package/dist/tasks/task.controller.mjs

@@ -9,10 +9,10 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import * as CM from 'complex-matcher';
 import { XoController } from '../abstract-classes/xo-controller.mjs';
-import { Get, Path, Query, Request, Route, Security, Tags, Response, Example } from 'tsoa';
-import { badRequestResp, notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { Get, Path, Query, Request, Route, Security, Tags, Response, Example, Delete, Post, SuccessResponse } from 'tsoa';
+import { asynchronousActionResp, badRequestResp, noContentResp, notFoundResp, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { provide } from 'inversify-binding-decorators';
-import { partialTasks, task, taskIds } from '../open-api/oa-examples/task.oa-example.mjs';
+import { partialTasks, task, taskIds, taskLocation } from '../open-api/oa-examples/task.oa-example.mjs';
 import pDefer from 'promise-toolbox/defer';
 import { ApiError } from '../helpers/error.helper.mjs';
 import { Transform } from 'node:stream';
@@ -90,6 +90,33 @@ let TaskController = class TaskController extends XoController {
         }
         return this.getObject(taskId);
     }
+    async deleteTasks() {
+        await this.restApi.tasks.clearLogs();
+    }
+    /**
+     * @example id "0mdd1basu"
+     */
+    async deleteTask(id) {
+        const task = await this.getObject(id);
+        await this.restApi.tasks.deleteLog(task.id);
+    }
+    /**
+     * @example id "0mdd1basu"
+     */
+    async abortTask(id, sync) {
+        const taskId = id;
+        const action = async () => {
+            await this.restApi.tasks.abort(taskId);
+        };
+        return this.createAction(action, {
+            sync,
+            statusCode: noContentResp.status,
+            taskProperties: {
+                name: 'abort task',
+                objectId: taskId,
+            },
+        });
+    }
 };
 __decorate([
     Example(taskIds),
@@ -111,6 +138,25 @@ __decorate([
     __param(1, Path()),
     __param(2, Query())
 ], TaskController.prototype, "getTask", null);
+__decorate([
+    Delete(''),
+    SuccessResponse(noContentResp.status, noContentResp.description)
+], TaskController.prototype, "deleteTasks", null);
+__decorate([
+    Delete('{id}'),
+    SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], TaskController.prototype, "deleteTask", null);
+__decorate([
+    Example(taskLocation),
+    Post('{id}/actions/abort'),
+    SuccessResponse(asynchronousActionResp.status, asynchronousActionResp.description, asynchronousActionResp.produce),
+    Response(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path()),
+    __param(1, Query())
+], TaskController.prototype, "abortTask", null);
 TaskController = __decorate([
     Route('tasks'),
     Security('*'),

package/dist/tasks/task.service.mjs

@@ -0,0 +1,24 @@
+import * as CM from 'complex-matcher';
+export class TaskService {
+    #restApi;
+    constructor(restApi) {
+        this.#restApi = restApi;
+    }
+    async getTasks({ filter, limit = Infinity } = {}) {
+        const tasks = [];
+        let userFilter = () => true;
+        if (filter !== undefined) {
+            userFilter = typeof filter === 'string' ? CM.parse(filter).createPredicate() : filter;
+        }
+        for await (const task of this.#restApi.tasks.list()) {
+            if (limit === 0) {
+                break;
+            }
+            if (userFilter(task)) {
+                tasks.push(task);
+                limit--;
+            }
+        }
+        return tasks;
+    }
+}

package/dist/users/user.controller.mjs

@@ -8,28 +8,35 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Body, Delete, Example, Get, Middlewares, Patch, Path, Post, Query, Request, Response, Route, Security, SuccessResponse, Tags, } from 'tsoa';
+import { inject } from 'inversify';
 import { json } from 'express';
 import { provide } from 'inversify-binding-decorators';
 import { createdResp, forbiddenOperationResp, invalidParameters, noContentResp, notFoundResp, resourceAlreadyExists, unauthorizedResp, } from '../open-api/common/response.common.mjs';
 import { forbiddenOperation } from 'xo-common/api-errors.js';
-import { partialUsers, user, userId, userIds } from '../open-api/oa-examples/user.oa-example.mjs';
+import { partialUsers, user, authenticationTokens, userId, userIds } from '../open-api/oa-examples/user.oa-example.mjs';
+import { RestApi } from '../rest-api/rest-api.mjs';
+import { limitAndFilterArray } from '../helpers/utils.helper.mjs';
+import { UserService } from './user.service.mjs';
 import { XoController } from '../abstract-classes/xo-controller.mjs';
+import { groupIds, partialGroups } from '../open-api/oa-examples/group.oa-example.mjs';
 let UserController = class UserController extends XoController {
+    #userService;
+    constructor(restApi, userService) {
+        super(restApi);
+        this.#userService = userService;
+    }
     // --- abstract methods
     async getAllCollectionObjects() {
-        const users = await this.restApi.xoApp.getAllUsers();
-        return users.map(user => this.#sanitizeUser(user));
+        return this.#userService.getUsers();
     }
     async getCollectionObject(id) {
-        const user = await this.restApi.xoApp.getUser(id);
-        return this.#sanitizeUser(user);
+        return this.#userService.getUser(id);
     }
-    #sanitizeUser(user) {
-        const sanitizedUser = { ...user };
-        if (sanitizedUser.pw_hash !== undefined) {
-            sanitizedUser.pw_hash = '***obfuscated***';
-        }
-        return sanitizedUser;
+    #redirectCurrentUser(req) {
+        const currentUser = this.restApi.getCurrentUser();
+        const originalUrl = req.originalUrl;
+        const res = req.res;
+        res.redirect(307, originalUrl.replace(/\/users\/me(?=\/|$)/, `/users/${currentUser.id}`));
     }
     /**
      * @example fields "permission,name,id"
@@ -40,6 +47,18 @@ let UserController = class UserController extends XoController {
         const users = Object.values(await this.getObjects({ filter, limit }));
         return this.sendObjects(users, req);
     }
+    /**
+     * Redirect to `/users/:id`
+     */
+    redirectMe(req) {
+        this.#redirectCurrentUser(req);
+    }
+    /**
+     * Redirect to `/users/:id/<rest-of-your-path>`
+     */
+    redirectMeWithPath(req) {
+        this.#redirectCurrentUser(req);
+    }
     /**
      * @example id "722d17b9-699b-49d2-8193-be1ac573d3de"
      */
@@ -87,6 +106,31 @@ let UserController = class UserController extends XoController {
     async deleteUser(id) {
         await this.restApi.xoApp.deleteUser(id);
     }
+    /**
+     * @example id "722d17b9-699b-49d2-8193-be1ac573d3de"
+     * @example fields "name,id,users"
+     * @example filter "users:length:>0"
+     * @example limit 42
+     */
+    async getUserGroups(req, id, fields, ndjson, filter, limit) {
+        const user = await this.getObject(id);
+        const groups = await Promise.all(user.groups.map(group => this.restApi.xoApp.getGroup(group)));
+        return this.sendObjects(limitAndFilterArray(groups, { filter, limit }), req, 'groups');
+    }
+    /**
+     * @example id "722d17b9-699b-49d2-8193-be1ac573d3de"
+     * @example filter "expiration:>1757371582496"
+     * @example limit 42
+     */
+    async getAuthenticationTokens(req, id, filter, limit) {
+        const user = await this.getObject(id);
+        const me = this.restApi.getCurrentUser();
+        if (me.id !== user.id) {
+            throw forbiddenOperation('get authentication tokens', 'can only see own authentication tokens');
+        }
+        const tokens = await this.restApi.xoApp.getAuthenticationTokensForUser(user.id);
+        return limitAndFilterArray(tokens, { filter, limit });
+    }
 };
 __decorate([
     Example(userIds),
@@ -98,6 +142,16 @@ __decorate([
     __param(3, Query()),
     __param(4, Query())
 ], UserController.prototype, "getUsers", null);
+__decorate([
+    SuccessResponse(307, 'Temporary redirect'),
+    Get('me'),
+    __param(0, Request())
+], UserController.prototype, "redirectMe", null);
+__decorate([
+    SuccessResponse(307, 'Temporary redirect'),
+    Get('me/*'),
+    __param(0, Request())
+], UserController.prototype, "redirectMeWithPath", null);
 __decorate([
     Example(user),
     Get('{id}'),
@@ -129,11 +183,36 @@ __decorate([
     Response(notFoundResp.status, notFoundResp.description),
     __param(0, Path())
 ], UserController.prototype, "deleteUser", null);
+__decorate([
+    Example(groupIds),
+    Example(partialGroups),
+    Get('{id}/groups'),
+    Tags('groups'),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query()),
+    __param(3, Query()),
+    __param(4, Query()),
+    __param(5, Query())
+], UserController.prototype, "getUserGroups", null);
+__decorate([
+    Example(authenticationTokens),
+    Get('{id}/authentication_tokens'),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(forbiddenOperationResp.status, forbiddenOperationResp.description),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Query()),
+    __param(3, Query())
+], UserController.prototype, "getAuthenticationTokens", null);
 UserController = __decorate([
     Route('users'),
     Security('*'),
     Response(unauthorizedResp.status, unauthorizedResp.description),
     Tags('users'),
-    provide(UserController)
+    provide(UserController),
+    __param(0, inject(RestApi)),
+    __param(1, inject(UserService))
 ], UserController);
 export { UserController };

package/dist/users/user.service.mjs

@@ -0,0 +1,21 @@
+export class UserService {
+    #restApi;
+    constructor(restApi) {
+        this.#restApi = restApi;
+    }
+    #sanitizeUser(user) {
+        const sanitizedUser = { ...user };
+        if (sanitizedUser.pw_hash !== undefined) {
+            sanitizedUser.pw_hash = '***obfuscated***';
+        }
+        return sanitizedUser;
+    }
+    async getUser(id) {
+        const user = await this.#restApi.xoApp.getUser(id);
+        return this.#sanitizeUser(user);
+    }
+    async getUsers() {
+        const users = await this.#restApi.xoApp.getAllUsers();
+        return users.map(user => this.#sanitizeUser(user));
+    }
+}

package/dist/vdi-snapshots/vdi-snapshot.controller.mjs

@@ -7,21 +7,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Example, Get, Path, Query, Request, Response, Route, Security, Tags } from 'tsoa';
+import { Delete, Example, Get, Path, Query, Request, Response, Route, Security, SuccessResponse, Tags } from 'tsoa';
 import { inject } from 'inversify';
 import { provide } from 'inversify-binding-decorators';
 import { escapeUnsafeComplexMatcher } from '../helpers/utils.helper.mjs';
-import { notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
+import { noContentResp, notFoundResp, unauthorizedResp } from '../open-api/common/response.common.mjs';
 import { RestApi } from '../rest-api/rest-api.mjs';
 import { partialVdiSnapshots, vdiSnapshot, vdiSnapshotIds } from '../open-api/oa-examples/vdi-snapshot.oa-example.mjs';
 import { XapiXoController } from '../abstract-classes/xapi-xo-controller.mjs';
 import { genericAlarmsExample } from '../open-api/oa-examples/alarm.oa-example.mjs';
 import { AlarmService } from '../alarms/alarm.service.mjs';
+import { VdiService } from '../vdis/vdi.service.mjs';
 let VdiSnapshotController = class VdiSnapshotController extends XapiXoController {
     #alarmService;
-    constructor(restApi, alarmService) {
+    #vdiService;
+    constructor(restApi, alarmService, vdiService) {
         super('VDI-snapshot', restApi);
         this.#alarmService = alarmService;
+        this.#vdiService = vdiService;
     }
     /**
      * @example fields "uuid,snapshot_time,$snapshot_of"
@@ -31,6 +34,22 @@ let VdiSnapshotController = class VdiSnapshotController extends XapiXoController
     getVdiSnapshots(req, fields, ndjson, filter, limit) {
         return this.sendObjects(Object.values(this.getObjects({ filter, limit })), req);
     }
+    /**
+     *
+     * Export VDI-snapshot content
+     *
+     * @example id "d2727772-735b-478f-b6f9-11e7db56dfd0"
+     */
+    async exportVdiSnapshotContent(req, id, format) {
+        const res = req.res;
+        const stream = await this.#vdiService.exportContent(id, 'VDI-snapshot', {
+            format,
+            response: res,
+        });
+        process.on('SIGTERM', () => req.destroy());
+        req.on('close', () => stream.destroy());
+        return stream;
+    }
     /**
      * @example id "d2727772-735b-478f-b6f9-11e7db56dfd0"
      */
@@ -51,6 +70,13 @@ let VdiSnapshotController = class VdiSnapshotController extends XapiXoController
         });
         return this.sendObjects(Object.values(alarms), req, 'alarms');
     }
+    /**
+     * @example id "d2727772-735b-478f-b6f9-11e7db56dfd0"
+     */
+    async deleteVdiSnapshot(id) {
+        const xapiVdiSnapshot = this.getXapiObject(id);
+        await xapiVdiSnapshot.$xapi.VDI_destroy(xapiVdiSnapshot.$ref);
+    }
 };
 __decorate([
     Example(vdiSnapshotIds),
@@ -62,6 +88,15 @@ __decorate([
     __param(3, Query()),
     __param(4, Query())
 ], VdiSnapshotController.prototype, "getVdiSnapshots", null);
+__decorate([
+    Get('{id}.{format}'),
+    SuccessResponse(200, 'Download started', 'application/octet-stream'),
+    Response(notFoundResp.status, notFoundResp.description),
+    Response(422, 'Invalid format'),
+    __param(0, Request()),
+    __param(1, Path()),
+    __param(2, Path())
+], VdiSnapshotController.prototype, "exportVdiSnapshotContent", null);
 __decorate([
     Example(vdiSnapshot),
     Get('{id}'),
@@ -80,6 +115,12 @@ __decorate([
     __param(4, Query()),
     __param(5, Query())
 ], VdiSnapshotController.prototype, "getVdiSnapshotAlarms", null);
+__decorate([
+    Delete('{id}'),
+    SuccessResponse(noContentResp.status, noContentResp.description),
+    Response(notFoundResp.status, notFoundResp.description),
+    __param(0, Path())
+], VdiSnapshotController.prototype, "deleteVdiSnapshot", null);
 VdiSnapshotController = __decorate([
     Route('vdi-snapshots'),
     Security('*'),
@@ -87,6 +128,7 @@ VdiSnapshotController = __decorate([
     Tags('vdis'),
     provide(VdiSnapshotController),
     __param(0, inject(RestApi)),
-    __param(1, inject(AlarmService))
+    __param(1, inject(AlarmService)),
+    __param(2, inject(VdiService))
 ], VdiSnapshotController);
 export { VdiSnapshotController };