@camera.ui/server 0.0.49 → 0.0.50-internal.0

package/src/api/controllers/cameras.controller.ts

@@ -0,0 +1,1029 @@
+import { createSourceName, orderBy } from '@camera.ui/common/utils';
+import { createReadStream, truncate } from 'node:fs';
+import { Readable } from 'node:stream';
+import { container } from 'tsyringe';
+
+import { createCameraSchema } from '../schemas/cameras.schema.js';
+import { CamerasService } from '../services/cameras.service.js';
+import { PluginsService } from '../services/plugins.service.js';
+
+import type { CameraInputSettings, CameraRole, Extension, ProbeConfig } from '@camera.ui/types';
+import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import type { CameraUiAPI } from '../../api.js';
+import type { ProxyServer } from '../../rpc/index.js';
+import type { ConfigService } from '../../services/config/index.js';
+import type { DBCamera } from '../database/types.js';
+import type { Go2RtcApi } from '../go2rtc/index.js';
+import type { OnvifSource } from '../go2rtc/types.js';
+import type {
+  AuthLoginRequest,
+  CameraDiscoverQueryRequest,
+  CameraPairRequest,
+  CameraProbeSourceQueryRequest,
+  CameraSnapshotQueryRequest,
+  CameraSourceParamsRequest,
+  CameraZoneInsertPatchRequest,
+  CamerasExtensionsParamsRequest,
+  CamerasExtensionsRequest,
+  CamerasInsertRequest,
+  CamerasParamsIdRequest,
+  CamerasParamsRequest,
+  CamerasPatchRequest,
+  CamerasPreviewRequest,
+  CamerasStreamRequest,
+  PaginationRequest,
+  PluginExtension,
+  PluginExtensionConfig,
+  StoragePatchRequest,
+  StorageSetRequest,
+  StorageSubmitRequest,
+} from '../types/index.js';
+
+export class CamerasController {
+  private app: FastifyInstance;
+  private api: CameraUiAPI;
+  private go2rtcApi: Go2RtcApi;
+  private configService: ConfigService;
+  private service: CamerasService;
+  private pluginsService: PluginsService;
+  private proxyServer: ProxyServer;
+
+  constructor(app: FastifyInstance) {
+    this.app = app;
+    this.service = new CamerasService();
+    this.pluginsService = new PluginsService();
+
+    this.api = container.resolve<CameraUiAPI>('api');
+    this.configService = container.resolve<ConfigService>('configService');
+    this.proxyServer = container.resolve<ProxyServer>('proxy');
+    this.go2rtcApi = container.resolve<Go2RtcApi>('go2rtcApi');
+  }
+
+  public getByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): FastifyReply {
+    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: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public getZones(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): FastifyReply {
+    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.detectionZones);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async patchZones(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraZoneInsertPatchRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    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 newZone = await this.service.patchZones(req.params.cameraname, req.body);
+
+      return reply.code(200).send(newZone);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public getExtensionsByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): FastifyReply {
+    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: PluginExtension[] = [];
+
+      camera.extensions.plugins.forEach((extension: Extension) => {
+        const plugin = this.pluginsService.getPluginByName(extension.name);
+        if (plugin) {
+          cameraExtensions.push({
+            pluginName: plugin.pluginName,
+            displayName: plugin.displayName,
+            type: plugin.contract.extensions,
+          });
+        }
+      });
+
+      const ordered = orderBy(cameraExtensions, ['displayName'], ['asc', 'asc']);
+
+      return reply.code(200).send(ordered);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getExtensionConfigByName(req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    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);
+      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 proxy = await cameraDevice.storageProxy(plugin.id);
+      const cameraSchemaConfig = await proxy.getConfig();
+
+      const cameraExtension: PluginExtensionConfig = {
+        pluginName: plugin.pluginName,
+        displayName: plugin.displayName,
+        type: plugin.contract.extensions,
+        ...cameraSchemaConfig,
+      };
+
+      return reply.code(200).send(cameraExtension);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async patchExtensionConfigByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & StoragePatchRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply> {
+    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);
+      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 proxy = await cameraDevice.storageProxy(plugin.id);
+      await proxy.setConfig(req.body);
+
+      return reply.code(200).send(req.body);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async setExtensionConfigByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & StorageSetRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply> {
+    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);
+      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 proxy = await cameraDevice.storageProxy(plugin.id);
+      await proxy.setValue<undefined>(req.body.key, undefined);
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async submitExtensionConfigByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & StorageSubmitRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply> {
+    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);
+      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 proxy = await cameraDevice.storageProxy(plugin.id);
+      const response = await proxy.submitValue(req.body.key, req.body.payload);
+
+      return reply.code(200).send(response);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async probeSourceByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraSourceParamsRequest & CameraProbeSourceQueryRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply> {
+    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: ProbeConfig = {
+        video: req.query.video,
+        audio: req.query.audio,
+        microphone: req.query.microphone,
+      };
+
+      const 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: any) {
+      return reply.code(error.response?.status ?? 500).send({
+        statusCode: error.response?.status ?? 500,
+        message: error.response?.statusText ?? error.message,
+      });
+    }
+  }
+
+  public async getSnapshotByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CameraSnapshotQueryRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    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.snapshotSource ?? cameraController.streamSource;
+      const snapshot = await cameraController.snapshot(source._id, req.query.forceNew);
+      const base64string = snapshot ? Buffer.from(snapshot).toString('base64') : undefined;
+
+      reply.header('Content-Type', 'image/jpeg');
+      return reply.code(200).send(base64string);
+    } catch (error: any) {
+      return reply.code(error.response?.status ?? 500).send({
+        statusCode: error.response?.status ?? 500,
+        message: error.response?.statusText ?? error.message,
+      });
+    }
+  }
+
+  public async getSnapshotById(req: FastifyRequest<AuthLoginRequest & CamerasParamsIdRequest & CameraSnapshotQueryRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const camera = this.service.findById(req.params.cameraid);
+      const cameraController = this.api.getCamera(camera?._id ?? '');
+
+      if (!camera || !cameraController) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Camera not exists',
+        });
+      }
+
+      const source = cameraController.snapshotSource ?? cameraController.streamSource;
+      const snapshot = await cameraController.snapshot(source._id, req.query.forceNew);
+      const base64string = snapshot ? Buffer.from(snapshot).toString('base64') : undefined;
+
+      reply.header('Content-Type', 'image/jpeg');
+      return reply.code(200).send(base64string);
+    } catch (error: any) {
+      return reply.code(error.response?.status ?? 500).send({
+        statusCode: error.response?.status ?? 500,
+        message: error.response?.statusText ?? error.message,
+      });
+    }
+  }
+
+  public async insert(req: FastifyRequest<AuthLoginRequest & CamerasInsertRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    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: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async pairCamera(req: FastifyRequest<AuthLoginRequest & CameraPairRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    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 cameraSources: Omit<CameraInputSettings, '_id'>[] = [];
+      const existingGo2RtcSources = Object.keys(this.configService.go2rtcConfig.streams ?? {});
+
+      const checkSourceExists = (sourceName: string): FastifyReply | undefined => {
+        if (existingGo2RtcSources.includes(sourceName)) {
+          return reply.code(409).send({
+            statusCode: 409,
+            message: 'Go2Rtc Source already exist',
+          });
+        }
+        return undefined;
+      };
+
+      if (req.body.type === 'HomeKit') {
+        const sourceName = createSourceName(req.body.name, 'main');
+
+        const sourceExistsError = checkSourceExists(sourceName);
+        if (sourceExistsError) {
+          return sourceExistsError;
+        }
+
+        if (!req.body.pin) {
+          return reply.code(400).send({
+            statusCode: 400,
+            message: 'PIN is required for HomeKit',
+          });
+        }
+
+        const { source } = await this.go2rtcApi.streamsApi.pairHomekit({
+          id: sourceName,
+          url: req.body.url,
+          pin: req.body.pin,
+        });
+
+        cameraSources.push({
+          name: 'main',
+          role: 'high-resolution',
+          urls: [source.url],
+          useForSnapshot: true,
+          hotMode: 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() });
+
+        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: { source: OnvifSource; role: CameraRole }[] = [];
+
+        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(req.body.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,
+          });
+        }
+      } else if (req.body.type === 'Google') {
+        const sourceName = createSourceName(req.body.name, 'main');
+
+        const sourceExistsError = checkSourceExists(sourceName);
+        if (sourceExistsError) {
+          return sourceExistsError;
+        }
+
+        if (!req.body.clientId || !req.body.clientSecret || !req.body.refreshToken || !req.body.projectId) {
+          return reply.code(400).send({
+            statusCode: 400,
+            message: 'Google credentials are required',
+          });
+        }
+
+        // Todo
+      } else if (req.body.type === 'Ring') {
+        const sourceName = createSourceName(req.body.name, 'main');
+
+        const sourceExistsError = checkSourceExists(sourceName);
+        if (sourceExistsError) {
+          return sourceExistsError;
+        }
+
+        if (!req.body.email || !req.body.password) {
+          return reply.code(400).send({
+            statusCode: 400,
+            message: 'Ring credentials are required',
+          });
+        }
+
+        // Todo
+      } else if (req.body.type === 'Roborock') {
+        const sourceName = createSourceName(req.body.name, 'main');
+
+        const sourceExistsError = checkSourceExists(sourceName);
+        if (sourceExistsError) {
+          return sourceExistsError;
+        }
+
+        if (!req.body.username || !req.body.password) {
+          return reply.code(400).send({
+            statusCode: 400,
+            message: 'Roborock credentials are required',
+          });
+        }
+
+        // Todo
+      } else {
+        return reply.code(400).send({
+          statusCode: 400,
+          message: 'Invalid camera type',
+        });
+      }
+
+      if (!cameraSources.length) {
+        return reply.code(500).send({
+          statusCode: 500,
+          message: 'No sources found',
+        });
+      }
+
+      const parsedCamera: DBCamera = createCameraSchema.parse({
+        name: req.body.name,
+        sources: cameraSources,
+      });
+
+      const newCamera = await this.service.createCamera(parsedCamera);
+
+      return reply.code(201).send(newCamera);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async preview(req: FastifyRequest<AuthLoginRequest & CamerasPreviewRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    const sourceName: string = 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,
+      });
+
+      if (!img.byteLength) {
+        return reply.code(500).send({
+          statusCode: 500,
+          message: 'Failed to take snapshot',
+        });
+      }
+
+      reply.header('Content-Type', 'image/jpeg');
+      return reply.code(201).send(Buffer.from(img).toString('base64'));
+    } catch (error: any) {
+      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,
+      });
+    }
+  }
+
+  public list(req: FastifyRequest<AuthLoginRequest & PaginationRequest>, reply: FastifyReply): FastifyReply | DBCamera[] {
+    try {
+      const result = this.service.list();
+      const ordered = orderBy(result, ['name'], ['asc']);
+
+      return ordered;
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async getStreamUrl(req: FastifyRequest<CamerasStreamRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      const camera = this.api.getCamera(req.params.cameraid);
+      if (!camera) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Camera not exists',
+        });
+      }
+
+      const streamUrl = await camera.interfaces.streamUrl(req.params.sourcename);
+      if (!streamUrl) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Stream URL not found',
+        });
+      }
+
+      return reply.code(200).send({ streamUrl });
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async discoverCameras(req: FastifyRequest<AuthLoginRequest & CameraDiscoverQueryRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    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);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async patchByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest & CamerasPatchRequest>, reply: FastifyReply): Promise<FastifyReply | void> {
+    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: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public clearLog(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): FastifyReply | void {
+    try {
+      const cameraController = this.api.getCamera(req.params.cameraname);
+
+      if (!cameraController) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Camera not exists',
+        });
+      }
+
+      truncate(cameraController.logPath, (error) => {
+        if (error) {
+          return reply.code(500).send({
+            statusCode: 500,
+            message: error.message,
+          });
+        }
+
+        this.app.io.of('/logs').emit('clear-camera-log', cameraController.name);
+
+        return reply.code(204).send();
+      });
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public downloadLog(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): FastifyReply | void {
+    try {
+      const cameraController = this.api.getCamera(req.params.cameraname);
+
+      if (!cameraController) {
+        return reply.code(404).send({
+          statusCode: 404,
+          message: 'Camera not exists',
+        });
+      }
+
+      const buffer = new Readable();
+      buffer._read = () => {};
+
+      const readStream = createReadStream(cameraController.logPath);
+
+      readStream.on('data', (data) => {
+        buffer.push(data.toString('utf8').replace(/\x1b\[[0-9;]*m/g, ''));
+      });
+
+      readStream.on('end', () => {
+        buffer.push(null);
+      });
+
+      reply.header('Content-Type', 'application/octet-stream');
+      reply.header('Content-Disposition', `attachment; filename=camera.ui.${cameraController.name.replace(/ /g, '_')}.log.txt`);
+
+      return reply.code(200).send(buffer);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async enableExtensionByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & CamerasExtensionsRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply | void> {
+    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: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async disableExtensionByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & CamerasExtensionsRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply | void> {
+    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: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async addExtensionByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & CamerasExtensionsRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply | void> {
+    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, req.query.type);
+
+      return reply.code(200).send(newCamera);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async removeExtensionByName(
+    req: FastifyRequest<AuthLoginRequest & CamerasExtensionsParamsRequest & CamerasExtensionsRequest>,
+    reply: FastifyReply,
+  ): Promise<FastifyReply | void> {
+    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, req.query.type);
+
+      return reply.code(200).send(newCamera);
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async removeByName(req: FastifyRequest<AuthLoginRequest & CamerasParamsRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    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: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  public async removeAll(req: FastifyRequest<AuthLoginRequest>, reply: FastifyReply): Promise<FastifyReply> {
+    try {
+      await this.service.removeAll();
+
+      return reply.code(204).send();
+    } catch (error: any) {
+      return reply.code(500).send({
+        statusCode: 500,
+        message: error.message,
+      });
+    }
+  }
+
+  private resolvePluginName(params: CamerasExtensionsParamsRequest['Params']): string {
+    if (params.scope) {
+      const at = params.scope.startsWith('@') ? '' : '@';
+      return `${at}${params.scope}/${params.pluginname}`;
+    } else {
+      return params.pluginname;
+    }
+  }
+}