@camera.ui/server 0.0.69 → 0.0.71-dev.0

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

@@ -1,10 +1,12 @@
-import { createSourceName, orderBy } from '@camera.ui/common/utils';
+import { orderBy } from '@camera.ui/common/utils';
 import { createReadStream, truncate } from 'node:fs';
 import { Readable } from 'node:stream';
 import { container } from 'tsyringe';
+import { createSourceName } from '../../utils/camera.js';
 import { createCameraSchema } from '../schemas/cameras.schema.js';
 import { CamerasService } from '../services/cameras.service.js';
 import { PluginsService } from '../services/plugins.service.js';
+import { resolvePluginName } from '../utils/plugin.js';
 export class CamerasController {
     app;
     api;
@@ -22,6 +24,14 @@ export class CamerasController {
         this.proxyServer = container.resolve('proxy');
         this.go2rtcApi = container.resolve('go2rtcApi');
     }
+    listRooms(_req, reply) {
+        try {
+            return reply.code(200).send(this.service.getRooms());
+        }
+        catch (error) {
+            return reply.code(500).send({ statusCode: 500, message: error.message });
+        }
+    }
     getByName(req, reply) {
         try {
             const camera = this.service.findByName(req.params.cameraname) ?? this.service.findById(req.params.cameraname);
@@ -77,6 +87,43 @@ export class CamerasController {
             });
         }
     }
+    getLines(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.detectionLines ?? []);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async patchLines(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 updated = await this.service.patchLines(req.params.cameraname, req.body);
+            return reply.code(200).send(updated);
+        }
+        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);
@@ -87,13 +134,13 @@ export class CamerasController {
                 });
             }
             const cameraExtensions = [];
