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服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("名称", () => 片.称, E角色.客户);
_对象.添加属性("描述", () => 片.描述, E角色.客户);
_对象.添加属性("版本号", () => 片.版本号, E角色.客户);
_对象.添加属性("版本时间", () => 片.版本时间, E角色.客户);
_对象.添加方法("查询", __实参列表 => HJSON.序列化(片), E角色.客户, null, null);
_对象.添加方法("查询参数", __实参列表 => HJSON.序列化(参数列表), E角色.客户, null, null);
_IT服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("已连接设备", () => HJSON.序列化(_登录缓存.Values.ToList()), E角色.客户, null);
_对象.添加事件("已建立连接", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//IP, 端口号, 设备类型, 设备标识, 账号, 成功, 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
}
}
}
});
_对象.添加事件("已断开连接", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//IP, 端口号, 设备类型, 设备标识, 账号, 成功, 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
}
}
}
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
static void Main()
{
H调试.初始化();
IT服务端 __IT服务端 = FT通用访问工厂.创建服务端();
H容器.注入 <IT服务端>(__IT服务端);
H容器.注入 <IB基本状态, B基本状态>();
H容器.注入 <IB业务, B业务>();
H容器.注入 <IB调试信息, B调试信息>();
var __对象 = new B测试().创建对象();
__IT服务端.添加对象("测试", () => __对象);
__IT服务端.端口 = 8888;
__IT服务端.开启();
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
F主窗口 = new F主窗口();
Application.Run(F主窗口);
}
private void 配置通用访问(string __对象名称)
{
var __对象 = new M对象(__对象名称, null);
__对象.添加属性("启用", () => _MGPS过滤.启用.ToString(), E角色.工程);
__对象.添加属性("省", () => _MGPS过滤.省, E角色.工程);
__对象.添加属性("市", () => _MGPS过滤.市, E角色.工程);
__对象.添加方法("设置", q =>
{
_MGPS过滤.启用 = bool.Parse(q["启用"]);
_MGPS过滤.省 = q["省"];
_MGPS过滤.市 = q["市"];
H程序配置.设置("GPS过滤", HJSON.序列化(_MGPS过滤, false).Replace('"', '\''));
设置区域(_MGPS过滤.省, _MGPS过滤.市);
return(null);
}, E角色.工程, new List <M形参> {
new M形参("启用", "bool"), new M形参("省", "string"), new M形参("市", "string")
});
_IT服务端.添加对象(__对象名称, () => __对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("支持", () => 支持.ToString(), E角色.客户, null);
_对象.添加属性("运行中", () => 运行中.ToString(), E角色.客户, null);
_对象.添加属性("端口号", () => 端口号.ToString(), E角色.客户, null);
_对象.添加属性("目录路径", () => H路径.序目录, E角色.客户, null);
_对象.添加属性("编码", () => "GB2312", E角色.客户, null);
_对象.添加方法("开启", __实参列表 =>
{
开启();
return("");
}, E角色.客户, null, null);
_对象.添加方法("关闭", __实参列表 =>
{
关闭();
return("");
}, E角色.客户, null, null);
_IT服务端.添加对象(_对象名称, () => _对象);
}
public void 配置()
{
INET.H日志输出.设置(q => Console.WriteLine(string.Format("{0}\t{1}\t{2}\n{3}\t{4}({5})\n{6}", q.等级, q.概要, q.详细, q.文件, q.方法, q.行号, q.异常)));
_IT服务端 = FT通用访问工厂.创建服务端();
var __命令行 = new B命令行();
var __命令行对象 = 创建对象(_IT服务端, __命令行);
_IT服务端.添加对象("命令行", () => __命令行对象);
var __进程管理 = new B进程管理();
var __进程管理对象 = 创建对象(_IT服务端, __进程管理);
_IT服务端.添加对象("进程管理", () => __进程管理对象);
var __FTP = new BFTP();
var __FTP对象 = 创建对象(_IT服务端, __FTP);
_IT服务端.添加对象("FTP", () => __FTP对象);
var __链路监控配置 = HJSON.反序列化 <M链路监控配置>(File.ReadAllText(H路径.获取绝对路径("链路监控配置.txt"), Encoding.UTF8));
var __链路监控 = new B链路监控(__链路监控配置);
var __链路监控对象 = 创建对象(_IT服务端, __链路监控);
_IT服务端.添加对象("链路监控", () => __链路监控对象);
var __进程监控配置 = HJSON.反序列化 <M进程监控配置>(File.ReadAllText(H路径.获取绝对路径("进程监控配置.txt"), Encoding.UTF8));
var __进程监控 = new B进程监控(__进程监控配置);
var __进程监控对象 = 创建对象(_IT服务端, __进程监控);
_IT服务端.添加对象("进程监控", () => __进程监控对象);
var __资源监控配置 = HJSON.反序列化 <M资源监控配置>(File.ReadAllText(H路径.获取绝对路径("资源监控配置.txt"), Encoding.UTF8));
var __资源监控 = new B资源监控(__资源监控配置);
var __资源监控对象 = 创建对象(_IT服务端, __资源监控);
_IT服务端.添加对象("资源监控", () => __资源监控对象);
var __业务日志对象 = 创建对象(_IT服务端);
_IT服务端.添加对象("业务日志", () => __业务日志对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("已登录设备", () => HJSON.序列化(_登录缓存.Values.ToList()), E角色.客户, null);
_对象.添加方法("登录", (__实参列表, __地址) =>
{
var __条件 = HJSON.反序列化 <M登录请求>(__实参列表["请求参数"]);
登录(__条件, __地址);
return("");
}, E角色.客户, new List <M形参> {
new M形参 {
称 = "请求参数", 元数据 = new M元数据
{
//设备类型, 设备标识, 账号, 密码
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
new M子成员("密码", "string"),
}
}
}
}, null);
_对象.添加方法("查询登录", (__实参列表, __地址) =>
{
IPAddress __IP = null;
IPAddress.TryParse(__实参列表["IP"], out __IP);
int?__端口号 = null;
if (!string.IsNullOrEmpty(__实参列表["端口号"]))
{
__端口号 = int.Parse(__实参列表["端口号"]);
}
var __结果 = 查询(__IP, __端口号, __实参列表["账号"]);
return(HJSON.序列化(__结果));
}, E角色.客户, new List <M形参> {
new M形参("IP", "string"), new M形参("端口号", new M元数据("int?")
{
描述 = "可为空"
})
}, null);
_对象.添加方法("注销", (__实参列表, __地址) =>
{
注销(__地址);
return("");
}, E角色.客户, null, null);
_对象.添加事件("登录完毕", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//IP, 端口号, 设备类型, 设备标识, 账号, 成功, 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
new M子成员("成功", "string"),
new M子成员("描述", "string"),
}
}
}
});
_对象.添加事件("注销完毕", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("IP", "string"),
new M子成员("端口号", "int"),
new M子成员("设备类型", "string"),
new M子成员("设备标识", "string"),
new M子成员("账号", "string"),
}
}
}
});
_对象.添加方法("修改密码", __实参列表 =>
{
var __旧密码 = __实参列表["旧密码"];
var __新密码 = __实参列表["新密码"];
修改密码(__旧密码, __新密码);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("旧密码", "string"), new M形参("新密码", "string")
});
_对象.添加方法("增加账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
var __密码 = __实参列表["密码"];
var __备注 = __实参列表["备注"];
增加账号(__账号, __密码, __备注);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("账号", "string"), new M形参("密码", "string"), new M形参("备注", "string")
});
_对象.添加方法("删除账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
除账号(__账号);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("账号", "string")
});
_对象.添加方法("修改账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
var __备注 = __实参列表["备注"];
修改账号(__账号, __备注);
return(null);
}, E角色.客户, new List <M形参> {
new M形参("账号", "string"), new M形参("备注", "string")
});
_对象.添加方法("查询账号", (__实参列表, __地址) =>
{
var __当前账号 = 查询账号(__地址);
if (__当前账号 == null || __当前账号.账号 != "admin")
{
throw new ApplicationException("无权限");
}
var __账号 = __实参列表["账号"];
var __备注 = __实参列表["备注"];
return(HJSON.序列化(查询账号(__账号, __备注)));
}, E角色.客户, new List <M形参> {
new M形参("账号", "string"), new M形参("备注", "string")
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
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服务端.添加对象(__对象名称, () => __对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加方法("查询日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M日志文件查询条件>(__实参列表["过滤参数"]);
return(HJSON.序列化(查询日志文件列表(__条件)));
}, E角色.客户, new List <M形参>
{
new M形参
{
称 = "过滤参数",
元数据 = new M元数据
{
结构 = E数据结构.对象,
子成员列表 = new List <M子成员>
{
new M子成员("起始时间", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("结束时间", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
}
}
}
});
_对象.添加方法("删除日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <List <string> >(__实参列表["地址列表"]);
return(HJSON.序列化(除日志文件列表(__条件)));
}, E角色.客户, new List <M形参>
{
new M形参("地址列表", "string", E数据结构.单值数组)
});
_对象.添加方法("导出日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <List <string> >(__实参列表["地址列表"]);
return(HJSON.序列化(导出日志文件列表(__条件)));
}, E角色.客户, new List <M形参>
{
new M形参("地址列表", "string", E数据结构.单值数组)
});
_对象.添加方法("压缩日志文件", __实参列表 =>
{
var __条件 = HJSON.反序列化 <List <string> >(__实参列表["地址列表"]);
string __下载地址;
压缩日志文件列表(__条件, out __下载地址);
return(__下载地址);
}, E角色.客户, new List <M形参>
{
new M形参("地址列表", "string", E数据结构.单值数组)
});
_对象.添加方法("过滤工程日志", 设置工程日志过滤, E角色.客户, new List <M形参>
{
new M形参
{
称 = "过滤参数",
元数据 = new M元数据
{
结构 = E数据结构.对象,
子成员列表 = new List <M子成员>
{
new M子成员("重要性", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("方向", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("对端设备类型", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("对端设备标识", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("业务类型", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("业务标识", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("业务标签", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("关键字", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
}
}
}
});
_对象.添加方法("过滤开发日志", 设置开发日志过滤, E角色.客户, new List <M形参>
{
new M形参
{
称 = "过滤参数",
元数据 = new M元数据
{
结构 = E数据结构.对象,
子成员列表 = new List <M子成员>
{
new M子成员("重要性", new M元数据 {
类型 = "string", 描述 = "可为空"
}),
new M子成员("线程", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("标题", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
new M子成员("内容", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可为空"
}),
}
}
}
});
_对象.添加事件("上报工程日志", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数",
元数据 = new M元数据
{
//时间, 重要性, 方向(输入/输出), 对端设备类型, 对端设备名称, 业务类型, 业务标识, 业务标签[], 描述
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("时间", "string"),
new M子成员("重要性", "string"),
new M子成员("方向", "string"),
new M子成员("对端设备类型", "string"),
new M子成员("对端设备标识", "string"),
new M子成员("业务类型", "string"),
new M子成员("业务标识", "string"),
new M子成员("业务标签", new M元数据 {
类型 = "string", 结构 = E数据结构.单值数组, 描述 = "可选"
}),
new M子成员("描述", "string"),
}
}
}
});
_对象.添加事件("上报开发日志", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//时间, 重要性, 模块, 函数, 线程, 描述, 文件及行号
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("时间", "string"),
new M子成员("重要性", "string"),
new M子成员("线程", "string"),
new M子成员("标题", "string"),
new M子成员("内容", "string"),
}
}
}
});
//_对象.添加事件("日志压缩完毕", E角色.客户, new List<M形参>
//{
// new M形参{ 名称 = "事件参数", 元数据 = new M元数据
// {
// //时间, 重要性, 模块, 函数, 线程, 描述, 文件及行号
// 结构 = E数据结构.行, 子成员列表 = new List<M子成员>
// {
// new M子成员("成功", "bool"),
// new M子成员("描述", "string"),
// new M子成员("相对路径","string"),
// new M子成员("下载地址", "string"),
// }
// }
// }
//});
_IT服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("概要状态", () => HJSON.序列化(查询业务概要(null, null)), E角色.客户, null);
_对象.添加属性("启动时间", () => 启动时间.ToString(), E角色.客户, null);
_对象.添加属性("健康状态", () => 健康状态.ToString(), E角色.客户, null);
_对象.添加属性("状态开始时间", () => 状态开始时间.ToString(), E角色.客户, null);
_对象.添加属性("未清除告警数量", () => _待处理问题.Count.ToString(), E角色.客户, null);
_对象.添加方法("查询概要状态", __实参列表 =>
{
return(HJSON.序列化(查询概要状态()));
}, E角色.客户);
_对象.添加方法("查询业务概要", __实参列表 =>
{
var __类别 = __实参列表["类别"];
var __属性 = __实参列表["属性"];
return(HJSON.序列化(查询业务概要(__类别, __属性)));
}, E角色.客户, new List <M形参> {
new M形参("类别", new M元数据 {
类型 = "string", 描述 = "可为空"
}), new M形参("属性", new M元数据 {
类型 = "string", 描述 = "可为空"
})
}, null);
_对象.添加方法("查询未清除告警", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M查询条件>(__实参列表["条件"]);
return(HJSON.序列化(查询未清除告警(__条件)));
}, E角色.客户, new List <M形参> {
new M形参 {
称 = "条件", 元数据 = new M元数据
{
//每页数量, 页数, 来源设备类型(可选), 来源设备标识(可选), 类别(可选), 重要性(可选), 关键字(可选)
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("每页数量", "int"),
new M子成员("页数", "int"),
new M子成员("来源设备类型", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("来源设备标识", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("类别", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("重要性", new M元数据 {
类型 = "string", 描述 = "可选"
}),
new M子成员("关键字", new M元数据 {
类型 = "string", 描述 = "可选"
}),
}
}
}
}, null);
_对象.添加事件("上报告警", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//标识, 来源设备类型, 来源设备标识, 产生时间, 类别, 重要性, 描述, 原因, 解决方案
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("标识", "string"),
new M子成员("来源设备类型", "string"),
new M子成员("来源设备标识", "string"),
new M子成员("产生时间", "string"),
new M子成员("类别", "string"),
new M子成员("重要性", "string"),
new M子成员("描述", "string"),
new M子成员("原因", "string"),
new M子成员("解决方案", "string"),
}
}
}
});
_对象.添加事件("上报清除", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//标识, 来源设备类型, 来源设备标识
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("标识", "string"),
new M子成员("来源设备类型", "string"),
new M子成员("来源设备标识", "string"),
}
}
}
});
_对象.添加事件("健康状态变化", E角色.客户, new List <M形参>
{
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
//标识, 来源设备类型, 来源设备标识
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("旧状态", "int"),
new M子成员("新状态", "int"),
}
}
}
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("支持发送点名", () => 支持发送点名.ToString(), E角色.客户, null);
_对象.添加属性("支持点名响应", () => 支持点名响应.ToString(), E角色.客户, null);
_对象.添加属性("点名请求地址", () => _请求地址.ToString(), E角色.客户, null);
_对象.添加属性("事件上报地址", () => _响应地址.ToString(), E角色.客户, null);
_对象.添加方法("点名", __实参列表 =>
{
var __条件 = HJSON.反序列化 <M点名条件>(__实参列表["点名条件"]);
点名(__条件);
return("");
}, E角色.客户, new List <M形参> {
new M形参 {
称 = "点名条件", 元数据 = new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("参数列表", new M元数据 {
结构 = E数据结构.对象数组, 子成员列表 = new List <M子成员>
{
new M子成员("名称", "string"),
new M子成员("值", "int"),
}
}),
new M子成员("状态概要", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("健康状态", "string"),
new M子成员("未清除告警数量", "int"),
new M子成员("启动时间", "string"),
new M子成员("状态开始时间", "string"),
}
}),
}
}
}
}, null);
_对象.添加事件("设备事件上报", E角色.客户, new List <M形参> {
new M形参 {
称 = "事件参数", 元数据 = new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("地址", "string"),
new M子成员("类型", "string"),
new M子成员("参数", new M元数据
{
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("参数列表", new M元数据 {
结构 = E数据结构.对象数组, 子成员列表 = new List <M子成员>
{
new M子成员("名称", "string"),
new M子成员("值", "int"),
}
}),
new M子成员("状态概要", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("健康状态", "string"),
new M子成员("未清除告警数量", "int"),
new M子成员("启动时间", "string"),
new M子成员("状态开始时间", "string"),
}
}),
}
}),
}
}
}
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
private void 配置通用访问()
{
var _对象 = new M对象(_对象名称, "通用服务");
_对象.添加属性("支持", () => 支持.ToString(), E角色.客户, null);
_对象.添加属性("默认端口号", () => 默认端口号.ToString(), E角色.客户, null);
_对象.添加方法("请求上传", __实参列表 =>
{
var __版本 = HJSON.反序列化 <M请求上传>(__实参列表["版本"]);
请求上传(__版本);
return(null);
}, E角色.客户, new List <M形参>
{
new M形参("版本", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
new M子成员("版本号", "string"),
new M子成员("标签", "string", E数据结构.单值数组),
new M子成员("文件名", "string"),
new M子成员("补丁", "bool"),
new M子成员("md5校验码", "string"),
new M子成员("大小", new M元数据 {
类型 = "int", 描述 = "单位:KB"
}),
}
})
}, null);
_对象.添加方法("结束上传", __实参列表 =>
{
结束上传();
return(null);
}, E角色.客户);
_对象.添加方法("开始升级", __实参列表 =>
{
var __版本 = __实参列表["版本号"];
开始升级(__版本);
return(null);
}, E角色.客户, new List <M形参>
{
new M形参("版本号", "string")
}, null);
_对象.添加方法("删除版本", __实参列表 =>
{
var __版本 = __实参列表["版本号"];
除版本(__版本);
return(null);
}, E角色.客户, new List <M形参>
{
new M形参("版本号", "string")
}, null);
_对象.添加事件("准备好接收数据", E角色.客户, new List <M形参> {
new M形参("事件参数", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
//端口号，每包最大(单位KB)，每包间隔（毫秒）
new M子成员("端口号", "int"),
new M子成员("每包最大", new M元数据 {
类型 = "int", 描述 = "单位:KB"
}),
new M子成员("每包间隔", new M元数据 {
类型 = "int", 描述 = "单位:毫秒"
}),
}
})
});
_对象.添加事件("升级完成", E角色.客户, new List <M形参> {
new M形参("事件参数", new M元数据 {
结构 = E数据结构.对象, 子成员列表 = new List <M子成员>
{
//成功(true/false), 描述, 需要重启(true/false)
new M子成员("成功", "bool"),
new M子成员("描述", "string"),
new M子成员("需要重启", "bool"),
}
})
});
_IT服务端.添加对象(_对象名称, () => _对象);
}
