using Azure;
using InSituLaboratory.Common;
using InSituLaboratory.Entities;
using InSituLaboratory.Entities.SqlSugar;
using InSituLaboratory.IService;
using InSituLaboratory.IService.Sensor;
using InSituLaboratory.Models;
using InSituLaboratory.Service;
using Microsoft.EntityFrameworkCore.Metadata.Internal;
using Microsoft.EntityFrameworkCore.Query.Internal;
using Prism.Commands;
using Prism.Regions;
using Prism.Services.Dialogs;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Forms;
using System.Windows.Markup;

namespace InSituLaboratory.ViewModels.Pages
{
    public class SequentialDistributionViewModel : ViewModelBase
    {

        #region 实体类
        public ObservableCollection<SysSequentialDetails> sysSequentialDetailsListS1 { get; set; } = new ObservableCollection<SysSequentialDetails>();
        public ObservableCollection<SysSequentialDetails> sysSequentialDetailsListS2 { get; set; } = new ObservableCollection<SysSequentialDetails>();
        public ObservableCollection<SysSequentialDetails> sysSequentialDetailsListS3 { get; set; } = new ObservableCollection<SysSequentialDetails>();
        public ObservableCollection<SysSequentialDetails> sysSequentialDetailsListS4 { get; set; } = new ObservableCollection<SysSequentialDetails>();
        public ObservableCollection<SysSequentialDetails> sysSequentialDetailsListS5 { get; set; } = new ObservableCollection<SysSequentialDetails>();
        public CurrentSequentiualModel CurrentSequentiual { get; set; } = new CurrentSequentiualModel(); //当前运行时序状态表
        public SequentStatusModel sequentStatusModel { get; set; } = new SequentStatusModel();


        System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"^[0-9]\d*$");
        #endregion

        IDialogService _dialogService;
        ISysSequentialService _sysSequentialService;
        ISensorService _sensorService;
        public SequentialDistributionViewModel(IRegionManager regionManager, IDialogService dialogService, ISysSequentialService sysSequentialService, ISensorService sensorService) : base(regionManager)
        {
            this.PageTitle = "时序下发";
            _dialogService = dialogService;
            _sysSequentialService = sysSequentialService;
            _sensorService = sensorService;

            Refresh();
            RefreshS1();
            RefreshS2();
            RefreshS3();
            RefreshS4();
            RefreshS5();
        }

        /// <summary>
        /// 页面刷新
        /// </summary>
        public override void Refresh()
        {
            //获取当前运行时序状态表
            var CurrentSequentiualList = _sensorService.GetCurrentSequentiual();

            //当前运行时序状态数据
            if (CurrentSequentiualList.Count() != 0)
            {
                var data = _sensorService.GetCurrentSequentiual().FirstOrDefault();

                CurrentSequentiual.Sequentiual1Status = data.Sequentiual1Status;
                CurrentSequentiual.Sequentiual2Status = data.Sequentiual2Status;
                CurrentSequentiual.Sequentiual3Status = data.Sequentiual3Status;
                CurrentSequentiual.Sequentiual4Status = data.Sequentiual4Status;
                CurrentSequentiual.Sequentiual5Status = data.Sequentiual5Status;
            }
        }

        #region 时序 1
        public override void RefreshS1()
        {
            int num = 1;
            SearchKey = "时序1";
            sysSequentialDetailsListS1.Clear();

            //获取时序母表数据
            var list = _sysSequentialService.GetSequentials(SearchKey).ToList();
            if (list.Count != 0)
            {
                var data = _sysSequentialService.GetSequentials(SearchKey).First();

                //获取时序子表数据
                var dataDetails = _sysSequentialService.GetSequentialDetails(data.Number).ToList();
                foreach (var item in dataDetails)
                {
                    SysSequentialDetails sysSequentialDetail = new SysSequentialDetails();
                    sysSequentialDetail.Number = item.Number;
                    sysSequentialDetail.DurationTime = item.DurationTime;
                    sysSequentialDetail.SensorID = item.SensorID;
                    sysSequentialDetail.WorkTime = item.WorkTime;
                    sysSequentialDetail.SequenceGroup = item.SequenceGroup;
                    sysSequentialDetail.CreateTime = item.CreateTime;
                    sysSequentialDetail.Sequential = item.Sequential;
                    sysSequentialDetail.SysSquentialID = item.SysSquentialID;
                    sysSequentialDetail.IsDelete = item.IsDelete;
                    sysSequentialDetail.num = num;

                    sysSequentialDetailsListS1.Add(sysSequentialDetail);
                    num++;
                }
                sequentStatusModel.SequentialStartTime1 = data.StartTime;
                sequentStatusModel.SequentialEndTime1 = data.EndTime;
                sequentStatusModel.Status1 = data.Status;
            }
        }

