DMS/DMS.WPF/Services/ViewService/VariableViewService.cs

using AutoMapper;
using CommunityToolkit.Mvvm.ComponentModel;
using DMS.Application.DTOs;
using DMS.Application.Interfaces;
using DMS.Core.Models;
using DMS.WPF.Interfaces;
using DMS.WPF.ItemViewModel;
using System.Collections.ObjectModel;
using DMS.Application.Interfaces.Management;
using DMS.Application.Services.Management;

namespace DMS.WPF.Services.ViewService;

/// <summary>
/// 变量数据服务类，负责管理变量表和变量相关的数据和操作。
/// </summary>
public class VariableViewService : IVariableViewService
{
    private readonly IMapper _mapper;
    private readonly IAppDataService _appDataService;
    private readonly IVariableManagementService _variableManagementService;
    private readonly IViewDataService _viewDataService;
    private readonly IAppCenterService _appCenterService;


    /// <summary>
    /// VariableDataService类的构造函数。
    /// </summary>
    /// <param name="mapper">AutoMapper 实例。</param>
    /// <param name="appCenterService">数据服务中心实例。</param>
    public VariableViewService(IMapper mapper, IAppDataService appStorageService,
                               IVariableManagementService variableManagementService, IViewDataService dataStorageService,
                               IAppCenterService appCenterService)
    {
        _mapper = mapper;
        _appDataService = appStorageService;
        _variableManagementService = variableManagementService;
        _viewDataService = dataStorageService;
        _appCenterService = appCenterService;
    }

    /// <summary>
    /// 加载所有变量
    /// </summary>
    public void LoadAllVariables()
    {
        foreach (var variableTable in _viewDataService.VariableTables)
        {
            foreach (var variable in variableTable.Value.Variables)
            {
                _viewDataService.Variables.Add(variable.Id, variable);
            }
        }
    }

    /// <summary>
    /// 添加变量表。
    /// </summary>
    public async Task<bool> AddVariableTableToView(VariableTable tableDto)
    {
        // 添加null检查
        if (tableDto == null || tableDto.DeviceId == 0)
            return false;

        if (_viewDataService.Devices.TryGetValue(tableDto.DeviceId, out var device))
        {
            var variableTableItem = _mapper.Map<VariableTableItem>(tableDto);
            device.VariableTables.Add(variableTableItem);
            _viewDataService.VariableTables.TryAdd(variableTableItem.Id, variableTableItem);
        }


        return true;
    }

    /// <summary>
    /// 更新变量表。
    /// </summary>
    public async Task<bool> UpdateVariableTable(VariableTableItem variableTableItem)
    {
        if (variableTableItem is null)
        {
            return false;
        }

        var variableTable = _mapper.Map<VariableTable>(variableTableItem);
        if (await _appCenterService.VariableTableManagementService.UpdateVariableTableAsync(variableTable) > 0)
        {
            // 更新数据库后会自动更新内存，无需额外操作
            return true;
        }

        return false;
    }

    /// <summary>
    /// 删除变量表。
    /// </summary>
    public async Task<bool> DeleteVariableTable(VariableTableItem variableTable, bool isDeleteDb = false)
    {
        if (variableTable == null)
        {
            return false;
        }

        if (isDeleteDb)
        {
            if (!await _appCenterService.VariableTableManagementService.DeleteVariableTableAsync(variableTable.Id))
            {
                return false;
            }
        }

        // 删除与当前变量表关联的所有变量
        foreach (var variable in variableTable.Variables)
        {
            _viewDataService.Variables.Remove(variable.Id);
        }

        // 删除变量表
        _viewDataService.VariableTables.Remove(variableTable.Id);
        variableTable.Device.VariableTables.Remove(variableTable);
        return true;
    }

    /// <summary>
    /// 添加变量。
    /// </summary>
    public void AddVariable(VariableItem variableItem)
    {
        if (variableItem == null)
        {
            return;
        }

        _viewDataService.Variables.Add(variableItem.Id, variableItem);
    }

    /// <summary>
    /// 添加变量。
    /// </summary>
    public async Task<bool> AddAsync(List<VariableItem> variableItems, VariableTableItem variableTable)
    {

        foreach (var variableDto in variableItems)
        {
            variableDto.IsActive = true;
            variableDto.CreatedAt = DateTime.Now;
            variableDto.UpdatedAt = DateTime.Now;
            variableDto.VariableTableId = variableTable.Id;
        }

        var resVariables = await _variableManagementService.AddAsync(_mapper.Map<List<Variable>>(variableItems));
        
            

        List<VariableItem> resVariableItems = _mapper.Map<List<VariableItem>>(resVariables);
        foreach (var variableItem in resVariableItems)
        {
            _viewDataService.Variables.TryAdd(variableItem.Id, variableItem);
            variableTable.Variables.Add(variableItem);
        }

        return true;
    }

    /// <summary>
    /// 删除变量。
    /// </summary>
    public void DeleteVariable(int id)
    {
        if (!_viewDataService.Variables.TryGetValue(id, out var variableItem))
        {
            return;
        }

        if (_viewDataService.VariableTables.TryGetValue(variableItem.VariableTableId, out var variableTable))
        {
            variableTable.Variables.Remove(variableItem);
        }

        _viewDataService.Variables.Remove(variableItem.Id);
    }

    public async Task<bool> DeleteAsync(List<VariableItem> variableItems)
    {
        List<Variable> deleteList = new List<Variable>();
        foreach (var variable in variableItems)
        {
            if (_appDataService.Variables.TryGetValue(variable.Id, out var mVariable))
            {
                deleteList.Add(mVariable);
            }
        }

        return await _variableManagementService.DeleteAsync(deleteList);
    }





    public List<VariableItem> CheckExistingVariables(List<VariableItem> importedVariables, DeviceItem device)
    {
        List<VariableItem>? existList = new List<VariableItem>();
        var allVariable = device.VariableTables.SelectMany(vt => vt.Variables);
        foreach (var variable in allVariable)
        {
            foreach (var item in importedVariables)
            {
                bool slelect = item.Name == variable.Name || item.S7Address == variable.S7Address || item.OpcUaNodeId == variable.OpcUaNodeId;
                if (slelect)
                {
                    existList.Add(item);
                }
            }
        }

        return existList;
    }
}