20230201_145_upperpc/InSituLaboratory/ViewModels/Pages/SequentialDistributionViewModel.cs
2024-07-02 16:23:29 +08:00

2375 lines
119 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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;
DoRefreshSe("Refresh");
DoRefreshSe("sequent1Refresh");
DoRefreshSe("sequent2Refresh");
DoRefreshSe("sequent3Refresh");
DoRefreshSe("sequent4Refresh");
DoRefreshSe("sequent5Refresh");
}
/// <summary>
/// 页面刷新
/// </summary>
public override void DoRefreshSe(object o)
{
string[] msg = o.ToString().Split(',');
switch (msg[0])
{
//当前运行时序状态刷新
case "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;
}
break;
//时序1刷新
case "sequent1Refresh":
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;
}
break;
//时序2刷新
case "sequent2Refresh":
int num2 = 1;
SearchKey = "时序2";
sysSequentialDetailsListS2.Clear();
var list2 = _sysSequentialService.GetSequentials(SearchKey).ToList();
if (list2.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 = num2;
sysSequentialDetailsListS2.Add(sysSequentialDetail);
num2++;
}
sequentStatusModel.SequentialStartTime2 = data.StartTime;
sequentStatusModel.SequentialEndTime2 = data.EndTime;
sequentStatusModel.Status2 = data.Status;
}
break;
//时序3刷新
case "sequent3Refresh":
int num3 = 1;
SearchKey = "时序3";
sysSequentialDetailsListS3.Clear();
var list3 = _sysSequentialService.GetSequentials(SearchKey).ToList();
if (list3.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 = num3;
sysSequentialDetailsListS3.Add(sysSequentialDetail);
num3++;
}
sequentStatusModel.SequentialStartTime3 = data.StartTime;
sequentStatusModel.SequentialEndTime3 = data.EndTime;
sequentStatusModel.Status3 = data.Status;
}
break;
//时序4刷新
case "sequent4Refresh":
int num4 = 1;
SearchKey = "时序4";
sysSequentialDetailsListS4.Clear();
var list4 = _sysSequentialService.GetSequentials(SearchKey).ToList();
if (list4.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 = num4;
sysSequentialDetailsListS4.Add(sysSequentialDetail);
num4++;
}
sequentStatusModel.SequentialStartTime4 = data.StartTime;
sequentStatusModel.SequentialEndTime4 = data.EndTime;
sequentStatusModel.Status4 = data.Status;
}
break;
//时序5刷新
case "sequent5Refresh":
int num5 = 1;
SearchKey = "时序5";
sysSequentialDetailsListS5.Clear();
var list5 = _sysSequentialService.GetSequentials(SearchKey).ToList();
if (list5.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 = num5;
sysSequentialDetailsListS5.Add(sysSequentialDetail);
num5++;
}
sequentStatusModel.SequentialStartTime5 = data.StartTime;
sequentStatusModel.SequentialEndTime5 = data.EndTime;
sequentStatusModel.Status5 = data.Status;
}
break;
default:
break;
}
}
/// <summary>
/// 时序下发
/// </summary>
/// <param name="o"></param>
public override void DoSend(object o)
{
string[] msg = o.ToString().Split(',');
switch (msg[0])
{
//时序1
case "sequent1Send":
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, 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(startTime, endTime, 0x01, 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.DoRefreshSe("sequent1Refresh");
}
else
{
throw new Exception("请先连接服务端!");
}
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序2
case "sequent2Send":
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)
{
throw new Exception("时序2中未有设备无法下发");
}
else
{
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DateTime startTime = (DateTime)sequentStatusModel.SequentialStartTime2;
DateTime endTime = (DateTime)sequentStatusModel.SequentialEndTime2;
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, 0x02, 0x01, "时序2");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序2", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
//修改且关闭该时序所有设备
else if (s1 == System.Windows.Forms.DialogResult.No)
{
//计算设备功耗是否超总功耗及设备运行时长是否超时
List<byte> byteaq = encode(startTime, endTime,0x02, 0x02, "时序2");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序2", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
throw new Exception("当前时序已下发!!!");
}
this.DoRefreshSe("sequent2Refresh");
}
else
{
throw new Exception("请先连接服务端!");
}
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序3
case "sequent3Send":
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)
{
throw new Exception("时序3中未有设备无法下发");
}
else
{
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DateTime startTime = (DateTime)sequentStatusModel.SequentialStartTime3;
DateTime endTime = (DateTime)sequentStatusModel.SequentialEndTime3;
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, 0x03, 0x01, "时序3");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序3", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
//修改且关闭该时序所有设备
else if (s1 == System.Windows.Forms.DialogResult.No)
{
//计算设备功耗是否超总功耗及设备运行时长是否超时
List<byte> byteaq = encode(startTime, endTime, 0x03, 0x02, "时序3");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序3", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
throw new Exception("当前时序已下发!!!");
}
this.DoRefreshSe("sequent3Refresh");
}
else
{
throw new Exception("请先连接服务端!");
}
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序4
case "sequent4Send":
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)
{
throw new Exception("时序4中未有设备无法下发");
}
else
{
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DateTime startTime = (DateTime)sequentStatusModel.SequentialStartTime4;
DateTime endTime = (DateTime)sequentStatusModel.SequentialEndTime4;
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, 0x04, 0x01, "时序4");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序4", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
//修改且关闭该时序所有设备
else if (s1 == System.Windows.Forms.DialogResult.No)
{
//计算设备功耗是否超总功耗及设备运行时长是否超时
List<byte> byteaq = encode(startTime, endTime, 0x04, 0x02, "时序4");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序4", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
throw new Exception("当前时序已下发!!!");
}
this.DoRefreshSe("sequent4Refresh");
}
else
{
throw new Exception("请先连接服务端!");
}
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序5
case "sequent5Send":
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)
{
throw new Exception("时序5中未有设备无法下发");
}
else
{
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DateTime startTime = (DateTime)sequentStatusModel.SequentialStartTime5;
DateTime endTime = (DateTime)sequentStatusModel.SequentialEndTime5;
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, 0x05, 0x01, "时序5");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序5", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
//修改且关闭该时序所有设备
else if (s1 == System.Windows.Forms.DialogResult.No)
{
//计算设备功耗是否超总功耗及设备运行时长是否超时
List<byte> byteaq = encode(startTime, endTime, 0x05, 0x02, "时序5");
List<byte> buffer = Escape(byteaq.ToArray());
string list = tools.byteToHexStr(buffer.ToArray());
byte[] bytea = tools.ConvertHexStringToBytes(list);
RelayViewModel.clientModel.SendData(bytea);
//更新时序母表及时序总表状态字段
UpdateData(startTime, endTime, "时序5", "已下发");
System.Windows.Forms.MessageBox.Show("命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
throw new Exception("当前时序已下发!!!");
}
this.DoRefreshSe("sequent5Refresh");
}
else
{
throw new Exception("请先连接服务端!");
}
}
}
catch (Exception ex)
{
System.Windows.Forms.MessageBox.Show(ex.Message, "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
default:
break;
}
}
/// <summary>
/// 时序清空
/// </summary>
/// <param name="o"></param>
public override void DoClear(object o)
{
string[] msg = o.ToString().Split(',');
switch (msg[0])
{
//时序1
case "sequent1Clear":
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.DoRefreshSe("sequent1Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序2
case "sequent2Clear":
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.DoRefreshSe("sequent2Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序3
case "sequent3Clear":
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.DoRefreshSe("sequent3Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序4
case "sequent4Clear":
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.DoRefreshSe("sequent4Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序5
case "sequent5Clear":
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.DoRefreshSe("sequent5Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
default:
break;
}
}
/// <summary>
/// 时序启动
/// </summary>
/// <param name="o"></param>
public override void DoBegin(object o)
{
string[] msg = o.ToString().Split(',');
switch (msg[0])
{
//时序1
case "sequent1Begin":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
dosend(0x01, 0x05);
System.Windows.Forms.MessageBox.Show("时序启动命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
this.DoRefreshSe("sequent1Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序2
case "sequent2Begin":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
dosend(0x02, 0x05);
System.Windows.Forms.MessageBox.Show("时序启动命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
this.DoRefreshSe("sequent2Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序3
case "sequent3Begin":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
dosend(0x03, 0x05);
System.Windows.Forms.MessageBox.Show("时序启动命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
this.DoRefreshSe("sequent3Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序4
case "sequent4Begin":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
dosend(0x04, 0x05);
System.Windows.Forms.MessageBox.Show("时序启动命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
this.DoRefreshSe("sequent4Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序5
case "sequent5Begin":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
dosend(0x05, 0x05);
System.Windows.Forms.MessageBox.Show("时序启动命令已下发!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
this.DoRefreshSe("sequent5Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
default:
break;
}
}
/// <summary>
/// 时序暂停
/// </summary>
/// <param name="o"></param>
public override void DoSuspend(object o)
{
string[] msg = o.ToString().Split(',');
switch (msg[0])
{
//时序1
case "sequent1Suspend":
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.DoRefreshSe("sequent1Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序2
case "sequent2Suspend":
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.DoRefreshSe("sequent2Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序3
case "sequent3Suspend":
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.DoRefreshSe("sequent3Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序4
case "sequent4Suspend":
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.DoRefreshSe("sequent4Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序5
case "sequent5Suspend":
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.DoRefreshSe("sequent5Refresh");
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
default:
break;
}
}
/// <summary>
/// 时序同步 -- 请求当前时序
/// </summary>
/// <param name="o"></param>
public override void DoSync(object o)
{
string[] msg = o.ToString().Split(',');
switch (msg[0])
{
//时序1
case "sequent1":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DoSyncSend(0x01);
System.Windows.Forms.MessageBox.Show("已请求同步当前时序!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序2
case "sequent2":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DoSyncSend(0x02);
System.Windows.Forms.MessageBox.Show("已请求同步当前时序!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序3
case "sequent3":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DoSyncSend(0x03);
System.Windows.Forms.MessageBox.Show("已请求同步当前时序!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序4
case "sequent4":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DoSyncSend(0x04);
System.Windows.Forms.MessageBox.Show("已请求同步当前时序!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
//时序5
case "sequent5":
if (RelayViewModel.SocketInfo.ConnectionMessage == "断开")
{
DoSyncSend(0x05);
System.Windows.Forms.MessageBox.Show("已请求同步当前时序!", "提示", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
System.Windows.Forms.MessageBox.Show("请先连接服务端!", "警告", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
break;
default:
break;
}
}
#region 1
/// <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.DoRefreshSe("sequent1Refresh");
}
});
}
}
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.DoRefreshSe("sequent1Refresh");
}
});
}
}
}
}
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.DoRefreshSe("sequent1Refresh");
}
}
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);
}
}
#endregion
#region 2
/// <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.DoRefreshSe("sequent2Refresh");
}
});
}
}
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.DoRefreshSe("sequent2Refresh");
}
});
}
}
}
}
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.DoRefreshSe("sequent2Refresh");
}
}
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);
}
}
#endregion
#region 3
/// <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.DoRefreshSe("sequent3Refresh");
}
});
}
}
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.DoRefreshSe("sequent3Refresh");
}
});
}
}
}
}
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.DoRefreshSe("sequent3Refresh");
}
}
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);
}
}
#endregion
#region 4
/// <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.DoRefreshSe("sequent4Refresh");
}
});
}
}
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.DoRefreshSe("sequent4Refresh");
}
});
}
}
}
}
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.DoRefreshSe("sequent4Refresh");
}
}
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);
}
}
#endregion
#region 5
/// <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.DoRefreshSe("sequent5Refresh");
}
});
}
}
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.DoRefreshSe("sequent5Refresh");
}
});
}
}
}
}
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.DoRefreshSe("sequent5Refresh");
}
}
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);
}
}
#endregion
/// <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="OpeKind">操作类型</param>
/// <param name="kind">时序类型</param>
/// <returns></returns>
public List<byte> encode(DateTime StartTime, DateTime EndTime, byte GroupNumber, byte OpeKind, 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(OpeKind);
//开始时间
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 ? jn + 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);
}
}
}
}