1018 lines
32 KiB
Go
1018 lines
32 KiB
Go
package service
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
|
|
"3588AdminBackend/internal/storage"
|
|
)
|
|
|
|
var legacyBuiltinTemplateAliases = map[string]string{
|
|
"workshop_face_shoe_alarm": "std_workshop_face_recognition_shoe_alarm",
|
|
"std_service_smoke_stream": "std_service_test_stream",
|
|
}
|
|
|
|
type ConfigTemplateAsset struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
Origin string `json:"origin"`
|
|
ReadOnly bool `json:"read_only"`
|
|
Description string `json:"description"`
|
|
Source string `json:"source"`
|
|
Slots TemplateSlotGroup `json:"slots"`
|
|
NodeCount int `json:"node_count"`
|
|
EdgeCount int `json:"edge_count"`
|
|
MinIOEndpoint string `json:"minio_endpoint"`
|
|
MinIOBucket string `json:"minio_bucket"`
|
|
ExternalGetTokenURL string `json:"external_get_token_url"`
|
|
ExternalPutMessageURL string `json:"external_put_message_url"`
|
|
TenantCode string `json:"tenant_code"`
|
|
AdvancedParams map[string]any `json:"advanced_params"`
|
|
Raw map[string]any `json:"raw"`
|
|
}
|
|
|
|
type ConfigProfileAsset struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
Description string `json:"description"`
|
|
BusinessName string `json:"business_name"`
|
|
QueueSize int `json:"queue_size"`
|
|
QueueStrategy string `json:"queue_strategy"`
|
|
Instances []ConfigProfileInstanceAsset `json:"instances"`
|
|
Raw map[string]any `json:"raw"`
|
|
}
|
|
|
|
type ConfigProfileInstanceAsset struct {
|
|
Name string `json:"name"`
|
|
Template string `json:"template"`
|
|
VideoSourceRef string `json:"video_source_ref"`
|
|
DisplayName string `json:"display_name"`
|
|
DeviceCode string `json:"device_code"`
|
|
SiteName string `json:"site_name"`
|
|
PublishHLSPath string `json:"publish_hls_path"`
|
|
PublishRTSPPort string `json:"publish_rtsp_port"`
|
|
PublishRTSPPath string `json:"publish_rtsp_path"`
|
|
ChannelNo string `json:"channel_no"`
|
|
AdvancedParams map[string]any `json:"advanced_params"`
|
|
}
|
|
|
|
type ConfigOverlayAsset struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
Description string `json:"description"`
|
|
OverrideTargets []string `json:"override_targets"`
|
|
OverrideTargetNum int `json:"override_target_num"`
|
|
Raw map[string]any `json:"raw"`
|
|
}
|
|
|
|
type ConfigIntegrationServiceAsset struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
Type string `json:"type"`
|
|
TypeLabel string `json:"type_label"`
|
|
Description string `json:"description"`
|
|
Enabled bool `json:"enabled"`
|
|
AddressSummary string `json:"address_summary"`
|
|
RefCount int `json:"ref_count"`
|
|
ObjectStorage *ObjectStorageConfig `json:"object_storage,omitempty"`
|
|
TokenService *TokenServiceConfig `json:"token_service,omitempty"`
|
|
AlarmService *AlarmServiceConfig `json:"alarm_service,omitempty"`
|
|
Raw map[string]any `json:"raw"`
|
|
}
|
|
|
|
type ObjectStorageConfig struct {
|
|
Endpoint string `json:"endpoint"`
|
|
Bucket string `json:"bucket"`
|
|
AccessKey string `json:"access_key"`
|
|
SecretKey string `json:"secret_key"`
|
|
}
|
|
|
|
type TokenServiceConfig struct {
|
|
GetTokenURL string `json:"get_token_url"`
|
|
Username string `json:"username"`
|
|
Password string `json:"password"`
|
|
TenantCode string `json:"tenant_code"`
|
|
}
|
|
|
|
type AlarmServiceConfig struct {
|
|
PutMessageURL string `json:"put_message_url"`
|
|
Username string `json:"username"`
|
|
Password string `json:"password"`
|
|
TenantCode string `json:"tenant_code"`
|
|
}
|
|
|
|
type ConfigVideoSourceAsset struct {
|
|
Name string `json:"name"`
|
|
Path string `json:"path"`
|
|
SourceType string `json:"source_type"`
|
|
SourceTypeLabel string `json:"source_type_label"`
|
|
Area string `json:"area"`
|
|
Description string `json:"description"`
|
|
RefCount int `json:"ref_count"`
|
|
SourceSummary string `json:"source_summary"`
|
|
Config VideoSourceConfig `json:"config"`
|
|
Raw map[string]any `json:"raw"`
|
|
}
|
|
|
|
type VideoSourceConfig struct {
|
|
URL string `json:"url"`
|
|
Resolution string `json:"resolution"`
|
|
FrameSize string `json:"frame_size"`
|
|
FPS string `json:"fps"`
|
|
VideoFormat string `json:"video_format"`
|
|
FocalLength string `json:"focal_length"`
|
|
MountHeight string `json:"mount_height"`
|
|
MountAngle string `json:"mount_angle"`
|
|
}
|
|
|
|
func (s *ConfigPreviewService) ListTemplateAssets() ([]ConfigTemplateAsset, error) {
|
|
items := make([]ConfigTemplateAsset, 0)
|
|
seen := map[string]bool{}
|
|
|
|
if s != nil && s.assets != nil {
|
|
records, err := s.assets.ListTemplates()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, record := range records {
|
|
name := strings.TrimSpace(record.Name)
|
|
if name == "" || seen[name] || legacyBuiltinTemplateAliases[name] != "" {
|
|
continue
|
|
}
|
|
readOnly := isStandardTemplateName(name)
|
|
origin := "user"
|
|
if readOnly {
|
|
origin = "standard"
|
|
}
|
|
item, err := s.templateAssetFromRecord(record, origin, readOnly)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
items = append(items, *item)
|
|
seen[item.Name] = true
|
|
}
|
|
}
|
|
|
|
sort.Slice(items, func(i, j int) bool {
|
|
if items[i].ReadOnly != items[j].ReadOnly {
|
|
return items[i].ReadOnly
|
|
}
|
|
return items[i].Name < items[j].Name
|
|
})
|
|
return items, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) GetTemplateAsset(name string) (*ConfigTemplateAsset, error) {
|
|
name = canonicalTemplateAssetName(name)
|
|
if err := validateConfigName(name); err != nil {
|
|
return nil, err
|
|
}
|
|
if s != nil && s.assets != nil {
|
|
record, err := s.assets.GetTemplate(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if record != nil {
|
|
readOnly := isStandardTemplateName(name)
|
|
origin := "user"
|
|
if readOnly {
|
|
origin = "standard"
|
|
}
|
|
return s.templateAssetFromRecord(*record, origin, readOnly)
|
|
}
|
|
}
|
|
return nil, os.ErrNotExist
|
|
}
|
|
|
|
func (s *ConfigPreviewService) SaveTemplateAsset(name string, description string, bodyJSON string) error {
|
|
if s == nil || s.assets == nil {
|
|
return fmt.Errorf("asset repository is not configured")
|
|
}
|
|
name = canonicalTemplateAssetName(name)
|
|
if err := validateConfigName(name); err != nil {
|
|
return err
|
|
}
|
|
if isStandardTemplateName(name) {
|
|
return fmt.Errorf("standard template %q is read-only; please copy it before editing", name)
|
|
}
|
|
return s.assets.SaveTemplate(name, description, bodyJSON)
|
|
}
|
|
|
|
func (s *ConfigPreviewService) RenameTemplateAsset(oldName string, newName string, description string, bodyJSON string) error {
|
|
if s == nil || s.assets == nil {
|
|
return fmt.Errorf("asset repository is not configured")
|
|
}
|
|
oldName = canonicalTemplateAssetName(oldName)
|
|
newName = canonicalTemplateAssetName(newName)
|
|
if err := validateConfigName(oldName); err != nil {
|
|
return err
|
|
}
|
|
if err := validateConfigName(newName); err != nil {
|
|
return err
|
|
}
|
|
if isStandardTemplateName(oldName) {
|
|
return fmt.Errorf("standard template %q is read-only; please copy it before editing", oldName)
|
|
}
|
|
if oldName != newName && isStandardTemplateName(newName) {
|
|
return fmt.Errorf("standard template name %q is reserved", newName)
|
|
}
|
|
return s.assets.RenameTemplate(oldName, newName, description, bodyJSON)
|
|
}
|
|
|
|
func (s *ConfigPreviewService) DeleteTemplateAsset(name string) error {
|
|
if s == nil || s.assets == nil {
|
|
return fmt.Errorf("asset repository is not configured")
|
|
}
|
|
name = canonicalTemplateAssetName(name)
|
|
if err := validateConfigName(name); err != nil {
|
|
return err
|
|
}
|
|
if isStandardTemplateName(name) {
|
|
return fmt.Errorf("standard template %q is read-only and cannot be deleted", name)
|
|
}
|
|
refs, err := s.profileNamesReferencingTemplate(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(refs) > 0 {
|
|
return fmt.Errorf("template %q is used by business configs: %s", name, strings.Join(refs, ", "))
|
|
}
|
|
return s.assets.DeleteTemplate(name)
|
|
}
|
|
|
|
func (s *ConfigPreviewService) ListProfileAssets() ([]ConfigProfileAsset, error) {
|
|
sources, err := s.ListSources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]ConfigProfileAsset, 0, len(sources.Profiles))
|
|
for _, source := range sources.Profiles {
|
|
item, err := s.GetProfileAsset(source.Name)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
items = append(items, *item)
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) profileNamesReferencingTemplate(templateName string) ([]string, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, nil
|
|
}
|
|
records, err := s.assets.ListProfiles()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
refs := make([]string, 0)
|
|
for _, record := range records {
|
|
if strings.TrimSpace(record.TemplateName) == templateName || strings.Contains(record.BodyJSON, `"`+"template"+`": "`+templateName+`"`) {
|
|
refs = append(refs, record.Name)
|
|
}
|
|
}
|
|
sort.Strings(refs)
|
|
return refs, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) GetProfileAsset(name string) (*ConfigProfileAsset, error) {
|
|
raw, path, err := s.readAssetJSON("profiles", name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
queueMap, _ := raw["queue"].(map[string]any)
|
|
instancesRaw, _ := raw["instances"].([]any)
|
|
instances := make([]ConfigProfileInstanceAsset, 0, len(instancesRaw))
|
|
for _, item := range instancesRaw {
|
|
instanceMap, _ := item.(map[string]any)
|
|
paramsMap, _ := instanceMap["params"].(map[string]any)
|
|
sceneMeta, _ := instanceMap["scene_meta"].(map[string]any)
|
|
inputBindings, _ := instanceMap["input_bindings"].(map[string]any)
|
|
outputBindings, _ := instanceMap["output_bindings"].(map[string]any)
|
|
advanced := cloneMap(paramsMap)
|
|
for _, key := range []string{
|
|
"display_name",
|
|
"device_code",
|
|
"site_name",
|
|
"video_source_ref",
|
|
"publish_hls_path",
|
|
"publish_rtsp_port",
|
|
"publish_rtsp_path",
|
|
"channel_no",
|
|
} {
|
|
delete(advanced, key)
|
|
}
|
|
if len(advanced) == 0 {
|
|
advanced = nil
|
|
}
|
|
instances = append(instances, ConfigProfileInstanceAsset{
|
|
Name: stringValue(instanceMap["name"]),
|
|
Template: stringValue(instanceMap["template"]),
|
|
VideoSourceRef: bindingField(inputBindings, "video_input_main", "video_source_ref"),
|
|
DisplayName: stringValue(sceneMeta["display_name"]),
|
|
DeviceCode: stringValue(sceneMeta["device_code"]),
|
|
SiteName: stringValue(sceneMeta["site_name"]),
|
|
PublishHLSPath: bindingField(outputBindings, "stream_output_main", "publish_hls_path"),
|
|
PublishRTSPPort: valueString(bindingAny(outputBindings, "stream_output_main", "publish_rtsp_port")),
|
|
PublishRTSPPath: bindingField(outputBindings, "stream_output_main", "publish_rtsp_path"),
|
|
ChannelNo: bindingField(outputBindings, "stream_output_main", "channel_no"),
|
|
AdvancedParams: advanced,
|
|
})
|
|
}
|
|
return &ConfigProfileAsset{
|
|
Name: firstString(raw["name"], name),
|
|
Path: path,
|
|
Description: stringValue(raw["description"]),
|
|
BusinessName: stringValue(raw["business_name"]),
|
|
QueueSize: intValue(queueMap["size"]),
|
|
QueueStrategy: stringValue(queueMap["strategy"]),
|
|
Instances: instances,
|
|
Raw: raw,
|
|
}, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) ListOverlayAssets() ([]ConfigOverlayAsset, error) {
|
|
sources, err := s.ListSources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]ConfigOverlayAsset, 0, len(sources.Overlays))
|
|
for _, source := range sources.Overlays {
|
|
item, err := s.GetOverlayAsset(source.Name)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
items = append(items, *item)
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) GetOverlayAsset(name string) (*ConfigOverlayAsset, error) {
|
|
raw, path, err := s.readAssetJSON("overlays", name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
targets := make([]string, 0)
|
|
if overrides, ok := raw["instance_overrides"].(map[string]any); ok {
|
|
for key := range overrides {
|
|
targets = append(targets, key)
|
|
}
|
|
sort.Strings(targets)
|
|
}
|
|
return &ConfigOverlayAsset{
|
|
Name: name,
|
|
Path: path,
|
|
Description: stringValue(raw["description"]),
|
|
OverrideTargets: targets,
|
|
OverrideTargetNum: len(targets),
|
|
Raw: raw,
|
|
}, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) ListIntegrationServices() ([]ConfigIntegrationServiceAsset, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, nil
|
|
}
|
|
records, err := s.assets.ListIntegrationServices()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]ConfigIntegrationServiceAsset, 0, len(records))
|
|
for _, record := range records {
|
|
item, err := integrationServiceAssetFromRecord(record)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if refs, err := s.profileNamesReferencingIntegrationService(item.Name); err == nil {
|
|
item.RefCount = len(refs)
|
|
}
|
|
items = append(items, *item)
|
|
}
|
|
sort.Slice(items, func(i, j int) bool { return items[i].Name < items[j].Name })
|
|
return items, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) ListVideoSources() ([]ConfigVideoSourceAsset, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, nil
|
|
}
|
|
records, err := s.assets.ListVideoSources()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
items := make([]ConfigVideoSourceAsset, 0, len(records))
|
|
for _, record := range records {
|
|
item, err := videoSourceAssetFromRecord(record)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if refs, err := s.profileNamesReferencingVideoSource(item.Name); err == nil {
|
|
item.RefCount = len(refs)
|
|
}
|
|
items = append(items, *item)
|
|
}
|
|
sort.Slice(items, func(i, j int) bool { return items[i].Name < items[j].Name })
|
|
return items, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) GetVideoSource(name string) (*ConfigVideoSourceAsset, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, fmt.Errorf("基础配置仓库未初始化")
|
|
}
|
|
if err := validateVideoSourceName(name); err != nil {
|
|
return nil, err
|
|
}
|
|
record, err := s.assets.GetVideoSource(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if record == nil {
|
|
return nil, os.ErrNotExist
|
|
}
|
|
item, err := videoSourceAssetFromRecord(*record)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if refs, err := s.profileNamesReferencingVideoSource(item.Name); err == nil {
|
|
item.RefCount = len(refs)
|
|
}
|
|
return item, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) SaveVideoSourceAsset(asset ConfigVideoSourceAsset) error {
|
|
if s == nil || s.assets == nil {
|
|
return fmt.Errorf("基础配置仓库未初始化")
|
|
}
|
|
name := strings.TrimSpace(asset.Name)
|
|
if err := validateVideoSourceName(name); err != nil {
|
|
return fmt.Errorf("视频源名称不合法：%w", err)
|
|
}
|
|
sourceType := strings.TrimSpace(asset.SourceType)
|
|
if sourceType == "" {
|
|
return fmt.Errorf("视频源类型不能为空")
|
|
}
|
|
urlValue := strings.TrimSpace(asset.Config.URL)
|
|
if urlValue == "" {
|
|
return fmt.Errorf("视频源地址不能为空")
|
|
}
|
|
raw := map[string]any{
|
|
"name": name,
|
|
"source_type": sourceType,
|
|
"area": strings.TrimSpace(asset.Area),
|
|
"description": strings.TrimSpace(asset.Description),
|
|
"config": map[string]any{},
|
|
}
|
|
configMap := raw["config"].(map[string]any)
|
|
setAnyString(configMap, "url", asset.Config.URL)
|
|
setAnyString(configMap, "resolution", asset.Config.Resolution)
|
|
setAnyString(configMap, "frame_size", asset.Config.FrameSize)
|
|
setAnyString(configMap, "fps", asset.Config.FPS)
|
|
setAnyString(configMap, "video_format", asset.Config.VideoFormat)
|
|
setAnyString(configMap, "focal_length", asset.Config.FocalLength)
|
|
setAnyString(configMap, "mount_height", asset.Config.MountHeight)
|
|
setAnyString(configMap, "mount_angle", asset.Config.MountAngle)
|
|
body, err := marshalConfigJSON(raw)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.assets.SaveVideoSource(name, sourceType, strings.TrimSpace(asset.Area), strings.TrimSpace(asset.Description), string(body))
|
|
}
|
|
|
|
func (s *ConfigPreviewService) DeleteVideoSource(name string) error {
|
|
if s == nil || s.assets == nil {
|
|
return fmt.Errorf("基础配置仓库未初始化")
|
|
}
|
|
if err := validateVideoSourceName(name); err != nil {
|
|
return err
|
|
}
|
|
refs, err := s.profileNamesReferencingVideoSource(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(refs) > 0 {
|
|
return fmt.Errorf("视频源 %q 已被场景配置引用：%s", name, strings.Join(refs, ", "))
|
|
}
|
|
return s.assets.DeleteVideoSource(name)
|
|
}
|
|
|
|
func (s *ConfigPreviewService) GetIntegrationService(name string) (*ConfigIntegrationServiceAsset, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, fmt.Errorf("asset repository is not configured")
|
|
}
|
|
if err := validateConfigName(name); err != nil {
|
|
return nil, err
|
|
}
|
|
record, err := s.assets.GetIntegrationService(name)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if record == nil {
|
|
return nil, os.ErrNotExist
|
|
}
|
|
item, err := integrationServiceAssetFromRecord(*record)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if refs, err := s.profileNamesReferencingIntegrationService(item.Name); err == nil {
|
|
item.RefCount = len(refs)
|
|
}
|
|
return item, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) DeleteIntegrationService(name string) error {
|
|
if s == nil || s.assets == nil {
|
|
return fmt.Errorf("asset repository is not configured")
|
|
}
|
|
if err := validateConfigName(name); err != nil {
|
|
return err
|
|
}
|
|
refs, err := s.profileNamesReferencingIntegrationService(name)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if len(refs) > 0 {
|
|
return fmt.Errorf("third-party service %q is used by scene configs: %s", name, strings.Join(refs, ", "))
|
|
}
|
|
return s.assets.DeleteIntegrationService(name)
|
|
}
|
|
|
|
func (s *ConfigPreviewService) SaveIntegrationServiceAsset(asset ConfigIntegrationServiceAsset) error {
|
|
if s == nil || s.assets == nil {
|
|
return fmt.Errorf("asset repository is not configured")
|
|
}
|
|
name := strings.TrimSpace(asset.Name)
|
|
if err := validateConfigName(name); err != nil {
|
|
return fmt.Errorf("invalid third-party service name: %w", err)
|
|
}
|
|
serviceType := strings.TrimSpace(asset.Type)
|
|
if serviceType == "" {
|
|
return fmt.Errorf("third-party service type is required")
|
|
}
|
|
raw := map[string]any{
|
|
"name": name,
|
|
"type": serviceType,
|
|
"description": strings.TrimSpace(asset.Description),
|
|
"enabled": asset.Enabled,
|
|
}
|
|
configMap := map[string]any{}
|
|
switch serviceType {
|
|
case "object_storage":
|
|
if asset.ObjectStorage == nil {
|
|
return fmt.Errorf("object storage config is required")
|
|
}
|
|
setAnyString(configMap, "endpoint", asset.ObjectStorage.Endpoint)
|
|
setAnyString(configMap, "bucket", asset.ObjectStorage.Bucket)
|
|
setAnyString(configMap, "access_key", asset.ObjectStorage.AccessKey)
|
|
setAnyString(configMap, "secret_key", asset.ObjectStorage.SecretKey)
|
|
for _, key := range []string{"endpoint", "bucket", "access_key", "secret_key"} {
|
|
if strings.TrimSpace(stringValue(configMap[key])) == "" {
|
|
return fmt.Errorf("object storage %s is required", key)
|
|
}
|
|
}
|
|
case "token_service":
|
|
if asset.TokenService == nil {
|
|
return fmt.Errorf("token service config is required")
|
|
}
|
|
setAnyString(configMap, "get_token_url", asset.TokenService.GetTokenURL)
|
|
setAnyString(configMap, "username", asset.TokenService.Username)
|
|
setAnyString(configMap, "password", asset.TokenService.Password)
|
|
setAnyString(configMap, "tenant_code", asset.TokenService.TenantCode)
|
|
if strings.TrimSpace(stringValue(configMap["get_token_url"])) == "" {
|
|
return fmt.Errorf("token service get_token_url is required")
|
|
}
|
|
case "alarm_service":
|
|
if asset.AlarmService == nil {
|
|
return fmt.Errorf("alarm service config is required")
|
|
}
|
|
setAnyString(configMap, "put_message_url", asset.AlarmService.PutMessageURL)
|
|
setAnyString(configMap, "username", asset.AlarmService.Username)
|
|
setAnyString(configMap, "password", asset.AlarmService.Password)
|
|
setAnyString(configMap, "tenant_code", asset.AlarmService.TenantCode)
|
|
if strings.TrimSpace(stringValue(configMap["put_message_url"])) == "" {
|
|
return fmt.Errorf("alarm service put_message_url is required")
|
|
}
|
|
default:
|
|
return fmt.Errorf("unsupported third-party service type: %s", serviceType)
|
|
}
|
|
raw["config"] = configMap
|
|
body, err := marshalConfigJSON(raw)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return s.assets.SaveIntegrationService(name, serviceType, strings.TrimSpace(asset.Description), asset.Enabled, string(body))
|
|
}
|
|
|
|
func (s *ConfigPreviewService) profileNamesReferencingIntegrationService(name string) ([]string, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, nil
|
|
}
|
|
records, err := s.assets.ListProfiles()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
name = strings.TrimSpace(name)
|
|
if name == "" {
|
|
return nil, nil
|
|
}
|
|
refs := make([]string, 0)
|
|
for _, record := range records {
|
|
var raw map[string]any
|
|
if err := json.Unmarshal([]byte(record.BodyJSON), &raw); err != nil {
|
|
continue
|
|
}
|
|
if raw == nil {
|
|
continue
|
|
}
|
|
instances, _ := raw["instances"].([]any)
|
|
for _, item := range instances {
|
|
instanceMap, _ := item.(map[string]any)
|
|
serviceBindings, _ := instanceMap["service_bindings"].(map[string]any)
|
|
found := false
|
|
for _, slot := range []string{"object_storage_main", "token_service_main", "alarm_service_main"} {
|
|
if strings.TrimSpace(bindingField(serviceBindings, slot, "service_ref")) == name {
|
|
refs = append(refs, record.Name)
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
if found {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
sort.Strings(refs)
|
|
return refs, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) profileNamesReferencingVideoSource(name string) ([]string, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, nil
|
|
}
|
|
records, err := s.assets.ListProfiles()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
name = strings.TrimSpace(name)
|
|
if name == "" {
|
|
return nil, nil
|
|
}
|
|
refs := make([]string, 0)
|
|
for _, record := range records {
|
|
var raw map[string]any
|
|
if err := json.Unmarshal([]byte(record.BodyJSON), &raw); err != nil {
|
|
continue
|
|
}
|
|
instances, _ := raw["instances"].([]any)
|
|
for _, item := range instances {
|
|
instanceMap, _ := item.(map[string]any)
|
|
inputBindings, _ := instanceMap["input_bindings"].(map[string]any)
|
|
if strings.TrimSpace(bindingField(inputBindings, "video_input_main", "video_source_ref")) == name {
|
|
refs = append(refs, record.Name)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
sort.Strings(refs)
|
|
return refs, nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) readAssetJSON(kind string, name string) (map[string]any, string, error) {
|
|
if s == nil || s.assets == nil {
|
|
return nil, "", fmt.Errorf("asset repository is not configured")
|
|
}
|
|
raw, path, ok, err := s.readRepoAssetJSON(kind, name)
|
|
if err != nil {
|
|
return nil, "", err
|
|
}
|
|
if ok {
|
|
return raw, path, nil
|
|
}
|
|
return nil, "", os.ErrNotExist
|
|
}
|
|
|
|
func (s *ConfigPreviewService) readRepoAssetJSON(kind string, name string) (map[string]any, string, bool, error) {
|
|
if err := validateConfigName(name); err != nil {
|
|
return nil, "", false, err
|
|
}
|
|
var (
|
|
record *storage.AssetRecord
|
|
err error
|
|
)
|
|
switch kind {
|
|
case "templates":
|
|
record, err = s.assets.GetTemplate(name)
|
|
case "profiles":
|
|
record, err = s.assets.GetProfile(name)
|
|
case "overlays":
|
|
record, err = s.assets.GetOverlay(name)
|
|
default:
|
|
return nil, "", false, fmt.Errorf("unsupported asset kind: %s", kind)
|
|
}
|
|
if err != nil {
|
|
return nil, "", true, err
|
|
}
|
|
if record == nil {
|
|
return nil, "", false, nil
|
|
}
|
|
var raw map[string]any
|
|
if err := json.Unmarshal([]byte(record.BodyJSON), &raw); err != nil {
|
|
return nil, "", true, err
|
|
}
|
|
if raw == nil {
|
|
raw = map[string]any{}
|
|
}
|
|
if strings.TrimSpace(record.Description) != "" {
|
|
raw["description"] = record.Description
|
|
}
|
|
if kind == "profiles" {
|
|
if strings.TrimSpace(record.TemplateName) != "" {
|
|
raw["primary_template_name"] = record.TemplateName
|
|
}
|
|
if strings.TrimSpace(record.BusinessName) != "" && stringValue(raw["business_name"]) == "" {
|
|
raw["business_name"] = record.BusinessName
|
|
}
|
|
}
|
|
return raw, repoAssetPath(kind, name), true, nil
|
|
}
|
|
|
|
func cloneMap(in map[string]any) map[string]any {
|
|
if len(in) == 0 {
|
|
return map[string]any{}
|
|
}
|
|
out := make(map[string]any, len(in))
|
|
for k, v := range in {
|
|
out[k] = v
|
|
}
|
|
return out
|
|
}
|
|
|
|
func bindingAny(bindings map[string]any, slot string, field string) any {
|
|
entry, _ := bindings[slot].(map[string]any)
|
|
return entry[field]
|
|
}
|
|
|
|
func (s *ConfigPreviewService) templateAssetFromRecord(record storage.AssetRecord, origin string, readOnly bool) (*ConfigTemplateAsset, error) {
|
|
var raw map[string]any
|
|
if err := json.Unmarshal([]byte(record.BodyJSON), &raw); err != nil {
|
|
return nil, err
|
|
}
|
|
if raw == nil {
|
|
raw = map[string]any{}
|
|
}
|
|
if strings.TrimSpace(record.Description) != "" {
|
|
raw["description"] = record.Description
|
|
}
|
|
return buildTemplateAsset(raw, repoAssetPath("templates", record.Name), origin, readOnly), nil
|
|
}
|
|
|
|
func buildTemplateAsset(raw map[string]any, path string, origin string, readOnly bool) *ConfigTemplateAsset {
|
|
templateMap, _ := raw["template"].(map[string]any)
|
|
paramsMap, _ := raw["params"].(map[string]any)
|
|
nodes, _ := templateMap["nodes"].([]any)
|
|
edges, _ := templateMap["edges"].([]any)
|
|
slots, _ := parseTemplateSlots(raw)
|
|
advanced := cloneMap(paramsMap)
|
|
for _, key := range []string{
|
|
"minio_endpoint",
|
|
"minio_bucket",
|
|
"external_get_token_url",
|
|
"external_put_message_url",
|
|
"tenant_code",
|
|
} {
|
|
delete(advanced, key)
|
|
}
|
|
if len(advanced) == 0 {
|
|
advanced = nil
|
|
}
|
|
return &ConfigTemplateAsset{
|
|
Name: firstString(raw["name"], filepath.Base(strings.TrimSuffix(path, filepath.Ext(path)))),
|
|
Path: path,
|
|
Origin: origin,
|
|
ReadOnly: readOnly,
|
|
Description: stringValue(raw["description"]),
|
|
Source: stringValue(raw["source"]),
|
|
Slots: slots,
|
|
NodeCount: len(nodes),
|
|
EdgeCount: len(edges),
|
|
MinIOEndpoint: stringValue(paramsMap["minio_endpoint"]),
|
|
MinIOBucket: stringValue(paramsMap["minio_bucket"]),
|
|
ExternalGetTokenURL: stringValue(paramsMap["external_get_token_url"]),
|
|
ExternalPutMessageURL: stringValue(paramsMap["external_put_message_url"]),
|
|
TenantCode: valueString(paramsMap["tenant_code"]),
|
|
AdvancedParams: advanced,
|
|
Raw: raw,
|
|
}
|
|
}
|
|
|
|
func integrationServiceAssetFromRecord(record storage.IntegrationServiceRecord) (*ConfigIntegrationServiceAsset, error) {
|
|
var raw map[string]any
|
|
if err := json.Unmarshal([]byte(record.BodyJSON), &raw); err != nil {
|
|
return nil, err
|
|
}
|
|
if raw == nil {
|
|
raw = map[string]any{}
|
|
}
|
|
configMap, _ := raw["config"].(map[string]any)
|
|
sourceMap := raw
|
|
if len(configMap) > 0 {
|
|
sourceMap = configMap
|
|
}
|
|
item := &ConfigIntegrationServiceAsset{
|
|
Name: firstString(raw["name"], record.Name),
|
|
Path: repoAssetPath("integration_services", record.Name),
|
|
Type: firstString(record.ServiceType, stringValue(raw["type"])),
|
|
Description: firstString(raw["description"], record.Description),
|
|
Enabled: boolValue(raw["enabled"], record.Enabled),
|
|
Raw: raw,
|
|
}
|
|
item.TypeLabel = integrationTypeLabel(item.Type)
|
|
switch item.Type {
|
|
case "object_storage":
|
|
item.ObjectStorage = &ObjectStorageConfig{
|
|
Endpoint: stringValue(sourceMap["endpoint"]),
|
|
Bucket: stringValue(sourceMap["bucket"]),
|
|
AccessKey: firstString(sourceMap["access_key"], stringValue(sourceMap["minio_access_key"])),
|
|
SecretKey: firstString(sourceMap["secret_key"], stringValue(sourceMap["minio_secret_key"])),
|
|
}
|
|
item.AddressSummary = strings.TrimSpace(strings.Trim(strings.Join([]string{item.ObjectStorage.Endpoint, item.ObjectStorage.Bucket}, " / "), " /"))
|
|
case "token_service":
|
|
item.TokenService = &TokenServiceConfig{
|
|
GetTokenURL: stringValue(sourceMap["get_token_url"]),
|
|
Username: stringValue(sourceMap["username"]),
|
|
Password: stringValue(sourceMap["password"]),
|
|
TenantCode: stringValue(sourceMap["tenant_code"]),
|
|
}
|
|
item.AddressSummary = item.TokenService.GetTokenURL
|
|
case "alarm_service":
|
|
item.AlarmService = &AlarmServiceConfig{
|
|
PutMessageURL: stringValue(sourceMap["put_message_url"]),
|
|
Username: stringValue(sourceMap["username"]),
|
|
Password: stringValue(sourceMap["password"]),
|
|
TenantCode: stringValue(sourceMap["tenant_code"]),
|
|
}
|
|
item.AddressSummary = item.AlarmService.PutMessageURL
|
|
}
|
|
return item, nil
|
|
}
|
|
|
|
func videoSourceAssetFromRecord(record storage.VideoSourceRecord) (*ConfigVideoSourceAsset, error) {
|
|
var raw map[string]any
|
|
if err := json.Unmarshal([]byte(record.BodyJSON), &raw); err != nil {
|
|
return nil, err
|
|
}
|
|
if raw == nil {
|
|
raw = map[string]any{}
|
|
}
|
|
configMap, _ := raw["config"].(map[string]any)
|
|
sourceMap := raw
|
|
if len(configMap) > 0 {
|
|
sourceMap = configMap
|
|
}
|
|
item := &ConfigVideoSourceAsset{
|
|
Name: firstString(raw["name"], record.Name),
|
|
Path: repoAssetPath("video_sources", record.Name),
|
|
SourceType: firstString(record.SourceType, stringValue(raw["source_type"])),
|
|
Area: firstString(raw["area"], record.Area),
|
|
Description: firstString(raw["description"], record.Description),
|
|
SourceTypeLabel: videoSourceTypeLabel(firstString(record.SourceType, stringValue(raw["source_type"]))),
|
|
Config: VideoSourceConfig{
|
|
URL: stringValue(sourceMap["url"]),
|
|
Resolution: stringValue(sourceMap["resolution"]),
|
|
FrameSize: stringValue(sourceMap["frame_size"]),
|
|
FPS: valueString(sourceMap["fps"]),
|
|
VideoFormat: stringValue(sourceMap["video_format"]),
|
|
FocalLength: stringValue(sourceMap["focal_length"]),
|
|
MountHeight: stringValue(sourceMap["mount_height"]),
|
|
MountAngle: stringValue(sourceMap["mount_angle"]),
|
|
},
|
|
Raw: raw,
|
|
}
|
|
item.SourceSummary = item.Config.URL
|
|
return item, nil
|
|
}
|
|
|
|
func integrationTypeLabel(v string) string {
|
|
switch strings.TrimSpace(v) {
|
|
case "object_storage":
|
|
return "对象存储"
|
|
case "token_service":
|
|
return "认证服务"
|
|
case "alarm_service":
|
|
return "告警服务"
|
|
default:
|
|
return strings.TrimSpace(v)
|
|
}
|
|
}
|
|
|
|
func videoSourceTypeLabel(v string) string {
|
|
switch strings.TrimSpace(v) {
|
|
case "rtsp":
|
|
return "RTSP"
|
|
case "rtmp":
|
|
return "RTMP"
|
|
case "file":
|
|
return "文件"
|
|
case "usb_camera":
|
|
return "USB 摄像头"
|
|
default:
|
|
return strings.TrimSpace(v)
|
|
}
|
|
}
|
|
|
|
func validateVideoSourceName(name string) error {
|
|
name = strings.TrimSpace(name)
|
|
if name == "" {
|
|
return fmt.Errorf("不能为空")
|
|
}
|
|
if strings.Contains(name, "..") {
|
|
return fmt.Errorf("不能包含 '..'")
|
|
}
|
|
if strings.ContainsAny(name, `/\`) {
|
|
return fmt.Errorf("不能包含 / 或 \\")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (s *ConfigPreviewService) templateIsBuiltin(name string) bool {
|
|
return isStandardTemplateName(name)
|
|
}
|
|
|
|
func isStandardTemplateName(name string) bool {
|
|
name = canonicalTemplateAssetName(name)
|
|
return strings.HasPrefix(strings.TrimSpace(name), "std_")
|
|
}
|
|
|
|
func canonicalTemplateAssetName(name string) string {
|
|
name = strings.TrimSpace(name)
|
|
if next := strings.TrimSpace(legacyBuiltinTemplateAliases[name]); next != "" {
|
|
return next
|
|
}
|
|
return name
|
|
}
|
|
|
|
func stringValue(v any) string {
|
|
if s, ok := v.(string); ok {
|
|
return strings.TrimSpace(s)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func valueString(v any) string {
|
|
switch value := v.(type) {
|
|
case string:
|
|
return strings.TrimSpace(value)
|
|
case float64:
|
|
if float64(int(value)) == value {
|
|
return fmt.Sprintf("%d", int(value))
|
|
}
|
|
return fmt.Sprintf("%v", value)
|
|
case int:
|
|
return fmt.Sprintf("%d", value)
|
|
case int64:
|
|
return fmt.Sprintf("%d", value)
|
|
default:
|
|
return ""
|
|
}
|
|
}
|
|
|
|
func boolValue(v any, fallback bool) bool {
|
|
switch value := v.(type) {
|
|
case bool:
|
|
return value
|
|
case float64:
|
|
return value != 0
|
|
case int:
|
|
return value != 0
|
|
case int64:
|
|
return value != 0
|
|
case string:
|
|
value = strings.TrimSpace(strings.ToLower(value))
|
|
return value == "1" || value == "true" || value == "yes" || value == "on"
|
|
default:
|
|
return fallback
|
|
}
|
|
}
|
|
|
|
func firstString(v any, fallback string) string {
|
|
if got := stringValue(v); got != "" {
|
|
return got
|
|
}
|
|
return fallback
|
|
}
|
|
|
|
func intValue(v any) int {
|
|
switch value := v.(type) {
|
|
case int:
|
|
return value
|
|
case int64:
|
|
return int(value)
|
|
case float64:
|
|
return int(value)
|
|
default:
|
|
return 0
|
|
}
|
|
}
|