        /// <summary>
        /// 编辑或者新增
        /// </summary>
        /// <param name="model"></param>
        public override void DoModifyS1(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime1 && m.EndTime == sequentStatusModel.SequentialEndTime1 && m.IsDelete == 0 && m.Sequential == "时序1").ToList();
                if (sequentStatusModel.SequentialStartTime1 == null || sequentStatusModel.SequentialEndTime1 == null)
                {
                    throw new Exception("时序1:  开始时间和结束时间不能为空!");
                }
                else
                {
                    if (datalist1.Count() != 0)
                    {
                        foreach (var item in datalist1)
                        {
                            status = item.Status;
                        }
                        if (status == "已生成未下发")
                        {
                            DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime1;
                            DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime1;
                            DateTime dateTime = DateTime.Now;

                            if (expirationDate < dateTime)
                            {
                                throw new Exception("时序1:  开始时间不得早于当前时间!");
                            }
                            else if (expirationDate1 < dateTime)
                            {
                                throw new Exception("时序1:  结束时间不得早于当前时间!");
                            }
                            else if (expirationDate >= expirationDate1)
                            {
                                throw new Exception("时序1:  结束时间不得早于开始时间!");
                            }
                            else
                            {
                                DialogParameters ps = new DialogParameters();
                                ps.Add("model", model);
                                ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime1);
                                ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime1);
                                ps.Add("kind", "时序1");
                                _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                                {
                                    // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                    if (result.Result == ButtonResult.OK)
                                    {
                                        this.RefreshS1();
                                    }
                                });
                            }
                        }
                        else
                        {
                            throw new Exception("当前时序已下发！！！ \n 若要设置新的时序，您可以修改时序的开始时间和结束时间即可！");
                        }
                    }
                    else
                    {
                        DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime1;
                        DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime1;
                        DateTime dateTime = DateTime.Now;

                        if (expirationDate < dateTime)
                        {
                            throw new Exception("时序1:  开始时间不得早于当前时间!");
                        }
                        else if (expirationDate1 < dateTime)
                        {
                            throw new Exception("时序1:  结束时间不得早于当前时间!");
                        }
                        else if (expirationDate >= expirationDate1)
                        {
                            throw new Exception("时序1:  结束时间不得早于开始时间!");
                        }
                        else
                        {
                            DialogParameters ps = new DialogParameters();
                            ps.Add("model", model);
                            ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime1);
                            ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime1);
                            ps.Add("kind", "时序1");
                            _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                            {
                                // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                if (result.Result == ButtonResult.OK)
                                {
                                    this.RefreshS1();
                                }
                            });
                        }

                    }
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="model"></param>
        public override void DoDeleteS1(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime1 && m.EndTime == sequentStatusModel.SequentialEndTime1 && m.IsDelete == 0 && m.Sequential == "时序1").ToList();
                foreach (var item in datalist1)
                {
                    status += item.Status;
                }
                if (status != "已下发")
                {
                    if (System.Windows.Forms.MessageBox.Show("是否确定删除此项？", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.OK)
                    {
                        // 软删除
                        var data = _sysSequentialService.Find<SysSequentialDetails>((model as SysSequentialDetails).Number);
                        data.IsDelete = 1;
                        _sysSequentialService.Update(data);

                        //查询删除后子表是否还存在时序配置
                        var list = _sysSequentialService.GetSequentialDetails(data.SysSquentialID).ToList();
                        //若子表不存在当前时序下配置信息，则删除对应的母表时序
                        if (list.Count() == 0)
                        {
                            var SysSequential = _sysSequentialService.Find<SysSequential>(data.SysSquentialID);
                            SysSequential.IsDelete = 1;
                            _sysSequentialService.Update(SysSequential);
                        }

                        ///更新时序总表
                        var data1 = _sysSequentialService.Find<SysSequentialTotal>((model as SysSequentialDetails).Number);
                        data1.IsDelete = 1;
                        _sysSequentialService.Update(data1);

                        System.Windows.Forms.MessageBox.Show("删除完成！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        this.RefreshS1();
                    }
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show(" 当前时序已下发！！！ \n 无法删除！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }

        }

        /// <summary>
        /// 时序下发
        /// </summary>
        public override void SendS1()
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime1 && m.EndTime == sequentStatusModel.SequentialEndTime1 && m.IsDelete == 0 && m.Sequential == "时序1").ToList();

                if (sequentStatusModel.SequentialStartTime1 == null || sequentStatusModel.SequentialEndTime1 == null)
                {
                    throw new Exception("时序1:  开始时间和结束时间不能为空!");
                }
                else if (datalist1.Count() == 0)
                {
                    throw new Exception("时序1中未有设备，无法下发！！！");
                }
                else
                {
                    if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
                    {
                        DateTime startTime = (DateTime)sequentStatusModel.SequentialStartTime1;
                        DateTime endTime = (DateTime)sequentStatusModel.SequentialEndTime1;
                        foreach (var item in datalist1)
                        {
                            status = item.Status;
                        }
                        if (status == "已生成未下发")
                        {
                            System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否修改并等待当前工作设备工作完最短周期后生效新时序？ \n若选择否，则修改且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                            //修改并等待当前工作设备工作完最短周期后生效新时序
                            if (s1 == System.Windows.Forms.DialogResult.Yes)
                            {
                                //计算设备功耗是否超总功耗及设备运行时长是否超时
                                List<byte> byteaq = encode(startTime, endTime, 0x01, "时序1");
                                List<byte> buffer = Escape(byteaq.ToArray());
                                string list = tools.byteToHexStr(buffer.ToArray());
                                byte[] bytea = tools.ConvertHexStringToBytes(list);
                                RelayViewModel.clientModel.SendData(bytea);

                                //更新时序母表及时序总表状态字段
                                UpdateData(startTime, endTime, "时序1", "已下发");
                                System.Windows.Forms.MessageBox.Show("命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                            }
                            //修改且关闭该时序所有设备
                            else if (s1 == System.Windows.Forms.DialogResult.No)
                            {
                                //计算设备功耗是否超总功耗及设备运行时长是否超时
                                List<byte> byteaq = encode((DateTime)sequentStatusModel.SequentialStartTime1, (DateTime)sequentStatusModel.SequentialEndTime1, 0x02, "时序1");
                                List<byte> buffer = Escape(byteaq.ToArray());
                                string list = tools.byteToHexStr(buffer.ToArray());
                                byte[] bytea = tools.ConvertHexStringToBytes(list);
                                RelayViewModel.clientModel.SendData(bytea);

                                //更新时序母表及时序总表状态字段
                                UpdateData(startTime, endTime, "时序1", "已下发");
                                System.Windows.Forms.MessageBox.Show("命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                            }
                        }
                        else
                        {
                            throw new Exception("当前时序已下发！！！");
                        }
                        this.RefreshS1();
                    }
                    else
                    {
                        throw new Exception("请先连接服务端！");
                    }
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 时序清空
        /// </summary>
        public override void ClearS1()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否清空并等待当前工作设备工作完最短周期？ \n若选择否，则清空且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //清空并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x01, 0x03);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //清空且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x01, 0x04);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS1();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 时序启动
        /// </summary>
        public override void BeginS1()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                dosend(0x01, 0x05);
                System.Windows.Forms.MessageBox.Show("时序启动命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                this.RefreshS1();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }

        /// <summary>
        /// 时序暂停
        /// </summary>
        public override void SuspendS1()
        {

            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {

                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否暂停并等待当前工作设备工作完最短周期？ \n若选择否，则暂停且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //暂停并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x01, 0x07);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //暂停且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x01, 0x08);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS1();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
        #endregion

        #region 时序 2
        public override void RefreshS2()
        {
            int num = 1;
            SearchKey = "时序2";
            sysSequentialDetailsListS2.Clear();
            var list = _sysSequentialService.GetSequentials(SearchKey).ToList();
            if (list.Count != 0)
            {
                var data = _sysSequentialService.GetSequentials(SearchKey).First();

                var dataDetails = _sysSequentialService.GetSequentialDetails(data.Number).ToList();
                foreach (var item in dataDetails)
                {
                    SysSequentialDetails sysSequentialDetail = new SysSequentialDetails();
                    sysSequentialDetail.Number = item.Number;
                    sysSequentialDetail.DurationTime = item.DurationTime;
                    sysSequentialDetail.SensorID = item.SensorID;
                    sysSequentialDetail.WorkTime = item.WorkTime;
                    sysSequentialDetail.SequenceGroup = item.SequenceGroup;
                    sysSequentialDetail.CreateTime = item.CreateTime;
                    sysSequentialDetail.Sequential = item.Sequential;
                    sysSequentialDetail.SysSquentialID = item.SysSquentialID;
                    sysSequentialDetail.IsDelete = item.IsDelete;
                    sysSequentialDetail.num = num;

                    sysSequentialDetailsListS2.Add(sysSequentialDetail);
                    num++;
                }
                sequentStatusModel.SequentialStartTime2 = data.StartTime;
                sequentStatusModel.SequentialEndTime2 = data.EndTime;
                sequentStatusModel.Status2 = data.Status;
            }
        }

        /// <summary>
        /// 编辑或者新增
        /// </summary>
        /// <param name="model"></param>
        public override void DoModifyS2(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime2 && m.EndTime == sequentStatusModel.SequentialEndTime2 && m.IsDelete == 0 && m.Sequential == "时序2").ToList();
                if (sequentStatusModel.SequentialStartTime2 == null || sequentStatusModel.SequentialEndTime2 == null)
                {
                    throw new Exception("时序2:  开始时间和结束时间不能为空!");
                }
                else
                {
                    if (datalist1.Count() != 0)
                    {
                        foreach (var item in datalist1)
                        {
                            status = item.Status;
                        }
                        if (status == "已生成未下发")
                        {
                            DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime2;
                            DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime2;
                            DateTime dateTime = DateTime.Now;

                            if (expirationDate < dateTime)
                            {
                                throw new Exception("时序2:  开始时间不得早于当前时间!");
                            }
                            else if (expirationDate1 < dateTime)
                            {
                                throw new Exception("时序2:  结束时间不得早于当前时间!");
                            }
                            else if (expirationDate >= expirationDate1)
                            {
                                throw new Exception("时序2:  结束时间不得早于开始时间!");
                            }
                            else
                            {
                                DialogParameters ps = new DialogParameters();
                                ps.Add("model", model);
                                ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime2);
                                ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime2);
                                ps.Add("kind", "时序2");
                                _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                                {
                                    // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                    if (result.Result == ButtonResult.OK)
                                    {
                                        this.RefreshS2();
                                    }
                                });
                            }
                        }
                        else
                        {
                            throw new Exception("当前时序已下发！！！ \n 若要设置新的时序，您可以修改时序的开始时间和结束时间即可！");
                        }
                    }
                    else
                    {
                        DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime2;
                        DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime2;
                        DateTime dateTime = DateTime.Now;

                        if (expirationDate < dateTime)
                        {
                            throw new Exception("时序2:  开始时间不得早于当前时间!");
                        }
                        else if (expirationDate1 < dateTime)
                        {
                            throw new Exception("时序2:  结束时间不得早于当前时间!");
                        }
                        else if (expirationDate >= expirationDate1)
                        {
                            throw new Exception("时序2:  结束时间不得早于开始时间!");
                        }
                        else
                        {
                            DialogParameters ps = new DialogParameters();
                            ps.Add("model", model);
                            ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime2);
                            ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime2);
                            ps.Add("kind", "时序2");
                            _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                            {
                                // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                if (result.Result == ButtonResult.OK)
                                {
                                    this.RefreshS2();
                                }
                            });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="model"></param>
        public override void DoDeleteS2(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime2 && m.EndTime == sequentStatusModel.SequentialEndTime2 && m.IsDelete == 0 && m.Sequential == "时序2").ToList();
                foreach (var item in datalist1)
                {
                    status += item.Status;
                }
                if (status != "已下发")
                {
                    if (System.Windows.Forms.MessageBox.Show("是否确定删除此项？", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.OK)
                    {
                        // 软删除
                        var data = _sysSequentialService.Find<SysSequentialDetails>((model as SysSequentialDetails).Number);
                        data.IsDelete = 1;
                        _sysSequentialService.Update(data);

                        //查询删除后子表是否还存在时序配置
                        var list = _sysSequentialService.GetSequentialDetails(data.SysSquentialID).ToList();
                        //若子表不存在当前时序下配置信息，则删除对应的母表时序
                        if (list.Count() == 0)
                        {
                            var SysSequential = _sysSequentialService.Find<SysSequential>(data.SysSquentialID);
                            SysSequential.IsDelete = 1;
                            _sysSequentialService.Update(SysSequential);
                        }

                        ///更新时序总表
                        var data1 = _sysSequentialService.Find<SysSequentialTotal>((model as SysSequentialDetails).Number);
                        data1.IsDelete = 1;
                        _sysSequentialService.Update(data1);

                        System.Windows.Forms.MessageBox.Show("删除完成！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        this.RefreshS2();
                    }
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show(" 当前时序已下发！！！ \n 无法删除！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }

        }


        /// <summary>
        /// 时序清空
        /// </summary>
        public override void ClearS2()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否清空并等待当前工作设备工作完最短周期？ \n若选择否，则清空且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //清空并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x02, 0x03);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //清空且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x02, 0x04);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS2();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 时序启动
        /// </summary>
        public override void BeginS2()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                dosend(0x02, 0x05);
                System.Windows.Forms.MessageBox.Show("时序启动命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                this.RefreshS2();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }

        /// <summary>
        /// 时序暂停
        /// </summary>
        public override void SuspendS2()
        {

            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {

                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否暂停并等待当前工作设备工作完最短周期？ \n若选择否，则暂停且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //暂停并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x02, 0x07);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //暂停且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x02, 0x08);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS2();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }

        #endregion

        #region 时序 3
        public override void RefreshS3()
        {
            int num = 1;
            SearchKey = "时序3";
            sysSequentialDetailsListS3.Clear();
            var list = _sysSequentialService.GetSequentials(SearchKey).ToList();
            if (list.Count != 0)
            {
                var data = _sysSequentialService.GetSequentials(SearchKey).First();

                var dataDetails = _sysSequentialService.GetSequentialDetails(data.Number).ToList();
                foreach (var item in dataDetails)
                {
                    SysSequentialDetails sysSequentialDetail = new SysSequentialDetails();
                    sysSequentialDetail.Number = item.Number;
                    sysSequentialDetail.DurationTime = item.DurationTime;
                    sysSequentialDetail.SensorID = item.SensorID;
                    sysSequentialDetail.WorkTime = item.WorkTime;
                    sysSequentialDetail.SequenceGroup = item.SequenceGroup;
                    sysSequentialDetail.CreateTime = item.CreateTime;
                    sysSequentialDetail.Sequential = item.Sequential;
                    sysSequentialDetail.SysSquentialID = item.SysSquentialID;
                    sysSequentialDetail.IsDelete = item.IsDelete;
                    sysSequentialDetail.num = num;

                    sysSequentialDetailsListS3.Add(sysSequentialDetail);
                    num++;
                }
                sequentStatusModel.SequentialStartTime3 = data.StartTime;
                sequentStatusModel.SequentialEndTime3 = data.EndTime;
                sequentStatusModel.Status3 = data.Status;
            }
        }

        /// <summary>
        /// 编辑或者新增
        /// </summary>
        /// <param name="model"></param>
        public override void DoModifyS3(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime3 && m.EndTime == sequentStatusModel.SequentialEndTime3 && m.IsDelete == 0 && m.Sequential == "时序3").ToList();
                if (sequentStatusModel.SequentialStartTime3 == null || sequentStatusModel.SequentialEndTime3 == null)
                {
                    throw new Exception("时序3:  开始时间和结束时间不能为空!");
                }
                else
                {
                    if (datalist1.Count() != 0)
                    {
                        foreach (var item in datalist1)
                        {
                            status = item.Status;
                        }
                        if (status == "已生成未下发")
                        {
                            DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime3;
                            DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime3;
                            DateTime dateTime = DateTime.Now;

                            if (expirationDate < dateTime)
                            {
                                throw new Exception("时序3:  开始时间不得早于当前时间!");
                            }
                            else if (expirationDate1 < dateTime)
                            {
                                throw new Exception("时序3:  结束时间不得早于当前时间!");
                            }
                            else if (expirationDate >= expirationDate1)
                            {
                                throw new Exception("时序3:  结束时间不得早于开始时间!");
                            }
                            else
                            {
                                DialogParameters ps = new DialogParameters();
                                ps.Add("model", model);
                                ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime3);
                                ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime3);
                                ps.Add("kind", "时序3");
                                _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                                {
                                    // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                    if (result.Result == ButtonResult.OK)
                                    {
                                        this.RefreshS3();
                                    }
                                });
                            }
                        }
                        else
                        {
                            throw new Exception("当前时序已下发！！！ \n 若要设置新的时序，您可以修改时序的开始时间和结束时间即可！");
                        }
                    }
                    else
                    {
                        DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime3;
                        DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime3;
                        DateTime dateTime = DateTime.Now;

                        if (expirationDate < dateTime)
                        {
                            throw new Exception("时序3:  开始时间不得早于当前时间!");
                        }
                        else if (expirationDate1 < dateTime)
                        {
                            throw new Exception("时序3:  结束时间不得早于当前时间!");
                        }
                        else if (expirationDate >= expirationDate1)
                        {
                            throw new Exception("时序3:  结束时间不得早于开始时间!");
                        }
                        else
                        {
                            DialogParameters ps = new DialogParameters();
                            ps.Add("model", model);
                            ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime3);
                            ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime3);
                            ps.Add("kind", "时序3");
                            _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                            {
                                // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                if (result.Result == ButtonResult.OK)
                                {
                                    this.RefreshS3();
                                }
                            });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="model"></param>
        public override void DoDeleteS3(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime3 && m.EndTime == sequentStatusModel.SequentialEndTime3 && m.IsDelete == 0 && m.Sequential == "时序3").ToList();
                foreach (var item in datalist1)
                {
                    status += item.Status;
                }
                if (status != "已下发")
                {
                    if (System.Windows.Forms.MessageBox.Show("是否确定删除此项？", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.OK)
                    {
                        // 软删除
                        var data = _sysSequentialService.Find<SysSequentialDetails>((model as SysSequentialDetails).Number);
                        data.IsDelete = 1;
                        _sysSequentialService.Update(data);

                        //查询删除后子表是否还存在时序配置
                        var list = _sysSequentialService.GetSequentialDetails(data.SysSquentialID).ToList();
                        //若子表不存在当前时序下配置信息，则删除对应的母表时序
                        if (list.Count() == 0)
                        {
                            var SysSequential = _sysSequentialService.Find<SysSequential>(data.SysSquentialID);
                            SysSequential.IsDelete = 1;
                            _sysSequentialService.Update(SysSequential);
                        }

                        ///更新时序总表
                        var data1 = _sysSequentialService.Find<SysSequentialTotal>((model as SysSequentialDetails).Number);
                        data1.IsDelete = 1;
                        _sysSequentialService.Update(data1);

                        System.Windows.Forms.MessageBox.Show("删除完成！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        this.RefreshS3();
                    }
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show(" 当前时序已下发！！！ \n 无法删除！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }

        }

        /// <summary>
        /// 时序清空
        /// </summary>
        public override void ClearS3()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否清空并等待当前工作设备工作完最短周期？ \n若选择否，则清空且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //清空并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x03, 0x03);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //清空且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x03, 0x04);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS3();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 时序启动
        /// </summary>
        public override void BeginS3()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                dosend(0x03, 0x05);
                System.Windows.Forms.MessageBox.Show("时序启动命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                this.RefreshS3();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }

        /// <summary>
        /// 时序暂停
        /// </summary>
        public override void SuspendS3()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {

                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否暂停并等待当前工作设备工作完最短周期？ \n若选择否，则暂停且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //暂停并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x03, 0x07);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //暂停且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x03, 0x08);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS3();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
        #endregion

        #region 时序 4
        public override void RefreshS4()
        {
            int num = 1;
            SearchKey = "时序4";
            sysSequentialDetailsListS4.Clear();
            var list = _sysSequentialService.GetSequentials(SearchKey).ToList();
            if (list.Count != 0)
            {
                var data = _sysSequentialService.GetSequentials(SearchKey).First();

                var dataDetails = _sysSequentialService.GetSequentialDetails(data.Number).ToList();
                foreach (var item in dataDetails)
                {
                    SysSequentialDetails sysSequentialDetail = new SysSequentialDetails();
                    sysSequentialDetail.Number = item.Number;
                    sysSequentialDetail.DurationTime = item.DurationTime;
                    sysSequentialDetail.SensorID = item.SensorID;
                    sysSequentialDetail.WorkTime = item.WorkTime;
                    sysSequentialDetail.SequenceGroup = item.SequenceGroup;
                    sysSequentialDetail.CreateTime = item.CreateTime;
                    sysSequentialDetail.Sequential = item.Sequential;
                    sysSequentialDetail.SysSquentialID = item.SysSquentialID;
                    sysSequentialDetail.IsDelete = item.IsDelete;
                    sysSequentialDetail.num = num;

                    sysSequentialDetailsListS4.Add(sysSequentialDetail);
                    num++;
                }
                sequentStatusModel.SequentialStartTime4 = data.StartTime;
                sequentStatusModel.SequentialEndTime4 = data.EndTime;
                sequentStatusModel.Status4 = data.Status;
            }
        }

        /// <summary>
        /// 编辑或者新增
        /// </summary>
        /// <param name="model"></param>
        public override void DoModifyS4(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime4 && m.EndTime == sequentStatusModel.SequentialEndTime4 && m.IsDelete == 0 && m.Sequential == "时序4").ToList();
                if (sequentStatusModel.SequentialStartTime4 == null || sequentStatusModel.SequentialEndTime4 == null)
                {
                    throw new Exception("时序4:  开始时间和结束时间不能为空!");
                }
                else
                {
                    if (datalist1.Count() != 0)
                    {
                        foreach (var item in datalist1)
                        {
                            status = item.Status;
                        }
                        if (status == "已生成未下发")
                        {
                            DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime4;
                            DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime4;
                            DateTime dateTime = DateTime.Now;

                            if (expirationDate < dateTime)
                            {
                                throw new Exception("时序4:  开始时间不得早于当前时间!");
                            }
                            else if (expirationDate1 < dateTime)
                            {
                                throw new Exception("时序4:  结束时间不得早于当前时间!");
                            }
                            else if (expirationDate >= expirationDate1)
                            {
                                throw new Exception("时序4:  结束时间不得早于开始时间!");
                            }
                            else
                            {
                                DialogParameters ps = new DialogParameters();
                                ps.Add("model", model);
                                ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime4);
                                ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime4);
                                ps.Add("kind", "时序4");
                                _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                                {
                                    // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                    if (result.Result == ButtonResult.OK)
                                    {
                                        this.RefreshS4();
                                    }
                                });
                            }
                        }
                        else
                        {
                            throw new Exception("当前时序已下发！！！ \n 若要设置新的时序，您可以修改时序的开始时间和结束时间即可！");
                        }
                    }
                    else
                    {
                        DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime4;
                        DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime4;
                        DateTime dateTime = DateTime.Now;

                        if (expirationDate < dateTime)
                        {
                            throw new Exception("时序4:  开始时间不得早于当前时间!");
                        }
                        else if (expirationDate1 < dateTime)
                        {
                            throw new Exception("时序4:  结束时间不得早于当前时间!");
                        }
                        else if (expirationDate >= expirationDate1)
                        {
                            throw new Exception("时序4:  结束时间不得早于开始时间!");
                        }
                        else
                        {
                            DialogParameters ps = new DialogParameters();
                            ps.Add("model", model);
                            ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime4);
                            ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime4);
                            ps.Add("kind", "时序4");
                            _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                            {
                                // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                if (result.Result == ButtonResult.OK)
                                {
                                    this.RefreshS4();
                                }
                            });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="model"></param>
        public override void DoDeleteS4(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime4 && m.EndTime == sequentStatusModel.SequentialEndTime4 && m.IsDelete == 0 && m.Sequential == "时序4").ToList();
                foreach (var item in datalist1)
                {
                    status += item.Status;
                }
                if (status != "已下发")
                {
                    if (System.Windows.Forms.MessageBox.Show("是否确定删除此项？", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.OK)
                    {
                        // 软删除
                        var data = _sysSequentialService.Find<SysSequentialDetails>((model as SysSequentialDetails).Number);
                        data.IsDelete = 1;
                        _sysSequentialService.Update(data);

                        //查询删除后子表是否还存在时序配置
                        var list = _sysSequentialService.GetSequentialDetails(data.SysSquentialID).ToList();
                        //若子表不存在当前时序下配置信息，则删除对应的母表时序
                        if (list.Count() == 0)
                        {
                            var SysSequential = _sysSequentialService.Find<SysSequential>(data.SysSquentialID);
                            SysSequential.IsDelete = 1;
                            _sysSequentialService.Update(SysSequential);
                        }

                        ///更新时序总表
                        var data1 = _sysSequentialService.Find<SysSequentialTotal>((model as SysSequentialDetails).Number);
                        data1.IsDelete = 1;
                        _sysSequentialService.Update(data1);

                        System.Windows.Forms.MessageBox.Show("删除完成！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        this.RefreshS4();
                    }
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show(" 当前时序已下发！！！ \n 无法删除！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }

        }

        /// <summary>
        /// 时序清空
        /// </summary>
        public override void ClearS4()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否清空并等待当前工作设备工作完最短周期？ \n若选择否，则清空且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //清空并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x04, 0x03);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //清空且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x04, 0x04);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS4();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 时序启动
        /// </summary>
        public override void BeginS4()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                dosend(0x04, 0x05);
                System.Windows.Forms.MessageBox.Show("时序启动命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                this.RefreshS4();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }

        /// <summary>
        /// 时序暂停
        /// </summary>
        public override void SuspendS4()
        {

            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {

                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否暂停并等待当前工作设备工作完最短周期？ \n若选择否，则暂停且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //暂停并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x04, 0x07);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //暂停且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x04, 0x08);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS4();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
        #endregion

        #region 时序 5
        public override void RefreshS5()
        {
            int num = 1;
            SearchKey = "时序5";
            sysSequentialDetailsListS5.Clear();
            var list = _sysSequentialService.GetSequentials(SearchKey).ToList();
            if (list.Count != 0)
            {
                var data = _sysSequentialService.GetSequentials(SearchKey).First();

                var dataDetails = _sysSequentialService.GetSequentialDetails(data.Number).ToList();
                foreach (var item in dataDetails)
                {
                    SysSequentialDetails sysSequentialDetail = new SysSequentialDetails();
                    sysSequentialDetail.Number = item.Number;
                    sysSequentialDetail.DurationTime = item.DurationTime;
                    sysSequentialDetail.SensorID = item.SensorID;
                    sysSequentialDetail.WorkTime = item.WorkTime;
                    sysSequentialDetail.SequenceGroup = item.SequenceGroup;
                    sysSequentialDetail.CreateTime = item.CreateTime;
                    sysSequentialDetail.Sequential = item.Sequential;
                    sysSequentialDetail.SysSquentialID = item.SysSquentialID;
                    sysSequentialDetail.IsDelete = item.IsDelete;
                    sysSequentialDetail.num = num;

                    sysSequentialDetailsListS5.Add(sysSequentialDetail);
                    num++;
                }
                sequentStatusModel.SequentialStartTime5 = data.StartTime;
                sequentStatusModel.SequentialEndTime5 = data.EndTime;
                sequentStatusModel.Status5 = data.Status;
            }
        }

        /// <summary>
        /// 编辑或者新增
        /// </summary>
        /// <param name="model"></param>
        public override void DoModifyS5(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime5 && m.EndTime == sequentStatusModel.SequentialEndTime5 && m.IsDelete == 0 && m.Sequential == "时序5").ToList();
                if (sequentStatusModel.SequentialStartTime5 == null || sequentStatusModel.SequentialEndTime5 == null)
                {
                    throw new Exception("时序5:  开始时间和结束时间不能为空!");
                }
                else
                {
                    if (datalist1.Count() != 0)
                    {
                        foreach (var item in datalist1)
                        {
                            status = item.Status;
                        }
                        if (status == "已生成未下发")
                        {
                            DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime5;
                            DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime5;
                            DateTime dateTime = DateTime.Now;

                            if (expirationDate < dateTime)
                            {
                                throw new Exception("时序5:  开始时间不得早于当前时间!");
                            }
                            else if (expirationDate1 < dateTime)
                            {
                                throw new Exception("时序5:  结束时间不得早于当前时间!");
                            }
                            else if (expirationDate >= expirationDate1)
                            {
                                throw new Exception("时序5:  结束时间不得早于开始时间!");
                            }
                            else
                            {
                                DialogParameters ps = new DialogParameters();
                                ps.Add("model", model);
                                ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime5);
                                ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime5);
                                ps.Add("kind", "时序5");
                                _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                                {
                                    // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                    if (result.Result == ButtonResult.OK)
                                    {
                                        this.RefreshS5();
                                    }
                                });
                            }
                        }
                        else
                        {
                            throw new Exception("当前时序已下发！！！ \n 若要设置新的时序，您可以修改时序的开始时间和结束时间即可！");
                        }
                    }
                    else
                    {
                        DateTime expirationDate = (DateTime)sequentStatusModel.SequentialStartTime5;
                        DateTime expirationDate1 = (DateTime)sequentStatusModel.SequentialEndTime5;
                        DateTime dateTime = DateTime.Now;

                        if (expirationDate < dateTime)
                        {
                            throw new Exception("时序5:  开始时间不得早于当前时间!");
                        }
                        else if (expirationDate1 < dateTime)
                        {
                            throw new Exception("时序5:  结束时间不得早于当前时间!");
                        }
                        else if (expirationDate >= expirationDate1)
                        {
                            throw new Exception("时序5:  结束时间不得早于开始时间!");
                        }
                        else
                        {
                            DialogParameters ps = new DialogParameters();
                            ps.Add("model", model);
                            ps.Add("sequentialStartTime", sequentStatusModel.SequentialStartTime5);
                            ps.Add("sequentialEndTime", sequentStatusModel.SequentialEndTime5);
                            ps.Add("kind", "时序5");
                            _dialogService.ShowDialog("ModifySequentialView", ps, result =>
                            {
                                // 判断子窗口的返回状态，如果OK，刷新当前页面，否则不管
                                if (result.Result == ButtonResult.OK)
                                {
                                    this.RefreshS5();
                                }
                            });
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="model"></param>
        public override void DoDeleteS5(object model)
        {
            try
            {
                var status = "";
                var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == sequentStatusModel.SequentialStartTime5 && m.EndTime == sequentStatusModel.SequentialEndTime5 && m.IsDelete == 0 && m.Sequential == "时序5").ToList();
                foreach (var item in datalist1)
                {
                    status += item.Status;
                }
                if (status != "已下发")
                {
                    if (System.Windows.Forms.MessageBox.Show("是否确定删除此项？", "提示", MessageBoxButtons.OKCancel, MessageBoxIcon.Question) == System.Windows.Forms.DialogResult.OK)
                    {
                        // 软删除
                        var data = _sysSequentialService.Find<SysSequentialDetails>((model as SysSequentialDetails).Number);
                        data.IsDelete = 1;
                        _sysSequentialService.Update(data);

                        //查询删除后子表是否还存在时序配置
                        var list = _sysSequentialService.GetSequentialDetails(data.SysSquentialID).ToList();
                        //若子表不存在当前时序下配置信息，则删除对应的母表时序
                        if (list.Count() == 0)
                        {
                            var SysSequential = _sysSequentialService.Find<SysSequential>(data.SysSquentialID);
                            SysSequential.IsDelete = 1;
                            _sysSequentialService.Update(SysSequential);
                        }

                        ///更新时序总表
                        var data1 = _sysSequentialService.Find<SysSequentialTotal>((model as SysSequentialDetails).Number);
                        data1.IsDelete = 1;
                        _sysSequentialService.Update(data1);

                        System.Windows.Forms.MessageBox.Show("删除完成！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                        this.RefreshS5();
                    }
                }
                else
                {
                    System.Windows.Forms.MessageBox.Show(" 当前时序已下发！！！ \n 无法删除！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
            }
            catch (Exception ex)
            {
                System.Windows.Forms.MessageBox.Show(ex.Message, "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
            }

        }

        /// <summary>
        /// 时序清空
        /// </summary>
        public override void ClearS5()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否清空并等待当前工作设备工作完最短周期？ \n若选择否，则清空且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //清空并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x05, 0x03);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //清空且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x05, 0x04);
                    System.Windows.Forms.MessageBox.Show("时序清空命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS5();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }

        }

        /// <summary>
        /// 时序启动
        /// </summary>
        public override void BeginS5()
        {
            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {
                dosend(0x05, 0x05);
                System.Windows.Forms.MessageBox.Show("时序启动命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                this.RefreshS5();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }

        /// <summary>
        /// 时序暂停
        /// </summary>
        public override void SuspendS5()
        {

            if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
            {

                System.Windows.Forms.DialogResult s1 = System.Windows.Forms.MessageBox.Show("是否暂停并等待当前工作设备工作完最短周期？ \n若选择否，则暂停且关闭该时序所有设备！！！", "警告", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);

                //暂停并等待当前工作设备工作完最短周期
                if (s1 == System.Windows.Forms.DialogResult.Yes)
                {
                    dosend(0x05, 0x07);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                //暂停且关闭该时序所有设备
                else if (s1 == System.Windows.Forms.DialogResult.No)
                {
                    dosend(0x05, 0x08);
                    System.Windows.Forms.MessageBox.Show("时序暂停命令已下发！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                }
                this.RefreshS5();
            }
            else
            {
                System.Windows.Forms.MessageBox.Show("请先连接服务端！", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
            }
        }
        #endregion

        /// <summary>
        /// 请求当前时序
        /// </summary>
        /// <param name="o"></param>
        public override void DoSync(object o)
        {
            string[] msg = o.ToString().Split(',');
            switch (msg[0])
            {
                //时序1
                case "sequent1":
                    DoSyncSend(0x01);
                    break;
                //时序2
                case "sequent2":
                    DoSyncSend(0x02);
                    break;
                //时序3
                case "sequent3":
                    DoSyncSend(0x03);
                    break;
                //时序4
                case "sequent4":
                    DoSyncSend(0x04);
                    break;
                //时序5
                case "sequent5":
                    DoSyncSend(0x05);
                    break;
                default:
                    break;
            }
            System.Windows.Forms.MessageBox.Show("已请求当前时序同步！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
        }

        /// <summary>
        /// 转义封装
        /// </summary>
        /// <param name="bytes"></param>
        /// <returns></returns>
        public List<byte> Escape(byte[] bytes)
        {
            //标志位
            byte head = 0x7f;
            //crc
            byte nr_crc = 0;
            nr_crc = tools.CRC(bytes.ToArray(), 0, bytes.Length);

            ///转义
            int j = 0;
            List<byte> tBuffer = bytes.ToList();
            tBuffer.Add(nr_crc);
            int length = tBuffer.ToArray().Length;
            byte[] newAnswer = tBuffer.ToArray();
            for (int i = 0; i < length; i++)
            {
                if (newAnswer[i] == 0x7e || newAnswer[i] == 0x7f)
                {
                    j++;
                }
            }
            byte[] newSendBuffer = new byte[length + j];
            for (int i = 0; i < length; i++)
            {
                newSendBuffer[i] = newAnswer[i];
            }
            for (int i = 0; i < length + j; i++)
            {
                if (newSendBuffer[i] == 0x7e)
                {
                    for (int k = length + j - 1; k > i + 1; k--)
                    {
                        newSendBuffer[k] = newSendBuffer[k - 1];
                    }
                    newSendBuffer[i + 1] = 0x01;
                }
                if (newSendBuffer[i] == 0x7f)
                {
                    newSendBuffer[i] = 0x7e;
                    for (int k = length + j - 1; k > i + 1; k--)
                    {
                        newSendBuffer[k] = newSendBuffer[k - 1];
                    }
                    newSendBuffer[i + 1] = 0x02;
                }
            }

            List<byte> buffer = new List<byte>();
            buffer.Add(head);
            for (int i = 0; i < newSendBuffer.Length; i++)
            {
                buffer.Add(newSendBuffer[i]);
            }
            buffer.Add(head);

            return buffer;
        }


        /// <summary>
        /// 命令发送 ---时序清空
        /// </summary>
        /// <param name="x1">时序号</param>
        /// <param name="x2">操作类型</param>
        public void dosend(byte x1, byte x2)
        {
            //消息体
            byte[] byteaq = new byte[] { 0x91, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, x1, x2 };

            List<byte> buffer = Escape(byteaq);
            string list = tools.byteToHexStr(buffer.ToArray());
            byte[] bytea = tools.ConvertHexStringToBytes(list);
            RelayViewModel.clientModel.SendData(bytea);
        }


        /// <summary>
        /// 请求当前时序下发
        /// </summary>
        /// <param name="x1">时序组号</param>
        public void DoSyncSend(byte x1)
        {
            //消息体
            byte[] byteaq = new byte[] { 0x92, 0x02, 0x10, 0x01, 0x00, 0x00, 0x00, 0x01, x1 };
            List<byte> buffer = Escape(byteaq);
            string list = tools.byteToHexStr(buffer.ToArray());
            byte[] bytea = tools.ConvertHexStringToBytes(list);
            RelayViewModel.clientModel.SendData(bytea);

        }


        /// <summary>
        /// 时序下发封装数据域
        /// </summary>
        /// <param name="StartTime">时序开始时间</param>
        /// <param name="EndTime">时序结束时间</param>
        /// <param name="GroupNumber">时序组号</param>
        /// <param name="kind">时序类型</param>
        /// <returns></returns>
        public List<byte> encode(DateTime StartTime, DateTime EndTime, byte GroupNumber, string kind)
        {
            #region 定义参数
            DateTime startTime = StartTime;
            DateTime endTime = EndTime;

            ulong senddate;
            ulong year;
            ulong month;
            ulong day;
            ulong hour;
            ulong min;
            ulong sec;

            ulong sendenddate;
            ulong endyear;
            ulong endmonth;
            ulong endday;
            ulong endhour;
            ulong endmin;
            ulong endsec;

            //初始化电能板1 负载功耗=0
            float EnergyBoard1 = 0;
            //初始化电能板2 负载功耗=0
            float EnergyBoard2 = 0;
            //初始化电能板3 负载功耗=0
            float EnergyBoard3 = 0;
            //初始化电能板4 负载功耗=0
            float EnergyBoard4 = 0;

            //定义消息体数组
            List<byte> byteaq = new List<byte>();


            #endregion

            //计算两个日期的分钟数差值，用于下发时间校验
            System.TimeSpan t3 = endTime - startTime;
            float getMinute = (float)t3.TotalMinutes;



            year = (ulong)startTime.Year * 10000000000UL;
            month = (ulong)startTime.Month * 100000000UL;
            day = (ulong)startTime.Day * 1000000UL;
            hour = (ulong)startTime.Hour * 10000UL;
            min = (ulong)startTime.Minute * 100UL;
            sec = (ulong)startTime.Second;
            senddate = year + month + day + hour + min + sec;

            endyear = (ulong)endTime.Year * 10000000000UL;
            endmonth = (ulong)endTime.Month * 100000000UL;
            endday = (ulong)endTime.Day * 1000000UL;
            endhour = (ulong)endTime.Hour * 10000UL;
            endmin = (ulong)endTime.Minute * 100UL;
            endsec = (ulong)endTime.Second;
            sendenddate = endyear + endmonth + endday + endhour + endmin + endsec;

            //消息头
            byteaq.Add(0x91);
            byteaq.Add(0x00);
            byteaq.Add(0x10);
            byteaq.Add(0x01);
            byteaq.Add(0x00);
            byteaq.Add(0x00);
            byteaq.Add(0x00);
            byteaq.Add(0x00);


            //时序组号
            byteaq.Add(GroupNumber);

            //操作类型
            byteaq.Add(0x01);

            //开始时间
            byteaq.Add((byte)((senddate >> 56) & 0xff));
            byteaq.Add((byte)((senddate >> 48) & 0xff));
            byteaq.Add((byte)((senddate >> 40) & 0xff));
            byteaq.Add((byte)((senddate >> 32) & 0xff));
            byteaq.Add((byte)((senddate >> 24) & 0xff));
            byteaq.Add((byte)((senddate >> 16) & 0xff));
            byteaq.Add((byte)((senddate >> 8) & 0xff));
            byteaq.Add((byte)(senddate & 0xff));


            //结束时间
            byteaq.Add((byte)((sendenddate >> 56) & 0xff));
            byteaq.Add((byte)((sendenddate >> 48) & 0xff));
            byteaq.Add((byte)((sendenddate >> 40) & 0xff));
            byteaq.Add((byte)((sendenddate >> 32) & 0xff));
            byteaq.Add((byte)((sendenddate >> 24) & 0xff));
            byteaq.Add((byte)((sendenddate >> 16) & 0xff));
            byteaq.Add((byte)((sendenddate >> 8) & 0xff));
            byteaq.Add((byte)(sendenddate & 0xff));


            var datalist = _sysSequentialService.Query<SysSequentialTotal>(m => m.StartTime == startTime && m.EndTime == endTime && m.IsDelete == 0 && m.Sequential == kind).OrderBy(n => n.SequenceGroup).ThenBy(s => s.CreateTime).ToArray();

            //单体循环数量
            List<int> b = new List<int>();

            //这个m 在每次SequenceGroup变化的时候记录一下 变化的节点
            //拿下一次的节点i - 上一次的节点m  就是当前的长度，同时把新的节点赋到m上
            //最后只要把总长度减去最后一个节点的长度，就是最后一个的长度
            int m = 0;
            float? totalTime = 0;
            //先遍历 datalist 确定 SequenceGroup的种类和数量
            for (int i = 0; i < datalist.Length; i++)
            {
                //只有一个子时序且子时序中只有一台设备
                if (datalist.Length == 1)
                {
                    b.Add(1);
                }
                else if (i != 0 && datalist.Length > 1)
                {
                    if (datalist[i].SequenceGroup != datalist[i - 1].SequenceGroup)
                    {
                        b.Add(i - m);
                        m = i;
                    }
                    if (i == datalist.Length - 1)
                    {
                        b.Add(datalist.Length - m);
                        m = 0;
                    }
                }
                totalTime += datalist[i].WorkTime;
            }
            if (totalTime > getMinute)
            {
                throw new Exception("当前所下发的时序中，所有设备工作总时长:" + totalTime + "分钟，已经超过时序规定时长：" + getMinute + "分钟!" + "\n请修改设备后重试！！！");
            }

            //b = new List<int>() { 4, 3, 4, 6 };
            //3 3 2 1
            for (int i = 0; i < b.Count; i++)
            {
                //添加循环传感器的个数
                byteaq.Add((byte)b[i]);

                //定义一个循环间隔时长
                int d = 0;
                float dm = 0f;
                //添加传感器识别码和工作时长
                for (int j = 0; j < b[i]; j++)
                {
                    //去b[i - 1]之前的和
                    int n = 0;
                    for (int k = 0; k < i; k++)
                    {
                        n += b[k];
                    }
                    //获取传感器的ID 用字典获取  datalist[i == 0 ? j：n + j].SensorID
                    switch (datalist[i == 0 ? j : n + j].SensorID)
                    {
                        case "工控机":
                            byteaq.Add(0x00);
                            EnergyBoard3 += 12;

                            break;
                        case "色质联用":
                            byteaq.Add(0x01);
                            EnergyBoard2 += 150;

                            break;
                        case "备用串口1":
                            byteaq.Add(0x02);
                            EnergyBoard1 += 100;

                            break;
                        case "备用串口2":
                            byteaq.Add(0x03);
                            EnergyBoard1 += 100;

                            break;
                        case "光通讯机":
                            byteaq.Add(0x04);
                            EnergyBoard1 += 30;

                            break;
                        case "ADCP":
                            byteaq.Add(0x05);
                            EnergyBoard1 += 24;

                            break;
                        case "CTD":
                            byteaq.Add(0x06);
                            EnergyBoard1 += 0.2F;

                            break;
                        case "气相色谱仪":
                            byteaq.Add(0x07);
                            EnergyBoard3 += 120;

                            break;
                        case "甲烷传感器":
                            byteaq.Add(0x08);
                            EnergyBoard2 += 80;

                            break;
                        case "二氧化碳同位素分析仪":
                            byteaq.Add(0x09);
                            EnergyBoard3 += 48;

                            break;
                        case "备用网口设备":
                            byteaq.Add(0x0a);
                            break;
                        case "ICL":
                            byteaq.Add(0x0b);
                            EnergyBoard2 += 8;

                            break;
                        case "显微拉曼分析仪":
                            byteaq.Add(0x0c);
                            EnergyBoard4 += 150;

                            break;
                        case "质谱仪":
                            byteaq.Add(0x0d);
                            EnergyBoard4 += 150;

                            break;
                        case "声学定位":
                            byteaq.Add(0x0e);
                            EnergyBoard4 += 10;

                            break;
                        case "摄像1":
                            byteaq.Add(0x0f);
                            EnergyBoard2 += 3;

                            break;
                        case "摄像2":
                            byteaq.Add(0x10);
                            EnergyBoard3 += 3;


                            break;
                        case "电交换机2":
                            byteaq.Add(0x11);
                            EnergyBoard4 += 8.4F;
                            break;
                        default:
                            break;
                    }

                    //定义接收工作时长
                    float w = Convert.ToSingle(datalist[i == 0 ? j : n + j].WorkTime) * 60;

                    //判断w 是否是整数
                    if (regex.IsMatch(w.ToString()))
                    {
                        int worktime = (int)w;
                        byteaq.Add((byte)(worktime & 0xFF));
                        byteaq.Add((byte)((worktime & 0xFF00) >> 8));
                        byteaq.Add((byte)((worktime & 0xFF0000) >> 16));
                        byteaq.Add((byte)((worktime >> 24) & 0xFF));
                    }
                    else
                    {
                        byte[] bytes = BitConverter.GetBytes(w);
                        Array.Reverse(bytes);
                        byte[] bytes1 = tools.PadArrayWithZeros(bytes, 4);
                        byteaq.AddRange(bytes1);
                    }

                    //接收循环间隔时长
                    dm = Convert.ToSingle(datalist[i == 0 ? j : n + j].DurationTime) * 60;
                }
                //判断dm是否为整数
                if (regex.IsMatch(dm.ToString()))
                {
                    int durationTime = (int)dm;
                    byteaq.Add((byte)(durationTime & 0xFF));
                    byteaq.Add((byte)((durationTime & 0xFF00) >> 8));
                    byteaq.Add((byte)((durationTime & 0xFF0000) >> 16));
                    byteaq.Add((byte)((durationTime >> 24) & 0xFF));
                }
                else
                {
                    byte[] bytesm = BitConverter.GetBytes(dm);
                    Array.Reverse(bytesm);
                    byte[] bytesm1 = tools.PadArrayWithZeros(bytesm, 4);
                    byteaq.AddRange(bytesm1);
                }

                if (EnergyBoard1 > 250)
                {
                    throw new Exception("当前所下发的时序中电能板1总功耗：" + EnergyBoard1 + "W" + " ，已超过电能板1额定功率250W \n 时序无法下发，请修改设备后重试！！！");
                }
                if (EnergyBoard2 > 250)
                {
                    throw new Exception("当前所下发的时序中电能板2总功耗：" + EnergyBoard2 + "W" + " ，已超过电能板2额定功率250W \n 时序无法下发，请修改设备后重试！！！");
                }
                if (EnergyBoard3 > 250)
                {
                    throw new Exception("当前所下发的时序中电能板3总功耗：" + EnergyBoard3 + "W" + " ，已超过电能板3额定功率250W \n 时序无法下发，请修改设备后重试！！！");
                }
                if (EnergyBoard4 > 250)
                {
                    throw new Exception("当前所下发的时序中电能板4总功耗：" + EnergyBoard4 + "W" + " ，已超过电能板4额定功率250W \n 时序无法下发，请修改设备后重试！！！");
                }
            }
            return byteaq;
        }

        /// <summary>
        /// 更新时序母表及时序总表状态字段
        /// </summary>
        /// <param name="StartTime">时序开始时间</param>
        /// <param name="EndTime">时序结束时间</param>
        /// <param name="kind">时序号</param>
        /// <param name="action">更新内容</param>
        public void UpdateData(DateTime StartTime, DateTime EndTime, string kind, string action)
        {
            var datalist = _sysSequentialService.Query<SysSequentialTotal>(m => m.StartTime == StartTime && m.EndTime == EndTime && m.IsDelete == 0 && m.Sequential == kind).OrderBy(n => n.SequenceGroup).ThenBy(s => s.CreateTime).ToArray();

            //更新时序总表状态字段 已生成未下发 -> action
            foreach (var item in datalist)
            {
                var data = _sysSequentialService.Find<SysSequentialTotal>(item.ID);
                data.Status = action;
                _sysSequentialService.Update(data);
            }
            var datalist1 = _sysSequentialService.Query<SysSequential>(m => m.StartTime == StartTime && m.EndTime == EndTime && m.IsDelete == 0 && m.Sequential == kind);

            //更新时序母表状态 已生成未下发 -> action
            foreach (var item in datalist1)
            {
                var data = _sysSequentialService.Find<SysSequential>(item.Number);
                data.Status = action;
                _sysSequentialService.Update(data);
            }
        }
    }
}