DW5S/DW5S.App/UserControl/CtrlSignal.cs

using DevExpress.Utils.About;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;

using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Documents;
using System.Windows.Forms;
using DW5S.App.EditForms;
using DW5S.Entity;
using DW5S.Repostory;
using Serilog;
using DevExpress.XtraBars.Customization;
using DW5S.Service;
using DW5S.ViewModel;

namespace DW5S.App.UserControl
{
    public partial class CtrlSignal : DevExpress.XtraEditors.XtraUserControl
    {
        readonly List<SigViewModel> listSigInfo = new List<SigViewModel>();
        readonly List<SigDelayViewModel> listSigDelay = new List<SigDelayViewModel>();
        public CtrlSignal()
        {
            InitializeComponent();
        }

        private async void CtrlSignal_Load(object sender, EventArgs e)
        {
            try
            {
                gridSignal.UseDefault(listSigInfo).UseMultiSelect().UseRowNumber()
                    .UseAddAsync(AddSigInfo)
                    .UseEditAsync<SigViewModel>(EditSigInfo)
                    .UseDeleteAsync<SigViewModel>(DeleteSigInfo);
                gridSigDelay.UseDefault(listSigDelay).UseMultiSelect().UseRowNumber()
                   .UseAddAsync(AddSigDelay)
                   .UseEditAsync<SigDelayViewModel>(EditSigDelay)
                   .UseDeleteAsync<SigDelayViewModel>(DeleteSigDelay);

                var unitOfWork = IocContainer.UnitOfWork;
                var repsSig = unitOfWork.Of<SigInfo>();
                var items = await repsSig.GetAllAsync(p => p.FreqUp);
                listSigInfo.AddRange(items.To<List<SigViewModel>>().OrderBy(i=>i.FreqDown));
                var repsFixedStation = unitOfWork.Of<FixedStation>();
                var fixedStations = await repsFixedStation.FindAsync(p => p.Enable);
                foreach (var item in listSigInfo)
                {
                    if (fixedStations.Any(p => p.FreqUpHz == item.FreqUp))
                        item.IsFixedStationFreq = "✔";
                    else
                        item.IsFixedStationFreq = "✖";
                }
                if (listSigInfo.Count > 0)
                {
                    var repsSigDelay = unitOfWork.Of<SigDelay>();
                    var repsSat = unitOfWork.Of<SatInfo>();
                    var delayItems = await repsSigDelay.FindAsync(w => w.SigInfoId == listSigInfo.First().Id);
                    var sats = await repsSat.GetAllAsync();
                    foreach (var delayItem in delayItems)
                    {
                        SigDelay sigDelay = delayItem as SigDelay;
                        var satInfo = sats.FirstOrDefault(f => f.SatCode == sigDelay.SatInfoSatCode);
                        if (satInfo != null)
                        {
                            sigDelay.Sat = $"[{satInfo.SatLon}°]{satInfo.SatName}({satInfo.SatCode})";
                        }
                        listSigDelay.Add(sigDelay.To<SigDelayViewModel>());
                    }
                }

                gridViewSignal.RefreshData();
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "查询信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("查询信号信息异常");
            }
        }
        private async Task<SigViewModel> AddSigInfo()
        {
            try
            {
                SigEditor frm = new SigEditor();
                if (frm.ShowDialog() != DialogResult.OK) return null;
                var addItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSig = unitOfWork.Of<SigInfo>();
                var sig = await repsSig.AddOrUpdateAsync(addItem.To<SigInfo>());
                await unitOfWork.SaveAsync();
                addItem.Id = sig.Id;
                return addItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "添加信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("添加信号信息异常");
                return null;
            }
        }
        private async Task<SigViewModel> EditSigInfo(SigViewModel editItem)
        {
            try
            {
                SigEditor frm = new SigEditor(editItem);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                editItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSig = unitOfWork.Of<SigInfo>();
                var sig = await repsSig.AddOrUpdateAsync(editItem.To<SigInfo>());
                await unitOfWork.SaveAsync();

                return editItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "保存信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("保存信号信息异常");
                return null;
            }
        }
        private async Task<bool> DeleteSigInfo(List<SigViewModel> list)
        {
            try
            {
                var ids = list.Select(p => p.Id);
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                var delayItems = await repsSigDelay.FindAsync(p => ids.Contains(p.SigInfoId));
                await repsSigDelay.DeleteAsync(delayItems);
                var repsSig = unitOfWork.Of<SigInfo>();
                await repsSig.DeleteAsync(list.To<List<SigInfo>>());
                await unitOfWork.SaveAsync();

                return true;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "删除信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("删除信号信息异常");
                return false;
            }
        }
        private async Task<SigDelayViewModel> AddSigDelay()
        {
            try
            {
                var sigInfoId = gridViewSignal.GetFocusedRow() as SigViewModel;
                if (sigInfoId == null) return null;
                SigDelayEditor frm = new SigDelayEditor(sigInfoId.Id);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                var addItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                addItem.SigInfoId = sigInfoId.Id;
                var sigDelay = repsSigDelay.AddOrUpdateAsync(addItem.To<SigDelay>());
                await unitOfWork.SaveAsync();
                addItem.Id = sigDelay.Id;
                return addItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "添加转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("添加转发延迟异常");
                return null;
            }
        }
        private async Task<SigDelayViewModel> EditSigDelay(SigDelayViewModel editItem)
        {
            try
            {
                var sigInfoId = gridViewSignal.GetFocusedRow() as SigViewModel;
                if (sigInfoId == null) return null;
                SigDelayEditor frm = new SigDelayEditor(editItem, sigInfoId.Id);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                editItem = frm.info;
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                await repsSigDelay.AddOrUpdateAsync(editItem.To<SigDelay>());
                await unitOfWork.SaveAsync();

                return editItem;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "保存转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("保存转发延迟异常");
                return null;
            }
        }
        private async Task<bool> DeleteSigDelay(List<SigDelayViewModel> list)
        {
            try
            {
                var ids = list.Select(p => p.Id);
                var unitOfWork = IocContainer.UnitOfWork;
                var repsSigDelay = unitOfWork.Of<SigDelay>();
                await repsSigDelay.DeleteAsync(list.To<List<SigDelay>>());
                await unitOfWork.SaveAsync();

                return true;
            }
            catch (Exception ex)
            {
                IocContainer.Logger.Error(ex, "删除转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("删除转发延迟异常");
                return false;
            }
        }

        private async void gridViewSignal_FocusedRowObjectChanged(object sender, DevExpress.XtraGrid.Views.Base.FocusedRowObjectChangedEventArgs e)
        {
            listSigDelay.Clear();
            var sigInfoId = gridViewSignal.GetFocusedRow() as SigViewModel;
            if (sigInfoId == null) return;
            var unitOfWork = IocContainer.UnitOfWork;
            var repsSigDelay = unitOfWork.Of<SigDelay>();
            var repsSat = unitOfWork.Of<SatInfo>();
            var delayItems = await repsSigDelay.FindAsync(w => w.SigInfoId == sigInfoId.Id);
            var sats = await repsSat.GetAllAsync();
            foreach (var delayItem in delayItems)
            {
                SigDelay sigDelay = delayItem as SigDelay;
                var satInfo = sats.FirstOrDefault(f => f.SatCode == sigDelay.SatInfoSatCode);
                if (satInfo != null)
                {
                    sigDelay.Sat = $"[{satInfo.SatLon}°]{satInfo.SatName}({satInfo.SatCode})";
                }
                listSigDelay.Add(sigDelay.To<SigDelayViewModel>());
            }
            gridViewSigDelay.RefreshData();
        }

        private async void gridViewSignal_DoubleClick(object sender, EventArgs e)
        {
            var editItem = gridViewSignal.GetFocusedRow() as SigViewModel;
            if (editItem == null) return;
            await EditSigInfo(editItem);
        }

        private async void gridViewSigDelay_DoubleClick(object sender, EventArgs e)
        {
            var editItem = gridViewSigDelay.GetFocusedRow() as SigDelayViewModel;
            if (editItem == null) return;
            await EditSigDelay(editItem);

        }
    }
}