private void 导入(string __文件名)
{
var __json = File.ReadAllText(H路径.获取绝对路径(__文件名), Encoding.UTF8);
var __命令列表 = H序列化.FromJSON字符串 <List <M命令> >(__json);
__命令列表.Sort(new Comparison <M命令>((m, n) => m.类别.CompareTo(n.类别)));
this.out命令列表.Nodes.Clear();
this.out命令列表.Tag = __文件名;
var __所有操作系统 = __命令列表.GroupBy <M命令, string>(q => q.操作系统).OrderBy(q => q.Key);
foreach (var __操作系统 in __所有操作系统)
{
var __父节点 = this.out命令列表.Nodes.Add(__操作系统.Key.IsNotNullOrEmpty() ? __操作系统.Key : "未分类");
var __所有分组 = __操作系统.GroupBy <M命令, string>(q => q.类别).OrderBy(q => q.Key);
foreach (var __分组 in __所有分组)
{
var __子节点 = __父节点.Nodes.Add(__分组.Key.IsNotNullOrEmpty() ? __分组.Key : "未分类");
var __排序分组 = __分组.OrderBy(q => q.称);
foreach (M命令 item in __排序分组)
{
__子节点.Nodes.Add(new TreeNode(item.称)
{
Tag = item, ToolTipText = item.ToString(), BackColor = item.常用 ? Color.LightYellow : Color.White
});
}
}
}
}
static H权限()
{
H调试.记录明细("构造函数");
_文件路径 = "存储\\权限";
_所有数据 = (Tuple <List <M角色>, List <M用户> >)H序列化.二进制读取(_文件路径) ??
new Tuple <List <M角色>, List <M用户> >(new List <M角色>(), new List <M用户>());
__所有角色 = _所有数据.Item1;
__所有用户 = _所有数据.Item2;
if (__所有角色.Count == 0 || __所有用户.Count == 0)
{
H调试.记录明细("初始化");
__所有角色.Clear();
__所有用户.Clear();
var __管理员角色 = new M角色 {
称 = "管理员"
};
var __操作员角色 = new M角色 {
称 = "操作员"
};
__所有角色.Add(__管理员角色);
__所有角色.Add(__操作员角色);
__所有用户.Add(new M用户 {
帐号 = "admin", 密码 = "admin", 角色列表 = new List <M角色> {
__管理员角色
}
});
存储();
}
}
public D命令()
{
if (H路径.验证文件是否存在(_文件名))
{
_缓存 = H序列化.FromJSON字符串 <List <M命令> >(File.ReadAllText(H路径.获取绝对路径(_文件名), Encoding.UTF8));
}
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
this.do连接.Click += do连接_Click;
this.inIP.SelectedIndexChanged += inIP_SelectedIndexChanged;
_访问记录 = H序列化.FromJSON字符串 <List <M访问记录> >(H程序配置.获取字符串("访问记录"));
if (_访问记录.Count > 0)
{
this.inIP.Items.AddRange(_访问记录.Select(q => string.Format("{0}:{1}", q.IP, q.端口号)).ToArray());
this.inIP.SelectedIndex = 0;
}
this.ParentForm.FormClosing += OnClosing;
var __参数 = Environment.GetCommandLineArgs();
if (__参数.Length > 2)
{
var __地址 = __参数[1];
var __端口号 = __参数[2];
this.inIP2.Text = __地址;
this.in端口号.Text = __端口号;
this.do连接.PerformClick();
}
}
public M最后位置查询结果 查询(M最后位置查询条件 __条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "查询最后位置", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__条件) }
}, 30000);
return(HJSON.反序列化 <M最后位置查询结果>(H序列化.AES解压(__返回值)));
}
public M轨迹查询结果 查询(M轨迹查询条件 __条件)
{
var __返回值 = _IT客户端.执行方法(_对象名称, "查询轨迹", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__条件) }
}, 30000);
//return HJSON.反序列化<M轨迹查询结果>(__返回值);
var __解压 = H序列化.AES解压(__返回值);
return(HJSON.反序列化 <M轨迹查询结果>(__解压));
}
void do连接_Click(object sender, EventArgs e)
{
var __ip = this.inIP2.Text;
var __port = this.in端口号.Text;
var __最后访问 = _访问记录.Find(q => q.IP.ToString() == __ip && q.端口号.ToString() == __port);
if (__最后访问 == null)
{
if (!H检测网络.IsHostAlive(__ip, int.Parse(__port), 2000))
{
new F对话框_确定("连接失败").ShowDialog();
return;
}
else
{
__最后访问 = new M访问记录 {
IP = __ip, 端口号 = int.Parse(__port)
};
}
}
else
{
_访问记录.Remove(__最后访问);
}
_访问记录.Insert(0, __最后访问);
H程序配置.设置("访问记录", H序列化.ToJSON字符串(_访问记录));
H日志输出.设置(q =>
{
if (q.等级 <= TraceEventType.Information)
{
if (q.异常 != null)
{
H日志.记录异常(q.异常, q.概要, q.详细, q.等级, q.方法, q.文件, q.行号);
}
else
{
H日志.记录(q.概要, q.等级, q.详细, q.方法, q.文件, q.行号);
}
}
});
_IT客户端 = FT通用访问工厂.创建客户端();
H容器.注入 <IT客户端>(_IT客户端, false);
_IT客户端.自动重连 = true;
_IT客户端.已断开 += q => 设置连接状态();
_IT客户端.已连接 += 设置连接状态;
_IT客户端.连接(new IPEndPoint(IPAddress.Parse(__ip), int.Parse(__port)));
this.ParentForm.ShowInTaskbar = false;
this.ParentForm.Visible = false;
_F主窗口 = new F空窗口(new F主窗口(), "");
设置连接状态();
_F主窗口.FormClosing += OnClosing;
_F主窗口.ShowDialog();
}
private void 保存()
{
_缓存.Sort((n, m) => {
if (m.显示顺序.CompareTo(n.显示顺序) == 0)
{
return(m.文件名.CompareTo(n.文件名));
}
else
{
return(m.显示顺序.CompareTo(n.显示顺序));
}
});
File.WriteAllText(H路径.获取绝对路径(_文件名), H序列化.ToJSON字符串(_缓存), Encoding.UTF8);
}
public static void 初始化(TraceEventType __日志级别 = TraceEventType.Verbose, string __日志目录 = "日志", string __日志文件名称 = "", int __保留天数 = 30)
{
if (_已初始化)
{
return;
}
_已初始化 = true;
H日志.初始化(__日志级别, __日志目录, __日志文件名称);
日志目录 = __日志目录;
var __环境信息 = new Dictionary <string, object>();
__环境信息["Version"] = Assembly.GetCallingAssembly().GetName().Version.ToString();
__环境信息["FileVersion"] = FileVersionInfo.GetVersionInfo(Assembly.GetCallingAssembly().Location).FileVersion;
__环境信息["MachineName"] = Environment.MachineName;
__环境信息["UserName"] = Environment.UserName;
__环境信息["IP"] = String.Join(";", H网络配置.获取可用IP().Select(q => q.ToString()));
__环境信息["OSVersion"] = Environment.OSVersion.VersionString;
__环境信息["CLR Version"] = Environment.Version;
__环境信息["Is64BitProcess"] = Environment.Is64BitProcess;
__环境信息["CurrentDirectory"] = Environment.CurrentDirectory;
记录提示("程序启动", H序列化.ToJSON字符串(__环境信息));
if (__保留天数 != int.MaxValue)
{
清除过期调试文件(日志目录, __保留天数);
}
if (处理异常)
{
Application.ThreadException += (sender, ex) => H异常.处理UI线程(ex.Exception, 未处理异常自动退出);
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
if (e.ExceptionObject == null)
{
return;
}
var ex = e.ExceptionObject as Exception;
if (ex == null)
{
记录致命(e.ExceptionObject.ToString());
}
else
{
H异常.处理非UI线程(ex);
}
};
}
}
public List <MGPS> 查询轨迹(List <Tuple <int, DateTime, DateTime> > __条件)
{
var __结果 = new List <MGPS>();
__条件.ForEach(q =>
{
var __轨迹查询条件 = new M轨迹查询条件 {
号码 = q.Item1, 开始时间 = q.Item2, 结束时间 = q.Item3
};
var __返回值 = _IT客户端.执行方法(_对象名称, "查询轨迹", new Dictionary <string, string> {
{ "条件", HJSON.序列化(__轨迹查询条件) }
});
__结果.AddRange(HJSON.反序列化 <M轨迹查询结果>(H序列化.AES解压(__返回值)).列表);
});
return(__结果);
}
void do查询_Click(object sender, EventArgs e)
{
var __输入 = this.in号码范围.Text;
List <int> __列表;
try
{
__列表 = H序列化.字符串转单值列表(__输入);
}
catch (Exception)
{
new F对话框_确定("输入错误!").ShowDialog();
return;
}
_F显示号码.设置号码(__列表.Select(q => new M个号 {
号码 = q
}).ToList());
}
public static List <M部门> 获取部门()
{
var __webapi地址 = string.Format("http://{0}/numberbook.k", _号码簿地址);
try
{
var __json = HttpClient.发送请求(__webapi地址, null, "GET", Encoding.UTF8);
File.WriteAllText(H路径.获取绝对路径("部门数据.json", true), __json, Encoding.UTF8);
return(H序列化.FromJSON字符串 <List <M部门> >(__json, false, 50000000) ?? new List <M部门>());
}
catch (Exception ex)
{
H日志.记录提示(string.Format("从webapi {0} 同步失败", __webapi地址), ex.Message);
}
if (!H路径.验证文件是否存在("部门数据.json", true))
{
//File.WriteAllText(H路径.获取绝对路径("部门数据.json", true), HJSON.序列化(H部门测试数据.部门列表), Encoding.UTF8);
return(new List <M部门>());
}
return(H序列化.FromJSON字符串 <List <M部门> >(File.ReadAllText(H路径.获取绝对路径("部门数据.json", true), Encoding.UTF8), false, 20000000) ?? new List <M部门>());
}
void do登录_Click(object sender, EventArgs e)
{
var __ip = this.inIP2.Text;
var __port = this.in端口号.Text;
var __最后访问 = _访问记录.Find(q => q.IP.ToString() == __ip && q.端口号.ToString() == __port);
if (__最后访问 == null)
{
if (!H检测网络.IsHostAlive(__ip, int.Parse(__port), 2000))
{
new F对话框_确定("连接失败").ShowDialog();
return;
}
else
{
__最后访问 = new M访问记录 {
IP = __ip, 端口号 = int.Parse(__port)
};
}
}
else
{
_访问记录.Remove(__最后访问);
}
_访问记录.Insert(0, __最后访问);
H程序配置.设置("访问记录", H序列化.ToJSON字符串(_访问记录));
B入口.已断开 += q => 设置连接状态();
B入口.已连接 += 设置连接状态;
B入口.连接(new IPEndPoint(IPAddress.Parse(__ip), int.Parse(__port)), true);
this.ParentForm.ShowInTaskbar = false;
this.ParentForm.Visible = false;
_窗口 = new F空窗口(new F主窗口(), 获取标题())
{
允许设置 = true,
点击设置 = () => new F空窗口(new F配置(), "配置").ShowDialog()
};
_窗口.ShowDialog();
Application.Exit();
}
static void 存储()
{
H序列化.二进制存储(_所有数据, _文件路径);
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加方法("查询轨迹", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M轨迹查询条件>(__实参列表["条件"]);
var __字符串 = HJSON.序列化(查询轨迹(__条件));
//return __字符串;
return(H序列化.AES压缩(__字符串));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("号码", "string"),
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("页数", "int"),
new M子成员("每页数量", "int"),
}
})
});
__对象.添加方法("查询最后位置", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M最后位置查询条件>(__实参列表["条件"]);
var __字符串 = HJSON.序列化(查询最后位置(__条件));
return(H序列化.AES压缩(__字符串));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("号码列表", "string", E数据结构.单值数组),
new M子成员("页数", "int?"),
new M子成员("每页数量", "int?"),
}
})
});
__对象.添加方法("查询活跃号码", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M活跃号码查询条件>(__实参列表["条件"]);
return(HJSON.序列化(查询活跃号码(__条件)));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("号码列表", "string", E数据结构.单值数组),
}
})
}, new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员> {
new M子成员("总数", "string"), new M子成员("号码列表", "string", E数据结构.单值数组),
}
});
__对象.添加方法("统计活跃号码", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M活跃号码查询条件>(__实参列表["条件"]);
return(HJSON.序列化(统计活跃号码(__条件)));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("号码列表", "string", E数据结构.单值数组),
}
})
}, new M元数据("int"));
__对象.添加方法("统计频率", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M频率统计条件>(__实参列表["条件"]);
return(HJSON.序列化(统计频率(__条件)));
}, E角色.客户, new List <M形参> {
new M形参("条件", new M元数据()
{
结构 = E数据结构.单值, 子成员列表 = new List <M子成员>
{
new M子成员("开始时间", "string"),
new M子成员("结束时间", "string"),
new M子成员("号码列表", "string", E数据结构.单值数组),
}
})
}, new M元数据("float")
{
描述 = "(秒/次)"
});
_IT服务端.添加对象(__对象名称, () => __对象);
}
public void 初始化()
{
var __路径 = Path.Combine(Path.GetDirectoryName(Assembly.GetAssembly(typeof(B插件)).Location), "插件");
if (!Directory.Exists(__路径))
{
H日志.记录错误("插件目录不存在");
return;
}
var __子目录 = Directory.GetDirectories(__路径);
if (__子目录.Length == 0)
{
H日志.记录错误("无任何插件");
return;
}
配置通用访问("插件");
H日志.记录提示("开始加载插件");
var __插件配置 = HJSON.反序列化 <List <M插件配置> >(H程序配置.获取字符串("插件配置"));
Action <string, string> __记录日志 = (__插件名称, __内容) => _IB日志.增加(new DTO.日志.M日志 {
描述 = __内容, 时间 = DateTime.Now, 类别 = __插件名称
});
var __输入插件 = new List <IPluginGPS输入>();
var __输出插件 = new List <IPluginGPS输出>();
for (int i = 0; i < __子目录.Length; i++)
{
var __目录 = new DirectoryInfo(__子目录[i]).Name;
var __入口路径 = Path.Combine(__子目录[i], __目录 + ".dll");
if (!File.Exists(__入口路径))
{
continue;
}
var __输入实例 = H反射.获取实例 <IPluginGPS输入>(__入口路径);
if (__输入实例 != null)
{
__输入插件.Add(__输入实例);
var __启用 = 查询启用(__插件配置, __目录);
_所有插件.Add(new M插件参数
{
描述 = __输入实例.接口描述,
称 = __输入实例.接口名称,
启用 = __启用,
管理界面 = __输入实例.管理界面,
目录 = __目录
});
if (__启用)
{
_输入插件列表.Add(__输入实例);
}
__输入实例.记录日志 = __内容 => __记录日志(__输入实例.接口名称, __内容);
}
var __输出实例 = H反射.获取实例 <IPluginGPS输出>(__入口路径);
if (__输出实例 != null)
{
__输出插件.Add(__输出实例);
var __启用 = 查询启用(__插件配置, __目录);
_所有插件.Add(new M插件参数
{
描述 = __输出实例.接口描述,
称 = __输出实例.接口名称,
启用 = __启用,
管理界面 = __输出实例.管理界面,
目录 = __目录
});
if (__启用)
{
_输出插件列表.Add(__输出实例);
}
__输出实例.记录日志 = __内容 => __记录日志(__输出实例.接口名称, __内容);
}
}
H日志.记录提示("插件状态", H序列化.ToJSON字符串(_所有插件));
_输入插件列表.ForEach(__插件 =>
{
__插件.GPS上报 += (__号码, __GPS) =>
{
if (!_IBGPS过滤.判断合法(__号码, __GPS))
{
return;
}
OnGps上报(__号码, __GPS);
_输出插件列表.ForEach(k =>
{
try
{
k.接收GPS(__号码, __GPS);
}
catch (Exception ex)
{
H调试.记录异常(ex);
}
});
};
});
_输出插件列表.ForEach(q =>
{
q.初始化();
});
_输入插件列表.ForEach(q =>
{
q.初始化();
});
}
