void do解析_Click(object sender, EventArgs e) { var __元数据 = _方法.返回值元数据; var __值 = (string)this.do解析.Tag; var __数据结构 = __元数据 == null?HJSON.识别数据结构(__值) : _方法.返回值元数据.结构; var __标题 = "返回值 - " + (__元数据 == null ? "" : __元数据.类型); switch (__数据结构) { case E数据结构.点: if (__值.Length > 10) { new F点结构_查看(__元数据, __值, "返回值").ShowDialog(); } break; case E数据结构.行: new F行结构_查看(__元数据 == null ? null : __元数据.子成员列表, __值, __标题).ShowDialog(); break; case E数据结构.列: new F列结构_查看(__元数据, __值, __标题).ShowDialog(); break; case E数据结构.表: new F表格结构_查看(__元数据 == null ? null : __元数据.子成员列表, __值, __标题).ShowDialog(); break; default: throw new ArgumentOutOfRangeException(); } }
public List <M业务日志> 查询缓存() { //var __结果 = HJSON.AES解压(_IT客户端.执行方法(_对象名称, "查询缓存")); var __结果 = _IT客户端.执行方法(_对象名称, "查询缓存"); return(HJSON.反序列化 <List <M业务日志> >(__结果)); }
public void 登录(M登录请求 __请求, IPEndPoint __地址) { if (_登录验证 != null) { try { _登录验证(__请求, __地址); } catch (Exception ex) { _IT服务端.触发事件(_对象名称, "登录完毕", new Dictionary <string, string> { { "事件参数", HJSON.序列化(new M登录事件 { 成功 = false, 设备标识 = __请求.设备标识, 设备类型 = __请求.设备类型, 账号 = __请求.账号, 描述 = ex.Message }) } }); throw; } } _登录缓存[__地址] = new M已登录设备 { IP = __地址.Address, 端口号 = __地址.Port, 登录时间 = DateTime.Now, 设备标识 = __请求.设备标识, 设备类型 = __请求.设备类型, 账号 = __请求.账号 }; _IT服务端.触发事件(_对象名称, "登录完毕", new Dictionary <string, string> { { "事件参数", HJSON.序列化(new M登录事件 { 成功 = true, 设备标识 = __请求.设备标识, 设备类型 = __请求.设备类型, 账号 = __请求.账号 }) } }); }
private string 设置开发日志过滤(Dictionary <string, string> __实参列表, IPEndPoint __地址) { var __条件 = HJSON.反序列化 <M过滤开发日志>(__实参列表["过滤参数"]); _开发日志过滤[__地址] = __条件; return(""); }
private void 配置通用访问() { var _对象 = new M对象(_对象名称, "通用服务"); _对象.添加方法("重启", q => { if (重启 != null) { 重启(); return(""); } throw new ApplicationException("该功能不支持"); }, E角色.客户); _对象.添加方法("关闭", q => { if (关闭 != null) { 关闭(); return(""); } throw new ApplicationException("该功能不支持"); }, E角色.客户); _对象.添加方法("查询版本记录", q => { if (查询版本记录 != null) { return(HJSON.序列化(查询版本记录())); } throw new ApplicationException("该功能不支持"); }, E角色.客户); _IT服务端.添加对象(_对象名称, () => _对象); }
M对象 创建对象(IT服务端 __IT服务端, B资源监控 __监控, string __对象名称 = "资源监控", string __分类 = "") { var __对象 = new M对象(__对象名称, __分类); __对象.添加属性("配置", () => HJSON.序列化(__监控.配置), E角色.客户, null); __对象.添加属性("总内存", () => string.Format("{0} GB", __监控.总内存 / 1024), E角色.客户, null); __对象.添加方法("设置配置", __实参列表 => { var __配置 = HJSON.反序列化 <M资源监控配置>(__实参列表["配置"]); __监控.配置 = __配置; File.WriteAllText(H路径.获取绝对路径("资源监控配置.txt"), HJSON.序列化(__配置), Encoding.UTF8); return(""); }, E角色.客户, null, null); __对象.添加方法("查询状态", __实参列表 => { return(HJSON.序列化(__监控.查询状态())); }, E角色.客户, null, null); __对象.添加事件("告警", E角色.客户, new List <M形参> { new M形参("描述", "string") }); __监控.阈值告警 += __描述 => { H业务日志.记录("进程", __描述); __IT服务端.触发事件(__对象名称, "告警", new Dictionary <string, string> { { "描述", __描述 } }); }; return(__对象); }
void do保存_Click(object sender, EventArgs e) { var __账号 = this.in账号.Text; var __密码 = this.in密码.Text; var __数据源 = this.in数据源.Text; var __保留天数 = this.in保留.Text; var __GPS过滤_开启 = this.inGPS过滤_开启.Checked; var __GPS过滤_省 = this.inGPS过滤_省.Text; var __GPS过滤_市 = this.inGPS过滤_市.Text; var __插件配置 = new List <M插件配置>(); for (int i = 0; i < this.out互联插件.Rows.Count; i++) { __插件配置.Add(new M插件配置 { 目录 = this.out互联插件.Rows[i].Cells[1].Value.ToString(), 启用 = (bool)this.out互联插件.Rows[i].Cells[0].Value }); } _IT客户端.执行方法("数据库", "设置连接参数", new Dictionary <string, string> { { "账号", __账号 }, { "密码", __密码 }, { "数据源", __数据源 } }); _IT客户端.执行方法("数据库", "设置保留天数", new Dictionary <string, string> { { "天数", __保留天数 } }); _IT客户端.执行方法("GPS过滤", "设置", new Dictionary <string, string> { { "启用", __GPS过滤_开启.ToString() }, { "省", __GPS过滤_省 }, { "市", __GPS过滤_市 } }); _IT客户端.执行方法("插件", "设置", new Dictionary <string, string> { { "配置", HJSON.序列化(__插件配置) } }); }
private void 增加(List <string> __号码列表, IPEndPoint __地址) { HB日志.记录("订阅", string.Format("{0} 增加 {1}", __地址, string.Join(",", __号码列表))); if (!_客户端订阅缓存.ContainsKey(__地址)) { _客户端订阅缓存[__地址] = __号码列表; } else { var __合并 = new List <int>(); _客户端订阅缓存[__地址].AddRange(__号码列表); _客户端订阅缓存[__地址] = _客户端订阅缓存[__地址].Distinct().ToList(); } __号码列表.ForEach(q => { if (!_号码状态缓存.ContainsKey(q)) { _号码状态缓存[q] = new M号码状态(); } if (!_号码状态缓存[q].订购者.Contains(__地址)) { _号码状态缓存[q].订购者.Add(__地址); } if (_号码状态缓存[q].最后位置 != null && _号码状态缓存[q].最后位置.时间.AddMinutes(2) > DateTime.Now) { _IT服务端.触发事件("订阅", "GPS上报", new Dictionary <string, string> { { "号码", q }, { "GPS", HJSON.序列化(_号码状态缓存[q].最后位置) } }, new List <IPEndPoint> { __地址 }); } }); }
public void 点名(M点名条件 __条件) { var __udp = new UdpClient(0); var __内容 = Encoding.UTF8.GetBytes(HJSON.序列化(__条件)); __udp.Send(__内容, __内容.Length, _请求地址); }
public M对象 创建对象(string __名称 = "测试", string __分类 = "") { var __对象 = new M对象(__名称, __分类); __对象.添加属性("点结构属性1", () => "HELLO 你好!!!!!!!!"); __对象.添加属性("点结构属性2", () => "1"); __对象.添加属性("列结构属性", () => HJSON.序列化(new List <int> { 1, 2, 3 }), E角色.开发, new M元数据 { 类型 = "int", 结构 = E数据结构.单值数组, 默认值 = "[1,2,3]", 范围 = "1-10", }); __对象.添加属性("行结构属性", () => HJSON.序列化(new Mdemo { 点属性 = 111, 行属性 = new Mdemo1 { 点属性1 = 1211, 点属性2 = "1221" } })); __对象.添加属性("表结构属性", () => HJSON.序列化(new List <Mdemo> { new Mdemo { 点属性 = 111, 行属性 = new Mdemo1 { 点属性1 = 1211, 点属性2 = "1221" } }, new Mdemo { 点属性 = 112, 行属性 = new Mdemo1 { 点属性1 = 1212, 点属性2 = "1222" } }, })); __对象.添加方法("使用单值", 实参列表 => 执行方法("使用单值", 实参列表), E角色.开发, new List <M形参> { new M形参("参数1", "int"), new M形参("参数2", "string"), }, new M元数据 { 类型 = "string", 描述 = "描述xxx", 结构 = E数据结构.单值, 范围 = "范围xxx" }); __对象.添加方法("使用对象", 实参列表 => 执行方法("使用对象", 实参列表), E角色.开发, new List <M形参> { new M形参("参数1", 获取行元数据()), }, 获取行元数据()); __对象.添加方法("使用单值数组", 实参列表 => 执行方法("使用单值数组", 实参列表), E角色.开发, new List <M形参> { new M形参("参数1", "int", E数据结构.单值数组), new M形参("参数2", "string"), }, new M元数据 { 类型 = "int", 描述 = "描述xxx", 结构 = E数据结构.单值数组, 范围 = "范围xxx" }); __对象.添加方法("使用对象数组", 实参列表 => 执行方法("使用对象数组", 实参列表), E角色.开发, new List <M形参> { new M形参("参数1", 获取表元数据()), }, 获取表元数据()); //__对象.添加方法("使用单值2", "参数1:int.参数2:string", "string", 实参列表 => 执行方法("使用单值", 实参列表), E角色.开发); //__对象.添加方法("使用对象数组2", // "参数1:,对象数组(参数1:int;参数2:string),描述.参数2:MXXX,对象(参数1:int,单值数组,xxx;参数2:string,,事大法师的).参数3:int,单值数组", // "", // 实参列表 => 执行方法("使用对象数组", 实参列表), E角色.开发); __对象.添加方法("返回字符串表格", 实参列表 => 执行方法("返回字符串表格", 实参列表)); __对象.添加方法("返回字符串表格2", 实参列表 => 执行方法("返回字符串表格2", 实参列表)); return(__对象); }
void do刷新_Click(object sender, EventArgs e) { this.in账号.Text = _IT客户端.查询属性值("数据库", "账号"); this.in密码.Text = _IT客户端.查询属性值("数据库", "密码"); this.in数据源.Text = _IT客户端.查询属性值("数据库", "数据源"); try { this.in保留.SelectedItem = int.Parse(_IT客户端.查询属性值("数据库", "保留天数")); } catch (Exception) { this.in保留.SelectedIndex = 0; } this.inGPS过滤_省.SelectedIndexChanged += in省_SelectedIndexChanged; List <string> __所有省 = H行政区位置.所有.Select(q => q.省).Distinct().ToList(); this.inGPS过滤_省.DataSource = __所有省; this.inGPS过滤_开启.Checked = bool.Parse(_IT客户端.查询属性值("GPS过滤", "启用")); this.inGPS过滤_省.SelectedItem = _IT客户端.查询属性值("GPS过滤", "省"); this.inGPS过滤_市.SelectedItem = _IT客户端.查询属性值("GPS过滤", "市"); this.out互联插件.Rows.Clear(); var __插件列表 = HJSON.反序列化 <List <M插件参数> >(_IT客户端.查询属性值("插件", "配置")); __插件列表.ForEach(q => { var __行 = this.out互联插件.Rows.Add(q.启用, q.称, q.目录, q.描述, q.管理界面 ? "管理" : ""); this.out互联插件.Rows[__行].Tag = q; }); }
public void 新增开发日志(M上报开发日志 __日志) { var __缓存 = new Dictionary <IPEndPoint, M过滤开发日志>(_开发日志过滤); var __匹配 = new List <IPEndPoint>(); foreach (var __kv in __缓存) { var __条件 = __kv.Value; if (__条件.线程关键字 != null && __条件.线程关键字.Count > 0 && !string.IsNullOrEmpty(__日志.线程) && __条件.线程关键字.All(q => !__日志.线程.Contains(q))) { continue; } if (__条件.标题关键字 != null && __条件.标题关键字.Count > 0 && !string.IsNullOrEmpty(__日志.标题) && __条件.标题关键字.All(q => !__日志.标题.Contains(q))) { continue; } if (__条件.内容关键字 != null && __条件.内容关键字.Count > 0 && !string.IsNullOrEmpty(__日志.内容) && __条件.内容关键字.All(q => !__日志.内容.Contains(q))) { continue; } if (__条件.重要性.HasValue && __条件.重要性 > __日志.重要性) { continue; } __匹配.Add(__kv.Key); } if (__匹配.Count > 0) { _IT服务端.触发事件(_对象名称, "上报开发日志", new Dictionary <string, string> { { "事件参数", HJSON.序列化(__日志) } }, __匹配); } }
private void 处理事件() { var __udp = new UdpClient(_响应地址.Port); __udp.JoinMulticastGroup(_响应地址.Address, 64); new Thread(() => { IPEndPoint __远端 = null; var __响应列表 = new List <IPEndPoint>(); while (true) { var __接收数据 = __udp.Receive(ref __远端); if (__响应列表.Contains(__远端)) { continue; } __响应列表.Add(__远端); var __接收信息 = Encoding.UTF8.GetString(__接收数据); try { var __点名 = HJSON.反序列化 <M点名事件>(__接收信息); On收到事件(__点名); } catch (Exception ex) { H调试.记录异常(ex); } } }) { IsBackground = true }.Start(); }
private void 响应被点名() { new Thread(() => { var __udp = new UdpClient(_请求地址.Port); __udp.JoinMulticastGroup(_请求地址.Address, 64); IPEndPoint __远端 = null; while (true) { var __接收数据 = __udp.Receive(ref __远端); var __接收信息 = Encoding.UTF8.GetString(__接收数据); try { var __点名条件 = HJSON.反序列化 <M点名条件>(__接收信息); var __事件参数 = _处理被点名 == null ? null : _处理被点名(__点名条件); if (__事件参数 != null) { 发布事件(E事件.点名响应, __事件参数); On设备被点名(__远端); } } catch (Exception ex) { H调试.记录异常(ex); } } }) { IsBackground = true }.Start(); }
public void 过滤开发日志(M过滤开发日志 __过滤开发日志) { _过滤开发日志 = __过滤开发日志; _IT客户端.执行方法(_对象名称, "过滤开发日志", new Dictionary <string, string> { { "过滤参数", HJSON.序列化(__过滤开发日志) } }); }
public int 统计(M活跃号码查询条件 __条件) { var __返回值 = _IT客户端.执行方法(_对象名称, "统计活跃号码", new Dictionary <string, string> { { "条件", HJSON.序列化(__条件) } }, 30000); return(int.Parse(__返回值)); }
public float 统计(M频率统计条件 __条件) { var __返回值 = _IT客户端.执行方法(_对象名称, "统计频率", new Dictionary <string, string> { { "条件", HJSON.序列化(__条件) } }, 30000); return(float.Parse(__返回值)); }
public M最后位置查询结果 查询(M最后位置查询条件 __条件) { var __返回值 = _IT客户端.执行方法(_对象名称, "查询最后位置", new Dictionary <string, string> { { "条件", HJSON.序列化(__条件) } }, 30000); return(HJSON.反序列化 <M最后位置查询结果>(H序列化.AES解压(__返回值))); }
public List <M上报告警> 查询未清除告警(M查询条件 查询条件) { var __返回值 = _IT客户端.执行方法(_对象名称, "查询未清除告警", new Dictionary <string, string> { { "条件", 查询条件 == null ? "" : HJSON.序列化(查询条件) } }); return(HJSON.反序列化 <List <M上报告警> >(__返回值)); }
public M活跃号码查询结果 查询(M活跃号码查询条件 __条件) { var __返回值 = _IT客户端.执行方法(_对象名称, "查询活跃号码", new Dictionary <string, string> { { "条件", HJSON.序列化(__条件) } }, 60000); return(HJSON.反序列化 <M活跃号码查询结果>(__返回值)); }
public BGPS过滤() { _MGPS过滤 = HJSON.反序列化 <MGPS过滤>(H程序配置.获取字符串("GPS过滤")); var __省 = _MGPS过滤.省; var __市 = _MGPS过滤.市; 设置区域(__省, __市); 配置通用访问("GPS过滤"); }
public override void 解码消息内容(H字段解码 __解码) { var __内容 = __解码.解码文本(FT通用访问工厂.文本编码, __解码.剩余字节数); //var __内容 = __解码.解码GB2132(__解码.剩余字节数); this.响应 = new M对象列表 { 对象列表 = HJSON.反序列化 <List <M对象概要> >(__内容) }; }
public void 发布事件(E事件 __事件, M点名事件参数 __参数) { var __udp = new UdpClient(0); var __点名事件 = new M点名事件 { 地址 = (IPEndPoint)__udp.Client.LocalEndPoint, 参数 = __参数, 类型 = __事件 }; var __内容 = Encoding.UTF8.GetBytes(HJSON.序列化(__点名事件)); __udp.Send(__内容, __内容.Length, _响应地址); }
public void 新增工程日志(M上报工程日志 __日志) { var __缓存 = new Dictionary <IPEndPoint, M过滤工程日志>(_工程日志过滤); var __匹配 = new List <IPEndPoint>(); foreach (var __kv in __缓存) { var __条件 = __kv.Value; if (!string.IsNullOrEmpty(__条件.边界类型) && __条件.边界类型 != __日志.边界类型) { continue; } if (!string.IsNullOrEmpty(__条件.边界标识) && __条件.边界标识 != __日志.边界标识) { continue; } if (!string.IsNullOrEmpty(__条件.方向) && __条件.方向 != __日志.方向) { continue; } if (!string.IsNullOrEmpty(__条件.业务标识) && __条件.业务标识 != __日志.业务标识) { continue; } if (__条件.重要性.HasValue && __条件.重要性 > __日志.重要性) { continue; } if (__条件.关键字 != null && __条件.关键字.Count > 0 && ( __条件.关键字.All(q => !__日志.描述.Contains(q)) || __条件.关键字.All(q => !__日志.业务标识.Contains(q)) || __条件.关键字.All(q => !__日志.边界类型.Contains(q)) || __条件.关键字.All(q => !__日志.边界标识.Contains(q)) || (__日志.业务标签 != null && __日志.业务标签.Count > 0 && __条件.关键字.All(q => !__日志.业务标签.Contains(q))) )) { continue; } if (__条件.业务类型 != null && __条件.业务类型.Count > 0 && __条件.业务类型.All(q => __日志.业务类型 != q)) { continue; } if (__条件.业务标签 != null && __条件.业务标签.Count > 0 && __条件.业务标签.All(q => __日志.业务标签.Contains(q))) { continue; } __匹配.Add(__kv.Key); } if (__匹配.Count > 0) { _IT服务端.触发事件(_对象名称, "上报工程日志", new Dictionary <string, string> { { "事件参数", HJSON.序列化(__日志) } }, __匹配); } }
public void 新增告警(M上报告警 告警) { if (告警.重要性 != E重要性.一般) { _待处理问题.Add(告警); 计算健康状态(true); } _IT服务端.触发事件(_对象名称, "上报告警", new Dictionary <string, string> { { "事件参数", HJSON.序列化(告警) } }); }
public M轨迹查询结果 查询(M轨迹查询条件 __条件) { var __返回值 = _IT客户端.执行方法(_对象名称, "查询轨迹", new Dictionary <string, string> { { "条件", HJSON.序列化(__条件) } }, 30000); //return HJSON.反序列化<M轨迹查询结果>(__返回值); var __解压 = H序列化.AES解压(__返回值); return(HJSON.反序列化 <M轨迹查询结果>(__解压)); }
private void 处理GPS上报(Dictionary <string, string> __实参列表) { var __号码 = __实参列表["号码"]; var __GPS = HJSON.反序列化 <MGPS>(__实参列表["GPS"]); if (__GPS.时间 > DateTime.Now) { __GPS.时间 = DateTime.Now; } OnGps上报(__号码, __GPS); }
//public void 执行(string __进程标识, M命令 __命令, Dictionary<string, string> __参数 = null) //{ // if (!_客户端.连接正常) // { // throw new ApplicationException("未连接"); // } // var __命令行列表 = __命令.命令行列表; // if (__命令.参数列表 != null && __命令.参数列表.Count > 0 && __参数 != null) // { // __命令行列表 = new List<string>(__命令行列表); // for (int i = 0; i < __命令行列表.Count; i++) // { // foreach (var item in __参数) // { // __命令行列表[i] = __命令行列表[i].Replace("<" + item.Key + ">", item.Value); // } // } // } // _客户端.执行方法(_对象名, "执行", new Dictionary<string, string> { // { "进程标识",__进程标识}, // { "命令行列表",HJSON.序列化(__命令行列表) }, // }); //} public void 执行(string __进程标识, List <string> __命令列表) { if (!_客户端.连接正常) { throw new ApplicationException("未连接"); } _客户端.执行方法(_对象名, "执行", new Dictionary <string, string> { { "进程标识", __进程标识 }, { "命令行列表", HJSON.序列化(__命令列表) }, }); }
protected virtual void On健康状态变化(M概要状态 __新状态) { var handler = 健康状态变化; if (handler != null) { handler(__新状态); } _IT服务端.触发事件(_对象名称, "健康状态变化", new Dictionary <string, string> { { "事件参数", HJSON.序列化(__新状态) } }); }
void out客户端列表_CellContentClick(object sender, DataGridViewCellEventArgs e) { if (e.ColumnIndex == this.out客户端列表.ColumnCount - 1 && e.RowIndex >= 0) { var __地址 = this.out客户端列表.Rows[e.RowIndex].Cells[0].Value.ToString(); var __号码段列表 = HJSON.反序列化 <List <string> >(_IT客户端.执行方法("订阅", "查询客户端明细", new Dictionary <string, string> { { "IP", __地址.Split(':')[0] }, { "端口号", __地址.Split(':')[1] } })); new F空窗口(new F订阅_详细(__号码段列表), "订阅明细").ShowDialog(this.ParentForm); } }