camera.ui3 0.0.3-1.alpha.0

package/dist/server/src/api/controllers/backup.controller.js

@@ -0,0 +1,52 @@
+import { readFile } from 'node:fs';
+import { container } from 'tsyringe';
+import { BackupService } from '../services/backup.service.js';
+export class BackupController {
+    app;
+    logger;
+    service;
+    constructor(app) {
+        this.app = app;
+        this.logger = container.resolve('logger');
+        this.service = new BackupService();
+    }
+    async download(req, reply) {
+        try {
+            const backup = await this.service.createBackup(req.body.localStorage);
+            readFile(backup.backupFile, (error, fileBuffer) => {
+                if (error) {
+                    this.logger.error(error);
+                }
+                this.service.removeBackup(backup);
+                reply.send(error || fileBuffer);
+            });
+            reply.header('Content-Type', 'application/octet-stream');
+            reply.header('Content-Disposition', 'attachment; filename=camera.ui.log.txt');
+            return reply;
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async restore(req, reply) {
+        try {
+            if (!req.isMultipart()) {
+                throw new Error('No multipart request!');
+            }
+            const localStorage = await this.service.restoreBackup(req.body.upload);
+            //inform main process
+            process.send?.('restored');
+            return reply.code(201).send(localStorage);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+}
+//# sourceMappingURL=backup.controller.js.map

package/dist/server/src/api/controllers/backup.controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup.controller.js","sourceRoot":"","sources":["../../../../../src/api/controllers/backup.controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAM9D,MAAM,OAAO,gBAAgB;IACnB,GAAG,CAAkB;IACrB,MAAM,CAAgB;IACtB,OAAO,CAAgB;IAE/B,YAAY,GAAoB;QAC9B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QACf,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC,OAAO,CAAgB,QAAQ,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,EAAE,CAAC;IACrC,CAAC;IAEM,KAAK,CAAC,QAAQ,CAAC,GAA2D,EAAE,KAAmB;QACpG,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAEtE,QAAQ,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;gBAChD,IAAI,KAAK,EAAE,CAAC;oBACV,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC3B,CAAC;gBAED,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;gBAClC,KAAK,CAAC,IAAI,CAAC,KAAK,IAAI,UAAU,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;YAEH,KAAK,CAAC,MAAM,CAAC,cAAc,EAAE,0BAA0B,CAAC,CAAC;YACzD,KAAK,CAAC,MAAM,CAAC,qBAAqB,EAAE,wCAAwC,CAAC,CAAC;YAE9E,OAAO,KAAK,CAAC;QACf,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;gBAC1B,UAAU,EAAE,GAAG;gBACf,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,GAA4D,EAAE,KAAmB;QACpG,IAAI,CAAC;YACH,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,EAAE,CAAC;gBACvB,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAC;YAC3C,CAAC;YAED,MAAM,YAAY,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAEvE,qBAAqB;YACrB,OAAO,CAAC,IAAI,EAAE,CAAC,UAAU,CAAC,CAAC;YAE3B,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAC5C,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC;gBAC1B,UAAU,EAAE,GAAG;gBACf,OAAO,EAAE,KAAK,CAAC,OAAO;aACvB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;CACF"}

package/dist/server/src/api/controllers/cameras.controller.d.ts

@@ -0,0 +1,36 @@
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import type { DBCamera } from '../database/types.js';
+import type { AuthLoginRequest, CameraSourceParamsRequest, CameraZoneInsertPatchRequest, CameraZonesParamsRequest, CamerasExtensionsParamsRequest, CamerasExtensionsRequest, CamerasInsertRequest, CamerasParamsIdRequest, CamerasParamsRequest, CamerasPatchRequest, CamerasPreviewRequest, ExtensionsPatchRequest, ExtensionsSubmitRequest, PaginationRequest } from '../types/index.js';
+export declare class CamerasController {
+    private app;
+    private api;
+    private go2rtcApi;
+    private configService;
+    private service;
+    private pluginsService;
+    private proxyServer;
+    constructor(app: FastifyInstance);
+    getByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): FastifyReply;
+    getZoneByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraZonesParamsRequest>, reply: FastifyReply): FastifyReply;
+    insertZone(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraZoneInsertPatchRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    patchZoneByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraZonesParamsRequest & CameraZoneInsertPatchRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    removeZoneByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraZonesParamsRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    getExtensionsByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): FastifyReply;
+    getExtensionConfigByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    patchExtensionConfigByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & ExtensionsPatchRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    submitExtensionConfigByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & ExtensionsSubmitRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    probeSourceByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraSourceParamsRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    getSnapshotByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    getSnapshotById(req: FastifyRequest<AuthLoginRequest & CamerasParamsIdRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    insert(req: FastifyRequest<AuthLoginRequest & CamerasInsertRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    preview(req: FastifyRequest<AuthLoginRequest & CamerasPreviewRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    list(req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply): FastifyReply | DBCamera[];
+    patchByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CamerasPatchRequest>, reply: FastifyReply): Promise<FastifyReply | void>;
+    enableExtensionByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & CamerasExtensionsRequest>, reply: FastifyReply): Promise<FastifyReply | void>;
+    disableExtensionByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & CamerasExtensionsRequest>, reply: FastifyReply): Promise<FastifyReply | void>;
+    addExtensionByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest>, reply: FastifyReply): Promise<FastifyReply | void>;
+    removeExtensionByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest>, reply: FastifyReply): Promise<FastifyReply | void>;
+    removeByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    removeAll(req: FastifyRequest<AuthLoginRequest>, reply: FastifyReply): Promise<FastifyReply>;
+    private resolvePluginName;
+}

