سأكمل بالخطوة الخامسة وهي إنشاء وحدات إدارة الكاميرات والتسجيلات. سنقوم ببناء نظام متكامل لإدارة الكاميرات وتخزين التسجيلات مع دمج ميزات التحليل الذكي. ```xml import { ICamera } from '../../interfaces/ICamera'; import CameraModel from '../../models/CameraModel'; import { IRecording } from '../../interfaces/IRecording'; import RecordingModel from '../../models/RecordingModel'; import { join } from 'path'; import { mkdirSync, existsSync } from 'fs'; import { createWriteStream } from 'fs'; import { v4 as uuidv4 } from 'uuid'; import ffmpeg from 'fluent-ffmpeg'; import FaceRecognitionService from '../faceRecognition/FaceRecognitionService'; import LicensePlateService from '../licensePlate/LicensePlateService'; import { EventEmitter } from 'events'; class CameraService extends EventEmitter { private activeRecordings: Map = new Map(); public async getAllCameras(): Promise { return CameraModel.find(); } public async getCameraById(id: string): Promise { return CameraModel.findById(id); } public async addCamera(cameraData: Omit): Promise { const camera = new CameraModel(cameraData); await camera.save(); return camera; } public async updateCamera(id: string, updateData: Partial): Promise { return CameraModel.findByIdAndUpdate(id, updateData, { new: true }); } public async deleteCamera(id: string): Promise { await CameraModel.findByIdAndDelete(id); } public async startRecording(cameraId: string): Promise { const camera = await CameraModel.findById(cameraId); if (!camera) { throw new Error('Camera not found'); } // Create storage directory if not exists const recordingsDir = join(process.env.STORAGE_PATH || './storage', 'recordings'); if (!existsSync(recordingsDir)) { mkdirSync(recordingsDir, { recursive: true }); } const recordingId = uuidv4(); const recordingPath = join(recordingsDir, `${recordingId}.mp4`); const startTime = new Date(); // Create new recording record const recording = new RecordingModel({ cameraId: camera.id, startTime, filePath: recordingPath, motionDetected: false, facesDetected: [], licensePlatesDetected: [], isArchived: false }); await recording.save(); // Start FFmpeg recording process const command = ffmpeg(camera.url) .inputOptions([ '-rtsp_transport', 'tcp', '-stimeout', '5000000' ]) .output(recordingPath) .outputOptions([ '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '28', '-f', 'segment', '-segment_time', '300', '-segment_format', 'mp4', '-reset_timestamps', '1', '-strftime', '1' ]) .on('start', () => { console.log(`Recording started for camera ${cameraId}`); }) .on('error', (err) => { console.error(`Recording error for camera ${cameraId}:`, err); this.emit('recordingError', { cameraId, error: err }); }) .on('end', () => { console.log(`Recording ended for camera ${cameraId}`); this.activeRecordings.delete(cameraId); }); this.activeRecordings.set(cameraId, command); command.run(); return recording; } public async stopRecording(cameraId: string): Promise { const recordingProcess = this.activeRecordings.get(cameraId); if (recordingProcess) { recordingProcess.kill('SIGINT'); this.activeRecordings.delete(cameraId); // Update recording end time await RecordingModel.findOneAndUpdate( { cameraId, endTime: { $exists: false } }, { $set: { endTime: new Date() } } ); } } public async processCameraFrame(cameraId: string, frameBuffer: Buffer): Promise { const camera = await CameraModel.findById(cameraId); if (!camera) return; // Process frame based on camera settings const promises: Promise[] = []; if (camera.faceRecognition) { promises.push( FaceRecognitionService.detectFaces(frameBuffer, camera) .catch(err => console.error('Face detection error:', err)) ); } if (camera.licensePlateRecognition) { promises.push( LicensePlateService.detectLicensePlates(frameBuffer, camera) .catch(err => console.error('License plate detection error:', err)) ); } await Promise.all(promises); } public async getRecordings(filter: { cameraId?: string; startTime?: Date; endTime?: Date; hasFaces?: boolean; hasPlates?: boolean; } = {}): Promise { const query: any = {}; if (filter.cameraId) query.cameraId = filter.cameraId; if (filter.startTime) query.startTime = { $gte: filter.startTime }; if (filter.endTime) query.endTime = { $lte: filter.endTime }; if (filter.hasFaces) query.facesDetected = { $exists: true, $ne: [] }; if (filter.hasPlates) query.licensePlatesDetected = { $exists: true, $ne: [] }; return RecordingModel.find(query).sort({ startTime: -1 }); } public async getRecordingById(id: string): Promise { return RecordingModel.findById(id); } } export default new CameraService(); import { Request, Response } from 'express'; import CameraService from './CameraService'; import { ICamera } from '../../interfaces/ICamera'; class CameraController { async getAllCameras(req: Request, res: Response) { try { const cameras = await CameraService.getAllCameras(); res.json({ success: true, cameras }); } catch (error) { console.error('Error fetching cameras:', error); res.status(500).json({ success: false, error: 'Failed to fetch cameras' }); } } async getCamera(req: Request, res: Response) { try { const camera = await CameraService.getCameraById(req.params.id); if (!camera) { return res.status(404).json({ success: false, error: 'Camera not found' }); } res.json({ success: true, camera }); } catch (error) { console.error('Error fetching camera:', error); res.status(500).json({ success: false, error: 'Failed to fetch camera' }); } } async addCamera(req: Request, res: Response) { try { const cameraData: Omit = req.body; const camera = await CameraService.addCamera(cameraData); res.json({ success: true, camera }); } catch (error) { console.error('Error adding camera:', error); res.status(500).json({ success: false, error: 'Failed to add camera' }); } } async updateCamera(req: Request, res: Response) { try { const camera = await CameraService.updateCamera(req.params.id, req.body); if (!camera) { return res.status(404).json({ success: false, error: 'Camera not found' }); } res.json({ success: true, camera }); } catch (error) { console.error('Error updating camera:', error); res.status(500).json({ success: false, error: 'Failed to update camera' }); } } async deleteCamera(req: Request, res: Response) { try { await CameraService.deleteCamera(req.params.id); res.json({ success: true, message: 'Camera deleted successfully' }); } catch (error) { console.error('Error deleting camera:', error); res.status(500).json({ success: false, error: 'Failed to delete camera' }); } } async startRecording(req: Request, res: Response) { try { const recording = await CameraService.startRecording(req.params.cameraId); res.json({ success: true, recording }); } catch (error) { console.error('Error starting recording:', error); res.status(500).json({ success: false, error: 'Failed to start recording' }); } } async stopRecording(req: Request, res: Response) { try { await CameraService.stopRecording(req.params.cameraId); res.json({ success: true, message: 'Recording stopped successfully' }); } catch (error) { console.error('Error stopping recording:', error); res.status(500).json({ success: false, error: 'Failed to stop recording' }); } } async getRecordings(req: Request, res: Response) { try { const { cameraId, startTime, endTime, hasFaces, hasPlates } = req.query; const filter: any = {}; if (cameraId) filter.cameraId = cameraId; if (startTime) filter.startTime = new Date(startTime as string); if (endTime) filter.endTime = new Date(endTime as string); if (hasFaces) filter.hasFaces = hasFaces === 'true'; if (hasPlates) filter.hasPlates = hasPlates === 'true'; const recordings = await CameraService.getRecordings(filter); res.json({ success: true, recordings }); } catch (error) { console.error('Error fetching recordings:', error); res.status(500).json({ success: false, error: 'Failed to fetch recordings' }); } } async getRecording(req: Request, res: Response) { try { const recording = await CameraService.getRecordingById(req.params.id); if (!recording) { return res.status(404).json({ success: false, error: 'Recording not found' }); } res.json({ success: true, recording }); } catch (error) { console.error('Error fetching recording:', error); res.status(500).json({ success: false, error: 'Failed to fetch recording' }); } } } export default new CameraController(); import express from 'express'; import CameraController from './CameraController'; const router = express.Router(); router.get('/', CameraController.getAllCameras); router.get('/:id', CameraController.getCamera); router.post('/', CameraController.addCamera); router.put('/:id', CameraController.updateCamera); router.delete('/:id', CameraController.deleteCamera); router.post('/:cameraId/start-recording', CameraController.startRecording); router.post('/:cameraId/stop-recording', CameraController.stopRecording); router.get('/:cameraId/recordings', CameraController.getRecordings); router.get('/recordings/:id', CameraController.getRecording); export default router; import mongoose, { Document, Model } from 'mongoose'; import { ICamera } from '../interfaces/ICamera'; const CameraSchema = new mongoose.Schema({ name: { type: String, required: true }, url: { type: String, required: true }, username: String, password: String, location: { type: String, required: true }, isActive: { type: Boolean, default: true }, faceRecognition: { type: Boolean, default: false }, licensePlateRecognition: { type: Boolean, default: false }, recordingMode: { type: String, enum: ['continuous', 'motion'], default: 'motion' }, createdAt: { type: Date, default: Date.now }, updatedAt: { type: Date, default: Date.now } }); CameraSchema.pre('save', function(next) { this.updatedAt = new Date(); next(); }); const CameraModel: Model = mongoose.model('Camera', CameraSchema); export default CameraModel; import mongoose, { Document, Model } from 'mongoose'; import { IRecording } from '../interfaces/IRecording'; const RecordingSchema = new mongoose.Schema({ cameraId: { type: String, required: true }, startTime: { type: Date, required: true }, endTime: Date, filePath: { type: String, required: true }, motionDetected: { type: Boolean, default: false }, facesDetected: { type: [String], default: [] }, licensePlatesDetected: { type: [String], default: [] }, isArchived: { type: Boolean, default: false } }); const RecordingModel: Model = mongoose.model('Recording', RecordingSchema); export default RecordingModel; import express from 'express'; import { createServer } from 'http'; import { Server } from 'socket.io'; import mongoose from 'mongoose'; import dotenv from 'dotenv'; import faceRecognitionRoutes from './modules/faceRecognition/FaceRecognitionRoutes'; import licensePlateRoutes from './modules/licensePlate/LicensePlateRoutes'; import cameraRoutes from './modules/camera/CameraRoutes'; import CameraService from './modules/camera/CameraService'; // تحميل إعدادات البيئة dotenv.config(); // إنشاء تطبيق Express const app = express(); const port = process.env.PORT || 3000; // Middleware app.use(express.json()); app.use(express.static('client/build')); // Routes app.use('/api/face', faceRecognitionRoutes); app.use('/api/plate', licensePlateRoutes); app.use('/api/cameras', cameraRoutes); // Serve React app app.get('*', (req, res) => { res.sendFile(join(__dirname, '../../client/build/index.html')); }); // إنشاء خادم HTTP const httpServer = createServer(app); // إعداد Socket.IO const io = new Server(httpServer, { cors: { origin: "*", methods: ["GET", "POST"] } }); // Handle camera events CameraService.on('recordingError', (data) => { io.emit('recordingError', data); }); // الاتصال بقاعدة البيانات mongoose.connect(process.env.DB_URI as string) .then(() => console.log('تم الاتصال بقاعدة البيانات بنجاح')) .catch(err => console.error('خطأ في الاتصال بقاعدة البيانات:', err)); // بدء الخادم httpServer.listen(port, () => { console.log(`الخادم يعمل على http://localhost:${port}`); }); import React, { useState, useEffect } from 'react'; import { Box, Typography, TextField, Button, Table, TableBody, TableCell, TableContainer, TableHead, TableRow, Paper, Switch, FormControlLabel, Select, MenuItem, Grid, Card, CardContent } from '@material-ui/core'; import axios from 'axios'; import { useSnackbar } from 'notistack'; const CameraManagement = () => { const [cameras, setCameras] = useState([]); const [formData, setFormData] = useState({ name: '', url: '', username: '', password: '', location: '', isActive: true, faceRecognition: false, licensePlateRecognition: false, recordingMode: 'motion' }); const [activeRecordings, setActiveRecordings] = useState>(new Set()); const { enqueueSnackbar } = useSnackbar(); useEffect(() => { fetchCameras(); fetchActiveRecordings(); }, []); const fetchCameras = async () => { try { const response = await axios.get('/api/cameras'); setCameras(response.data.cameras); } catch (error) { enqueueSnackbar('Error fetching cameras', { variant: 'error' }); console.error('Error fetching cameras:', error); } }; const fetchActiveRecordings = async () => { try { const recordings = await axios.get('/api/cameras/recordings?endTime=null'); const active = new Set(recordings.data.recordings.map((r: any) => r.cameraId)); setActiveRecordings(active); } catch (error) { console.error('Error fetching active recordings:', error); } }; const handleInputChange = (e: React.ChangeEvent) => { const { name, value } = e.target; setFormData(prev => ({ ...prev, [name]: value })); }; const handleSwitchChange = (e: React.ChangeEvent) => { const { name, checked } = e.target; setFormData(prev => ({ ...prev, [name]: checked })); }; const handleSelectChange = (e: React.ChangeEvent<{ name?: string; value: unknown }>) => { const name = e.target.name as string; setFormData(prev => ({ ...prev, [name]: e.target.value })); }; const handleSubmit = async (e: React.FormEvent) => { e.preventDefault(); try { await axios.post('/api/cameras', formData); enqueueSnackbar('Camera added successfully', { variant: 'success' }); fetchCameras(); setFormData({ name: '', url: '', username: '', password: '', location: '', isActive: true, faceRecognition: false, licensePlateRecognition: false, recordingMode: 'motion' }); } catch (error) { enqueueSnackbar('Error adding camera', { variant: 'error' }); console.error('Error adding camera:', error); } }; const handleStartRecording = async (cameraId: string) => { try { await axios.post(`/api/cameras/${cameraId}/start-recording`); enqueueSnackbar('Recording started', { variant: 'success' }); setActiveRecordings(prev => new Set(prev.add(cameraId))); } catch (error) { enqueueSnackbar('Error starting recording', { variant: 'error' }); console.error('Error starting recording:', error); } }; const handleStopRecording = async (cameraId: string) => { try { await axios.post(`/api/cameras/${cameraId}/stop-recording`); enqueueSnackbar('Recording stopped', { variant: 'success' }); setActiveRecordings(prev => { const newSet = new Set(prev); newSet.delete(cameraId); return newSet; }); } catch (error) { enqueueSnackbar('Error stopping recording', { variant: 'error' }); console.error('Error stopping recording:', error); } }; return ( إدارة الكاميرات إضافة كاميرا جديدة } label="الكاميرا نشطة" /> } label="تفعيل التعرف على الوجوه" /> } label="تفعيل التعرف على لوحات السيارات" /> قائمة الكاميرات الاسم الموقع الحالة التسجيل الإجراءات {cameras.map((camera) => ( {camera.name} {camera.location} {camera.isActive ? 'نشطة' : 'غير نشطة'} {activeRecordings.has(camera._id) ? ● تسجيل : 'غير مسجل'} {activeRecordings.has(camera._id) ? ( ) : ( )} ))}

); }; export default CameraManagement; ``` الخطوات التالية ستشمل: 1. تطبيق نظام التنبيهات عبر Telegram 2. إنشاء واجهة لعرض البث المباشر من الكاميرات 3. تطوير نظام إدارة المستخدمين والصلاحيات 4. إنشاء واجهة التقارير وتصدير PDF 5. تحسين أداء النظام للعمل في الوقت الحقيقي