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);
}
}