package/dist/server/src/api/controllers/cameras.controller.js

@@ -0,0 +1,586 @@
+// import { LRUCache } from 'lru-cache';
+import { createSourceName, orderBy } from '@camera.ui/common/utils';
+import { container } from 'tsyringe';
+import { CamerasService } from '../services/cameras.service.js';
+import { PluginsService } from '../services/plugins.service.js';
+// const cameraSourceProbeCache = new LRUCache<string, Go2RTCProbe>({ max: 100, ttl: 1000 * 60 * 60 * 24 });
+export class CamerasController {
+    app;
+    api;
+    go2rtcApi;
+    configService;
+    service;
+    pluginsService;
+    proxyServer;
+    constructor(app) {
+        this.app = app;
+        this.service = new CamerasService();
+        this.pluginsService = new PluginsService();
+        this.api = container.resolve('api');
+        this.configService = container.resolve('configService');
+        this.proxyServer = container.resolve('proxy');
+        this.go2rtcApi = container.resolve('go2rtcApi');
+    }
+    getByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            return reply.code(200).send(camera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    getZoneByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const zone = camera.activityZones.find((z) => z.name === req.params.zonename);
+            return reply.code(200).send(zone);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async insertZone(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const zone = camera.activityZones.find((z) => z.name === req.body.name);
+            if (zone) {
+                return reply.code(409).send({
+                    statusCode: 409,
+                    message: 'Zone already exists',
+                });
+            }
+            const newCamera = await this.service.createZone(camera.name, req.body);
+            return reply.code(201).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async patchZoneByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const zone = camera.activityZones.find((z) => z.name === req.params.zonename);
+            if (!zone) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Zone not exists',
+                });
+            }
+            const newZone = await this.service.patchZoneByName(req.params.cameraname, req.params.zonename, req.body);
+            return reply.code(200).send(newZone);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async removeZoneByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const zone = camera.activityZones.find((z) => z.name === req.params.zonename);
+            if (!zone) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Zone not exists',
+                });
+            }
+            await this.service.removeZoneByName(req.params.cameraname, req.params.zonename);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    getExtensionsByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const cameraExtensions = [];
+            const plugin = this.pluginsService.getPluginById(camera.pluginId);
+            if (plugin?.contract.builtIns) {
+                cameraExtensions.push({
+                    pluginName: plugin.pluginName,
+                    displayName: plugin.displayName,
+                    type: plugin.contract.builtIns,
+                    builtIn: true,
+                });
+            }
+            camera.extensions.plugins.forEach((pluginName) => {
+                const plugin = this.pluginsService.getPluginByName(pluginName);
+                if (plugin?.contract.extension || plugin?.contract.supportAdditionalCameras) {
+                    cameraExtensions.push({
+                        pluginName: plugin.pluginName,
+                        displayName: plugin.displayName,
+                        type: plugin?.contract.extension ? [plugin.contract.extension] : plugin.contract.builtIns,
+                    });
+                }
+            });
+            const ordered = orderBy(cameraExtensions, ['displayName'], ['asc', 'asc']);
+            return reply.code(200).send(ordered);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async getExtensionConfigByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            const cameraSchemaConfig = await this.proxyServer.requestStorageFn(plugin.id, camera._id, 'getConfig', []);
+            const rootSchema = cameraSchemaConfig?.rootSchema && Object.keys(cameraSchemaConfig.rootSchema).length ? cameraSchemaConfig.rootSchema : undefined;
+            const config = cameraSchemaConfig?.config && Object.keys(cameraSchemaConfig.config).length ? cameraSchemaConfig.config : undefined;
+            const cameraExtension = {
+                pluginName: plugin.pluginName,
+                displayName: plugin.displayName,
+                type: plugin.contract.extension ? [plugin.contract.extension] : plugin.contract.builtIns,
+                rootSchema,
+                config,
+            };
+            return reply.code(200).send(cameraExtension);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async patchExtensionConfigByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            await this.proxyServer.requestStorageFn(plugin.id, camera._id, 'setConfig', [req.body]);
+            return reply.code(200).send(req.body);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async submitExtensionConfigByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            await this.proxyServer.requestStorageFn(plugin.id, camera._id, 'setValue', [req.body.configPath, undefined]);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async probeSourceByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            const cameraDevice = this.api.getCamera(camera?._id || '');
+            if (!camera || !cameraDevice) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const source = cameraDevice.controller.sources.find((s) => s.name === req.params.sourcename);
+            if (!source) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Source not exists',
+                });
+            }
+            const src = createSourceName(camera.name, req.params.sourcename);
+            const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src });
+            return reply.code(200).send({ url: source.urls.rtsp.default, probe });
+            // if (cameraSourceProbeCache.has(src)) {
+            //   return reply.code(200).send(cameraSourceProbeCache.get(src));
+            // } else {
+            //   const probe = await this.go2rtcApi.streamsApi.probeStreamSource({ src });
+            //   cameraSourceProbeCache.set(src, probe);
+            //   return reply.code(200).send(probe);
+            // }
+        }
+        catch (error) {
+            return reply.code(error.response?.status || 500).send({
+                statusCode: error.response?.status || 500,
+                message: error.response?.statusText || error.message,
+            });
+        }
+    }
+    async getSnapshotByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            const cameraMap = this.api.getCamera(camera?._id || '');
+            const cameraDevice = cameraMap?.controller;
+            if (!camera || !cameraDevice) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const snapshot = await cameraDevice.snapshot();
+            const base64string = snapshot ? Buffer.from(snapshot).toString('base64') : undefined;
+            reply.header('Content-Type', 'image/jpeg');
+            return reply.code(200).send(base64string);
+        }
+        catch (error) {
+            return reply.code(error.response?.status || 500).send({
+                statusCode: error.response?.status || 500,
+                message: error.response?.statusText || error.message,
+            });
+        }
+    }
+    async getSnapshotById(req, reply) {
+        try {
+            const camera = this.service.findById(req.params.cameraid);
+            const cameraMap = this.api.getCamera(camera?._id || '');
+            const cameraDevice = cameraMap?.controller;
+            if (!camera || !cameraDevice) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const snapshot = await cameraDevice.snapshot();
+            const base64string = snapshot ? Buffer.from(snapshot).toString('base64') : undefined;
+            reply.header('Content-Type', 'image/jpeg');
+            return reply.code(200).send(base64string);
+        }
+        catch (error) {
+            return reply.code(error.response?.status || 500).send({
+                statusCode: error.response?.status || 500,
+                message: error.response?.statusText || error.message,
+            });
+        }
+    }
+    async insert(req, reply) {
+        try {
+            const camera = this.service.findByName(req.body.name) || this.service.findById(req.body.name);
+            if (camera) {
+                return reply.code(409).send({
+                    statusCode: 409,
+                    message: 'Camera already exists',
+                });
+            }
+            const existingGo2RtcSources = Object.keys(this.configService.go2rtcConfig.streams || {});
+            if (req.body.sources.some((source) => existingGo2RtcSources.includes(source.name))) {
+                return reply.code(409).send({
+                    statusCode: 409,
+                    message: 'Go2Rtc Source already exist',
+                });
+            }
+            const newCamera = await this.service.createCamera(req.body);
+            return reply.code(201).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async preview(req, reply) {
+        const sourceName = Math.random().toString(36).substring(7);
+        const streamSource = req.body.url;
+        try {
+            await this.go2rtcApi.streamsApi.createStream({
+                name: sourceName,
+                src: streamSource,
+            });
+            const img = await this.go2rtcApi.snapshotApi.jpeg({ src: sourceName });
+            await this.go2rtcApi.streamsApi.deleteStream({
+                src: sourceName,
+            });
+            reply.header('Content-Type', 'image/jpeg');
+            return reply.code(201).send(Buffer.from(img).toString('base64'));
+        }
+        catch (error) {
+            try {
+                await this.go2rtcApi.streamsApi.deleteStream({
+                    src: sourceName,
+                });
+            }
+            catch {
+                //
+            }
+            return reply.code(error.response?.status || 500).send({
+                statusCode: error.response?.status || 500,
+                message: error.response?.statusText || error.message,
+            });
+        }
+    }
+    list(req, reply) {
+        try {
+            const result = this.service.list();
+            const ordered = orderBy(result, ['name'], ['asc']);
+            return ordered;
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async patchByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const newCamera = await this.service.patchCameraByName(req.params.cameraname, req.body);
+            return reply.code(200).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async enableExtensionByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            const newCamera = await this.service.enableExtensionByName(req.params.cameraname, pluginName, req.query.type);
+            return reply.code(200).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async disableExtensionByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            const newCamera = await this.service.disableExtensionByName(req.params.cameraname, pluginName, req.query.type);
+            return reply.code(200).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async addExtensionByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            const newCamera = await this.service.addExtensionByName(req.params.cameraname, pluginName);
+            return reply.code(200).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async removeExtensionByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const pluginName = this.resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            const newCamera = await this.service.removeExtensionByName(req.params.cameraname, pluginName);
+            return reply.code(200).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async removeByName(req, reply) {
+        try {
+            const camera = this.service.findByName(req.params.cameraname) || this.service.findById(req.params.cameraname);
+            if (!camera) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            await this.service.removeByName(req.params.cameraname);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async removeAll(req, reply) {
+        try {
+            await this.service.removeAll();
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    resolvePluginName(params) {
+        if (params.scope) {
+            const at = params.scope.startsWith('@') ? '' : '@';
+            return `${at}${params.scope}/${params.pluginname}`;
+        }
+        else {
+            return params.pluginname;
+        }
+    }
+}
+//# sourceMappingURL=cameras.controller.js.map