XdCxRhDW/XdCxRhDW.App/UserControl/CtrlSignal.cs

using DevExpress.Utils.About;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.Entity;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Documents;
using System.Windows.Forms;
using XdCxRhDW.App.EditForms;
using XdCxRhDW.Entity;
using XdCxRhDW.Repostory;

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

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

                using (var db = new RHDWContext())
                {
                    var items = await db.SigInfos.OrderBy(p=>p.FreqUp).ToListAsync();
                    listSigInfo.AddRange(items);
                    var fixedStations=await db.FixedStation.Where(p => p.Enable).ToListAsync();
                    foreach (var item in listSigInfo)
                    {
                        if (fixedStations.Any(p => p.FreqUpHz == item.FreqUp))
                            item.IsFixedStationFreq = "✔";
                        else
                            item.IsFixedStationFreq = "✖";
                    }
                    //var delayItems = await db.SigDelays.ToListAsync();
                    //var delayRes = delayItems.Where(w => w.SigInfoID == items.FirstOrDefault().ID);
                    //listSigDelay.AddRange(delayRes);
                }
                gridViewSignal.RefreshData();
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "查询信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("查询信号信息异常");
            }
        }
        private async Task<SigInfo> AddSigInfo()
        {
            try
            {
                SigEditor frm = new SigEditor();
                if (frm.ShowDialog() != DialogResult.OK) return null;
                var addItem = frm.info;
                using (RHDWContext db = new RHDWContext())
                {
                    var sig = db.SigInfos.Add(addItem);
                    await db.SaveChangesAsync();
                }
                return addItem;
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "添加信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("添加信号信息异常");
                return null;
            }
        }
        private async Task<SigInfo> EditSigInfo(SigInfo editItem)
        {
            try
            {
                SigEditor frm = new SigEditor(editItem);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                editItem = frm.info;
                using (RHDWContext db = new RHDWContext())
                {
                    var find = await db.SigInfos.Where(p => p.ID == editItem.ID).FirstOrDefaultAsync();
                    find.FreqUp = editItem.FreqUp;
                    find.FreqDown = editItem.FreqDown;
                    find.SigType = editItem.SigType;
                    find.Band = editItem.Band;
                    find.Snr = editItem.Snr;
                    find.UpdateTime = DateTime.Now;
                    await db.SaveChangesAsync();
                }
                return editItem;
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "保存信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("保存信号信息异常");
                return null;
            }
        }
        private async Task<bool> DeleteSigInfo(List<SigInfo> list)
        {
            try
            {
                var ids = list.Select(p => p.ID);
                using (RHDWContext db = new RHDWContext())
                {
                    var delayItems= db.SigDelays.Where(p => ids.Contains(p.SigInfoId));
                    db.SigDelays.RemoveRange(delayItems);
                    var delItems = await db.SigInfos.Where(p => ids.Contains(p.ID)).ToListAsync();
                    db.SigInfos.RemoveRange(delItems);
                    await db.SaveChangesAsync();
                }
                return true;
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "删除信号信息异常");
                DxHelper.MsgBoxHelper.ShowError("删除信号信息异常");
                return false;
            }
        }
        private async Task<SigDelay> AddSigDelay()
        {
            try
            {
                var sigInfoId = gridViewSignal.GetFocusedRow() as SigInfo;
                if (sigInfoId == null) return null;
                SigDelayEditor frm = new SigDelayEditor(sigInfoId.ID);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                var addItem = frm.info;
                using (RHDWContext db = new RHDWContext())
                {
                    addItem.SigInfoId = sigInfoId.ID;
                    var sig = db.SigDelays.Add(addItem);
                    await db.SaveChangesAsync();
                }
                return addItem;
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "添加转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("添加转发延迟异常");
                return null;
            }
        }
        private async Task<SigDelay> EditSigDelay(SigDelay editItem)
        {
            try
            {
                var sigInfoId = gridViewSignal.GetFocusedRow() as SigInfo;
                if (sigInfoId == null) return null;
                SigDelayEditor frm = new SigDelayEditor(editItem, sigInfoId.ID);
                if (frm.ShowDialog() != DialogResult.OK) return null;
                editItem = frm.info;
                using (RHDWContext db = new RHDWContext())
                {
                    var find = await db.SigDelays.Where(p => p.ID == editItem.ID).FirstOrDefaultAsync();
                    find.SigInfoId = editItem.SigInfoId;
                    find.SatInfoSatCode = editItem.SatInfoSatCode;
                    find.Delay = editItem.Delay;
                    await db.SaveChangesAsync();
                }
                return editItem;
            }
            catch (Exception ex)
            {
                Serilog.Log.Error(ex, "保存转发延迟异常");
                DxHelper.MsgBoxHelper.ShowError("保存转发延迟异常");
                return null;
            }
        }
        private async Task<bool> DeleteSigDelay(List<SigDelay> list)
        {
            try
            {
                var ids = list.Select(p => p.ID);
                using (RHDWContext db = new RHDWContext())
                {
                    var delItems = await db.SigDelays.Where(p => ids.Contains(p.ID)).ToListAsync();
                    db.SigDelays.RemoveRange(delItems);
                    await db.SaveChangesAsync();
                }
                return true;
            }
            catch (Exception ex)
            {
                Serilog.Log.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 SigInfo;
            if (sigInfoId == null) return;
            using (var db = new RHDWContext())
            {
                var delayItems = await db.SigDelays.Where(w => w.SigInfoId == sigInfoId.ID).OrderBy(p=>p.SatInfo.SatName).ToListAsync();
                var sats = await db.SatInfos.ToListAsync();
                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);
                }
                gridViewSigDelay.RefreshData();
            }
        }

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

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

        }
    }
}