-            camera.extensions.plugins.forEach((extension) => {
+            camera.plugins.forEach((extension) => {
                 const plugin = this.pluginsService.getPluginByName(extension.name);
                 if (plugin) {
                     cameraExtensions.push({
                         pluginName: plugin.pluginName,
                         displayName: plugin.displayName,
-                        type: plugin.contract.extensions,
+                        contract: plugin.contract,
                     });
                 }
             });
@@ -116,7 +163,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             const cameraDevice = this.api.getCamera(camera._id);
             if (!plugin) {
@@ -131,12 +178,12 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const proxy = await cameraDevice.storageProxy(plugin.id);
+            const proxy = cameraDevice.storageProxy(plugin.id);
             const cameraSchemaConfig = await proxy.getConfig();
             const cameraExtension = {
                 pluginName: plugin.pluginName,
                 displayName: plugin.displayName,
-                type: plugin.contract.extensions,
+                contract: plugin.contract,
                 ...cameraSchemaConfig,
             };
             return reply.code(200).send(cameraExtension);
@@ -157,7 +204,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             const cameraDevice = this.api.getCamera(camera._id);
             if (!plugin) {
@@ -172,7 +219,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const proxy = await cameraDevice.storageProxy(plugin.id);
+            const proxy = cameraDevice.storageProxy(plugin.id);
             await proxy.setConfig(req.body);
             return reply.code(200).send(req.body);
         }
@@ -192,7 +239,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             const cameraDevice = this.api.getCamera(camera._id);
             if (!plugin) {
@@ -207,7 +254,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const proxy = await cameraDevice.storageProxy(plugin.id);
+            const proxy = cameraDevice.storageProxy(plugin.id);
             await proxy.setValue(req.body.key, undefined);
             return reply.code(204).send();
         }
@@ -227,7 +274,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             const cameraDevice = this.api.getCamera(camera._id);
             if (!plugin) {
@@ -242,7 +289,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const proxy = await cameraDevice.storageProxy(plugin.id);
+            const proxy = cameraDevice.storageProxy(plugin.id);
             const response = await proxy.submitValue(req.body.key, req.body.payload);
             return reply.code(200).send(response);
         }
@@ -254,35 +301,33 @@ export class CamerasController {
         }
     }
     async probeSourceByName(req, reply) {
+        const camera = this.service.findByName(req.params.cameraname) ?? this.service.findById(req.params.cameraname);
+        const cameraController = this.api.getCamera(camera?._id ?? '');
+        if (!camera || !cameraController) {
+            return reply.code(404).send({
+                statusCode: 404,
+                message: 'Camera not exists',
+            });
+        }
+        const source = cameraController.sources.find((s) => s.name === req.params.sourcename);
+        if (!source) {
+            return reply.code(404).send({
+                statusCode: 404,
+                message: 'Source not exists',
+            });
+        }
+        const probeConfig = {
+            video: req.query.video,
+            audio: req.query.audio,
+            microphone: req.query.microphone,
+        };
+        let probe;
         try {
-            const camera = this.service.findByName(req.params.cameraname) ?? this.service.findById(req.params.cameraname);
-            const cameraController = this.api.getCamera(camera?._id ?? '');
-            if (!camera || !cameraController) {
-                return reply.code(404).send({
-                    statusCode: 404,
-                    message: 'Camera not exists',
-                });
-            }
-            const source = cameraController.sources.find((s) => s.name === req.params.sourcename);
-            if (!source) {
-                return reply.code(404).send({
-                    statusCode: 404,
-                    message: 'Source not exists',
-                });
-            }
-            const probeConfig = {
-                video: req.query.video,
-                audio: req.query.audio,
-                microphone: req.query.microphone,
-            };
-            const probe = await this.service.probeCameraSource(camera, source, probeConfig);
+            probe = await this.service.probeCameraSource(camera, source, probeConfig);
             return reply.code(200).send({ rtspUrl: source.urls.rtsp.base, onvifUrl: source.urls.rtsp.onvif, probe });
         }
-        catch (error) {
-            return reply.code(error.response?.status ?? 500).send({
-                statusCode: error.response?.status ?? 500,
-                message: error.response?.statusText ?? error.message,
-            });
+        catch {
+            return reply.code(200).send({ rtspUrl: source.urls.rtsp.base, onvifUrl: source.urls.rtsp.onvif, probe: { producers: [], consumers: [] } });
         }
     }
     async streamSourceInfoByName(req, reply) {
@@ -416,7 +461,7 @@ export class CamerasController {
                         message: 'PIN is required for HomeKit',
                     });
                 }
-                const { source } = await this.go2rtcApi.streamsApi.pairHomekit({
+                const { source } = await this.go2rtcApi.streamsRoute.pairHomekit({
                     id: sourceName,
                     url: req.body.url,
                     pin: req.body.pin,
@@ -428,13 +473,14 @@ export class CamerasController {
                     useForSnapshot: true,
                     hotMode: false,
                     preload: false,
+                    prebuffer: false,
                 });
             }
             else if (req.body.type === 'Onvif') {
                 const url = new URL(req.body.url);
                 url.username = req.body.username ?? '';
                 url.password = req.body.password ?? '';
-                const { sources } = await this.go2rtcApi.discoverApi.discoverOnvif({ src: url.toString() });
+                const { sources } = await this.go2rtcApi.discoverRoute.discoverOnvif({ src: url.toString() });
                 if (!sources.length) {
                     throw new Error('No sources found');
                 }
@@ -491,6 +537,7 @@ export class CamerasController {
                         useForSnapshot: role === 'snapshot' ? false : snapshotRole === role,
                         hotMode: false,
                         preload: false,
+                        prebuffer: false,
                     });
                 }
             }
@@ -506,7 +553,6 @@ export class CamerasController {
                         message: 'Google credentials are required',
                     });
                 }
-                // Todo
             }
             else if (req.body.type === 'Ring') {
                 const sourceName = createSourceName(req.body.name, 'main');
@@ -520,7 +566,6 @@ export class CamerasController {
                         message: 'Ring credentials are required',
                     });
                 }
-                // Todo
             }
             else if (req.body.type === 'Roborock') {
                 const sourceName = createSourceName(req.body.name, 'main');
@@ -534,7 +579,6 @@ export class CamerasController {
                         message: 'Roborock credentials are required',
                     });
                 }
