/// <summary>
/// 发行器信息
/// </summary>
public void initCmdCard()
{
DataTable tab = initDev();
if (null == tab || tab.Rows.Count < 1)
{
this.cmdCard.SetTarget(null, -1, false);
return;
}
DataRow dr = this.dsUnit.Tables["发行器"].Rows[0];
string port = Convert.ToString(dr["串口"]);
int baudrate = Convert.ToInt32(dr["波特率"]);
Parity parity = Parity.None;
int databits = Convert.ToInt32(dr["数据位"]);
DevIdS = Convert.ToString(dr["站址"]);
StopBits stopbits = StopBits.One;
switch (Convert.ToString(dr["停止位"]))
{
case "1.5位": stopbits = StopBits.OnePointFive; break;
case "2位": stopbits = StopBits.Two; break;
default: stopbits = StopBits.One; break;
}
CommiTarget target = new CommiTarget(port, baudrate, parity, databits, stopbits);
int addrst = Convert.ToInt32(dr["站址"]);
bool success = this.cmdCard.SetTarget(target, addrst, false);
if (success)
{
this.cmdCard.Buzz(true);
}
}
/// <summary>
/// 检查通讯目标是否可连接
/// </summary>
/// <param name="dest">通讯目标</param>
/// <param name="timeout">超时时间，毫秒ms</param>
/// <returns>返回是否可连接</returns>
private static bool Ping(CommiTarget dest, int timeout)
{
bool rtn = false;
if (null == dest)
{
return(rtn);
}
DateTime dt1 = DateTime.Now;
do
{
rtn = CommiManager.GlobalManager.TestConnect(dest);
DateTime dt2 = DateTime.Now;
if (!rtn && timeout > 0)
{
TimeSpan ts = dt2 - dt1;
if (ts.TotalMilliseconds > timeout)
{
break;
}
Thread.Sleep(1000);
}
} while (!rtn && timeout > 0);
return(rtn);
}
/// <summary>
/// 设置通讯设备
/// </summary>
/// <param name="devid">设备ID</param>
/// <param name="target">通讯目标</param>
/// <param name="station">站址</param>
public override void SetDevice(CommiManager mgr, CommiTarget target, string devid, int station)
{
if (null == mgr || string.IsNullOrEmpty(devid) || null == target || station < 1)
{
return;
}
this.commimgr = mgr;
this.target = target;
this.devid = devid;
this.station = station;
NameObjectList ps = new NameObjectList();
ps["分组ID"] = devid;
DataTable tab = this.query.getTable("门禁设备", ps);
if (null == tab || tab.Rows.Count < 1)
{
return;
}
object val = tab.Rows[0]["记录位置"];
if (null == val || DBNull.Value == val)
{
val = 0;
}
this.posRecord = Convert.ToInt32(val);
val = tab.Rows[0]["控制器类型"];
this.devtype = Convert.ToString(val);
if (string.IsNullOrEmpty(this.devtype))
{
this.devtype = "考勤机";
}
}
/// <summary>
/// 设置通讯参数,port为空或station范围不正确则通讯置空
/// </summary>
/// <param name="port">通讯端口</param>
/// <param name="baudRate">通讯波特率</param>
/// <param name="station">通讯站址</param>
/// <param name="isCardIC">是否IC卡</param>
/// <returns>是否成功设置通讯参数</returns>
public bool setTarget(string port, int baudRate, int station, bool isCardIC)
{
CommiManager.GlobalManager.ClearCommand();
if (string.IsNullOrEmpty(port) || station < 1 || station > 255)
{
this.target = null;
this.cmdCard.SetTarget(null, -1, false);
return(false);
}
try
{
this.Beat();
this.target = new CommiTarget(port, baudRate);
this.station = station;
this.isCardIC = isCardIC;
return(this.cmdCard.SetTarget(target, station, isCardIC));
}
catch (Exception ex)
{
this.target = null;
this.cmdCard.SetTarget(null, -1, false);
return(false);
}
return(true);
}
/// <summary>
/// 发送指令，获取指令结果，在通讯失败时自动尝试执行5次
/// </summary>
/// <param name="mgr">通讯管理器</param>
/// <param name="target">通讯目标</param>
/// <param name="cmd">执行指令</param>
/// <param name="timeout">超时间隔</param>
/// <returns>返回指令响应结果</returns>
private static string getResponse(CommiManager mgr, CommiTarget target, CmdProtocol cmd, TimeSpan timeout)
{
if (null == mgr || null == target || null == cmd)
{
return("");
}
if (null == cmd.EventWh)
{
cmd.EventWh = new ManualResetEvent(false);
}
string msg = "";
for (int i = 0; i < 5; i++)
{
msg = "";
cmd.ResetState();
mgr.SendCommand(target, cmd);
if (cmd.EventWh.WaitOne(timeout, false))
{
msg = cmd.ResponseFormat;
}
string suc = basefun.valtag(msg, "Success");
if ("true" == suc)
{
break;
}
Thread.Sleep(200);
}
return(msg);
}
/// <summary>
/// 发行器信息
/// </summary>
public void initCmdCard()
{
DataTable taboption = initSet();
if (null == taboption || taboption.Rows.Count < 1)
{
this.cmdCard.SetTarget(null, -1, false);
return;
}
DataRow dr = taboption.Rows[0];
string port = Convert.ToString(dr["串口"]);
int baudrate = Convert.ToInt32(dr["波特率"]);
Parity parity = Parity.None;
int databits = Convert.ToInt32(dr["数据位"]);
StopBits stopbits = StopBits.One;
switch (Convert.ToString(dr["停止位"]))
{
case "1.5": stopbits = StopBits.OnePointFive; break;
case "2": stopbits = StopBits.Two; break;
default: stopbits = StopBits.One; break;
}
CommiTarget target = new CommiTarget(port, baudrate, parity, databits, stopbits);
int addrst = Convert.ToInt32(dr["站址"]);
bool success = this.cmdCard.SetTarget(target, addrst, this.radic.Checked);
}
/// <summary>
/// 对目标通讯关闭心跳
/// </summary>
/// <param name="mgr">通讯管理器</param>
/// <param name="target">通讯目标</param>
public static void CloseHeaderBeat(CommiManager mgr, CommiTarget target)
{
if (null == mgr || null == target)
{
return;
}
mgr.RemoveCommand(target, CmdHeaderBeat);
}
/// <summary>
/// 对目标通讯启动心跳,已经有则不会重复
/// </summary>
/// <param name="mgr">通讯管理器</param>
/// <param name="target">通讯目标</param>
public static void OpenHeaderBeat(CommiManager mgr, CommiTarget target)
{
if (null == mgr || null == target)
{
return;
}
target.setProtocol(CmdFileTrans.PTL);
mgr.SendCommand(target, CmdHeaderBeat);
}
/// <summary>
/// 搜索网络内支持UDP通讯的设备信息,设备信息使用tag格式数据
/// </summary>
/// <returns>返回tag格式数据信息</returns>
public static string[] SearchUDPnet()
{
IPEndPoint srv = new IPEndPoint(IPAddress.Broadcast, initport);
CommiTarget target = new CommiTarget(srv, CommiType.UDP);
target.setProtocol(ptlZnet);
DateTime dtStart = DateTime.Now;
CommandBase cmd = new CommandBase(false);
cmd.TimeSendInv = new TimeSpan(0, 0, 50);
cmd.TimeOut = new TimeSpan(0, 0, 2);
cmd.TimeFailLimit = new TimeSpan(0, 0, 5);
cmd.TimeLimit = new TimeSpan(0, 0, 20);
cmd.IsResposeHandle = isRpsZnet;
cmd.setCommand(initcmd, true);
cmd.ResponseHandle += new EventHandler <ResponseEventArgs>(cmd_ResponseHandle);
CommiManager.GlobalManager.SendCommand(target, cmd);
//广播搜索，有多个设备返回信息，直到超时停止接收
List <string> infolist = cmd.Tag as List <string>;
while (cmd.EventWh.WaitOne(cmd.TimeLimit, false) && DateTime.Now - dtStart < cmd.TimeLimit)
{
infolist = cmd.Tag as List <string>;
if (null == infolist || infolist.Count < 1)
{
continue;
}
string[] infos = infolist.ToArray();
bool iscomplete = true;
for (int i = 0; i < infos.Length; i++)
{
if (!string.IsNullOrEmpty(basefun.valtag(infos[i], "工作端口")))
{
continue;
}
iscomplete = false;
break;
}
if (iscomplete)
{
break;
}
}
cmd.TimeSendInv = new TimeSpan(0, 0, -10);
CommiManager.GlobalManager.RemoveCommand(target, cmd);
//返回搜索结果
infolist = cmd.Tag as List <string>;
cmd.Tag = null;
if (null == infolist || infolist.Count < 1)
{
return(new string[0]);
}
return(infolist.ToArray());
}
/// <summary>
/// 添加监控管理的设备
/// </summary>
/// <param name="devid">请求的客户端</param>
/// <param name="ispatrol">是否持续巡检</param>
private void addDevice(string devid, bool ispatrol)
{
//设备已经监控,则不再增加设备信息
DeviceBase[] devices = this.devlist.ToArray();
for (int i = 0; i < devices.Length; i++)
{
if (devid == devices[i].DevID)
{
return;
}
}
//增加设备监控
Estar.Common.Tools.NameObjectList ps = new Estar.Common.Tools.NameObjectList();
ps["设备ID"] = devid;
DataTable tab = this.query.getTable("设备通讯参数", ps);
if (null == tab || tab.Rows.Count < 1)
{
return;
}
DataRow dr = tab.Rows[0];
string dvtype = Convert.ToString(dr["通讯协议"]);
if (string.IsNullOrEmpty(dvtype) || DBNull.Value == dr["站址"])
{
return;
}
int station = Convert.ToInt32(dr["站址"]);
CommiTarget target = this.getTarget(dr);
CommiManager commimgr = CommiManager.GlobalManager;
DeviceBase device = null;
switch (dvtype)
{
case "门禁":
device = new DeviceDoor();
target.setProtocol(Protocol.PTLDoor);
break;
case "消费":
device = new DeviceEatery();
target.setProtocol(Protocol.PTLEatery);
break;
default:
return;
}
device.IsPatrol = ispatrol;
device.SetDevice(commimgr, target, devid, station);
this.devlist.Add(device);
device.RecordHandle += new EventHandler <DvRecordEventArgs>(device_RecordHandle);
device.SignalHandle += new EventHandler <DvSignalEventArgs>(device_SignalHandle);
device.AlarmHandle += new EventHandler <DvAlarmEventArgs>(device_AlarmHandle);
device.StartGather();
}
/// <summary>
/// 设置通讯设备
/// </summary>
/// <param name="devid">设备ID</param>
/// <param name="target">通讯目标</param>
/// <param name="station">站址</param>
public virtual void SetDevice(CommiManager mgr, CommiTarget target, string devid, int station)
{
if (null == mgr || string.IsNullOrEmpty(devid) || null == target || station < 1)
{
return;
}
this.commimgr = mgr;
this.target = target;
this.devid = devid;
this.station = station;
}
/// <summary>
/// 从服务器中获得图片
/// </summary>
/// <param name="savePath">图片保存相对路径</param>
/// <param name="pl">显示图片的容器</param>
public void getPic_Server(string filepath, Panel pl)
{
if (string.IsNullOrEmpty(filepath))
{
return;
}
int port = 2010;
string ipsrv = "127.0.0.1";
string sport = DataAccRes.AppSettings("Granity文件服务");
string conn = DataAccRes.DefaultDataConnInfo.Value;
if (!string.IsNullOrEmpty(sport))
{
try { port = Convert.ToInt32(sport); }
catch { return; }
}
Regex regIP = new Regex(@"server=([\w.\(\)]*)(;|\\)");
if (regIP.IsMatch(conn))
{
Match mt = regIP.Match(conn);
if (mt.Groups.Count > 1)
{
ipsrv = mt.Groups[1].Value.ToLower();
}
if ("(local)" == ipsrv || "127.0.0.1" == ipsrv)
{
ipsrv = Dns.GetHostName();
}
ipsrv = Dns.GetHostAddresses(ipsrv)[0].ToString();
}
CommiTarget target = new CommiTarget(ipsrv, port, CommiType.TCP);
target.setProtocol(CmdFileTrans.PTL);
CmdFileTrans cmd = new CmdFileTrans(false);
cmd.GetFile(filepath);
CommiManager.GlobalManager.SendCommand(target, cmd);
if (cmd.EventWh.WaitOne(new TimeSpan(0, 0, 15), false))
{
byte[] data = cmd.FileContext;
if (data.Length < 1)
{
return;
}
MemoryStream stream = new MemoryStream(data);
pl.BackgroundImage = Image.FromStream(stream);
}
}
/// <summary>
/// 获取数据行的设备目标位置参数
/// 记录包含字段【访问方式】(TCP/UDP/SerialPort)、【端口】(60000/COM1)、【地址】(192.168.1.146)
/// </summary>
/// <param name="dr">数据记录</param>
/// <returns></returns>
private CommiTarget getTarget(DataRow dr)
{
if (null == dr)
{
return(null);
}
CommiTarget target = new CommiTarget();
CommiType commiType = CommiType.UDP;
int typecommi = 0;
if (dr["通讯类别"].ToString() == "485")
{
typecommi = 1;
}
else if (dr["通讯类别"].ToString() == @"TCP\IP")
{
typecommi = 2;
}
else
{
typecommi = 3;
}
if (DBNull.Value != dr["通讯类别"])
{
//int typecommi = Convert.ToInt16(dr["通讯类别"]);
if (1 == typecommi)
{
commiType = CommiType.SerialPort;
}
if (2 == typecommi)
{
commiType = CommiType.TCP;
}
}
if (CommiType.SerialPort == commiType)
{
string portname = "COM" + Convert.ToString(dr["端口"]);
target.SetProtocolParam(portname, 19200);
}
else
{
string addr = Convert.ToString(dr["站址"]);
int port = Convert.ToInt16(dr["端口"]);
target.SetProtocolParam(addr, port, commiType);
}
target.setProtocol(Protocol.PTLPark);
return(target);
}
/// <summary>
/// 初始化发行器
/// </summary>
public void initCmdCard()
{
IPHostEntry IpEntry = Dns.GetHostEntry(Dns.GetHostName());
string myip = IpEntry.AddressList[0].ToString();
NameObjectList pstrans = new NameObjectList();
ParamManager.MergeParam(pstrans, this.paramwin);
pstrans["IP地址"] = myip;
//查询数据
QueryDataRes query = new QueryDataRes(this.unitItem.DataSrcFile);
DataTable tab = dsUnit.Tables["设备设置"];
tab.Clear();
query.FillDataSet(tab.TableName, pstrans, this.dsUnit);
if (null == tab || tab.Rows.Count < 1)
{
return;
}
if (tab.Rows.Count < 1)
{
MessageBox.Show("请设置发行器");
return;
}
DataRow dr = this.dsUnit.Tables["设备设置"].Rows[0];
string port = Convert.ToString(dr["串口"]);
int baudrate = Convert.ToInt32(dr["波特率"]);
Parity parity = Parity.None;
int databits = Convert.ToInt32(dr["数据位"]);
StopBits stopbits = StopBits.One;
switch (Convert.ToString(dr["停止位"]))
{
case "1.5位": stopbits = StopBits.OnePointFive; break;
case "2位": stopbits = StopBits.Two; break;
default: stopbits = StopBits.One; break;
}
CommiTarget target = new CommiTarget(port, baudrate, parity, databits, stopbits);
int addrst = Convert.ToInt32(dr["站址"]);
bool success = this.cmdCard.SetTarget(target, addrst, this.radic.Checked);
if (success)
{
this.cmdCard.Buzz(true);
}
}
/// <summary>
/// 发送指令，获取指令结果，在通讯失败时自动尝试执行5次
/// </summary>
/// <param name="mgr">通讯管理器</param>
/// <param name="target">通讯目标</param>
/// <param name="cmd">执行指令</param>
/// <param name="strcmd">指令名称</param>
/// <param name="tag">指令内容</param>
/// <param name="timeout">超时间隔</param>
/// <returns>返回指令响应结果</returns>
private string getResponse(CommiManager mgr, CommiTarget target, CmdProtocol cmd, string strcmd, string tag, TimeSpan timeout)
{
if (null == mgr || null == target || null == cmd)
{
return("");
}
if (null == cmd.EventWh)
{
cmd.EventWh = new ManualResetEvent(false);
}
string msg = "";
for (int i = 0; i < 3; i++)
{
msg = "";
cmd.setCommand("门禁", strcmd, tag);
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 指令：" + strcmd + " " + tag);
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 指令：" + strcmd + " " + tag);
mgr.SendCommand(target, cmd, true);
this.isexecuting = true;
if (cmd.EventWh.WaitOne(timeout, false))
{
msg = cmd.ResponseFormat;
}
this.isexecuting = false;
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 响应：" + msg);
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 响应：" + msg);
string suc = basefun.valtag(msg, "Success");
if (!string.IsNullOrEmpty(suc))
{
break;
}
if (string.IsNullOrEmpty(msg) && CommiType.SerialPort != target.ProtocolType)
{
Debug.WriteLine(String.Format("{0:HH:mm:ss.fff} 测试网络连接...", DateTime.Now));
myLog.WriteLine(String.Format("{0:HH:mm:ss.fff} 测试网络连接...", DateTime.Now));
bool pingcn = Ping(target, CNtimeout);
Debug.WriteLine(String.Format("{0:HH:mm:ss.fff} Ping 连接 {1}", DateTime.Now, pingcn));
myLog.WriteLine(String.Format("{0:HH:mm:ss.fff} Ping 连接 {1}", DateTime.Now, pingcn));
if (!pingcn)
{
break;
}
}
}
return(msg);
}
/// <summary>
/// 添加监控管理的设备
/// </summary>
/// <param name="devid">请求的客户端</param>
/// <param name="ispatrol">是否持续巡检</param>
private DeviceBase addDevice(string devid, bool ispatrol)
{
//增加设备监控
Estar.Common.Tools.NameObjectList ps = new Estar.Common.Tools.NameObjectList();
ps["设备ID"] = devid;
DataTable tab = this.query.getTable("设备通讯参数", ps);
if (null == tab || tab.Rows.Count < 1)
{
return(null);
}
DataRow dr = tab.Rows[0];
string dvtype = Convert.ToString(dr["通讯协议"]);
if (string.IsNullOrEmpty(dvtype) || DBNull.Value == dr["站址"])
{
return(null);
}
int station = Convert.ToInt32(dr["站址"]);
CommiTarget target = this.getTarget(dr);
CommiManager commimgr = CommiManager.GlobalManager;
DeviceBase device = null;
switch (dvtype)
{
case "门禁":
device = new DeviceDoor();
target.setProtocol(Protocol.PTLDoor);
break;
case "消费":
device = new DeviceEatery();
target.setProtocol(Protocol.PTLEatery);
break;
default:
return(null);
}
device.IsPatrol = ispatrol;
device.dtBeat = DateTime.Now;
device.SetDevice(commimgr, target, devid, station);
this.devlist.Add(device);
device.StartGather();
return(device);
}
/// <summary>
/// 发送指令，获取指令结果，在通讯失败时自动尝试执行5次
/// </summary>
/// <param name="mgr">通讯管理器</param>
/// <param name="target">通讯目标</param>
/// <param name="cmd">执行指令</param>
/// <param name="strcmd">指令名称</param>
/// <param name="timeout">超时间隔</param>
/// <returns>返回指令响应结果</returns>
private string getResponse(CommiManager mgr, CommiTarget target, CmdProtocol cmd, string strcmd, string tag, TimeSpan timeout)
{
if (null == mgr || null == target || null == cmd || string.IsNullOrEmpty(strcmd) || string.IsNullOrEmpty(tag))
{
return("");
}
if (null == cmd.EventWh)
{
cmd.EventWh = new ManualResetEvent(false);
}
string msg = "";
for (int i = 0; i < 5; i++)
{
msg = "";
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 请求：" + strcmd + " " + tag);
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 请求：" + strcmd + " " + tag);
cmd.setCommand("消费", strcmd, tag);
mgr.SendCommand(target, cmd, true);
this.isexecuting = true;
if (cmd.EventWh.WaitOne(timeout, false))
{
msg = cmd.ResponseFormat;
}
this.isexecuting = false;
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 响应：" + msg);
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 响应：" + msg);
string suc = basefun.valtag(msg, "Success");
if ("true" == suc)
{
break;
}
//失败时重新采集当前记录
if ("取下一条消费记录" == strcmd)
{
strcmd = "取当前消费记录";
}
if ("取下一条补助记录" == strcmd)
{
strcmd = "取当前补助记录";
}
Thread.Sleep(200);
}
return(msg);
}
/// <summary>
/// 加载系统时间
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void SetTimeBtn_Click(object sender, EventArgs e)
{
int[] indexlist = this.getCheckedList();
if (indexlist.Length < 1)
{
MessageBox.Show("请选择设备", "提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
return;
}
string msg = "";
string tpl = "停车场", cmd = "加载系统时间";
DataTable tab = this.dbGrid.DataSource as DataTable;
foreach (int i in indexlist)
{
DataRow dr = tab.Rows[i];
CommiTarget target = this.getTarget(dr);
CmdProtocol cmdP = new CmdProtocol(Convert.ToString(dr["名称"]), false);
string tagdata = "@设备地址=" + Convert.ToString(dr["站址"]);
cmdP.setCommand(tpl, cmd, tagdata);
CommiManager.GlobalManager.SendCommand(target, cmdP);
if (!cmdP.EventWh.WaitOne(2000, false))
{
msg = cmdP.CmdId + "：通讯失败,请检查设备连接或通讯参数后重试！";
}
string rpmsg = basefun.valtag(cmdP.ResponseFormat, "{状态}");
if (string.IsNullOrEmpty(msg) && !string.IsNullOrEmpty(rpmsg) && "操作成功！" != rpmsg)
{
msg = cmdP.CmdId + "：" + rpmsg;
}
if (!string.IsNullOrEmpty(msg))
{
break;
}
}
if (string.IsNullOrEmpty(msg))
{
MessageBox.Show("成功加载系统时间！", "设备通讯", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
MessageBox.Show(msg, "设备通讯", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
/// <summary>
/// 设置通讯设备
/// </summary>
/// <param name="devid">设备ID</param>
/// <param name="target">通讯目标</param>
/// <param name="station">站址</param>
public override void SetDevice(CommiManager mgr, CommiTarget target, string devid, int station)
{
if (null == mgr || string.IsNullOrEmpty(devid) || null == target || station < 1)
{
return;
}
this.commimgr = mgr;
this.target = target;
this.devid = devid;
this.station = station;
NameObjectList ps = new NameObjectList();
ps["分组ID"] = devid;
DataTable tab = null;
try
{
Monitor.Enter(objquery);
tab = this.query.getTable("道闸设备", ps);
}
finally
{
Monitor.PulseAll(objquery);
Monitor.Exit(objquery);
}
if (null == tab || tab.Rows.Count < 1)
{
return;
}
object val = tab.Rows[0]["控制器类型"];
this.devtype = Convert.ToString(val);
val = tab.Rows[0]["区域"];
this.region = Convert.ToString(val);
val = tab.Rows[0]["区域ID"];
this.regionID = Convert.ToString(val);
DataRow[] drs = tab.Select("", "读卡器号");
for (int i = 0; i < 4 && i < drs.Length; i++)
{
channels[i] = Convert.ToString(drs[i]["名称"]);
}
}
/// <summary>
/// 火警联动
/// </summary>
/// <param name="sender">门禁设备</param>
/// <param name="e">报警事件</param>
void device_AlarmHandle(object sender, DvAlarmEventArgs e)
{
DeviceDoor door = sender as DeviceDoor;
if (null == door || null == e || string.IsNullOrEmpty(e.TagAlarm))
{
return;
}
string fire = basefun.valtag(e.TagAlarm, "火警");
if ("1" != fire)
{
return;
}
NameObjectList ps = new NameObjectList();
ps["设备ID"] = door.DevID;
DataTable tab = this.query.getTable("同组设备", ps);
CommiManager commimgr = CommiManager.GlobalManager;
for (int i = 0; i < tab.Rows.Count; i++)
{
DataRow dr = tab.Rows[i];
string dvid = Convert.ToString(dr["ID"]);
string dvtype = Convert.ToString(dr["通讯协议"]);
if (string.IsNullOrEmpty(dvtype) || DBNull.Value == dr["站址"])
{
return;
}
int station = Convert.ToInt32(dr["站址"]);
CommiTarget target = this.getTarget(dr);
if (null == target)
{
return;
}
target.setProtocol(Protocol.PTLDoor);
door = new DeviceDoor();
door.SetDevice(commimgr, target, dvid, station);
door.FireOpenDoor();
}
}
/// <summary>
/// 设置通讯设备
/// </summary>
/// <param name="devid">设备ID</param>
/// <param name="target">通讯目标</param>
/// <param name="station">站址</param>
public override void SetDevice(CommiManager mgr, CommiTarget target, string devid, int station)
{
if (null == mgr || string.IsNullOrEmpty(devid) || null == target || station < 1)
{
return;
}
this.commimgr = mgr;
this.target = target;
this.devid = devid;
this.station = station;
NameObjectList ps = new NameObjectList();
ps["设备ID"] = devid;
DataTable tab = this.query.getTable("消费设备", ps);
if (null == tab || tab.Rows.Count < 1)
{
return;
}
this.devName = Convert.ToString(tab.Rows[0]["名称"]);
}
/// <summary>
/// 设置RF通讯端口，波特率，站址，被动只接收数据
/// </summary>
/// <param name="port">RF射频串口</param>
/// <param name="baudRate">波特率</param>
/// <returns>能够打开端口则成功，端口占用或参数非法则失败</returns>
public bool setRfTarget(string port, int baudRate)
{
CommiManager mgr = CommiManager.GlobalManager;
if (null != this.rftar && this.rftar.PortName == port)
{
mgr.SendCommand(this.rftar, this.cmdRFID);
return(true);
}
if (null != this.rftar)
{
mgr.RemoveCommand(this.rftar);
}
this.rftar = null;
try
{
CommiTarget tar = new CommiTarget(port, baudRate);
Protocol ptl = new Protocol();
ptl.FrameHeader = new byte[] { 0x02 };
ptl.FrameFoot = new byte[] { 0x03, 0x0A, 0x0D };
ptl.TotalBytes = 13;
tar.setProtocol(ptl);
if (!mgr.TestConnect(tar))
{
return(false);
}
this.rftar = tar;
}
catch
{
return(false);
}
//命令只接收数据
this.cmdRFID.ResetState();
byte[] request = new byte[] { 0x02, 0x00, 0x00, 0x03, 0x0A, 0x0D };
this.cmdRFID.setCommand(request);
mgr.SendCommand(this.rftar, this.cmdRFID);
return(true);
}
/// <summary>
/// 搜索网络内支持UDP通讯的设备信息,设备信息使用tag格式数据
/// </summary>
/// <returns>返回tag格式数据信息</returns>
public static string[] SearchUDPDoor()
{
IPEndPoint srv = new IPEndPoint(IPAddress.Broadcast, searport);
CommiTarget target = new CommiTarget(srv, CommiType.UDP);
target.setProtocol(Protocol.PTLDoor);
DateTime dtStart = DateTime.Now;
CommandBase cmd = new CommandBase(false);
cmd.TimeSendInv = new TimeSpan(0, 0, 50);
cmd.TimeOut = new TimeSpan(0, 0, 2);
cmd.TimeFailLimit = new TimeSpan(0, 0, 5);
cmd.TimeLimit = new TimeSpan(0, 0, 20);
cmd.IsResposeHandle = isRpsDoor;
cmd.setCommand(searcmd, true);
cmd.ResponseHandle += new EventHandler <ResponseEventArgs>(cmd_RpsDoorHandle);
CommiManager.GlobalManager.SendCommand(target, cmd);
//广播搜索，有多个设备返回信息，直到超时停止接收
List <string> infolist = cmd.Tag as List <string>;
while (cmd.EventWh.WaitOne(cmd.TimeLimit, false) && DateTime.Now - dtStart < cmd.TimeLimit)
{
cmd.EventWh.Reset();
}
cmd.TimeSendInv = new TimeSpan(0, 0, -10);
CommiManager.GlobalManager.RemoveCommand(target, cmd);
//返回搜索结果
infolist = cmd.Tag as List <string>;
cmd.Tag = null;
if (null == infolist || infolist.Count < 1)
{
return(new string[0]);
}
return(infolist.ToArray());
}
/// <summary>
/// 接收广播反馈,需要多次交互获取完整信息
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private static void cmd_ResponseHandle(object sender, ResponseEventArgs e)
{
if (null == sender || !(sender is CommandBase) || null == e || !e.Success || null == e.Response || e.Response.Length < 1)
{
return;
}
CommandBase cmd = sender as CommandBase;
string rsl = CommandBase.Parse(cmd.ResponseData, true);
//检查功能码：搜索功能，获取网络信息，获取详细信息
string codesearch = "A1FD000922";
string codedetailA = "A114010200";
string codedetailB = "A114010202";
string code = parseFunCode(rsl);
string addr = parseAddrMac(rsl);
if (codesearch != code && codedetailA != code && codedetailB != code)
{
return;
}
//格式参数：普通/物理地址/IP地址/文本/数字
string[] formatinit = { "功能码,10,4;", "物理地址,4,6", "IP地址,17,4;", "", "" };
string[] formatdtlA = { "功能码,10,4;", "物理地址,4,6",
"IP地址,47,4;子网掩码,51,4;网关IP,55,4;DNS服务器,59,4;",
"设备名称,15,16;密码,31,5;",
"网页端口,71,1;命令端口,72,2;" };
string[] formatdtlB = { "功能码,10,4;", "物理地址,4,6", "", "",
"工作方式,15,1;工作端口,16,2;超时断开时间,18,3;心跳时间,21,1;波特率,26,3;数据位,29,1;停止位,30,1;校验位,31,1;" };
formatdtlB[4] += "分包长度,32,3;帧间隔,35,2;目标端口1,47,2;目标端口2,49,2;目标端口3,51,2;目标端口4,53,2;目标端口5,55,2;目标端口6,57,2;目标端口7,59,2;目标端口8,61,2;";
//读取信息列表
List <string> infolist = new List <string>();
if (null == cmd.Tag)
{
cmd.Tag = infolist;
}
int index = -1;
infolist = cmd.Tag as List <string>;
for (int i = 0; i < infolist.Count; i++)
{
if (addr != basefun.valtag(infolist[i], "物理地址"))
{
continue;
}
index = i;
break;
}
string info = "";
if (index > -1)
{
info = infolist[index];
}
if (codesearch == code)
{
info = parseDetail(rsl, info, formatinit[0], formatinit[1], formatinit[2], formatinit[3], formatinit[4], false);
}
else if (codedetailA == code)
{
info = parseDetail(rsl, info, formatdtlA[0], formatdtlA[1], formatdtlA[2], formatdtlA[3], formatdtlA[4], false);
}
else if (codedetailB == code)
{
info = parseDetail(rsl, info, formatdtlB[0], formatdtlB[1], formatdtlB[2], formatdtlB[3], formatdtlB[4], false);
}
if (index > -1)
{
infolist[index] = info;
}
else
{
infolist.Add(info);
}
//最后一步获取详细信息后结束
if (codedetailB == code)
{
return;
}
//再获取网络信息，最后获取详细信息
IPEndPoint srv = new IPEndPoint(IPAddress.Broadcast, infoport);
CommiTarget target = new CommiTarget(srv, CommiType.UDP);
target.setProtocol(ptlZnet);
string strcmd = string.Format(infocmd, addr.Replace("-", " "), codesearch == code ? "A114000200" : "A114000202");
CommandBase cmdNext = new CommandBase();
//使用相同的同步事件，可动态检测UDP搜索反馈结果
cmdNext.EventWh = cmd.EventWh;
cmdNext.Tag = cmd.Tag;
cmdNext.ResponseHandle += new EventHandler <ResponseEventArgs>(cmd_ResponseHandle);
cmdNext.IsResposeHandle = isResponseCmd;
cmdNext.setCommand(strcmd, true);
CommiManager.GlobalManager.SendCommand(target, cmdNext);
}
/// <summary>
/// 获取数据行的设备目标位置参数
/// 记录包含字段【访问方式】(TCP/UDP/SerialPort)、【端口】(60000/COM1)、【地址】(192.168.1.146)
/// </summary>
/// <param name="dr">数据记录</param>
/// <returns></returns>
private CommiTarget getTarget(DataRow dr)
{
if (null == dr || (DBNull.Value == dr["串口"] && DBNull.Value == dr["IP地址"]))
{
return(null);
}
CommiTarget target = new CommiTarget();
CommiType commiType = CommiType.UDP;
string stype = Convert.ToString(dr["通讯类别"]);
switch (stype)
{
case "TCP/IP(局域网)":
commiType = CommiType.TCP; break;
case "UDP/IP(局域网)":
commiType = CommiType.UDP; break;
default:
commiType = CommiType.SerialPort; break;
}
try
{
if (CommiType.SerialPort == commiType)
{
string portname = Convert.ToString(dr["串口"]);
int baudRate = Convert.ToInt16(dr["波特率"]);
int dataBits = Convert.ToInt16(dr["数据位"]);
decimal s = Convert.ToDecimal(dr["停止位"]);
StopBits sb = StopBits.None;
if (1 == s)
{
sb = StopBits.One;
}
else if (2 == s)
{
sb = StopBits.Two;
}
else if (1 < s && s < 2)
{
sb = StopBits.OnePointFive;
}
target.SetProtocolParam(portname, baudRate, Parity.None, dataBits, sb);
}
else
{
string addr = Convert.ToString(dr["IP地址"]);
if (string.IsNullOrEmpty(addr) || DBNull.Value == dr["端口"])
{
return(null);
}
int port = Convert.ToInt32(dr["端口"]);
target.SetProtocolParam(addr, port, commiType);
}
}
catch (Exception ex)
{
NameValueCollection data = new NameValueCollection();
data["操作"] = "创建通讯目标";
data["设备ID"] = Convert.ToString(dr["ID"]);
ServiceTool.LogMessage(ex, data, EventLogEntryType.Error);
return(null);
}
return(target);
}
/// <summary>
/// 添加监控管理的设备
/// </summary>
/// <param name="devid">请求的客户端</param>
/// <param name="ispatrol">是否持续巡检</param>
private DeviceBase addDevice(string devid, bool ispatrol)
{
//增加设备监控
NameObjectList ps = new NameObjectList();
ps["设备ID"] = devid;
DataTable tab = this.query.getTable("设备通讯参数", ps);
if (null == tab || tab.Rows.Count < 1)
{
return(null);
}
DataRow dr = tab.Rows[0];
if (!tab.Columns.Contains("通讯协议"))
{
string msg = "";
foreach (object obj in dr.ItemArray)
{
msg += Convert.ToString(obj) + " ";
}
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 设备通讯参数值：" + msg);
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 设备通讯参数值：" + msg);
return(null);
}
string dvtype = Convert.ToString(dr["通讯协议"]);
if (string.IsNullOrEmpty(dvtype) || DBNull.Value == dr["站址"])
{
return(null);
}
int station = Convert.ToInt32(dr["站址"]);
CommiTarget target = this.getTarget(dr);
if (null == target)
{
return(null);
}
CommiManager commimgr = CommiManager.GlobalManager;
DeviceBase device = null;
switch (dvtype)
{
case "门禁":
Debug.WriteLine("门禁");
string ctrltype = Convert.ToString(dr["控制器类型"]);
if ("进出口" == ctrltype || "出入口" == ctrltype)
{
device = new DeviceChannel();
}
else
{
device = new DeviceDoor();
}
target.setProtocol(Protocol.PTLDoor);
device.AlarmHandle += new EventHandler <DvAlarmEventArgs>(device_AlarmHandle);
break;
case "消费":
device = new DeviceEatery();
target.setProtocol(Protocol.PTLEatery);
break;
default:
return(null);
}
device.RecordHandle += new EventHandler <DvRecordEventArgs>(device_RecordHandle);
Monitor.Enter(devlist);
this.devlist.Add(device);
Monitor.PulseAll(devlist);
Monitor.Exit(devlist);
device.IsPatrol = ispatrol;
device.dtBeat = DateTime.Now;
device.SetDevice(commimgr, target, devid, station);
device.StartGather();
Debug.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 启动：" + Convert.ToString(station) + " 设备ID：" + devid);
myLog.WriteLine(DateTime.Now.ToString("HH:mm:ss.fff") + " 启动：" + Convert.ToString(station) + " 设备ID：" + devid);
return(device);
}
/// <summary>
/// 设置发行器
/// </summary>
/// <param name="target">发行器地址</param>
/// <param name="stationNum">发行器站址</param>
/// <param name="isCardIC">是否IC卡</param>
/// <returns>是否成功设置发行器</returns>
public bool SetTarget(CommiTarget target, int stationNum, bool isCardIC)
{
//重新设置则保持当前状态
if (null != target && stationNum > 0 && stationNum < 255 && null != this.targetwr)
{
if (this.addrst == Convert.ToString(stationNum) && this.isCardIC == isCardIC &&
((null != target.SrvEndPoint && null != this.targetwr.SrvEndPoint && this.targetwr.SrvEndPoint.Port == target.SrvEndPoint.Port && this.targetwr.SrvEndPoint.Address.ToString() == target.SrvEndPoint.Address.ToString()) ||
(this.targetwr.PortName == target.PortName && this.targetwr.BaudRate == target.BaudRate)))
{
if (!string.IsNullOrEmpty(this.cardid) || 0 == this.stateChecking)
{
return(true);
}
this.reChecking(1);
return(true);
}
}
this.TimeSendInv = new TimeSpan(24, 0, 0);
this.stateChecking = 0;
this.cardid = "";
this.cardserno = "";
this.cardnum = "";
string tagdata = "@设备地址=" + this.addrst;
//原发行器脱机
string[,] cmds = { { "卡务中心", "脱机" }, { "卡务中心", "蜂鸣" } };
if (null != this.targetwr && !string.IsNullOrEmpty(this.addrst))
{
for (int i = 0; i < cmds.GetLength(0); i++)
{
this.setCommand(cmds[i, 0], cmds[i, 1], tagdata);
this.ResetState();
this.commiMgr.SendCommand(this.targetwr, this);
this.EventWh.WaitOne(this.waitTime, false);
}
this.commiMgr.RemoveCommand(this.targetwr, this);
}
//置发行器脱机并蜂鸣提示
this.isCardIC = isCardIC;
this.targetwr = null;
this.addrst = "3";
if (null == target || stationNum < 1 || stationNum > 255)
{
return(false);
}
this.targetwr = target;
this.addrst = Convert.ToString(stationNum);
target.setProtocol(Protocol.PTLCard);
tagdata = "@设备地址=" + this.addrst;
cmds = new string[, ] {
{ "卡务中心", "联机" }, { "卡务中心", "防冲突" }
};
if (!isCardIC)
{
cmds = new string[, ] {
{ "卡务中心", "读卡" }
}
}
;
for (int i = 0; i < cmds.GetLength(0); i++)
{
this.setCommand(cmds[i, 0], cmds[i, 1], tagdata);
this.ResetState();
this.commiMgr.SendCommand(this.targetwr, this);
if (!this.EventWh.WaitOne(this.waitTime, false))
{
return(false);
}
}
this.tmIDcache.Change(Timeout.Infinite, Timeout.Infinite);
this.TimeSendInv = new TimeSpan(3000000);
this.stateChecking = isCardIC ? 2 : 1;
return(true);
}
private void tmRefresh_Tick(object sender, EventArgs e)
{
if (isRunning)
{
return;
}
isRunning = true;
//巡检过的设备地址加入devs中,避免重复巡检
string devs = ",", tpl = "门禁";
// isrealtime/是否实时状态,在最后刷卡时间5分钟不变化时可对累积数据大批量采集
bool isrealtime = false;
DateTime dtpre = DateTime.Now.AddMinutes(-5);
//有信息则记录日志
DataView dvinfo = gridViewInfo.DataSource as DataView;
//站址/记录数列表,非实时采集状态时优先批量采集记录数大的
Dictionary <string, int> devrecord = new Dictionary <string, int>();
Dictionary <string, string[]> devinfo = new Dictionary <string, string[]>();
List <CommiTarget> targetlist = new List <CommiTarget>();
CmdProtocol cmdP = new CmdProtocol(false);
cmdP.TimeOut = new TimeSpan(400 * 10000);
cmdP.TimeSendInv = new TimeSpan(1, 0, 0);
cmdP.TimeFailLimit = new TimeSpan(900 * 10000);
cmdP.TimeLimit = new TimeSpan(900 * 10000);
NameObjectList psdata = new NameObjectList();
for (int i = 0; i < lvDoor.Items.Count; i++)
{
string tag = Convert.ToString(lvDoor.Items[i].Tag);
if (string.IsNullOrEmpty(tag))
{
continue;
}
string[] devps = tag.Split(",".ToCharArray());
if (devs.Contains("," + devps[7] + ","))
{
continue;
}
CommiTarget target = this.getTarget(devps);
if (null == target)
{
continue;
}
targetlist.Add(target);
tag = "@设备地址=" + devps[7];
devs += devps[7] + ",";
cmdP.setCommand(tpl, "检测状态", tag);
cmdP.ResetState();
CommiManager.GlobalManager.SendCommand(target, cmdP);
if (!cmdP.EventWh.WaitOne(300, false))
{
continue;
}
string msg = cmdP.ResponseFormat;
DevID = basefun.valtag(msg, "{设备地址}");
//获得要开的门
getDKQ(devps[10], basefun.valtag(msg, "读卡器"));
//通讯图标显示
ListViewItem list1 = null;
for (int k = 0; k < lvDoor.Items.Count; k++)
{
list1 = this.lvDoor.Items[k];
DoorStatus(list1, basefun.valtag(msg, "Success"));
}
if ("true" != basefun.valtag(msg, "Success"))
{
continue;
}
//对比最后刷卡时间
string dtstr = basefun.valtag(msg, "{刷卡时间}");
if (!string.IsNullOrEmpty(dtstr) && !isrealtime)
{
if (dtpre < Convert.ToDateTime(dtstr))
{
isrealtime = true;
}
}
//记录数列表
int sum = Convert.ToInt32(basefun.valtag(msg, "{刷卡记录数}"));
devrecord.Add(devps[7], sum);
devinfo.Add(devps[7], devps);
//记录数少于50则直接采集
int rdcount = 0;
for (int j = 0; j < sum && sum <= 50; j++)
{
cmdP.ResetState();
cmdP.setCommand(tpl, "读取记录", tag);
CommiManager.GlobalManager.SendCommand(target, cmdP);
if (!cmdP.EventWh.WaitOne(1000, false))
{
continue;
}
msg = cmdP.ResponseFormat;
if ("true" != basefun.valtag(msg, "Success"))
{
break;
}
string state = basefun.valtag(msg, "状态编号");
state = this.getStateDoorCard(state);
psdata["控制器"] = devps[8];
psdata["读卡器"] = DKQNUN;
psdata["时间"] = basefun.valtag(msg, "{刷卡时间}");
psdata["卡号"] = basefun.valtag(msg, "{卡号}");
if (devps[10] == "考勤机")
{
psdata["状态"] = "考勤机";
}
else
{
psdata["状态"] = state;
}
this.Query.ExecuteNonQuery("采集门禁数据", psdata, psdata, psdata);
rdcount++;
//devrecord.Remove(devps[7]);
//DataRow drinfo = dvinfo.Table.NewRow();
//drinfo["状态"] = state;
//drinfo["卡号"] = basefun.valtag(msg, "{卡号}");
//int dkq = Convert.ToInt16(basefun.valtag(msg, "读卡器"));
//dkq = dkq + 1;
//drinfo["门"] = doorName + "(" + Convert.ToString(dkq) + ")";
//drinfo["设备地址"] = basefun.valtag(msg, "{设备地址}");
//drinfo["时间"] = basefun.valtag(msg, "{刷卡时间}");
//dvinfo.Table.Rows.InsertAt(drinfo, 0);
//gridViewInfo.SelectRow(0);
}
if (rdcount > 0)
{
dataCount = rdcount.ToString();
}
else
{
dataCount = "0";
}
//检查状态改变则记录
this.validateSate(lvDoor.Items[i], devps[8], msg, devps[10]);
}
//当前是实时状态,则忽略采集数据
if (isrealtime || devrecord.Count < 1)
{
foreach (CommiTarget tar in targetlist)
{
CommiManager.GlobalManager.RemoveCommand(tar, cmdP);
}
isRunning = false;
return;
}
string[] info = new string[0];
int summax = 0;
foreach (string key in devrecord.Keys)
{
if (summax >= devrecord[key])
{
continue;
}
summax = devrecord[key];
info = devinfo[key];
}
if (summax < 1)
{
foreach (CommiTarget tar in targetlist)
{
CommiManager.GlobalManager.RemoveCommand(tar, cmdP);
}
isRunning = false;
return;
}
CommiTarget dev = this.getTarget(info);
//记录数少于50则直接采集
int rdcountmax = 0;
for (int j = 0; j < summax && null != dev; j++)
{
string tag = "@设备地址=" + info[7];
cmdP.ResetState();
cmdP.setCommand(tpl, "读取记录", tag);
CommiManager.GlobalManager.SendCommand(dev, cmdP);
if (!cmdP.EventWh.WaitOne(1000, false))
{
continue;
}
string msg = cmdP.ResponseFormat;
if ("true" != basefun.valtag(msg, "Success"))
{
break;
}
string state = basefun.valtag(msg, "状态编号");
state = this.getStateDoorCard(state);
psdata["控制器"] = info[8];
psdata["读卡器"] = DKQNUN;
psdata["卡号"] = basefun.valtag(msg, "{卡号}");
psdata["时间"] = basefun.valtag(msg, "{刷卡时间}");
psdata["状态"] = state;
this.Query.ExecuteNonQuery("采集门禁数据", psdata, psdata, psdata);
rdcountmax++;
}
foreach (CommiTarget tar in targetlist)
{
CommiManager.GlobalManager.RemoveCommand(tar, cmdP);
}
isRunning = false;
}
/// <summary>
/// 获取数据行的设备目标位置参数
/// 记录包含字段【访问方式】(TCP/UDP/SerialPort)、【端口】(60000/COM1)、【地址】(192.168.1.146)
/// </summary>
/// <param name="dr">数据记录</param>
/// <returns></returns>
private CommiTarget getTarget(string[] devps)
{
string[] cols = { "通讯类别", "串口", "波特率", "数据位", "停止位", "IP地址", "端口", "站址", "控制器", "名称" };
if (null == devps || devps.Length < 7)
{
return(null);
}
CommiTarget target = new CommiTarget();
target.setProtocol(Protocol.PTLDoor);
CommiType commiType = CommiType.UDP;
string stype = Convert.ToString(devps[0]);
switch (stype)
{
case "TCP/IP(局域网)":
commiType = CommiType.TCP; break;
case "UDP/IP(局域网)":
commiType = CommiType.UDP; break;
default:
commiType = CommiType.SerialPort; break;
}
try
{
if (CommiType.SerialPort == commiType)
{
string portname = Convert.ToString(devps[1]);
int baudRate = Convert.ToInt16(devps[2]);
int dataBits = Convert.ToInt16(devps[3]);
decimal s = Convert.ToDecimal(devps[4]);
StopBits sb = StopBits.None;
if (1 == s)
{
sb = StopBits.One;
}
else if (2 == s)
{
sb = StopBits.Two;
}
else if (1 < s && s < 2)
{
sb = StopBits.OnePointFive;
}
target.SetProtocolParam(portname, baudRate, Parity.None, dataBits, sb);
}
else
{
string addr = Convert.ToString(devps[5]);
int port = Convert.ToInt32(devps[6]);
target.SetProtocolParam(addr, port, commiType);
}
}
catch (Exception ex)
{
return(null);
}
return(target);
}
/// <summary>-
/// 保存设备
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void tsbSave_Click(object sender, EventArgs e)
{
this.validateFeeTab();
DataTable tabpark = this.ds.Tables["停车场管理"];
DataTable tabfee = this.ds.Tables["收费标准"];
DataTable tabdspan = this.ds.Tables["收费标准时段"];
DataTable tabdtime = this.ds.Tables["收费标准时刻"];
DataTable[] tablist = { tabpark, tabfee, tabdspan, tabdtime };
bool isSuccess = this.Query.BeginTransaction();
string msg = "";
if (!isSuccess)
{
msg = "保存失败，无法打开事务！";
}
else
{
foreach (DataTable tab in tablist)
{
NameObjectList[] psins = ParamManager.createParam(tab, DataRowState.Added);
NameObjectList[] psupt = ParamManager.createParam(tab, DataRowState.Modified);
NameObjectList[] psdel = ParamManager.createParam(tab, DataRowState.Deleted);
isSuccess = this.Query.ExecuteNonQuery(tab.TableName, psins, psupt, psdel);
if (!isSuccess)
{
msg = "保存失败，请检查数据是否合法！";
break;
}
}
}
if (!isSuccess)
{
this.Query.RollbackAndClose();
}
else
{
this.Query.Commit();
this.Query.Close();
foreach (DataTable tab in tablist)
{
tab.AcceptChanges();
}
//发出通讯更新设备
int port = 2010;
string sport = DataAccRes.AppSettings("Granity文件服务");
if (!string.IsNullOrEmpty(sport))
{
try { port = Convert.ToInt32(sport); }
catch { return; }
}
string conn = DataAccRes.DefaultDataConnInfo.Value;
Regex regIP = new Regex(@"server=([\w.\(\)]*)(;|\\)");
string ipsrv = "127.0.0.1";
if (regIP.IsMatch(conn))
{
Match mt = regIP.Match(conn);
if (mt.Groups.Count > 1)
{
ipsrv = mt.Groups[1].Value.ToLower();
}
if ("(local)" == ipsrv || "127.0.0.1" == ipsrv)
{
ipsrv = Dns.GetHostName();
}
ipsrv = Dns.GetHostAddresses(ipsrv)[0].ToString();
}
CmdFileTrans cmd = new CmdFileTrans(false);
cmd.ExtRefreshDevice();
CommiTarget target = new CommiTarget(ipsrv, port, CommiType.TCP);
CommiManager.GlobalManager.SendCommand(target, cmd);
}
if (!isSuccess)
{
MessageBox.Show(msg, "保存提示", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
MessageBox.Show("保存成功！", "保存提示", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
