RTSPtoWeb/storageDatabase.go

package main

import (
	"fmt"
	"time"

	"github.com/sirupsen/logrus"
)

// InitDatabase 初始化数据库连接
func (obj *StorageST) InitDatabase() error {
	obj.mutex.Lock()
	defer obj.mutex.Unlock()

	if !obj.Database.Enabled {
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "InitDatabase",
		}).Infoln("Database is disabled")
		return nil
	}

	dbManager, err := NewDatabaseManager(obj.Database)
	if err != nil {
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "InitDatabase",
			"call":   "NewDatabaseManager",
		}).Errorln(err.Error())
		return err
	}

	obj.dbManager = dbManager
	log.WithFields(logrus.Fields{
		"module": "database",
		"func":   "InitDatabase",
	}).Infoln("Database initialized successfully")

	return nil
}

// LoadStreamsFromDatabase 从数据库加载流配置
func (obj *StorageST) LoadStreamsFromDatabase() error {
	obj.mutex.Lock()
	defer obj.mutex.Unlock()

	if obj.dbManager == nil {
		return fmt.Errorf("database manager not initialized")
	}

	cameras, err := obj.dbManager.GetAllCameras()
	if err != nil {
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "LoadStreamsFromDatabase",
			"call":   "GetAllCameras",
		}).Errorln(err.Error())
		return err
	}

	// 清空现有流配置（如果启用数据库模式）
	if obj.Server.DatabaseEnabled {
		obj.Streams = make(map[string]StreamST)
	}

	// 将摄像头转换为流配置
	for _, camera := range cameras {
		stream := CameraToStream(camera)
		streamID := fmt.Sprintf("%d", camera.CameraID)
		obj.Streams[streamID] = stream
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "LoadStreamsFromDatabase",
			"camera": camera.CameraName,
			"id":     camera.CameraID,
		}).Infoln("Loaded camera from database")
	}

	log.WithFields(logrus.Fields{
		"module": "database",
		"func":   "LoadStreamsFromDatabase",
		"count":  len(cameras),
	}).Infoln("Loaded cameras from database")

	return nil
}

// SyncStreamToDatabase 同步流配置到数据库
func (obj *StorageST) SyncStreamToDatabase(streamID string, stream StreamST) error {
	if obj.dbManager == nil || !obj.Server.DatabaseEnabled {
		return nil // 数据库未启用，跳过同步
	}

	// 检查摄像头是否已存在
	existingCamera, err := obj.dbManager.GetCameraByID(streamID)
	if err != nil {
		return err
	}

	camera := StreamToCamera(streamID, stream)

	if existingCamera == nil {
		// 创建新摄像头
		err = obj.dbManager.CreateCamera(&camera)
		if err != nil {
			log.WithFields(logrus.Fields{
				"module": "database",
				"func":   "SyncStreamToDatabase",
				"call":   "CreateCamera",
				"id":     streamID,
			}).Errorln(err.Error())
			return err
		}
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "SyncStreamToDatabase",
			"id":     streamID,
			"name":   camera.CameraName,
		}).Infoln("Created camera in database")
	} else {
		// 更新现有摄像头
		camera.CreateTime = existingCamera.CreateTime // 保持创建时间
		err = obj.dbManager.UpdateCamera(&camera)
		if err != nil {
			log.WithFields(logrus.Fields{
				"module": "database",
				"func":   "SyncStreamToDatabase",
				"call":   "UpdateCamera",
				"id":     streamID,
			}).Errorln(err.Error())
			return err
		}
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "SyncStreamToDatabase",
			"id":     streamID,
			"name":   camera.CameraName,
		}).Infoln("Updated camera in database")
	}

	return nil
}

// DeleteStreamFromDatabase 从数据库删除流配置
func (obj *StorageST) DeleteStreamFromDatabase(streamID string) error {
	if obj.dbManager == nil || !obj.Server.DatabaseEnabled {
		return nil // 数据库未启用，跳过删除
	}

	err := obj.dbManager.DeleteCamera(streamID)
	if err != nil {
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "DeleteStreamFromDatabase",
			"call":   "DeleteCamera",
			"id":     streamID,
		}).Errorln(err.Error())
		return err
	}

	log.WithFields(logrus.Fields{
		"module": "database",
		"func":   "DeleteStreamFromDatabase",
		"id":     streamID,
	}).Infoln("Deleted camera from database")

	return nil
}

// RefreshStreamsFromDatabase 刷新数据库中的流配置
func (obj *StorageST) RefreshStreamsFromDatabase() error {
	if obj.dbManager == nil || !obj.Server.DatabaseEnabled {
		return nil
	}

	// 停止所有现有流
	obj.StopAll()

	// 等待流停止
	time.Sleep(2 * time.Second)

	// 重新加载流配置
	err := obj.LoadStreamsFromDatabase()
	if err != nil {
		return err
	}

	// 启动所有流
	obj.StreamChannelRunAll()

	log.WithFields(logrus.Fields{
		"module": "database",
		"func":   "RefreshStreamsFromDatabase",
	}).Infoln("Refreshed streams from database")

	return nil
}

// GetDatabaseStatus 获取数据库状态
func (obj *StorageST) GetDatabaseStatus() map[string]interface{} {
	status := map[string]interface{}{
		"enabled":   obj.Database.Enabled,
		"type":      obj.Database.Type,
		"host":      obj.Database.Host,
		"port":      obj.Database.Port,
		"database":  obj.Database.Database,
		"connected": false,
		"error":     nil,
	}

	if obj.dbManager != nil && obj.dbManager.db != nil {
		if err := obj.dbManager.db.Ping(); err == nil {
			status["connected"] = true
		} else {
			status["error"] = err.Error()
		}
	}

	return status
}

// DatabaseGetCameras 获取所有摄像头
func (obj *StorageST) DatabaseGetCameras() ([]Camera, error) {
	obj.mutex.RLock()
	defer obj.mutex.RUnlock()

	if obj.dbManager == nil {
		return nil, fmt.Errorf("database manager not initialized")
	}

	return obj.dbManager.GetAllCameras()
}

// DatabaseGetCamera 根据ID获取摄像头
func (obj *StorageST) DatabaseGetCamera(id string) (*Camera, error) {
	obj.mutex.RLock()
	defer obj.mutex.RUnlock()

	if obj.dbManager == nil {
		return nil, fmt.Errorf("database manager not initialized")
	}

	return obj.dbManager.GetCameraByID(id)
}

// StreamExist 检查流是否存在
func (obj *StorageST) StreamExist(uuid string) bool {
	obj.mutex.RLock()
	defer obj.mutex.RUnlock()
	_, ok := obj.Streams[uuid]
	return ok
}

// CloseDatabase 关闭数据库连接
func (obj *StorageST) CloseDatabase() error {
	obj.mutex.Lock()
	defer obj.mutex.Unlock()

	if obj.dbManager != nil {
		err := obj.dbManager.Close()
		obj.dbManager = nil
		log.WithFields(logrus.Fields{
			"module": "database",
			"func":   "CloseDatabase",
		}).Infoln("Database connection closed")
		return err
	}

	return nil
}