camera.ui3 0.0.3-1.alpha.0

package/dist/server/src/api/services/cameras.service.js

@@ -0,0 +1,743 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { createSourceName, isEqual, mergeWith } from '@camera.ui/common/utils';
+import { container, delay, registry } from 'tsyringe';
+import { CAMERA_EXTENSIONS } from '../../plugins/types.js';
+import { ConfigService } from '../../services/config/index.js';
+import { Database } from '../database/index.js';
+import { cameraZonesSchema } from '../schemas/cameras.schema.js';
+import { generateInternalCameraSources } from '../utils/cameraSource.js';
+import { PluginsService } from './plugins.service.js';
+import { UsersService } from './users.service.js';
+let CamerasService = class CamerasService {
+    configService;
+    api;
+    dbs;
+    go2rtcApi;
+    usersService;
+    pluginsService;
+    constructor() {
+        this.configService = container.resolve('configService');
+        this.api = container.resolve('api');
+        this.dbs = container.resolve('dbs');
+        this.go2rtcApi = container.resolve('go2rtcApi');
+        this.usersService = new UsersService();
+        this.pluginsService = new PluginsService();
+    }
+    async createCamera(cameraData) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const plugin = this.pluginsService.getPluginById(cameraData.pluginId);
+        if (plugin?.contract.builtIns) {
+            plugin.contract.builtIns.forEach((extensionType) => {
+                if (!cameraData.extensions[extensionType]) {
+                    cameraData.extensions[extensionType] = plugin.pluginName;
+                }
+            });
+        }
+        cameraData.activityZones = [this.defaultZone()];
+        this.addInternalSources(cameraData);
+        await this.addCameraSourcesToConfig(cameraData.name, cameraData.sources);
+        cameras.push(cameraData);
+        await this.dbs.camerasDB.put('cameras', cameras);
+        const transformedCamera = this.transformCamera(cameraData);
+        await this.api.addCamera(transformedCamera);
+        return cameraData;
+    }
+    async createZone(cameraname, zoneData) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((camera) => camera.name === cameraname);
+        if (camera) {
+            camera.activityZones.push(zoneData);
+            await this.dbs.camerasDB.put('cameras', cameras);
+            this.api.updateCamera(this.transformCamera(camera));
+        }
+        return camera;
+    }
+    async patchZoneByName(cameraname, zonename, zoneData) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((camera) => camera.name === cameraname);
+        if (camera) {
+            const zone = camera.activityZones.find((zone) => zone.name === zonename);
+            if (zone) {
+                mergeWith(zone, zoneData, (objValue, srcValue) => {
+                    if (Array.isArray(objValue)) {
+                        return srcValue;
+                    }
+                });
+                await this.dbs.camerasDB.put('cameras', cameras);
+                this.api.updateCamera(this.transformCamera(camera));
+            }
+        }
+        return camera;
+    }
+    async removeZoneByName(cameraname, zonename) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((cameraObj) => cameraObj.name === cameraname);
+        if (camera) {
+            const zoneExists = camera.activityZones.some((zone) => zone.name === zonename);
+            camera.activityZones = camera.activityZones.filter((zone) => zone.name !== zonename);
+            if (zoneExists) {
+                await this.dbs.camerasDB.put('cameras', cameras);
+                this.api.updateCamera(this.transformCamera(camera));
+            }
+        }
+    }
+    async createCameraSource(cameraname, sourceName, source) {
+        const camera = this.findByName(cameraname);
+        if (!camera) {
+            throw new Error(`Camera ${cameraname} not found`);
+        }
+        if (!this.sourceExistAndEqual(sourceName, [source])) {
+            // fix after go2rtc update
+            await this.go2rtcApi.streamsApi.createStream({
+                name: sourceName,
+                src: source,
+            });
+            // if (this.configService.go2rtcConfig.streams?.[sourceName]) {
+            //   await this.go2rtcApi.streamsApi.updateStreamSource({
+            //     name: sourceName,
+            //     src: source,
+            //   });
+            // } else {
+            //   await this.go2rtcApi.streamsApi.createStream({
+            //     name: sourceName,
+            //     src: source,
+            //   });
+            // }
+            if (!this.configService.go2rtcConfig.streams)
+                this.configService.go2rtcConfig.streams = {};
+            this.configService.go2rtcConfig.streams[sourceName] = source;
+        }
+    }
+    list() {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        return cameras;
+    }
+    listTransformed() {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const transformedCameras = cameras.map((camera) => this.transformCamera(camera));
+        return transformedCameras;
+    }
+    listByPluginId(pluginId) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        return cameras.filter((camera) => camera.pluginId === pluginId);
+    }
+    listTransformedByPluginId(pluginId) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const filteredCameras = cameras.filter((camera) => camera.pluginId === pluginId);
+        const transformedCameras = filteredCameras.map((camera) => this.transformCamera(camera));
+        return transformedCameras;
+    }
+    listByExtension(pluginName) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        return cameras.filter((camera) => camera.extensions.plugins.includes(pluginName));
+    }
+    listTransformedByExtension(pluginName, extensions) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camerasMap = new Map();
+        for (const type of extensions) {
+            let dbCameras = [];
+            if (type === 'hub') {
+                dbCameras = cameras.filter((camera) => camera.extensions[type]?.includes(pluginName));
+            }
+            else {
+                dbCameras = cameras.filter((camera) => camera.extensions[type] === pluginName);
+            }
+            dbCameras.forEach((camera) => camerasMap.set(camera._id, this.transformCamera(camera)));
+        }
+        return Array.from(camerasMap.values());
+    }
+    findById(id) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        return cameras?.find((cameraObj) => cameraObj._id === id);
+    }
+    findTransformedById(id) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras?.find((cameraObj) => cameraObj._id === id);
+        if (camera) {
+            return this.transformCamera(camera);
+        }
+    }
+    findByName(cameraname) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        return cameras?.find((cameraObj) => cameraObj.name === cameraname);
+    }
+    findTransformedByName(cameraname) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras?.find((cameraObj) => cameraObj.name === cameraname);
+        if (camera) {
+            return this.transformCamera(camera);
+        }
+    }
+    findByPluginAndName(cameraname, pluginId) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        return cameras?.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginId === pluginId);
+    }
+    findTransformedByPluginAndName(cameraname, pluginId) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras?.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginId === pluginId);
+        if (camera) {
+            return this.transformCamera(camera);
+        }
+    }
+    async patchCameraByName(cameraname, cameraData) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((camera) => camera.name === cameraname);
+        const cameraOld = structuredClone(camera);
+        if (camera && cameraOld) {
+            mergeWith(camera, cameraData, (objValue, srcValue, key) => {
+                if (key === 'sources') {
+                    return srcValue.map((srcItem) => {
+                        const objItem = objValue.find((o) => o.name === srcItem.name);
+                        const sourceId = objItem?._id || srcItem._id;
+                        return objItem ? { ...objItem, ...srcItem, _id: sourceId, name: objItem.name } : srcItem;
+                    });
+                }
+                if (key === 'extensions') {
+                    return cameraOld.extensions;
+                }
+                if (Array.isArray(objValue)) {
+                    return srcValue;
+                }
+            });
+            if (!isEqual(cameraOld, camera, true)) {
+                if (cameraOld.name !== camera.name) {
+                    await this.removeCameraSourcesFromConfig(cameraOld.name, cameraOld.sources);
+                }
+                const orphanedSources = cameraOld.sources.filter((source) => !camera.sources.find((s) => s.name === source.name));
+                if (orphanedSources.length) {
+                    await this.removeCameraSourcesFromConfig(camera.name, orphanedSources);
+                }
+                this.addInternalSources(camera);
+                await this.addCameraSourcesToConfig(camera.name, camera.sources);
+            }
+            await this.dbs.camerasDB.put('cameras', cameras);
+            this.api.updateCamera(this.transformCamera(camera));
+        }
+        return camera;
+    }
+    async enableExtensionByName(cameraname, pluginNameOrId, extensionType) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const plugin = this.pluginsService.getPluginByName(pluginNameOrId) || this.pluginsService.getPluginById(pluginNameOrId);
+        const camera = cameras.find((camera) => camera.name === cameraname);
+        const cameraOld = structuredClone(camera);
+        if (camera && cameraOld && plugin) {
+            if (CAMERA_EXTENSIONS.includes(extensionType) &&
+                extensionType !== 'hub' &&
+                camera.extensions[extensionType] !== plugin.pluginName &&
+                (camera.extensions.plugins.includes(plugin.pluginName) || plugin.contract.builtIns?.includes(extensionType))) {
+                const oldExtension = camera.extensions[extensionType];
+                const oldPlugin = oldExtension ? this.pluginsService.getPluginByName(oldExtension) : undefined;
+                camera.extensions[extensionType] = plugin.pluginName;
+                const transformedCamera = this.transformCamera(camera);
+                await this.dbs.camerasDB.put('cameras', cameras);
+                if (oldPlugin && oldExtension) {
+                    this.api.deselectCamera(oldPlugin.id, transformedCamera, extensionType);
+                }
+                this.api.updateCamera(transformedCamera);
+                this.api.selectCamera(plugin.id, transformedCamera, extensionType);
+            }
+        }
+        return camera;
+    }
+    async disableExtensionByName(cameraname, pluginNameOrId, extensionType) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const plugin = this.pluginsService.getPluginByName(pluginNameOrId) || this.pluginsService.getPluginById(pluginNameOrId);
+        const camera = cameras.find((camera) => camera.name === cameraname);
+        const cameraOld = structuredClone(camera);
+        if (camera && cameraOld && plugin) {
+            if (CAMERA_EXTENSIONS.includes(extensionType) &&
+                extensionType !== 'hub' &&
+                camera.extensions[extensionType] === plugin.pluginName &&
+                (camera.extensions.plugins.includes(plugin.pluginName) || plugin.contract.builtIns?.includes(extensionType))) {
+                camera.extensions[extensionType] = undefined;
+                const transformedCamera = this.transformCamera(camera);
+                await this.dbs.camerasDB.put('cameras', cameras);
+                this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
+                this.api.updateCamera(transformedCamera);
+            }
+        }
+        return camera;
+    }
+    async addExtensionByName(cameraname, pluginNameOrId) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const plugin = this.pluginsService.getPluginByName(pluginNameOrId) || this.pluginsService.getPluginById(pluginNameOrId);
+        const camera = cameras.find((camera) => camera.name === cameraname);
+        const cameraOld = structuredClone(camera);
+        if (camera && cameraOld && (plugin?.contract.extension || plugin?.contract.supportAdditionalCameras) && !camera.extensions.plugins.includes(plugin.pluginName)) {
+            camera.extensions.plugins.push(plugin.pluginName);
+            const addedExtensions = [];
+            if (plugin?.contract.extension) {
+                const extensionType = plugin.contract.extension;
+                if (extensionType !== 'hub') {
+                    if (!camera.extensions[extensionType]) {
+                        camera.extensions[extensionType] = plugin.pluginName;
+                        addedExtensions.push(extensionType);
+                    }
+                }
+                else {
+                    if (!camera.extensions[extensionType]) {
+                        camera.extensions[extensionType] = [];
+                    }
+                    camera.extensions[extensionType].push(plugin.pluginName);
+                    addedExtensions.push(extensionType);
+                }
+            }
+            else {
+                const extensionTypes = plugin.contract.builtIns;
+                extensionTypes.forEach((extensionType) => {
+                    if (!camera.extensions[extensionType]) {
+                        camera.extensions[extensionType] = plugin.pluginName;
+                        addedExtensions.push(extensionType);
+                    }
+                });
+            }
+            const transformedCamera = this.transformCamera(camera);
+            await this.dbs.camerasDB.put('cameras', cameras);
+            this.api.updateCamera(transformedCamera);
+            for (const extensionType of addedExtensions) {
+                this.api.selectCamera(plugin.id, transformedCamera, extensionType);
+            }
+        }
+        return camera;
+    }
+    async removeExtensionByName(cameraname, pluginNameOrId) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        const plugin = this.pluginsService.getPluginByName(pluginNameOrId) || this.pluginsService.getPluginById(pluginNameOrId);
+        const camera = cameras.find((camera) => camera.name === cameraname);
+        const cameraOld = structuredClone(camera);
+        if (camera && cameraOld && (plugin?.contract.extension || plugin?.contract.supportAdditionalCameras) && camera.extensions.plugins.includes(plugin.pluginName)) {
+            camera.extensions.plugins = camera.extensions.plugins.filter((extension) => extension !== plugin.pluginName);
+            const removedExtensions = new Set();
+            if (plugin?.contract.extension) {
+                const extensionType = plugin.contract.extension;
+                if (extensionType !== 'hub') {
+                    if (camera.extensions[extensionType] === plugin.pluginName) {
+                        camera.extensions[extensionType] = undefined;
+                        removedExtensions.add(extensionType);
+                    }
+                }
+                else {
+                    if (!camera.extensions[extensionType]) {
+                        camera.extensions[extensionType] = [];
+                    }
+                    camera.extensions[extensionType] = camera.extensions[extensionType].filter((extension) => extension !== plugin.pluginName);
+                    removedExtensions.add(extensionType);
+                }
+            }
+            else if (plugin?.contract.supportAdditionalCameras) {
+                const extensionTypes = plugin.contract.builtIns;
+                extensionTypes.forEach((extensionType) => {
+                    if (camera.extensions[extensionType] === plugin.pluginName) {
+                        camera.extensions[extensionType] = undefined;
+                        removedExtensions.add(extensionType);
+                    }
+                });
+            }
+            const transformedCamera = this.transformCamera(camera);
+            await this.dbs.camerasDB.put('cameras', cameras);
+            for (const extensionType of removedExtensions) {
+                this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
+            }
+            this.api.updateCamera(transformedCamera);
+        }
+        return camera;
+    }
+    async removeExtension(pluginNameOrId) {
+        const cameras = this.dbs.camerasDB.get('cameras') || [];
+        for (const camera of cameras) {
+            const plugin = this.pluginsService.getPluginByName(pluginNameOrId) || this.pluginsService.getPluginById(pluginNameOrId);
+            if ((plugin?.contract.extension || plugin?.contract.supportAdditionalCameras) && camera.extensions.plugins.includes(plugin.pluginName)) {
+                camera.extensions.plugins = camera.extensions.plugins.filter((extension) => extension !== plugin.pluginName);
+                const removedExtensions = new Set();
+                if (plugin?.contract.extension) {
+                    const extensionType = plugin.contract.extension;
+                    if (extensionType !== 'hub') {
+                        if (camera.extensions[extensionType] === plugin.pluginName) {
+                            camera.extensions[extensionType] = undefined;
+                            removedExtensions.add(extensionType);
+                        }
+                    }
+                    else {
+                        if (!camera.extensions[extensionType]) {
+                            camera.extensions[extensionType] = [];
+                        }
+                        camera.extensions[extensionType] = camera.extensions[extensionType].filter((extension) => extension !== plugin.pluginName);
+                        removedExtensions.add(extensionType);
+                    }
+                }
+                else if (plugin?.contract.supportAdditionalCameras) {
+                    const extensionTypes = plugin.contract.builtIns;
+                    for (const extensionType of extensionTypes) {
+                        if (camera.extensions[extensionType] === plugin.pluginName) {
+                            camera.extensions[extensionType] = undefined;
+                            removedExtensions.add(extensionType);
+                        }
+                    }
+                }
+                const transformedCamera = this.transformCamera(camera);
+                await this.dbs.camerasDB.put('cameras', cameras);
+                for (const extensionType of removedExtensions) {
+                    this.api.deselectCamera(plugin.id, transformedCamera, extensionType);
+                }
+                this.api.updateCamera(this.transformCamera(camera));
+            }
+        }
+    }
+    async removeByName(cameraname) {
+        let cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((cameraObj) => cameraObj.name === cameraname);
+        if (camera) {
+            cameras = cameras.filter((cameraObj) => cameraObj.name !== camera.name);
+            await this.usersService.removeCameraFromPreferences(camera._id);
+            await this.dbs.camerasDB.put('cameras', cameras);
+            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+        }
+    }
+    async removeById(id) {
+        let cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((cameraObj) => cameraObj._id === id);
+        if (camera) {
+            cameras = cameras.filter((cameraObj) => cameraObj.name !== camera.name);
+            await this.usersService.removeCameraFromPreferences(camera._id);
+            await this.dbs.camerasDB.put('cameras', cameras);
+            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+        }
+    }
+    async removeByPluginName(pluginName) {
+        const plugin = this.pluginsService.getPluginDbByName(pluginName);
+        if (plugin) {
+            await this.removeByPluginId(plugin._id);
+        }
+    }
+    async removeByPluginId(pluginId) {
+        let cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((cameraObj) => cameraObj.pluginId === pluginId);
+        if (camera) {
+            cameras = cameras.filter((cameraObj) => cameraObj._id !== camera._id);
+            await this.usersService.removeCameraFromPreferences(camera._id);
+            await this.dbs.camerasDB.put('cameras', cameras);
+            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+        }
+    }
+    async removeByPluginIdAndName(cameraname, pluginId) {
+        let cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camera = cameras.find((cameraObj) => cameraObj.name === cameraname && cameraObj.pluginId === pluginId);
+        if (camera) {
+            cameras = cameras.filter((cameraObj) => cameraObj._id !== camera._id);
+            await this.usersService.removeCameraFromPreferences(camera._id);
+            await this.dbs.camerasDB.put('cameras', cameras);
+            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+            await this.api.removeCamera(this.transformCamera(camera), camera.extensions);
+        }
+    }
+    async removeAll() {
+        let cameras = this.dbs.camerasDB.get('cameras') || [];
+        const camerasToRemove = [];
+        cameras.forEach((camera) => camerasToRemove.push(camera));
+        cameras = [];
+        await this.usersService.resetAllPreferences();
+        await this.dbs.camerasDB.put('cameras', cameras);
+        for (const camera of camerasToRemove) {
+            await this.removeCameraSourcesFromConfig(camera.name, camera.sources);
+        }
+        await Promise.all(camerasToRemove.map((camera) => this.api.removeCamera(this.transformCamera(camera), camera.extensions)));
+    }
+    transformCamera(camera) {
+        const transformedCamera = {
+            _id: camera._id,
+            nativeId: camera.nativeId,
+            pluginId: camera.pluginId,
+            name: camera.name,
+            disabled: camera.disabled,
+            info: camera.info,
+            type: camera.type,
+            isCloud: camera.isCloud,
+            hasLight: camera.hasLight,
+            hasSiren: camera.hasSiren,
+            hasBinarySensor: camera.hasBinarySensor,
+            hasBattery: camera.hasBattery,
+            hasAudioDetector: this.extensionIsEnabled(camera.extensions.audioDetection, 'audioDetection'),
+            hasMotionDetector: this.extensionIsEnabled(camera.extensions.motionDetection, 'motionDetection'),
+            hasObjectDetector: this.extensionIsEnabled(camera.extensions.objectDetection, 'objectDetection'),
+            hasPtz: this.extensionIsEnabled(camera.extensions.ptz, 'ptz'),
+            hasPrebuffer: this.extensionIsEnabled(camera.extensions.prebuffer, 'prebuffer'),
+            activityZones: this.convertToDetectionZones(camera.activityZones),
+            activitySettings: camera.activitySettings,
+            frameWorkerSettings: camera.frameWorkerSettings,
+            sources: camera.sources.map((source) => ({
+                _id: source._id,
+                name: source.name,
+                roles: source.roles,
+                urls: {
+                    ws: this.generateWsUrls(camera, source),
+                    rtsp: this.generateRTSPUrls(camera, source),
+                    www: this.generateWWWUrls(camera, source),
+                },
+                internal: this.isInternalSource(source.name),
+            })),
+        };
+        return transformedCamera;
+    }
+    addInternalSources(camera) {
+        const sourcesToAdd = [];
+        camera.sources = camera.sources.filter((source) => !source.internal && !this.isInternalSource(source.name));
+        for (const source of camera.sources) {
+            if (source.internal) {
+                continue;
+            }
+            const defaultInternalSources = generateInternalCameraSources(camera.name, source.name, source.roles);
+            defaultInternalSources.forEach((internalSource) => {
+                sourcesToAdd.push(internalSource);
+            });
+        }
+        camera.sources.push(...sourcesToAdd);
+    }
+    async addCameraSourcesToConfig(cameraname, sources) {
+        for (const source of sources) {
+            if (source.internal) {
+                continue;
+            }
+            const sourceName = createSourceName(cameraname, source.name);
+            const ffmpegSourceNameAAC = `${sourceName}_aac`;
+            const ffmpegSourceNameOPUS = `${sourceName}_opus`;
+            const ffmpegSourceNamePCMA = `${sourceName}_pcma`;
+            const ffmpegSourceUrlAAC = `ffmpeg:${sourceName}#video=copy#audio=aac`;
+            const ffmpegSourceUrlOPUS = `ffmpeg:${sourceName}#video=copy#audio=opus`;
+            const ffmpegSourceUrlPCMA = `ffmpeg:${sourceName}#video=copy#audio=pcma`;
+            const ffmpegAACSource = {
+                name: ffmpegSourceNameAAC,
+                src: [ffmpegSourceUrlAAC],
+                // src: Array.from(new Set([`ffmpeg:${sourceName}#video=copy#audio=aac`, ...source.urls.filter((url) => !url.startsWith('ffmpeg'))])),
+            };
+            const ffmpegOPUSSource = {
+                name: ffmpegSourceNameOPUS,
+                src: [ffmpegSourceUrlOPUS],
+                // src: Array.from(new Set([`ffmpeg:${sourceName}#video=copy#audio=opus`, ...source.urls.filter((url) => !url.startsWith('ffmpeg'))])),
+            };
+            const ffmpegPCMAAudioSource = {
+                name: ffmpegSourceNamePCMA,
+                src: [ffmpegSourceUrlPCMA],
+                // src: Array.from(new Set([`ffmpeg:${sourceName}#video=copy#audio=pcma`, ...source.urls.filter((url) => !url.startsWith('ffmpeg'))])),
+            };
+            const cameraSources = [];
+            if (!this.sourceExistAndEqual(sourceName, source.urls)) {
+                cameraSources.push({ name: sourceName, src: source.urls });
+            }
+            const sourceWithoutTranscoding = source.roles.length === 1 && source.roles[0] === 'snapshot';
+            if (!sourceWithoutTranscoding) {
+                if (!this.configService.go2rtcConfig.streams?.[ffmpegAACSource.name]) {
+                    cameraSources.push(ffmpegAACSource);
+                }
+                if (!this.configService.go2rtcConfig.streams?.[ffmpegOPUSSource.name]) {
+                    cameraSources.push(ffmpegOPUSSource);
+                }
+                if (!this.configService.go2rtcConfig.streams?.[ffmpegPCMAAudioSource.name]) {
+                    cameraSources.push(ffmpegPCMAAudioSource);
+                }
+            }
+            for (const sourceData of cameraSources) {
+                // fix after go2rtc update
+                await this.go2rtcApi.streamsApi.createStream({
+                    name: sourceData.name,
+                    src: sourceData.src[0], // fix after go2rtc update
+                });
+                // if (this.configService.go2rtcConfig.streams?.[sourceData.name]) {
+                //   await this.go2rtcApi.streamsApi.updateStreamSource({
+                //     name: sourceData.name,
+                //     src: sourceData.src,
+                //   });
+                // } else {
+                //   await this.go2rtcApi.streamsApi.createStream({
+                //     name: sourceData.name,
+                //     src: sourceData.src,
+                //   });
+                // }
+            }
+            if (!this.configService.go2rtcConfig.streams) {
+                this.configService.go2rtcConfig.streams = {};
+            }
+            cameraSources.forEach((sourceData) => {
+                this.configService.go2rtcConfig.streams[sourceData.name] = sourceData.src;
+            });
+        }
+    }
+    async removeCameraSourcesFromConfig(cameraname, oldSources) {
+        for (const source of oldSources) {
+            if (source.internal) {
+                continue;
+            }
+            const sourceName = createSourceName(cameraname, source.name);
+            const ffmpegSourceNameAAC = `${sourceName}_aac`;
+            const ffmpegSourceNameOPUS = `${sourceName}_opus`;
+            const ffmpegSourceNamePCMA = `${sourceName}_pcma`;
+            const sourcesToRemove = [];
+            if (this.configService.go2rtcConfig.streams?.[sourceName]) {
+                sourcesToRemove.push(sourceName);
+            }
+            if (this.configService.go2rtcConfig.streams?.[ffmpegSourceNameAAC]) {
+                sourcesToRemove.push(ffmpegSourceNameAAC);
+            }
+            if (this.configService.go2rtcConfig.streams?.[ffmpegSourceNameOPUS]) {
+                sourcesToRemove.push(ffmpegSourceNameOPUS);
+            }
+            if (this.configService.go2rtcConfig.streams?.[ffmpegSourceNamePCMA]) {
+                sourcesToRemove.push(ffmpegSourceNamePCMA);
+            }
+            for (const src of sourcesToRemove) {
+                await this.go2rtcApi.streamsApi.deleteStream({ src });
+            }
+            if (!this.configService.go2rtcConfig.streams) {
+                this.configService.go2rtcConfig.streams = {};
+            }
+            sourcesToRemove.forEach((src) => {
+                delete this.configService.go2rtcConfig.streams?.[src];
+            });
+            if (Object.keys(this.configService.go2rtcConfig.streams).length === 0) {
+                delete this.configService.go2rtcConfig.streams;
+                await this.configService.writeGo2RtcConfigApi();
+            }
+        }
+    }
+    sourceExistAndEqual(sourceName, source) {
+        if (this.configService.go2rtcConfig.streams?.[sourceName]) {
+            let configSource = this.configService.go2rtcConfig.streams[sourceName];
+            configSource = typeof configSource === 'string' ? [configSource] : configSource;
+            return isEqual(configSource, source, true);
+        }
+        return false;
+    }
+    generateWsUrls(camera, source) {
+        const sourceName = createSourceName(camera.name, source.name);
+        const baseWebRtcUrl = `ws://${this.configService.go2rtcConfig.api.listen}/api/ws?src=${sourceName}`;
+        return {
+            webrtc: baseWebRtcUrl,
+        };
+    }
+    generateRTSPUrls(camera, source) {
+        const sourceName = createSourceName(camera.name, source.name);
+        const baseRtspUrl = `rtsp://${this.configService.go2rtcConfig.rtsp.listen}/${sourceName}`;
+        return {
+            single: baseRtspUrl,
+            default: `${baseRtspUrl}?video=all&audio=all`,
+            mp4: `${baseRtspUrl}?mp4`,
+        };
+    }
+    generateWWWUrls(camera, source) {
+        const sourceName = createSourceName(camera.name, source.name);
+        const baseStreamUrl = `http://${this.configService.go2rtcConfig.api.listen}/stream.html?src=${sourceName}`;
+        const baseMjpegStreamUrl = `http://${this.configService.go2rtcConfig.api.listen}/api/stream.mjpeg?src=${sourceName}`;
+        const baseMp4StreamUrl = `http://${this.configService.go2rtcConfig.api.listen}/api/stream.mp4?src=${sourceName}`;
+        const baseFrameMp4StreamUrl = `http://${this.configService.go2rtcConfig.api.listen}/api/frame.mp4?src=${sourceName}`;
+        const baseFrameJpegStreamUrl = `http://${this.configService.go2rtcConfig.api.listen}/api/frame.jpeg?src=${sourceName}`;
+        const baseHlsStreamUrl = `http://${this.configService.go2rtcConfig.api.listen}/api/stream.m3u8?src=${sourceName}`;
+        return {
+            webrtc: `${baseStreamUrl}&mode=webrtc`,
+            mse: `${baseStreamUrl}&mode=mse`,
+            lmp4: baseMp4StreamUrl,
+            mmp4: `${baseMp4StreamUrl}&mp4=flac`,
+            mp4: `${baseMp4StreamUrl}&mp4=all`,
+            mp4Snapshot: baseFrameMp4StreamUrl,
+            jpegSnapshot: baseFrameJpegStreamUrl,
+            lHlsTs: baseHlsStreamUrl,
+            lHlsFmp4: `${baseHlsStreamUrl}&mp4`,
+            mHlsFmp4: `${baseHlsStreamUrl}&mp4=flac`,
+            mjpeg: baseMjpegStreamUrl,
+            mjpegHtml: `${baseStreamUrl}&mode=mjpeg`,
+        };
+    }
+    extensionIsEnabled(extension, type) {
+        if (!extension || !type) {
+            return false;
+        }
+        const plugin = this.pluginsService.getPluginByName(extension);
+        if (plugin && !plugin.disabled && (plugin.contract.extension === type || plugin.contract.builtIns?.includes(type))) {
+            return true;
+        }
+        return false;
+    }
+    defaultZone() {
+        return cameraZonesSchema.parse({
+            name: 'Default',
+            regions: [
+                {
+                    _id: '',
+                    classes: ['motion', 'person'],
+                    coords: [
+                        {
+                            _id: '',
+                            points: [0, 0],
+                        },
+                        {
+                            _id: '',
+                            points: [0, 100],
+                        },
+                        {
+                            _id: '',
+                            points: [100, 100],
+                        },
+                        {
+                            _id: '',
+                            points: [100, 0],
+                        },
+                    ],
+                    filter: 'include',
+                    isPrivacyMask: false,
+                    type: 'contain',
+                },
+            ],
+        });
+    }
+    convertToDetectionZones(cameraZones) {
+        const zones = [];
+        for (const zone of cameraZones) {
+            const name = zone.name;
+            const regions = zone.regions;
+            regions.forEach((region) => {
+                const points = region.coords.map((coord) => coord.points);
+                const type = region.type;
+                const filter = region.filter;
+                const classes = region.classes;
+                const isPrivacyMask = region.isPrivacyMask;
+                zones.push({
+                    name,
+                    points,
+                    type,
+                    filter,
+                    classes,
+                    isPrivacyMask,
+                });
+            });
+        }
+        return zones;
+    }
+    isInternalSource(sourceName) {
+        return (sourceName.endsWith(' AAC') ||
+            sourceName.endsWith(' OPUS') ||
+            sourceName.endsWith(' PCMA') ||
+            sourceName.endsWith('_aac') ||
+            sourceName.endsWith('_opus') ||
+            sourceName.endsWith('_pcma'));
+    }
+};
+CamerasService = __decorate([
+    registry([
+        {
+            token: 'dbs',
+            useValue: delay(() => Database),
+        },
+    ]),
+    __metadata("design:paramtypes", [])
+], CamerasService);
+export { CamerasService };
+//# sourceMappingURL=cameras.service.js.map