-                // Todo
             }
             else {
                 return reply.code(400).send({
@@ -566,12 +610,12 @@ export class CamerasController {
         const sourceName = Math.random().toString(36).substring(7);
         const streamSource = req.body.url;
         try {
-            await this.go2rtcApi.streamsApi.createStream({
+            await this.go2rtcApi.streamsRoute.createStream({
                 name: sourceName,
                 src: [streamSource],
             });
-            const img = await this.go2rtcApi.snapshotApi.jpeg({ src: sourceName });
-            await this.go2rtcApi.streamsApi.deleteStream({
+            const img = await this.go2rtcApi.snapshotRoute.jpeg({ src: sourceName });
+            await this.go2rtcApi.streamsRoute.deleteStream({
                 src: sourceName,
             });
             if (!img.byteLength) {
@@ -585,7 +629,7 @@ export class CamerasController {
         }
         catch (error) {
             try {
-                await this.go2rtcApi.streamsApi.deleteStream({
+                await this.go2rtcApi.streamsRoute.deleteStream({
                     src: sourceName,
                 });
             }
@@ -598,7 +642,7 @@ export class CamerasController {
             });
         }
     }
-    list(req, reply) {
+    list(_req, reply) {
         try {
             const result = this.service.list();
             const ordered = orderBy(result, ['name'], ['asc']);
@@ -620,11 +664,19 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const streamUrl = await camera.interfaces.streamUrl(req.params.sourcename);
+            const source = camera.sources.find((s) => s.name === req.params.sourcename);
+            if (!source) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Source not exists',
+                });
+            }
+            const streamUrl = await camera.streamUrl(source._id);
             if (!streamUrl) {
+                // No custom stream URL from plugin, client should use default go2rtc URLs
                 return reply.code(404).send({
                     statusCode: 404,
-                    message: 'Stream URL not found',
+                    message: 'Custom stream URL not available, use default source URLs',
                 });
             }
             return reply.code(200).send({ streamUrl });
@@ -636,11 +688,179 @@ export class CamerasController {
             });
         }
     }
-    async discoverCameras(req, reply) {
+    getDiscoverSchema(req, reply) {
+        try {
+            const type = req.query.type;
+            if (!type) {
+                return reply.code(400).send({
+                    statusCode: 400,
+                    message: 'Device type is required',
+                });
+            }
+            const schema = this.service.getGo2rtcConnectionSchema(type);
+            return reply.code(200).send({ schema });
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async connectDiscoveredCamera(req, reply) {
         try {
-            const devices = await this.service.discoverCameras(req.query.type, req.query.src);
-            devices.sources = devices.sources.filter((source) => !this.configService.cameraURLExists(source.url));
-            return reply.code(200).send(devices);
+            const { name, url, type, username, password, pin } = req.body;
+            const existingCamera = this.service.findByName(name);
+            if (existingCamera) {
+                return reply.code(409).send({
+                    statusCode: 409,
+                    message: 'Camera already exists',
+                });
+            }
+            const cameraSources = [];
+            const existingGo2RtcSources = Object.keys(this.configService.go2rtcConfig.streams ?? {});
+            const checkSourceExists = (sourceName) => {
+                if (existingGo2RtcSources.includes(sourceName)) {
+                    return reply.code(409).send({
+                        statusCode: 409,
+                        message: 'Go2Rtc Source already exist',
+                    });
+                }
+                return undefined;
+            };
+            if (type === 'HomeKit') {
+                const sourceName = createSourceName(name, 'main');
+                const sourceExistsError = checkSourceExists(sourceName);
+                if (sourceExistsError) {
+                    return sourceExistsError;
+                }
+                if (!pin) {
+                    return reply.code(400).send({
+                        statusCode: 400,
+                        message: 'PIN is required for HomeKit',
+                    });
+                }
+                const { source } = await this.go2rtcApi.streamsRoute.pairHomekit({
+                    id: sourceName,
+                    url: url,
+                    pin: pin,
+                });
+                cameraSources.push({
+                    name: 'main',
+                    role: 'high-resolution',
+                    urls: [source.url],
+                    useForSnapshot: true,
+                    hotMode: false,
+                    preload: false,
+                    prebuffer: false,
+                });
+            }
+            else if (type === 'Onvif') {
+                const deviceUrl = new URL(url);
+                deviceUrl.username = username ?? '';
+                deviceUrl.password = password ?? '';
+                const { sources } = await this.go2rtcApi.discoverRoute.discoverOnvif({ src: deviceUrl.toString() });
+                if (!sources.length) {
+                    throw new Error('No sources found');
+                }
+                const streamSources = sources.filter((source) => source.id !== 'snapshot');
+                const snapshotSource = sources.find((source) => source.id === 'snapshot');
+                const hasMultipleStreams = streamSources.length > 2;
+                const sourceAssignments = [];
+                if (streamSources[0]) {
+                    sourceAssignments.push({
+                        source: streamSources[0],
+                        role: 'high-resolution',
+                    });
+                }
+                if (streamSources[1]) {
+                    sourceAssignments.push({
+                        source: streamSources[1],
+                        role: hasMultipleStreams ? 'mid-resolution' : 'low-resolution',
+                    });
+                }
+                if (streamSources[2]) {
+                    sourceAssignments.push({
+                        source: streamSources[2],
+                        role: 'low-resolution',
+                    });
+                }
+                if (snapshotSource) {
+                    sourceAssignments.push({
+                        source: snapshotSource,
+                        role: 'snapshot',
+                    });
+                }
+                for (const { source } of sourceAssignments) {
+                    const sourceName = createSourceName(name, source.id);
+                    const sourceExistsError = checkSourceExists(sourceName);
+                    if (sourceExistsError) {
+                        return sourceExistsError;
+                    }
+                }
+                const determineSnapshotSource = () => {
+                    if (snapshotSource)
+                        return false;
+                    if (streamSources[2])
+                        return 'low-resolution';
+                    if (streamSources[1])
+                        return hasMultipleStreams ? 'mid-resolution' : 'low-resolution';
+                    return 'high-resolution';
+                };
+                const snapshotRole = determineSnapshotSource();
+                for (const { source, role } of sourceAssignments) {
+                    cameraSources.push({
+                        name: source.id,
+                        role: role,
+                        urls: [source.url],
+                        useForSnapshot: role === 'snapshot' ? false : snapshotRole === role,
+                        hotMode: false,
+                        preload: false,
+                        prebuffer: false,
+                    });
+                }
+            }
+            else if (type === 'Hass' || type === 'FFmpeg' || type === 'GoPro' || type === 'DVRip' || type === 'Webtorrent') {
+                const sourceName = createSourceName(name, 'main');
+                const sourceExistsError = checkSourceExists(sourceName);
+                if (sourceExistsError) {
+                    return sourceExistsError;
+                }
+                let sourceUrl = url;
+                if (type === 'DVRip' && (username || password)) {
+                    const deviceUrl = new URL(url);
+                    deviceUrl.username = username ?? '';
+                    deviceUrl.password = password ?? '';
+                    sourceUrl = deviceUrl.toString();
+                }
+                cameraSources.push({
+                    name: 'main',
+                    role: 'high-resolution',
+                    urls: [sourceUrl],
+                    useForSnapshot: true,
+                    hotMode: false,
+                    preload: false,
+                    prebuffer: false,
+                });
+            }
+            else {
+                return reply.code(400).send({
+                    statusCode: 400,
+                    message: 'Unsupported device type',
+                });
+            }
+            if (!cameraSources.length) {
+                return reply.code(500).send({
+                    statusCode: 500,
+                    message: 'No sources found',
+                });
+            }
+            const parsedCamera = createCameraSchema.parse({
+                name: name,
+                sources: cameraSources,
+            });
+            const newCamera = await this.service.createCamera(parsedCamera);
+            return reply.code(201).send(newCamera);
         }
         catch (error) {
             return reply.code(500).send({
@@ -733,7 +953,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             if (!plugin) {
                 return reply.code(404).send({
@@ -741,7 +961,7 @@ export class CamerasController {
                     message: 'Plugin not exists',
                 });
             }
-            const newCamera = await this.service.enableExtensionByName(req.params.cameraname, pluginName, req.query.type);
+            const newCamera = await this.service.enableAssignmentByName(req.params.cameraname, pluginName, req.query.type);
             return reply.code(200).send(newCamera);
         }
         catch (error) {
@@ -760,7 +980,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             if (!plugin) {
                 return reply.code(404).send({
@@ -768,7 +988,7 @@ export class CamerasController {
                     message: 'Plugin not exists',
                 });
             }
-            const newCamera = await this.service.disableExtensionByName(req.params.cameraname, pluginName, req.query.type);
+            const newCamera = await this.service.disableAssignmentByName(req.params.cameraname, pluginName, req.query.type);
             return reply.code(200).send(newCamera);
         }
         catch (error) {
@@ -787,7 +1007,61 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = 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.addPluginByName(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 activateExtensionByName(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 = 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.activatePluginByName(req.params.cameraname, pluginName);
+            return reply.code(200).send(newCamera);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async deactivateExtensionByName(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 = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             if (!plugin) {
                 return reply.code(404).send({
@@ -795,7 +1069,7 @@ export class CamerasController {
                     message: 'Plugin not exists',
                 });
             }
-            const newCamera = await this.service.addExtensionByName(req.params.cameraname, pluginName, req.query.type);
+            const newCamera = await this.service.removePluginByName(req.params.cameraname, pluginName);
             return reply.code(200).send(newCamera);
         }
         catch (error) {
@@ -814,7 +1088,7 @@ export class CamerasController {
                     message: 'Camera not exists',
                 });
             }
-            const pluginName = this.resolvePluginName(req.params);
+            const pluginName = resolvePluginName(req.params);
             const plugin = this.pluginsService.getPluginByName(pluginName);
             if (!plugin) {
                 return reply.code(404).send({
@@ -822,7 +1096,7 @@ export class CamerasController {
                     message: 'Plugin not exists',
                 });
             }
-            const newCamera = await this.service.removeExtensionByName(req.params.cameraname, pluginName, req.query.type);
+            const newCamera = await this.service.removePluginByName(req.params.cameraname, pluginName);
             return reply.code(200).send(newCamera);
         }
         catch (error) {
@@ -851,7 +1125,7 @@ export class CamerasController {
             });
         }
     }
-    async removeAll(req, reply) {
+    async removeAll(_req, reply) {
         try {
             await this.service.removeAll();
             return reply.code(204).send();
@@ -863,13 +1137,160 @@ export class CamerasController {
             });
         }
     }
-    resolvePluginName(params) {
-        if (params.scope) {
-            const at = params.scope.startsWith('@') ? '' : '@';
-            return `${at}${params.scope}/${params.pluginname}`;
+    async getSensorConfigByName(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 = resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            const cameraDevice = this.api.getCamera(camera._id);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            if (!cameraDevice) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const sensorId = req.params.sensorId;
+            const proxy = cameraDevice.sensorStorageProxy(plugin.id, sensorId);
+            let schemaConfig = { schema: [], config: {} };
+            try {
+                schemaConfig = await proxy.getConfig();
+            }
+            catch {
+                // No storage registered for this sensor - return empty schema
+            }
+            const sensorExtension = {
+                pluginName: plugin.pluginName,
+                displayName: plugin.displayName,
+                contract: plugin.contract,
+                ...schemaConfig,
+            };
+            return reply.code(200).send(sensorExtension);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
         }
-        else {
-            return params.pluginname;
+    }
+    async patchSensorConfigByName(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 = resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            const cameraDevice = this.api.getCamera(camera._id);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            if (!cameraDevice) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const sensorId = req.params.sensorId;
+            const proxy = cameraDevice.sensorStorageProxy(plugin.id, sensorId);
+            await proxy.setConfig(req.body);
+            return reply.code(200).send(req.body);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async setSensorConfigByName(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 = resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            const cameraDevice = this.api.getCamera(camera._id);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            if (!cameraDevice) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const sensorId = req.params.sensorId;
+            const proxy = cameraDevice.sensorStorageProxy(plugin.id, sensorId);
+            await proxy.setValue(req.body.key, undefined);
+            return reply.code(204).send();
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
+        }
+    }
+    async submitSensorConfigByName(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 = resolvePluginName(req.params);
+            const plugin = this.pluginsService.getPluginByName(pluginName);
+            const cameraDevice = this.api.getCamera(camera._id);
+            if (!plugin) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Plugin not exists',
+                });
+            }
+            if (!cameraDevice) {
+                return reply.code(404).send({
+                    statusCode: 404,
+                    message: 'Camera not exists',
+                });
+            }
+            const sensorId = req.params.sensorId;
+            const proxy = cameraDevice.sensorStorageProxy(plugin.id, sensorId);
+            const response = await proxy.submitValue(req.body.key, req.body.payload);
+            return reply.code(200).send(response);
+        }
+        catch (error) {
+            return reply.code(500).send({
+                statusCode: 500,
+                message: error.message,
+            });
         }
     }
 }