using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using Newtonsoft.Json.Linq;
|
|
namespace ZigBee.Device
|
{
|
[System.Serializable]
|
public class Safeguard
|
{
|
/// <summary>
|
/// 当前主网关的ID
|
/// </summary>
|
public string GateWayId;
|
|
/// <summary>
|
/// 网关返回场景的命令标识
|
/// </summary>
|
public int DataID;
|
|
/// <summary>
|
/// 网关反馈的时间戳
|
/// </summary>
|
public int Time;
|
|
/// <summary>
|
/// 等待从网关接收数据的时间
|
/// </summary>
|
/// <value>The wait receive data time.</value>
|
public static int WaitReceiveDataTime
|
{
|
get
|
{
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
return 3000;
|
}
|
else if (mainGateway.IsVirtual)
|
{
|
return 6000;
|
}
|
else
|
{
|
return 3000;
|
}
|
}
|
}
|
|
/// <summary>
|
/// 网关信息错误反馈内容
|
/// </summary>
|
static string ErrorMess(int err)
|
{
|
string message = "";
|
switch (err)
|
{
|
case 1:
|
message = " 网关无法解析命令数据。";
|
break;
|
case 2:
|
message = " 协调器正在升级或备份 / 恢复数据。";
|
break;
|
case 3:
|
message = "操作设备 / 组 / 场景不存在";
|
break;
|
case 4:
|
message = " 其他错误";
|
break;
|
case 5:
|
message = " 数据传输错误（在某次客户端向网关发送数据的过程中，网关在合理时间范围内接收客户端数据不完整导致该错误发生。如客户端向网关一次发送100个字节的数据，但网关等待接收了一秒只接收了80个字节。发生该错误，网关将主动关闭客户端连接）";
|
break;
|
default:
|
break;
|
}
|
return message;
|
}
|
|
#region *管理员密码登陆;
|
///<summary >
|
/// *管理员密码登陆.(仅用于主网关接口）.
|
/// <para>password:管理员密码,初始化密码为“admin”。</para>
|
/// <para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。如果登陆成功，网关将记录该标识，app需要管理员权限的指令都应该带有该标识，网关会根据该标识来判断是否为管理员操作，如果标识错误，将返回“Security/Error_Respon”主题数据。 。</para>
|
/// <para>返回结果Result</para>
|
/// <para>0：登陆成功</para>
|
/// <para>1：密码错误，登陆失败。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<AdminLoginResponAllData> AdminLoginResponAsync(string password, string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AdminLoginResponAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new AdminLoginResponAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new AdminLoginResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new AdminLoginResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new AdminLoginResponAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AdminLogin_Respon")
|
{
|
var tempData = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (tempData == null)
|
{
|
d = new AdminLoginResponAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new AdminLoginResponAllData { Result = tempData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/AdminLogin_Actions 启动" + System.DateTime.Now.ToString());
|
|
try
|
{
|
var bytes = new byte[32];
|
var reamarkGwBytes = System.Text.Encoding.UTF8.GetBytes(password);
|
System.Array.Copy(reamarkGwBytes, 0, bytes, 0, 32 < reamarkGwBytes.Length ? 32 : reamarkGwBytes.Length);
|
password = System.Text.Encoding.UTF8.GetString(bytes);
|
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4001 }
|
};
|
var data = new JObject { { "Password", password }, { "LoginToken", loginToken } };
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/AdminLogin", jObject.ToString());
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new AdminLoginResponAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/AdminLogin_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 管理员密码登陆的数据,网关反馈信息
|
/// </summary>
|
public AdminLoginResponAllData adminLoginResponAllData;
|
/// <summary>
|
/// 管理员密码登陆返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AdminLoginResponAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 返回结果Result
|
/// <para>0：登陆成功</para>
|
/// <para>1：密码错误，登陆失败。</para>
|
/// </summary>
|
public int Result = 999;
|
/// <summary>
|
/// 返回错误结果
|
/// <para>1：网关不是主网关，无法进行该操作。</para>
|
/// <para>2：该操作需要安防管理员权限，需先以管理员身份进行登陆。</para>
|
/// </summary>
|
public int Error;
|
}
|
|
#endregion
|
|
#region 20修改管理员密码.
|
/// <summary>
|
/// 修改管理员密码(仅用于主网关接口）
|
/// </summary>
|
/// <returns>The admin password async.</returns>
|
/// <param name="password">新管理员密码 </param>
|
/// <param name="oldPassword">旧密码/param>
|
public static async System.Threading.Tasks.Task<ChangeAdminPasswordResponseAllData> ChangeAdminPasswordAsync(string oldPassword, string password)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ChangeAdminPasswordResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new ChangeAdminPasswordResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new ChangeAdminPasswordResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new ChangeAdminPasswordResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/ChangeAdminPassword_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var changeAdminPasswordResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ChangeAdminPasswordResponseData>(jobject["Data"].ToString());
|
if (changeAdminPasswordResponseData != null)
|
{
|
d = new ChangeAdminPasswordResponseAllData { changeAdminPasswordResponseData = changeAdminPasswordResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
else
|
{
|
d = new ChangeAdminPasswordResponseAllData { };
|
var r = new ChangeAdminPasswordResponseData();
|
if (result == 1)
|
{
|
r.Result = result;
|
d.errorMessageBase = "修改失败，原密码错误";
|
}
|
if (result == 2)
|
{
|
r.Result = result;
|
d.errorMessageBase = "2：修改失败，密码长度不正确";
|
}
|
d.changeAdminPasswordResponseData = r;
|
System.Console.WriteLine($"UI收到通知后的主题");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/ChangeAdminPassword_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4023}
|
};
|
var data = new JObject
|
{
|
{ "OldPassword", oldPassword },
|
{ "Password", password}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/ChangeAdminPassword", jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new ChangeAdminPasswordResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/ChangeAdminPassword_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 修改管理员密码返回的数据,网关反馈信息
|
/// </summary>
|
public ChangeAdminPasswordResponseAllData changeAdminPasswordResponseAllData;
|
/// <summary>
|
/// 修改管理员密码返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class ChangeAdminPasswordResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 修改管理员密码返回的数据
|
/// </summary>
|
public ChangeAdminPasswordResponseData changeAdminPasswordResponseData;
|
|
}
|
|
|
/// <summary>
|
/// 修改管理员密码返回的数据
|
/// </summary>
|
public ChangeAdminPasswordResponseData changeAdminPasswordResponseData;
|
/// <summary>
|
/// 修改管理员密码返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class ChangeAdminPasswordResponseData
|
{
|
/// <summary>
|
/// 0：修改成功
|
///<para>1：修改失败，原密码错误</para>
|
///<para>2：修改失败，密码长度不正确</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 新密码，最大32个字符。(当Result = 0时存在。)
|
/// </summary>
|
public string NewPassword;
|
|
}
|
#endregion
|
|
#region 16查看延时时间;
|
///<summary >
|
/// 查看延时时间(仅用于主网关接口）
|
/// </summary>
|
public static async System.Threading.Tasks.Task<CatDelayTimeResponseAllData> CatDelayTimeAsync()
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
CatDelayTimeResponseAllData d = null;
|
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new CatDelayTimeResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new CatDelayTimeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new CatDelayTimeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/CatDelayTime_Respon")
|
{
|
var catDelayTimeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<CatDelayTimeResponseData>(jobject["Data"].ToString());
|
if (catDelayTimeResponseData == null)
|
{
|
d = new CatDelayTimeResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new CatDelayTimeResponseAllData { catDelayTimeResponseData = catDelayTimeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/CatDelayTime_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4019}
|
};
|
mainGateway.Send("Security/CatDelayTime", jObject.ToString());
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new CatDelayTimeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/CatDelayTime_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 查看延时时间返回的数据,网关反馈信息
|
/// </summary>
|
public CatDelayTimeResponseAllData catDelayTimeResponseAllData;
|
/// <summary>
|
/// 查看延时时间返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class CatDelayTimeResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 查看延时时间返回的数据
|
/// </summary>
|
public CatDelayTimeResponseData catDelayTimeResponseData;
|
|
}
|
|
/// <summary>
|
/// 查看延时时间返回的数据
|
/// </summary>
|
public CatDelayTimeResponseData catDelayTimeResponseData;
|
/// <summary>
|
/// 查看延时时间返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class CatDelayTimeResponseData
|
{
|
/// <summary>
|
/// 进入延时时间，单位秒 范围：0-65535
|
/// </summary>
|
public int EntranceDelayTime;
|
/// <summary>
|
/// 外出延时时间,单位秒 范围：0-65535
|
/// </summary>
|
public int GoOutDelayTime;
|
|
}
|
#endregion
|
|
#region 17*设置出入防区延时时;
|
///<summary >
|
/// *设置出入防区延时时间（需要管理员权限））
|
/// <para>entranceDelayTime:进入延时时间，单位秒范围：0-65535</para>
|
/// <para>goOutDelayTime:外出延时时间，单位秒范围：0-65535</para>
|
/// <para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。如果登陆成功，网关将记录该标识，app需要管理员权限的指令都应该带有该标识，网关会根据该标识来判断是否为管理员操作，如果标识错误，将返回“Security/Error_Respon”主题数据。 。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SetDelayTimeResponseAllData> SetDelayTimeAsync(int entranceDelayTime, int goOutDelayTime, string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SetDelayTimeResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new SetDelayTimeResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new SetDelayTimeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new SetDelayTimeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var securityTemp = new Safeguard() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), GateWayId = mainGateway.GwId };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new SetDelayTimeResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/SetDelayTime_Respon")
|
{
|
var setDelayTimeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetDelayTimeResponseData>(jobject["Data"].ToString());
|
if (setDelayTimeResponseData == null)
|
{
|
d = new SetDelayTimeResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new SetDelayTimeResponseAllData { setDelayTimeResponseData = setDelayTimeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/SetDelayTime_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4020}
|
};
|
var data = new JObject
|
{
|
{ "EntranceDelayTime", entranceDelayTime},
|
{ "GoOutDelayTime", goOutDelayTime},
|
{ "LoginToken", loginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/SetDelayTime", jObject.ToString());
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new SetDelayTimeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/SetDelayTime_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 设置延时时间返回的数据,网关反馈信息
|
/// </summary>
|
public SetDelayTimeResponseAllData setDelayTimeResponseAllData;
|
/// <summary>
|
/// 设置延时时间返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class SetDelayTimeResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 设置延时时间返回的数据
|
/// </summary>
|
public SetDelayTimeResponseData setDelayTimeResponseData;
|
|
}
|
|
|
/// <summary>
|
/// 设置延时时间返回的数据
|
/// </summary>
|
public SetDelayTimeResponseData setDelayTimeResponseData;
|
/// <summary>
|
/// 设置延时时间返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class SetDelayTimeResponseData
|
{
|
/// <summary>
|
/// 进入延时时间，单位秒 范围：0-65535
|
/// </summary>
|
public int EntranceDelayTime;
|
/// <summary>
|
/// 外出延时时间,单位秒 范围：0-65535
|
/// </summary>
|
public int GoOutDelayTime;
|
|
}
|
#endregion
|
|
#region 21*查看用户密码和胁迫密码.;
|
///<summary >
|
/// *查看用户密码和胁迫密码（需要管理员权限）
|
/// <para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<CatUserPasswordResponseAllData> CatUserPasswordAsync(string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
CatUserPasswordResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new CatUserPasswordResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new CatUserPasswordResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new CatUserPasswordResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new CatUserPasswordResponseAllData { };
|
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/CatUserPassword_Respon")
|
{
|
var catUserPasswordResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<CatUserPasswordResponseData>(jobject["Data"].ToString());
|
if (catUserPasswordResponseData == null)
|
{
|
d = new CatUserPasswordResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new CatUserPasswordResponseAllData { catUserPasswordResponseData = catUserPasswordResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/CatUserPassword_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4024}
|
};
|
var data = new JObject
|
{
|
{ "LoginToken", loginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/CatUserPassword", jObject.ToString());
|
}
|
catch
|
{
|
}
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new CatUserPasswordResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/CatDelayTime_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 查看用户密码和胁迫密码返回的数据,网关反馈信息
|
/// </summary>
|
public CatUserPasswordResponseAllData catUserPasswordResponseAllData;
|
/// <summary>
|
/// 查看用户密码和胁迫密码返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class CatUserPasswordResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 查看用户密码和胁迫密码返回的数据
|
/// </summary>
|
public CatUserPasswordResponseData catUserPasswordResponseData;
|
|
}
|
|
|
/// <summary>
|
/// 查看用户密码和胁迫密码返回的数据
|
/// </summary>
|
public CatUserPasswordResponseData catUserPasswordResponseData;
|
/// <summary>
|
/// 查看用户密码和胁迫密码返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class CatUserPasswordResponseData
|
{
|
/// <summary>
|
/// 用户密码列表
|
/// </summary>
|
public List<UserPasswordListObj> UserPasswordList = new List<UserPasswordListObj>();
|
|
}
|
|
/// <summary>
|
/// 用户密码列表数据
|
/// </summary>
|
[System.Serializable]
|
public class UserPasswordListObj
|
{
|
|
/// <summary>
|
/// 用户id。Id为5时为胁迫密码
|
/// </summary>
|
public int UserId;
|
/// <summary>
|
/// 最少4个字符，最大32个字符
|
/// </summary>
|
public string Password;
|
/// <summary>
|
/// 用户密码提示语
|
/// </summary>
|
public string PassWordTips = string.Empty;
|
}
|
#endregion
|
|
#region 22*新增或重设用户密码.;
|
/// <summary>
|
/// *新增或重设用户密码（需要管理员权限）
|
/// <para>userId:用户id 如果用户id存在，则修改密码。如果用户id不存在，则为该id新增密码
|
/// 为0时，自动分配新的用户id。为5时，则修改胁迫密码。取值范围0-5。</para>
|
/// <para>password:新管理员密码</para>
|
/// <para>passWordTips:密码提示</para>
|
/// <para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SetUserPasswordResponseAllData> SetUserPasswordAsync(int userId, string password, string passWordTips, string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SetUserPasswordResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new SetUserPasswordResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new SetUserPasswordResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new SetUserPasswordResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var securityTemp = new Safeguard() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), GateWayId = mainGateway.GwId };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new SetUserPasswordResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/SetUserPassword_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var setUserPasswordResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetUserPasswordResponseData>(jobject["Data"].ToString());
|
if (setUserPasswordResponseData != null)
|
{
|
d = new SetUserPasswordResponseAllData { setUserPasswordResponseData = setUserPasswordResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
|
}
|
}
|
else
|
{
|
d = new SetUserPasswordResponseAllData { };
|
var r = new SetUserPasswordResponseData();
|
r.Result = result;
|
d.setUserPasswordResponseData = r;
|
System.Console.WriteLine($"失败设置，收到通知后的主题");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/SetUserPassword_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4025}
|
};
|
var data = new JObject
|
{
|
{ "UserId", userId },
|
{ "Password", password},
|
{ "PassWordTips", passWordTips},
|
{ "LoginToken", loginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/SetUserPassword", jObject.ToString());
|
}
|
catch
|
{
|
}
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new SetUserPasswordResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/SetUserPassword_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// *新增或重设用户密码（需要管理员权限）
|
/// <para>userId:用户id 如果用户id存在，则修改密码。如果用户id不存在，则为该id新增密码
|
/// 为0时，自动分配新的用户id。为5时，则修改胁迫密码。取值范围0-5。</para>
|
/// <para>password:新管理员密码</para>
|
/// <para>passWordTips:密码提示</para>
|
/// <para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SetUserPasswordResponseAllData> SetPassWordTipsAsync(int userId, string password, string passWordTips, string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SetUserPasswordResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new SetUserPasswordResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new SetUserPasswordResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new SetUserPasswordResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var securityTemp = new Safeguard() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), GateWayId = mainGateway.GwId };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new SetUserPasswordResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AddPassWordTips_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var setUserPasswordResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetUserPasswordResponseData>(jobject["Data"].ToString());
|
if (setUserPasswordResponseData != null)
|
{
|
d = new SetUserPasswordResponseAllData { setUserPasswordResponseData = setUserPasswordResponseData };
|
}
|
}
|
else
|
{
|
d = new SetUserPasswordResponseAllData { };
|
var r = new SetUserPasswordResponseData();
|
r.Result = result;
|
d.setUserPasswordResponseData = r;
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4037}
|
};
|
var data = new JObject
|
{
|
{ "UserId", userId },
|
{ "Password", password},
|
{ "PassWordTips", passWordTips},
|
{ "LoginToken", loginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/AddPassWordTips", jObject.ToString());
|
}
|
catch
|
{
|
}
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new SetUserPasswordResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 新增或重设用户密码返回的数据,网关反馈信息
|
/// </summary>
|
public SetUserPasswordResponseAllData setUserPasswordResponseAllData;
|
/// <summary>
|
/// 新增或重设用户密码返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class SetUserPasswordResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 修改管理员密码返回的数据
|
/// </summary>
|
public SetUserPasswordResponseData setUserPasswordResponseData;
|
|
}
|
|
|
/// <summary>
|
/// 新增或重设用户密码返回的数据
|
/// </summary>
|
public SetUserPasswordResponseData setUserPasswordResponseData;
|
/// <summary>
|
/// 新增或重设用户密码返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class SetUserPasswordResponseData
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，用户密码数已满（最大4个）</para>
|
///<para>2：失败，密码长度不正确。</para>
|
///<para>3：失败，密码和已存在的用户密码重复，4个用户密码不能相同。</para>
|
/// </summary>
|
public int Result = 999;
|
/// <summary>
|
/// 用户id
|
/// </summary>
|
public int UserId;
|
/// <summary>
|
/// 新密码 ，最大32个字符，至少4个字符。
|
/// </summary>
|
public string password;
|
|
}
|
#endregion
|
|
#region 23*删除用户密码.
|
/// <summary>
|
/// *删除用户密码（需要管理员权限）
|
/// <para>userId:用户id 如果用户id存在，则修改密码。如果用户id不存在，则为该id新增密码
|
/// 为0时，自动分配新的用户id。为5时，则修改胁迫密码。取值范围0-5。</para>
|
/// <para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<DelUserPasswordResponseAllData> DelUserPasswordAsync(int userId, string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
DelUserPasswordResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new DelUserPasswordResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new DelUserPasswordResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new DelUserPasswordResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new DelUserPasswordResponseAllData { };
|
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
if (topic == gatewayID + "/" + "Security/DelUserPassword_Respon")
|
{
|
var delUserPasswordResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<DelUserPasswordResponseData>(jobject["Data"].ToString());
|
if (delUserPasswordResponseData != null)
|
{
|
d = new DelUserPasswordResponseAllData { delUserPasswordResponseData = delUserPasswordResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
|
}
|
else
|
{
|
d = new DelUserPasswordResponseAllData { errorMessageBase = "返回数据为空" };
|
System.Console.WriteLine("返回数据为空");
|
}
|
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/DelUserPassword_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4026}
|
};
|
var data = new JObject
|
{
|
{ "UserId", userId },
|
{ "LoginToken", loginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/DelUserPassword", jObject.ToString());
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new DelUserPasswordResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/DelUserPassword_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 删除用户密码返回的数据,网关反馈信息
|
/// </summary>
|
public DelUserPasswordResponseAllData delUserPasswordResponseAllData;
|
/// <summary>
|
/// 删除用户密码返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class DelUserPasswordResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 删除用户密码返回的数据
|
/// </summary>
|
public DelUserPasswordResponseData delUserPasswordResponseData;
|
|
}
|
|
|
/// <summary>
|
/// 删除用户密码返回的数据
|
/// </summary>
|
public DelUserPasswordResponseData delUserPasswordResponseData;
|
/// <summary>
|
/// 删除用户密码返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class DelUserPasswordResponseData
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1:失败，用户id不存在。</para>
|
/// </summary>
|
public int Result = 999;
|
/// <summary>
|
/// 用户id
|
/// </summary>
|
public int UserId;
|
|
}
|
#endregion
|
|
//#region 新建或修改防区.
|
///// <summary>
|
///// 新建或修改防区。
|
///// </summary>
|
///// <returns>The new zone async.</returns>
|
///// <param name="addNewZoneData">新建或修改防区的数据</param>
|
//public static async System.Threading.Tasks.Task<AddNewZoneDataResponseAllData> AddNewZoneAsync(AddNewZoneData addNewZoneData)
|
//{
|
// return await System.Threading.Tasks.Task.Run(async () =>
|
// {
|
// var d = new AddNewZoneDataResponseAllData { };
|
// if (ZbGateway.MainGateWay == null)
|
// {
|
// d.errorMessageBase = "当前没有主网关";
|
// return d;
|
// }
|
// Action<string, string> action = (topic, message) =>
|
// {
|
// var gatewayID = topic.Split('/')[0];
|
// var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
// if (topic == gatewayID + "/" + "Error_Respon")
|
// {
|
// var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.GwId };
|
// var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
// if (temp == null)
|
// {
|
// d.errorMessageBase = "网关错误回复，且数据是空";
|
// }
|
// else
|
// {
|
// d.errorResponData = temp;
|
// d.errorMessageBase = ErrorMess(temp.Error);
|
// }
|
// }
|
|
// if (topic == gatewayID + "/" + "Security/AddNewZone_Respon")
|
// {
|
// var security = new Safeguard() { DataID = jobject.Value<int>("Data_ID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
// security.addNewZoneDataResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<AddNewZoneDataResponseData>(jobject["Data"].ToString());
|
// if (security.addNewZoneDataResponseData != null)
|
// {
|
// d.addNewZoneDataResponseData = security.addNewZoneDataResponseData;
|
// System.Console.WriteLine($"收到通知后的主题_{ topic}");
|
// }
|
// else
|
// {
|
// d.errorMessageBase = "网关返回的数据为空";
|
// }
|
// }
|
// };
|
// ZbGateway.MainGateWay.Actions += action;
|
// System.Console.WriteLine("Security/AddNewZone_Actions 启动" + System.DateTime.Now.ToString());
|
|
// if (addNewZoneData != null)
|
// {
|
// var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4002 } };
|
// var data = new JObject
|
// {
|
// { "ZoneId", addNewZoneData.ZoneId },
|
// { "ZoneName", addNewZoneData.ZoneName },
|
// { "ZoneType", addNewZoneData.ZoneType },
|
// { "Bypass", addNewZoneData.Bypass },
|
// { "ElasticBypass", addNewZoneData.ElasticBypass }
|
// };
|
// jObject.Add("Data", data);
|
// ZbGateway.MainGateWay?.Send(("Security/AddNewZone"), jObject.ToString());
|
// }
|
|
// var dateTime = DateTime.Now;
|
// while ((DateTime.Now - dateTime).TotalMilliseconds < 1000)
|
// {
|
// await System.Threading.Tasks.Task.Delay(10);
|
// if (d.addNewZoneDataResponseData != null)
|
// {
|
// break;
|
// }
|
// }
|
// if ((DateTime.Now - dateTime).TotalMilliseconds > 10000)
|
// {
|
// d.errorMessageBase = " 回复超时，请重新操作";
|
// }
|
|
// ZbGateway.MainGateWay.Actions -= action;
|
// System.Console.WriteLine("Security/AddNewZone_Actions 退出" + System.DateTime.Now.ToString());
|
|
// return d;
|
// });
|
//}
|
|
///// <summary>
|
///// 新建或修改防区返回的数据 ,网关反馈信息
|
///// </summary>
|
//public AddNewZoneDataResponseAllData addNewZoneDataResponseAllData;
|
///// <summary>
|
///// 新建或修改防区返回的数据,网关反馈信息
|
///// </summary>
|
//[System.Serializable]
|
//public class AddNewZoneDataResponseAllData
|
//{
|
// /// <summary>
|
// /// 错误信息
|
// /// </summary>
|
// public string errorMessageBase;
|
// /// <summary>
|
// /// 网关信息错误反馈
|
// /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
// /// </summary>
|
// public ErrorResponData errorResponData;
|
// /// <summary>
|
// ///新建或修改防区返回的数据
|
// /// </summary>
|
// public AddNewZoneDataResponseData addNewZoneDataResponseData;
|
//}
|
|
///// <summary>
|
///// 新建或修改防区返回的数据
|
///// </summary>
|
//public AddNewZoneDataResponseData addNewZoneDataResponseData;
|
///// <summary>
|
///// 新建或修改防区返回的数据
|
///// </summary>
|
//[System.Serializable]
|
//public class AddNewZoneDataResponseData
|
//{
|
// /// <summary>
|
// /// 返回结果
|
// /// <para>0：添加或修改成功</para>
|
// /// <para>1：失败，防区不存在</para>
|
// /// </summary>
|
// //public int Result = 2;
|
|
// /// <summary>
|
// /// 局部设防列表id
|
// /// </summary>
|
// public int ZoneId;
|
|
// /// <summary>
|
// /// 防区名称 ，最大32个字符(当Result = 0时才存在)
|
// /// </summary>
|
// public string ZoneName;
|
|
// /// <summary>
|
// /// 布防防区类型：(当Result = 0时才存在)
|
// ///<para>当Type=1时，该字段才存在。</para>
|
// ///<para>1：24小时防区。</para>
|
// ///<para>2：24小时静音防区。</para>
|
// ///<para>3：出入防区。</para>
|
// ///<para>4：内部防区。</para>
|
// ///<para>5：跟随防区。</para>
|
// ///<para>6：周界防区。</para>
|
// ///<para>7：周界延时防区。</para>
|
// /// </summary>
|
// public int ZoneType;
|
|
// /// <summary>
|
// /// 是否允许旁路(当Result = 0时才存在)
|
// ///<para>0：不允许旁路</para>
|
// ///<para>1：允许旁路</para>
|
// /// </summary>
|
// public int Bypass;
|
|
// /// <summary>
|
// /// 是否允许弹性旁路：(当Result = 0时才存在)
|
// ///<para>0：不允许弹性旁路</para>
|
// ///<para>1：允许弹性旁路</para>
|
// /// </summary>
|
// public int ElasticBypass;
|
//}
|
|
///// <summary>
|
///// 新建或修改防区的数据
|
///// </summary>
|
//public AddNewZoneData addNewZone;
|
///// <summary>
|
///// 新建或修改防区的数据
|
///// </summary>
|
//[System.Serializable]
|
//public class AddNewZoneData
|
//{
|
// /// <summary>
|
// /// 防区id。
|
// /// <para>0：0：新增防区</para>
|
// /// <para>其他：要修改的防区id</para>
|
// /// </summary>
|
// public int ZoneId;
|
|
// /// <summary>
|
// /// 防区名称 ，最大32个字符
|
// /// </summary>
|
// public string ZoneName;
|
|
// /// <summary>
|
// /// 防区类型:
|
// ///<para>当Type=1时，该字段才存在。</para>
|
// ///<para>1：24小时防区。</para>
|
// ///<para>2：24小时静音防区。</para>
|
// ///<para>3：出入防区。</para>
|
// ///<para>4：内部防区。</para>
|
// ///<para>5：跟随防区。</para>
|
// ///<para>6：周界防区。</para>
|
// ///<para>7：周界延时防区。</para>
|
// ///<para>如果为24小时（静音）类型防区将自动加入24小时布防模式中，并从自定义模式中清除该防区。如果原来是24小时（静音）类型防区修改为非24小时类型，将原防区将自动从24小时布防模式中清除。</para>
|
// /// </summary>
|
// public int ZoneType;
|
|
// /// <summary>
|
// /// 是否允许旁路
|
// ///<para>0：不允许旁路</para>
|
// ///<para>1：允许旁路</para>
|
// ///<para>若类型为24小时防区或24小时静音防区将不允许旁路，该字段将被忽略。</para>
|
// /// </summary>
|
// public int Bypass;
|
|
// /// <summary>
|
// /// 是否允许弹性旁路：
|
// ///<para>0：不允许弹性旁路</para>
|
// ///<para>1：允许弹性旁路</para>
|
// ///<para>若类型为24小时防区或24小时静音防区将不允许弹性旁路，该字段将被忽略。</para>
|
// /// </summary>
|
// public int ElasticBypass;
|
//}
|
//#endregion
|
|
#region 2 *设备加入防区.;
|
/// <summary>
|
/// *设备加入防区（需要管理员权限）
|
/// <para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。如果登陆成功，网关将记录该标识，app需要管理员权限的指令都应该带有该标识，网关会根据该标识来判断是否为管理员操作，如果标识错误，将返回“Security/Error_Respon”主题数据。 。</para>
|
/// </summary>
|
/// <returns>The device to zone async.</returns>
|
/// <param name="addDeviceToZoneData">设备加入防区的数据</param>
|
public static async System.Threading.Tasks.Task<AddDeviceToZoneResponseAllData> AddDeviceToZoneAsync(AddDeviceToZoneData addDeviceToZoneData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AddDeviceToZoneResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new AddDeviceToZoneResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new AddDeviceToZoneResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new AddDeviceToZoneResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var securityTemp = new Safeguard() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), GateWayId = mainGateway.GwId };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new AddDeviceToZoneResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AddEqToZone_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
|
if (result == 0)
|
{
|
var addDeviceToZoneResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<AddDeviceToZoneResponseData>(jobject["Data"].ToString());
|
if (addDeviceToZoneResponseData != null)
|
{
|
d = new AddDeviceToZoneResponseAllData { addDeviceToPartResponseData = addDeviceToZoneResponseData };
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new AddDeviceToZoneResponseAllData { errorMessageBase = "添加失败" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/AddEqToZone_Actions启动_{System.DateTime.Now.ToString()}");
|
try
|
{
|
if (addDeviceToZoneData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4003 } };
|
var deviceList = new JArray { };
|
foreach (var deviceInfo in addDeviceToZoneData.DeviceList)
|
{
|
var dInfo = new JObject{
|
{ "MacAddr", deviceInfo.MacAddr},
|
{ "Epoint",deviceInfo.Epoint},
|
{ "MomentStatus",deviceInfo.MomentStatus},
|
{ "TriggerZoneStatus",deviceInfo.TriggerZoneStatus}
|
};
|
deviceList.Add(dInfo);
|
}
|
var data = new JObject
|
{
|
{ "ZoneId", addDeviceToZoneData.ZoneId },
|
{ "DeviceList", deviceList},
|
{ "LoginToken", addDeviceToZoneData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/AddEqToZone_Actions 启动"), jObject.ToString());
|
}
|
}
|
catch
|
{
|
}
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new AddDeviceToZoneResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/AddEqToZone_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 设备加入防区的返回数据 ,网关反馈信息
|
/// </summary>
|
public AddDeviceToZoneResponseAllData addDeviceToPartResponseAllData;
|
/// <summary>
|
/// 设备加入防区的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AddDeviceToZoneResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 设备加入防区的返回数据
|
/// </summary>
|
public AddDeviceToZoneResponseData addDeviceToPartResponseData;
|
}
|
|
/// <summary>
|
/// 设备加入防区的返回数据
|
/// </summary>
|
public AddDeviceToZoneResponseData addDeviceToZoneResponseData;
|
/// <summary>
|
/// 设备加入防区的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class AddDeviceToZoneResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// <para>1：添加失败。（局部布防列表id不存在）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 防区id
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 安防设备列表(Result=0时存在)
|
/// </summary>
|
public List<DeviceListResponseObj> DeviceList = new List<DeviceListResponseObj>();
|
|
}
|
|
/// <summary>
|
/// 安防设备列表回复的数据
|
/// </summary>
|
[System.Serializable]
|
public class DeviceListResponseObj
|
{
|
/// <summary>
|
/// 0：添加成功
|
///<para>1：失败，设备不存在。</para>
|
///<para>2：失败，设备已经加入了其他防区。</para>
|
/// </summary>
|
public int Status;
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 设备上报的状态是否为瞬间状态，用于配合下面的TriggerZoneStatus值使用。
|
///<pata>0：非瞬间状态，该设备上报的安防状态可持续，直到状态被改变会再次报告安防状态信息。如门磁设备的开状态和关状态（开和关状态是能持续的）。</pata>
|
///<pata>1：表示安防状态为瞬间量，设备警告激活状态才上报安防信息，设备恢复常态不发送通知。如人体红外传感器（当有人时触发警告，但人走了后，不会发送消除警告信息。无法知道人还在不在）</pata>
|
/// </summary>
|
public int MomentStatus;
|
/// <summary>
|
/// <pata>当MomentStatus为0时，安防设备被触发上报安防信息的ZoneStatus值和TriggerZoneStatus进行与运算（&）结果不为0时激活防区警报，为0时解除激活。例如门磁设备，如果有人开门入侵将激活防区报警，可将TriggerZoneStatus设置为17，开门时上报的ZoneStatus值为1，（17 & 1）>0，此时说明有入侵，防区将被激活，发送警告信息到客户端和服务器并执行设定的警戒动作。</pata>
|
/// <pata>当MomentStatus为1时，说明安防设备的激活状态只是瞬间的，只有在上报ZoneStatus值（和TriggerZoneStatus相与不为0时）的瞬间激活，激活后将立即自动恢复为常态。</pata>
|
/// <pata>设置布防时，如果安防设备被触发，防区处于警告状态，要解除激活才能布防成功。如果上面MomentStatus为0，则需要安防设备再次上报的ZoneStatus值和TriggerZoneStatus值进行与运算结果为0才能解除激活状态 。如果MomentStatus为1，则说明设备已经自动恢复常态，布防可以成功。</pata>
|
/// <pata>如门磁设备关门时上报的ZoneStatus值为32，（32&1）=0。则说明门已经关上，防区激活状态将解除，可对防区进行布防。如果MomentStatus为1，则忽略该设备的最近警告状态进行布防。</pata>
|
/// </summary>
|
public int TriggerZoneStatus;
|
}
|
|
/// <summary>
|
/// 新建或修改防区的数据
|
/// </summary>
|
public AddDeviceToZoneData addDeviceToZoneData;
|
/// <summary>
|
/// 设备加入防区的数据
|
/// </summary>
|
[System.Serializable]
|
public class AddDeviceToZoneData
|
{
|
/// <summary>
|
/// 防区id。
|
///<para>1：24小时防区。</para>
|
///<para>2：24小时静音防区。</para>
|
///<para>3：出入防区。</para>
|
///<para>4：内部防区。</para>
|
///<para>5：周界防区。</para>
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 安防设备列表
|
/// </summary>
|
public List<DeviceListObj> DeviceList = new List<DeviceListObj>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
|
}
|
|
/// <summary>
|
/// 安防设备列表数据
|
/// </summary>
|
[System.Serializable]
|
public class DeviceListObj
|
{
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 设备上报的状态是否为瞬间状态，用于配合下面的TriggerZoneStatus值使用。
|
///<pata>0：非瞬间状态，该设备上报的安防状态可持续，直到状态被改变会再次报告安防状态信息。如门磁设备的开状态和关状态（开和关状态是能持续的）。</pata>
|
///<pata>1：表示安防状态为瞬间量，设备警告激活状态才上报安防信息，设备恢复常态不发送通知。如人体红外传感器（当有人时触发警告，但人走了后，不会发送消除警告信息。无法知道人还在不在）</pata>
|
/// </summary>
|
public int MomentStatus;
|
/// <summary>
|
///
|
/// <pata>当MomentStatus为0时，安防设备被触发上报安防信息的ZoneStatus值和TriggerZoneStatus进行与运算（&）结果不为0时激活防区警报，为0时解除激活。例如门磁设备，如果有人开门入侵将激活防区报警，可将TriggerZoneStatus设置为17，开门时上报的ZoneStatus值为1，（17 & 1）>0，此时说明有入侵，防区将被激活，发送警告信息到客户端和服务器并执行设定的警戒动作。</pata>
|
/// <pata>当MomentStatus为1时，说明安防设备的激活状态只是瞬间的，只有在上报ZoneStatus值（和TriggerZoneStatus相与不为0时）的瞬间激活，激活后将立即自动恢复为常态。</pata>
|
/// <pata>设置布防时，如果安防设备被触发，防区处于警告状态，要解除激活才能布防成功。如果上面MomentStatus为0，则需要安防设备再次上报的ZoneStatus值和TriggerZoneStatus值进行与运算结果为0才能解除激活状态 。如果MomentStatus为1，则说明设备已经自动恢复常态，布防可以成功。</pata>
|
/// <pata>如门磁设备关门时上报的ZoneStatus值为32，（32&1）=0。则说明门已经关上，防区激活状态将解除，可对防区进行布防。如果MomentStatus为1，则忽略该设备的最近警告状态进行布防。</pata>
|
/// </summary>
|
public int TriggerZoneStatus;
|
}
|
#endregion
|
|
#region 3 *新建或修改布防模式;
|
/// <summary>
|
/// *新建或修改布防模（需要管理员权限）.
|
/// </summary>
|
/// <returns>The new mode async.</returns>
|
/// <param name="addNewModeData">新建或修改布防模式的数据.</param>
|
public static async System.Threading.Tasks.Task<AddNewModeResponseAllData> AddNewModeAsync(AddNewModeData addNewModeData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AddNewModeResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new AddNewModeResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new AddNewModeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new AddNewModeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var securityTemp = new Safeguard() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), GateWayId = mainGateway.GwId };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
d = new AddNewModeResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AddNewMode_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
|
if (result == 0)
|
{
|
var addNewModeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<AddNewModeResponseData>(jobject["Data"].ToString());
|
if (addNewModeResponseData != null)
|
{
|
d = new AddNewModeResponseAllData { addNewModeResponseData = addNewModeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
}
|
}
|
else
|
{
|
d = new AddNewModeResponseAllData { errorMessageBase = "新建或修改模式失败" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/AddNewMode_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
if (addNewModeData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4004 } };
|
var data = new JObject
|
{
|
{ "ModeId", addNewModeData.ModeId },
|
{ "ModeName", addNewModeData.ModeName },
|
{ "AllowDisable", addNewModeData.AllowDisable },
|
{ "LoginToken", addNewModeData.LoginToken }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/AddNewMode"), jObject.ToString());
|
}
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new AddNewModeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/AddNewMode_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 新建或修改防区返回的数据 ,网关反馈信息
|
/// </summary>
|
public AddNewModeResponseAllData addNewModeResponseAllData;
|
/// <summary>
|
/// 新建或修改布防模式返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AddNewModeResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
///新建或修改布防模式返回的数据
|
/// </summary>
|
public AddNewModeResponseData addNewModeResponseData;
|
}
|
|
/// <summary>
|
/// 新建或修改布防模式返回的数据
|
/// </summary>
|
public AddNewModeResponseData addNewModeResponseData;
|
/// <summary>
|
/// 新建或修改布防模式返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class AddNewModeResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// 0：成功，修改或新增成功
|
///<para>1：失败，修改的布防模式不存在</para>
|
///<para>2：失败，24小时布防模式不允许修改。（当修改ModeId为255时，将返回该错误）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 布防模式ID
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 布防模式名称 ，最大32个字符。
|
/// </summary>
|
public string ModeName;
|
|
/// <summary>
|
/// 允许失能。
|
///<para>0：不允许失能。</para>
|
///<para>1：允许失能</para>
|
/// </summary>
|
public int AllowDisable;
|
}
|
|
/// <summary>
|
/// 新建或修改布防模式的数据
|
/// </summary>
|
public AddNewModeData addNewModeData;
|
/// <summary>
|
/// 新建或修改布防模式的数据
|
/// </summary>
|
[System.Serializable]
|
public class AddNewModeData
|
{
|
/// <summary>
|
/// 要修改的布防模式ID。
|
///<para>如果为0，则为新增布防模式。</para>
|
///<para>系统内置了两种布防模式，分别为在家布防（ModeId为1）、离家布防（ModeId为2）。两种内置模式不可删除。</para>
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 布防模式名称 ，最大32个字符。
|
///<para>不需要修改可忽略该字段。</para>
|
/// </summary>
|
public string ModeName;
|
|
/// <summary>
|
/// 允许失能。
|
///<para>0：不允许失能。</para>
|
///<para>1：允许失能</para>
|
///<para>如果不需要修改可忽略该字段。新增布防时，默认为0。 </para>
|
/// </summary>
|
public int AllowDisable;
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
}
|
#endregion
|
|
#region 4 *防区加入布防模式.
|
/// <summary>
|
/// *防区加入布防模式（需要管理员权限）.
|
/// </summary>
|
/// <returns>The join mode async.</returns>
|
/// <param name="zoneJoinModeData">防区加入布防模式的数据</param>
|
public static async System.Threading.Tasks.Task<ZoneJoinModeResponseAllData> ZoneJoinModeAsync(ZoneJoinModeData zoneJoinModeData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ZoneJoinModeResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new ZoneJoinModeResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new ZoneJoinModeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new ZoneJoinModeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
d = new ZoneJoinModeResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/ZoneJoinMode_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
var modeId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["ModeId"].ToString());
|
if (result == 0)
|
{
|
var zoneJoinModeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ZoneJoinModeResponseData>(jobject["Data"].ToString());
|
if (zoneJoinModeResponseData != null)
|
{
|
d = new ZoneJoinModeResponseAllData { zoneJoinModeResponseData = zoneJoinModeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
}
|
}
|
else
|
{
|
d = new ZoneJoinModeResponseAllData { };
|
var r = new ZoneJoinModeResponseData();
|
r.Result = result;
|
r.ModeId = modeId;
|
d.zoneJoinModeResponseData = r;
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/ZoneJoinMode_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
if (zoneJoinModeData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4005 } };
|
var zoneList = new JArray { };
|
foreach (var a in zoneJoinModeData.ZoneList)
|
{
|
var dInfo = new JObject{
|
{ "ZoneId", a.ZoneId}
|
};
|
zoneList.Add(dInfo);
|
}
|
var data = new JObject
|
{
|
{ "ModeId", zoneJoinModeData.ModeId },
|
{ "ZoneList", zoneList },
|
{ "LoginToken", zoneJoinModeData.LoginToken }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/ZoneJoinMode"), jObject.ToString());
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new ZoneJoinModeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/ZoneJoinMode_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 防区加入布防模式返回的数据 ,网关反馈信息
|
/// </summary>
|
public ZoneJoinModeResponseAllData zoneJoinModeResponseAllData;
|
/// <summary>
|
/// 防区加入布防模式返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class ZoneJoinModeResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
///防区加入布防模式返回的数据
|
/// </summary>
|
public ZoneJoinModeResponseData zoneJoinModeResponseData;
|
}
|
|
/// <summary>
|
/// 防区加入布防模式返回的数据
|
/// </summary>
|
public ZoneJoinModeResponseData zoneJoinModeResponseData;
|
/// <summary>
|
/// 防区加入布防模式返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class ZoneJoinModeResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// <para>1：失败，防区ID不存在。</para>
|
/// <para>2：24小时布防模式，不允许主动加入防区。（当ModeId设置为255时，将返回该错误）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 布防模式ID
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 防区列表(当Result = 0时存在。)
|
/// </summary>
|
public List<ZoneListResponseObj> ZoneList = new List<ZoneListResponseObj>();
|
|
}
|
/// <summary>
|
/// 防区列表
|
/// </summary>
|
[System.Serializable]
|
public class ZoneListResponseObj
|
{
|
/// <summary>
|
/// 返回结果0：加入成功
|
///<para>1：失败，防区不存在</para>
|
///<para>2：失败，防区已在模式中存在</para>
|
///<para>3：失败，防区为24小时（静音）防区类型。</para>
|
/// </summary>
|
public int Status = 999;
|
/// <summary>
|
/// 防区ID
|
/// </summary>
|
public int ZoneId;
|
|
}
|
|
/// <summary>
|
/// 防区加入布防模式的数据
|
/// </summary>
|
public ZoneJoinModeData zoneJoinModeData;
|
/// <summary>
|
/// 防区加入布防模式的数据
|
/// </summary>
|
[System.Serializable]
|
public class ZoneJoinModeData
|
{
|
/// <summary>
|
/// 布防模式ID。
|
/// </summary>
|
public int ModeId;
|
/// <summary>
|
/// 防区列表
|
/// <para>不包括24小时防区、和24小时静音防区。24小时防区和24小时静音防区是脱离布防模式不受布撤防影响的运行，不加入任何一种模式。</para>
|
/// </summary>
|
public List<ZoneListObj> ZoneList = new List<ZoneListObj>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
|
}
|
|
/// <summary>
|
/// 防区列表
|
/// </summary>
|
[System.Serializable]
|
public class ZoneListObj
|
{
|
/// <summary>
|
/// 防区ID
|
/// </summary>
|
public int ZoneId;
|
|
}
|
#endregion
|
|
#region 5 *从布防模式中移除防区.
|
/// <summary>
|
/// *从布防模式中移除防区（需要管理员权限）.
|
/// </summary>
|
/// <returns>removeZoneFromModeData:从布防模式中移除防区的数据</returns>
|
/// <param name="removeZoneFromModeData">Remove zone from mode data.</param>
|
public static async System.Threading.Tasks.Task<RemoveZoneFromModeResponseAllData> RemoveZoneFromModeAsync(RemoveZoneFromModeData removeZoneFromModeData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
RemoveZoneFromModeResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new RemoveZoneFromModeResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new RemoveZoneFromModeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new RemoveZoneFromModeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
d = new RemoveZoneFromModeResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/RemoveZoneFromMode_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
var modeId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["ModeId"].ToString());
|
|
if (result == 0)
|
{
|
var removeZoneFromModeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<RemoveZoneFromModeResponseData>(jobject["Data"].ToString());
|
if (removeZoneFromModeResponseData != null)
|
{
|
d = new RemoveZoneFromModeResponseAllData { removeZoneFromModeResponseData = removeZoneFromModeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
}
|
}
|
else
|
{
|
d = new RemoveZoneFromModeResponseAllData { };
|
var r = new RemoveZoneFromModeResponseData();
|
r.ModeId = modeId;
|
r.Result = result;
|
System.Console.WriteLine($"UI收到通知后的主题_{ topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/RemoveZoneFromMode_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
if (removeZoneFromModeData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4006 } };
|
var zoneList = new JArray { };
|
foreach (var a in removeZoneFromModeData.ZoneList)
|
{
|
var dInfo = new JObject{
|
{ "ZoneId", a.ZoneId}
|
};
|
zoneList.Add(dInfo);
|
}
|
var data = new JObject
|
{
|
{ "ModeId", removeZoneFromModeData.ModeId },
|
{ "ZoneList", zoneList },
|
{ "LoginToken", removeZoneFromModeData.LoginToken }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/RemoveZoneFromMode"), jObject.ToString());
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new RemoveZoneFromModeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/RemoveZoneFromMode_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 从布防模式中移除防区返回的数据 ,网关反馈信息
|
/// </summary>
|
public RemoveZoneFromModeResponseAllData removeZoneFromModeResponseAllData;
|
/// <summary>
|
/// 从布防模式中移除防区返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveZoneFromModeResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
///从布防模式中移除防区返回的数据
|
/// </summary>
|
public RemoveZoneFromModeResponseData removeZoneFromModeResponseData;
|
}
|
|
/// <summary>
|
/// 从布防模式中移除防区返回的数据
|
/// </summary>
|
public RemoveZoneFromModeResponseData removeZoneFromModeResponseData;
|
/// <summary>
|
/// 从布防模式中移除防区返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveZoneFromModeResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// <para>1：失败，防区ID不存在。</para>
|
/// <para>2：24小时布防模式，不允许主动加入防区。（当ModeId设置为255时，将返回该错误）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 布防模式ID
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 防区列表(当Result = 0时存在。)
|
/// </summary>
|
public List<RemoveZoneListResponseObj> ZoneList = new List<RemoveZoneListResponseObj>();
|
|
}
|
|
/// <summary>
|
/// 防区列表
|
/// </summary>
|
[System.Serializable]
|
public class RemoveZoneListResponseObj
|
{
|
/// <summary>
|
/// 返回结果0：移除成功
|
///<para>1：移除失败</para>
|
/// </summary>
|
public int Status;
|
/// <summary>
|
/// 防区ID
|
/// </summary>
|
public int ZoneId;
|
|
}
|
|
/// <summary>
|
/// 从布防模式中移除防区
|
/// </summary>
|
public RemoveZoneFromModeData removeZoneFromModeData;
|
/// <summary>
|
/// 从布防模式中移除防区
|
/// </summary>
|
[System.Serializable]
|
public class RemoveZoneFromModeData
|
{
|
/// <summary>
|
/// 布防模式ID。
|
/// </summary>
|
public int ModeId;
|
/// <summary>
|
/// 防区列表
|
/// <para>不包括24小时防区、和24小时静音防区。24小时防区和24小时静音防区是脱离布防模式不受布撤防影响的运行，不加入任何一种模式。</para>
|
/// </summary>
|
public List<ZoneListObj> ZoneList = new List<ZoneListObj>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
}
|
#endregion
|
|
#region 6 *添加模式指示动作;
|
/// <summary>
|
/// *安防模式触发动作添加（需要管理员权限）.
|
/// </summary>
|
/// <returns>The scene all info async.</returns>
|
/// <param name="addModeActonData">安防模式触发动作添加的数据.</param>
|
public static async System.Threading.Tasks.Task<AddModeActonResponAllData> AddModeActonAsync(AddModeActionData addModeActonData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AddModeActonResponAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new AddModeActonResponAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
var dateTime = DateTime.Now;
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new AddModeActonResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new AddModeActonResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
d = new AddModeActonResponAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AddModeActon_Respon")
|
{
|
dateTime = DateTime.Now;
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
var modeId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["ModeId"].ToString());
|
var actionType = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["ActionType"].ToString());
|
|
if (result == 0)
|
{
|
var addModeActonResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<AddModeActonResponData>(jobject["Data"].ToString());
|
if (addModeActonResponData != null)
|
{
|
d = new AddModeActonResponAllData { addModeActonResponData = addModeActonResponData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
else
|
{
|
d = new AddModeActonResponAllData { };
|
var r = new AddModeActonResponData();
|
r.Result = result;
|
r.ModeId = modeId;
|
r.ActionType = actionType;
|
d.addModeActonResponData = r;
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/AddModeActon_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
if (addModeActonData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4007 } };
|
var acList = new JArray { };
|
foreach (var act in addModeActonData.Actions)
|
{
|
if (act.Type == 0)
|
{
|
var taskList = new JArray { };
|
foreach (var taskInfo in act.TaskList)
|
{
|
var tInfo = new JObject{
|
{ "TaskType", taskInfo.TaskType},
|
{ "Data1", taskInfo.Data1},
|
{ "Data2",taskInfo.Data2}
|
};
|
taskList.Add(tInfo);
|
}
|
|
var a = new JObject {
|
{ "Type",act.Type},
|
{ "DeviceAddr", act.DeviceAddr} ,
|
{ "Epoint",act.Epoint} ,
|
{ "TaskList", taskList}
|
};
|
acList.Add(a);
|
}
|
else if (act.Type == 1)
|
{
|
var b = new JObject {
|
{ "Type",act.Type},
|
{ "ScenesId", act.ScenesId}
|
};
|
acList.Add(b);
|
}
|
}
|
var data = new JObject {
|
{ "ModeId",addModeActonData.ModeId},
|
{ "ActionType", addModeActonData.ActionType} ,
|
{ "Actions", acList},
|
{ "LoginToken", addModeActonData.LoginToken}
|
};
|
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/AddModeActon"), jObject.ToString());
|
}
|
}
|
catch { }
|
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/AddModeActon_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
/// <summary>
|
/// 安防模式触发动作添加的返回数据数据,网关反馈信息
|
/// </summary>
|
public AddModeActonResponAllData addModeActonResponAllData;
|
/// <summary>
|
/// 安防模式触发动作添加的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AddModeActonResponAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 安防模式触发动作添加的数据
|
/// </summary>
|
public AddModeActonResponData addModeActonResponData;
|
}
|
|
/// <summary>
|
/// 安防模式触发动作添加的回复数据
|
/// </summary>
|
public AddModeActonResponData addModeActonResponData;
|
/// <summary>
|
/// 安防模式触发动作添加的回复数据
|
/// </summary>
|
[System.Serializable]
|
public class AddModeActonResponData
|
{
|
/// <summary>
|
/// 0：默认
|
///<para>1：失败，模式不存在。</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 要修改的布防模式ID。
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 1：布防成功指示动作
|
///<para>2：布防失败指示动作</para>
|
///<para>3：撤防成功指示动作</para>
|
///<para>4：撤防失败指示动作</para>
|
///<para>5：延时防区、周界延时防区被触发进入延时指示动作。如果延时过后还没撤防将触发模式安防动作。</para>
|
///<para>6：模式安防动作，安防被最终激活后的报警动作（如延时防区被触发延时过后还没撤防、周界防区被触发、出入防区没触发却触发了内部防区等情况将执行该动作）。</para>
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 布防成功指示动作。
|
///<para>如果不需要修改或新增时候可忽略该字段。</para>
|
/// </summary>
|
public List<ActionsResponseData> Actions = new List<ActionsResponseData>();
|
}
|
/// <summary>
|
/// 布防成功指示动作数据
|
/// </summary>
|
public class ActionsResponseData
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>0：成功</para>
|
///<para>1：失败，设备或场景不存在</para>
|
/// </summary>
|
public int Status = 999;
|
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 动作参数列表。（当Type=0和Status = 0时存在）
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo>();
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 设备或场景名称，Status = 0时存在
|
/// </summary>
|
public string ESName;
|
|
}
|
/// <summary>
|
/// 安防模式触发动作添加的数据
|
/// </summary>
|
public AddModeActionData addModeActionData;
|
/// <summary>
|
/// 安防模式触发动作添加的数据
|
/// </summary>
|
[System.Serializable]
|
public class AddModeActionData
|
{
|
/// <summary>
|
/// 要修改的布防模式ID。
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 1：布防成功指示动作
|
///<para>2：布防失败指示动作</para>
|
///<para>3：撤防成功指示动作</para>
|
///<para>4：撤防失败指示动作</para>
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 布防成功指示动作。
|
///<para>如果不需要修改或新增时候可忽略该字段。</para>
|
/// </summary>
|
public List<ActionsData> Actions = new List<ActionsData>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
}
|
/// <summary>
|
/// 布防成功指示动作数据
|
/// </summary>
|
public class ActionsData
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public int Type = 999;
|
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 动作参数列表。当Type=0时存在
|
///<para>同一个设备最多可设置8个动作。</para>
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo>();
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
|
}
|
/// <summary>
|
/// 任务列表中的数据
|
/// </summary>
|
[System.Serializable]
|
public class TaskListInfo
|
{
|
/// <summary>
|
/// 任务类型。
|
///<para>1：开关 （设备具有开关功能时可用）</para>
|
///<para>3：亮度调整（设备具有亮度调节功能时可用）</para>
|
///<para>4：颜色调整 （设备具有颜色调节功能时可用）</para>
|
///<para>5：恒温器（设备具有恒温器功能时可用）</para>
|
///<para>6: 窗帘设备（设备具有窗帘功能时可用）</para>
|
///<para>7：设备identify识别。</para>
|
///<para>8：开关报警模式 </para>
|
///<para>9：squawk command</para>
|
///</summary>
|
public int TaskType;
|
/// <summary>
|
/// Data1取值
|
/// <para>开关 :Data1（数值）: 0关/1开</para>
|
///<para>亮度调整 Data1（数值）：亮度值</para>
|
///<para>颜色调整 Data1（数值）:色调</para>
|
/// <para>恒温器 Data1（数值）: 0加热/1制冷/2自动调节/3 设置工作模式/4 设置加热度数 5/设置制冷度数 6/设置风扇模式</para>
|
/// <para>窗帘设备 Data1（数值）: 0 打开/ 1关闭/ 2 停止转动/ 4 调整到指定高度/ 5 调整到指定的百分比处位置 / 7 调整到指定倾斜角/ 8 调整到指定的百分比倾斜度</para>
|
/// <para>设备identify识别。Data1为identify闪烁闪烁时间（0-65535秒）。</para>
|
/// <para>开关报警模式 Data1（数值，4字节整型）第1字节（bit0-bit7）表示报警模式，字节值0：停止蜂鸣器1：盗窃报警 2：火灾报警 3：紧急情况报警 4：警车发出的报警 5：消防车发出的报警 6：备用的报警。第2字节（bit8-bit15）表示是否启用报警灯，字节值 0：不启用 1：启用。第3字节（bit16-bit23）表示报警音量，字节值0：Low，1：Medium，2：high，3：very high。</para>
|
/// <para>squawk command Data1（数值，4字节整型）第1字节（bit0-bit7）表示报警模式，字节值0：安防系统“布防”音效” ，1：安防系统“撤防”音效。第2字节（bit8-bit15）表示是否启动报警灯，字节值0：不启动，1：启动。第3字节（bit16-bit23）表示报警音量，字节值0：Low ，1：Medium ，2：high ，3: very high。</para>
|
/// </summary>
|
public int Data1;
|
/// <summary>
|
/// Data2取值
|
/// <para>开关 Data2（数值）: 0</para>
|
/// <para>亮度调整 Data2（数值）: 0</para>
|
/// <para>颜色调整 Data2（数值）：饱和度 </para>
|
///<para> 恒温器Data2数值如下：
|
/// 【当Data1=0|1|2时，Data2为要变化的度数，单位：0.1℃ 。】
|
///【若Data1=3，Data2为要设定的空调模式（0-9），0：off，1：auto，3：cool， 4：heat ，5：emergency heating, 6：precooling，7：fan only ，8：dry，9：sleep。】
|
///【若Data1=4|5，Data2为加热或制冷度数，单位0.01摄氏度。】
|
///【若Data1=6，Data2为要设定的风扇模式（0-6），0：off，1：low，2：medium，3：high，4：on，5：auto，6：smart】 </para>
|
///<para>窗帘设备，Data2数值如下
|
///【当Data1=4或7，Data2为调整的高度或倾斜角度 倾斜角度单位为0.1°】。
|
///【当Data1=5 或 8，Data2为百分比，0-100表示0%-100%】</para>
|
///<para>设备identify识别。Data2（数值）: 0 </para>
|
///<para>开关报警模式 Data2（数值，4字节整型）第1、2字节（bit0-bit15）表示报警时长，字节值 0-65535，单位：秒。第3字节（bit16-bit23）表示闪烁占空比，字节值0-100。第4字节（bit16-bit23）表示报警灯亮度，字节值0：Low ，1：Medium ，2：high ，3: very high。</para>
|
///<para>squawk command：Data2（数值）: 0 </para>
|
/// </summary>
|
/// <value>The type of the task.</value>
|
public int Data2;
|
|
}
|
#endregion
|
|
#region 7 *将动作从布防模式中移除.
|
/// <summary>
|
/// *将动作从布防模式中移除（需要管理员权限）.
|
/// </summary>
|
/// <returns>The acton from mode async.</returns>
|
/// <param name="removeActonFromModeData"> 将动作从布防模式中移除的数据</param>
|
public static async System.Threading.Tasks.Task<RemoveActionFromModeAllData> RemoveActionFromModeAsync(RemoveActonFromModeData removeActonFromModeData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
RemoveActionFromModeAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new RemoveActionFromModeAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new RemoveActionFromModeAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new RemoveActionFromModeAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
d = new RemoveActionFromModeAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/RemoveActonFromMode_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var removeActonFromModeResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<RemoveActionFromModeResponData>(jobject["Data"].ToString());
|
if (removeActonFromModeResponData != null)
|
{
|
d = new RemoveActionFromModeAllData { removeActonFromModeResponData = removeActonFromModeResponData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
else
|
{
|
d = new RemoveActionFromModeAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/RemoveActonFromMode_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
if (removeActonFromModeData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4008 } };
|
var acList = new JArray { };
|
foreach (var act in removeActonFromModeData.Actions)
|
{
|
if (act.Type == 0)
|
{
|
var a = new JObject {
|
{ "Type",act.Type},
|
{ "DeviceAddr", act.DeviceAddr} ,
|
{ "Epoint",act.Epoint}
|
};
|
acList.Add(a);
|
}
|
else if (act.Type == 1)
|
{
|
var b = new JObject {
|
{ "Type",act.Type},
|
{ "ScenesId", act.ScenesId}
|
};
|
acList.Add(b);
|
}
|
}
|
var data = new JObject {
|
{ "ModeId",removeActonFromModeData.ModeId},
|
{ "ActionType", removeActonFromModeData.ActionType} ,
|
{ "Actions", acList},
|
{ "LoginToken", removeActonFromModeData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/RemoveActonFromMode"), jObject.ToString());
|
}
|
}
|
catch
|
{
|
|
}
|
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new RemoveActionFromModeAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/RemoveActonFromMode_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
/// <summary>
|
/// 将动作从布防模式中移除的数据,网关反馈信息
|
/// </summary>
|
public RemoveActionFromModeAllData removeActonFromModeAllData;
|
/// <summary>
|
/// 将动作从布防模式中移除的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveActionFromModeAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 将动作从布防模式中移除的回复数据
|
/// </summary>
|
public RemoveActionFromModeResponData removeActonFromModeResponData;
|
}
|
|
/// <summary>
|
/// 将动作从布防模式中移除的回复数据
|
/// </summary>
|
public RemoveActionFromModeResponData removeActonFromModeResponData;
|
/// <summary>
|
/// 将动作从布防模式中移除的回复数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveActionFromModeResponData
|
{
|
/// <summary>
|
/// 0：默认
|
///<para>1：失败，模式不存在。</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 模式id
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 1：布防成功指示动作
|
///<para>2：布防失败指示动作</para>
|
///<para>3：撤防成功指示动作</para>
|
///<para>4：撤防失败指示动作</para>
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 动作列表
|
/// </summary>
|
public List<RemoveActionsResponData> Actions = new List<RemoveActionsResponData>();
|
}
|
/// <summary>
|
/// 布防成功指示动作数据
|
/// </summary>
|
public class RemoveActionsResponData
|
{
|
/// <summary>
|
///<para>0：成功</para>
|
///<para>1：失败，设备或场景不存在</para>
|
/// </summary>
|
public int Status = 999;
|
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：场景</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
}
|
/// <summary>
|
/// 将动作从布防模式中移除的数据
|
/// </summary>
|
public RemoveActonFromModeData removeActonFromModeData;
|
/// <summary>
|
/// 将动作从布防模式中移除的数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveActonFromModeData
|
{
|
/// <summary>
|
/// 要修改的布防模式ID。
|
/// <para>如果为0，则为新增布防模式。</para>
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 1：布防成功指示动作
|
///<para>2：布防失败指示动作</para>
|
///<para>3：撤防成功指示动作</para>
|
///<para>4：撤防失败指示动作</para>
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 动作列表
|
/// </summary>
|
public List<RemoveActionsData> Actions = new List<RemoveActionsData>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
}
|
/// <summary>
|
/// 动作列表的数据
|
/// </summary>
|
public class RemoveActionsData
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public int Type = 999;
|
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
|
}
|
|
#endregion
|
|
#region 8 获取布防(安防）模式列表.;
|
///<summary >
|
/// 获取布防模式列表.(仅用于主网关接口）
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetModeListAllData> GetModeListAsync()
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetModeListAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new GetModeListAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new GetModeListAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new GetModeListAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/GetModeList_Repon")
|
{
|
var getModeListData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetModeListData>(jobject["Data"].ToString());
|
if (getModeListData == null)
|
{
|
d = new GetModeListAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new GetModeListAllData { getModeListData = getModeListData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/GetModeList_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4009 }
|
};
|
mainGateway.Send("Security/GetModeList", jObject.ToString());
|
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new GetModeListAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/GetModeList_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 获取布防模式列表返回的数据,网关反馈信息
|
/// </summary>
|
public GetModeListAllData getModeListAllData;
|
/// <summary>
|
/// 获取布防模式列表返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class GetModeListAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 获取布防模式列表返回的数据
|
/// </summary>
|
public GetModeListData getModeListData;
|
|
}
|
|
/// <summary>
|
/// 获取布防模式列表返回的数据
|
/// </summary>
|
public GetModeListData getModeListData;
|
/// <summary>
|
/// 获取布防模式列表返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class GetModeListData
|
{
|
/// <summary>
|
/// 布防模式总数
|
/// </summary>
|
public int ModeSum;
|
|
/// <summary>
|
/// 动作列表
|
/// </summary>
|
public List<ModeListData> ModeList = new List<ModeListData>();
|
}
|
/// <summary>
|
/// 布防模式列表数据
|
/// </summary>
|
public class ModeListData
|
{
|
/// <summary>
|
///布防模式ID
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 布防模式名称 ，最大32个字符
|
/// </summary>
|
public string ModeName;
|
|
/// <summary>
|
/// 允许失能。
|
///<para>0：不允许失能。</para>
|
///<para>1：允许失能</para>
|
/// </summary>
|
public string AllowDisable;
|
|
/// <summary>
|
/// 模式当前布撤防状态
|
///<para>0：撤防</para>
|
///<para>1：布防</para>
|
///<para>2：使能一次</para>
|
///<para>3：失能一次</para>
|
/// </summary>
|
public int Setting;
|
}
|
#endregion
|
|
#region 9 通过布防模式ID查看模式信息.
|
///<summary >
|
/// 通过布防模式ID查看模式信息.(仅用于主网关接口）
|
/// <para>modeId:布防模式id</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetModeInfoByIdResponAllData> GetModeInfoByIdAsync(int modeId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetModeInfoByIdResponAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new GetModeInfoByIdResponAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new GetModeInfoByIdResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new GetModeInfoByIdResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
if (topic == gatewayID + "/" + "Security/GetModeInfoById_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var getModeInfoByIdResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetModeInfoByIdResponData>(jobject["Data"].ToString());
|
if (getModeInfoByIdResponData != null)
|
{
|
d = new GetModeInfoByIdResponAllData { getModeInfoByIdResponData = getModeInfoByIdResponData };
|
}
|
System.Console.WriteLine("已收到通知返回");
|
}
|
else
|
{
|
d = new GetModeInfoByIdResponAllData { };
|
var r = new GetModeInfoByIdResponData();
|
r.Result = result;
|
d.getModeInfoByIdResponData = r;
|
System.Console.WriteLine("已收到通知返回");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/GetModeInfoById_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4010 }
|
};
|
var data = new JObject { { "ModeId", modeId } };
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/GetModeInfoById", jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new GetModeInfoByIdResponAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/GetModeInfoById_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 通过布防模式ID查看模式信息的数据,网关反馈信息
|
/// </summary>
|
public GetModeInfoByIdResponAllData getModeInfoByIdResponAllData;
|
/// <summary>
|
/// 通过布防模式ID查看模式信息的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class GetModeInfoByIdResponAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 通过布防模式ID查看模式信息返回的数据
|
/// </summary>
|
public GetModeInfoByIdResponData getModeInfoByIdResponData;
|
}
|
|
/// <summary>
|
/// 通过布防模式ID查看模式信息返回的数据
|
/// </summary>
|
public GetModeInfoByIdResponData getModeInfoByIdResponData;
|
/// <summary>
|
/// 通过布防模式ID查看模式信息返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class GetModeInfoByIdResponData
|
{
|
/// <summary>
|
/// 0：默认
|
///<para>1：失败，布防模式不存在</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 布防模式ID
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 布防模式名称 ，最大32个字符
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public string ModeName;
|
|
/// <summary>
|
/// 允许失能。
|
///<para>0：不允许失能。</para>
|
///<para>1：允许失能</para>
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public int AllowDisable = 100;
|
|
/// <summary>
|
/// 模式当前布撤防状态
|
///<para>0：撤防</para>
|
///<para>1：布防</para>
|
///<para>2：使能一次</para>
|
///<para>3：失能一次</para>
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public int Setting = 100;
|
|
/// <summary>
|
/// 加入模式的防区数量
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public int ZoneNum;
|
|
/// <summary>
|
/// 加入成功的防区列表，不包括24小时防区、和24小时静音防区。24小时防区和24小时静音防区是脱离布防模式不受布撤防影响的运行，加入任何一种模式。
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public List<ZoneListData> ZoneList = new List<ZoneListData>();
|
|
/// <summary>
|
/// 布防成功指示动作。
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public List<ActionsInfo> ProtectionSucceedActions = new List<ActionsInfo>();
|
/// <summary>
|
/// 布防失败指示动作。
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public List<ActionsInfo> ProtectionFailActions = new List<ActionsInfo>();
|
|
/// <summary>
|
/// 撤防成功指示动作。
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public List<ActionsInfo> WithdrawSucceedActions = new List<ActionsInfo>();
|
/// <summary>
|
/// 撤防失败指示动作。
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public List<ActionsInfo> WithdrawFailActions = new List<ActionsInfo>();
|
|
}
|
|
/// <summary>
|
/// 加入成功的防区列表的数据
|
/// </summary>
|
[System.Serializable]
|
public class ZoneListData
|
{
|
/// <summary>
|
/// 防区ID
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 防区名称
|
/// </summary>
|
public string ZoneName;
|
|
}
|
|
/// <summary>
|
/// 布防成功指示动作数据
|
/// </summary>
|
public class ActionsInfo
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public int Type = 999;
|
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 动作参数列表。当Type=0时存在
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo>();
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 设备或场景名称
|
/// </summary>
|
public string ESName;
|
}
|
#endregion
|
|
#region 10查看当前正在使用的布防模.
|
///<summary >
|
/// 查看当前正在使用的布防模式.(仅用于主网关接口）
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetModeUsingResponseAllData> GetModeUsingAsync()
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetModeUsingResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new GetModeUsingResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new GetModeUsingResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new GetModeUsingResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/GetModeUsing_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var getModeInfoByIdResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetModeUsingResponseData>(jobject["Data"].ToString());
|
if (getModeInfoByIdResponData != null)
|
{
|
d = new GetModeUsingResponseAllData { getModeUsingResponseData = getModeInfoByIdResponData };
|
}
|
System.Console.WriteLine("已收到正确的通知返回");
|
}
|
else
|
{
|
d = new GetModeUsingResponseAllData { };
|
var r = new GetModeUsingResponseData();
|
r.Result = result;
|
d.getModeUsingResponseData = r;
|
System.Console.WriteLine("已收到通知返回");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/GetModeUsing_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4011}
|
};
|
mainGateway.Send("Security/GetModeUsing", jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new GetModeUsingResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/GetModeUsing_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 查看当前正在使用的布防模式返回的数据,网关反馈信息
|
/// </summary>
|
public GetModeUsingResponseAllData getModeUsingResponseAllData;
|
/// <summary>
|
/// 查看当前正在使用的布防模式返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class GetModeUsingResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 查看当前正在使用的布防模式返回的数据
|
/// </summary>
|
public GetModeUsingResponseData getModeUsingResponseData;
|
|
}
|
|
|
/// <summary>
|
/// 查看当前正在使用的布防模式返回的数据
|
/// </summary>
|
public GetModeUsingResponseData getModeUsingResponseData;
|
/// <summary>
|
/// 查看当前正在使用的布防模式返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class GetModeUsingResponseData
|
{
|
/// <summary>
|
/// 0：默认
|
/// <para>1：系统当前没有进行布防</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 启用的布防模式id
|
/// </summary>
|
public int ModeId;
|
/// <summary>
|
/// 模式名称(Result =0时存在)
|
/// </summary>
|
public string ModeName;
|
/// <summary>
|
/// 设置 (Result = 0时存在)
|
/// <para>1：永久布防，直到撤防</para>
|
/// <para>2：使能一次，触发一次后将撤防。</para>
|
/// <para>3：失能一次，第一次被激活不警告不触发动作。</para>
|
/// </summary>
|
public int Setting;
|
|
}
|
#endregion
|
|
#region 11布防 ;
|
///<summary >
|
/// 布防 (仅用于主网关接口）
|
/// <para>EnableModeData:布防的数据</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<EnableModeResponAllData> EnableModeAsync(EnableModeData enableModeData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
EnableModeResponAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new EnableModeResponAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new EnableModeResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new EnableModeResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
if (topic == gatewayID + "/" + "Security/EnableMode_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
var modeId = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["ModeId"].ToString());
|
var enableModeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<EnableModeResponseData>(jobject["Data"].ToString());
|
if (enableModeResponseData == null)
|
{
|
d = new EnableModeResponAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new EnableModeResponAllData { enableModeResponseData = enableModeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/EnableMode_Actions 启动" + System.DateTime.Now.ToString());
|
|
try
|
{
|
if (enableModeData != null)
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4012 }
|
};
|
|
var data = new JObject
|
{
|
{ "Setting", enableModeData.Setting },
|
{ "ModeId", enableModeData .ModeId},
|
{ "CheckIASStatus", enableModeData.CheckIASStatus},
|
{ "UserPassword", enableModeData .UserPassword }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/EnableMode", jObject.ToString());
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new EnableModeResponAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/EnableMode_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 布防返回的数据,,网关反馈信息
|
/// </summary>
|
public EnableModeResponAllData enableModeResponAllData;
|
/// <summary>
|
/// 布防返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class EnableModeResponAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 布防返回的数据
|
/// </summary>
|
public EnableModeResponseData enableModeResponseData;
|
}
|
|
/// <summary>
|
/// 布防返回的数据
|
/// </summary>
|
public EnableModeResponseData enableModeResponseData;
|
/// <summary>
|
/// 布防返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class EnableModeResponseData
|
{
|
/// <summary>
|
/// 0：设置成功
|
///<para>1：设置失败，布防模式不存在</para>
|
///<para>2：设置失败，用户密码错误。</para>
|
///<para>3：布防失败，安防设备未就绪。</para>
|
///<para>4：布防失败，有其他布防模式正在启用（只能使用一种布防模式，需将正在启用的布防模式撤防才能布防新模式）。</para>
|
///<para>5：失败，模式属性不允许失能（如果新建布防模式时，AllowDisable设置为0，则布防Setting值不能为2或3，否则将报告该错误）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 启用的布防模式id
|
/// </summary>
|
public int ModeId;
|
/// <summary>
|
/// 模式名称(Result =0时存在)
|
/// </summary>
|
public string ModeName;
|
/// <summary>
|
/// 设置
|
/// <para>1：永久布防，直到撤防</para>
|
/// <para>2：使能一次，触发一次后将撤防。</para>
|
/// <para>3：失能一次，第一次被激活不警告不触发动作。</para>
|
/// </summary>
|
public int Setting;
|
|
/// <summary>
|
///当前正在启用的布防模式ID（当Result = 4时存在。）
|
/// </summary>
|
public int ModeIdBeUsing;
|
|
/// <summary>
|
///未就绪设备的mac地址（当Result =3时存在）
|
/// </summary>
|
public string IASMac;
|
|
/// <summary>
|
///未就绪设备的端口号（当Result = 3时存在。）
|
/// </summary>
|
public int IASEpoint;
|
|
/// <summary>
|
///未就绪设备名称（当Result = 3时存在）
|
/// </summary>
|
public string IASName;
|
|
/// <summary>
|
///设备最近一次上报的安防状态值（当Result=3时存在）
|
/// </summary>
|
public int IASStatus;
|
/// <summary>
|
///未就绪设备所在防区（当Result=3时存在）
|
/// </summary>
|
public int ZoneId;
|
/// <summary>
|
///未就绪设备所在防区（当Result=3时存在当Result = 3时存在）
|
/// </summary>
|
public string ZoneName;
|
}
|
|
/// <summary>
|
/// 布防
|
/// </summary>
|
public EnableModeData enableModeData;
|
/// <summary>
|
/// 布防
|
/// </summary>
|
[System.Serializable]
|
public class EnableModeData
|
{
|
/// <summary>
|
/// 1；永久布防，直到撤防
|
///<para>2：使能一次，触发一次后将撤防。</para>
|
///<para>3：失能一次，第一次被激活不警告不触发动作。</para>
|
/// </summary>
|
public int Setting;
|
|
/// <summary>
|
/// 启用的布防模式id
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
///检查防区设备最近上报的安防信息状态进行布防。
|
///<para>0：不检查</para>
|
///<para>1：检查</para>
|
/// </summary>
|
public int CheckIASStatus;
|
|
/// <summary>
|
///用户密码，最大32个字符
|
/// </summary>
|
public string UserPassword;
|
}
|
|
#endregion
|
|
#region 12撤防.;
|
///<summary >
|
/// 撤防.(仅用于主网关接口）
|
/// </summary>
|
public static async System.Threading.Tasks.Task<WithdrawModeResponseAllData> WithdrawModeAsync(string userPassword)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
WithdrawModeResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new WithdrawModeResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new WithdrawModeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new WithdrawModeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/WithdrawMode_Respon")
|
{
|
var withdrawModeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<WithdrawModeResponseData>(jobject["Data"].ToString());
|
if (withdrawModeResponseData == null)
|
{
|
d = new WithdrawModeResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new WithdrawModeResponseAllData { withdrawModeResponseData = withdrawModeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/WithdrawMode_Actions 启动" + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4013}
|
};
|
var data = new JObject
|
{
|
{ "UserPassword", userPassword}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/WithdrawMode", jObject.ToString());
|
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new WithdrawModeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/WithdrawMode_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 撤防返回的数据,网关反馈信息
|
/// </summary>
|
public WithdrawModeResponseAllData withdrawModeResponseAllData;
|
/// <summary>
|
/// 撤防返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class WithdrawModeResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 撤防返回的数据
|
/// </summary>
|
public WithdrawModeResponseData withdrawModeResponseData;
|
|
}
|
|
/// <summary>
|
/// 撤防返回的数据
|
/// </summary>
|
public WithdrawModeResponseData withdrawModeResponseData;
|
/// <summary>
|
/// 撤防返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class WithdrawModeResponseData
|
{
|
/// <summary>
|
/// 0：撤防成功。
|
///<para>1：失败，当前不存在布防。</para>
|
///<para>2：撤防失败，密码错误。</para>
|
///<para>3：撤防失败，模式不可撤防。（新建模式时，模式属性设为不可撤防则布防后将不能撤防）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 被撤防的模式
|
/// </summary>
|
public int ModeId;
|
/// <summary>
|
/// 被撤防的模式名称
|
/// </summary>
|
public string ModeName;
|
/// <summary>
|
/// 撤防所用的密码类型：
|
///<para>0：用户密码</para>
|
///<para>1：胁迫密码</para>
|
/// </summary>
|
public int PasswordType;
|
|
}
|
#endregion
|
|
#region 13删除布防模式.
|
///<summary >
|
/// 删除布防模式（需要管理员权限）.
|
/// </summary>
|
public static async System.Threading.Tasks.Task<RemoveModeResponseAllData> RemoveModeAsync(int modeId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
RemoveModeResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new RemoveModeResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new RemoveModeResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new RemoveModeResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new RemoveModeResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/RemoveMode_Respon")
|
{
|
var removeModeResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<RemoveModeResponseData>(jobject["Data"].ToString());
|
if (removeModeResponseData == null)
|
{
|
d = new RemoveModeResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
}
|
else
|
{
|
d = new RemoveModeResponseAllData { removeModeResponseData = removeModeResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/RemoveMode_Actions 启动" + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4014}
|
};
|
var data = new JObject
|
{
|
{ "ModeId", modeId}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/RemoveMode", jObject.ToString());
|
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new RemoveModeResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/RemoveMode_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 删除布防模式返回的数据,网关反馈信息
|
/// </summary>
|
public RemoveModeResponseAllData removeModeResponseAllData;
|
/// <summary>
|
/// 删除布防模式返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveModeResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 删除布防模式返回的数据
|
/// </summary>
|
public RemoveModeResponseData removeModeResponseData;
|
|
}
|
|
|
/// <summary>
|
/// 删除布防模式返回的数据
|
/// </summary>
|
public RemoveModeResponseData removeModeResponseData;
|
/// <summary>
|
/// 删除布防模式返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveModeResponseData
|
{
|
/// <summary>
|
/// 0：删除成功。
|
///<para>1：失败，不存在该布防模式。</para>
|
///<para>2：删除失败，不允许删除。（当ModeId为1或2时，离家布防和在家布防模式不允许删除）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 模式id
|
/// </summary>
|
public int ModeId;
|
/// <summary>
|
/// 模式名 (当Result=0时存在)。
|
/// </summary>
|
public string ModeName;
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
|
}
|
#endregion
|
|
#region *14将设备从防区中移除.
|
/// <summary>
|
/// *将设备从防区中移除（需要管理员权限）.
|
/// </summary>
|
/// <returns>The device to zone async.</returns>
|
/// <param name="removeEqToZoneData">将设备从防区中移除的数据.</param>
|
public static async System.Threading.Tasks.Task<RemoveDeviceToZoneAllData> RemoveDeviceToZoneAsync(RemoveEqToZoneData removeEqToZoneData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
RemoveDeviceToZoneAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new RemoveDeviceToZoneAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new RemoveDeviceToZoneAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new RemoveDeviceToZoneAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
d = new RemoveDeviceToZoneAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/RemoveEqToZone_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var removeDeviceToZoneResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<RemoveDeviceToZoneResponseData>(jobject["Data"].ToString());
|
if (removeDeviceToZoneResponseData != null)
|
{
|
d = new RemoveDeviceToZoneAllData { removeDeviceToZoneResponseData = removeDeviceToZoneResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
else
|
{
|
d = new RemoveDeviceToZoneAllData { };
|
var r = new RemoveDeviceToZoneResponseData();
|
r.Result = result;
|
d.removeDeviceToZoneResponseData = r;
|
System.Console.WriteLine("已收到通知返回");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/RemoveEqToZone_Actions启动_{System.DateTime.Now.ToString()}");
|
|
try
|
{
|
if (removeEqToZoneData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4016 } };
|
var deviceList = new JArray { };
|
foreach (var deviceInfo in removeEqToZoneData.RemoveDeviceList)
|
{
|
var dInfo = new JObject{
|
{ "MacAddr", deviceInfo.MacAddr},
|
{ "Epoint",deviceInfo.Epoint}
|
};
|
deviceList.Add(dInfo);
|
}
|
var data = new JObject
|
{
|
{ "ZoneId", removeEqToZoneData.ZoneId },
|
{ "RemoveDeviceList", deviceList},
|
{ "LoginToken", removeEqToZoneData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/RemoveEqToZone_Actions 启动"), jObject.ToString());
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new RemoveDeviceToZoneAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/RemoveEqToZone_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 将设备从防区中移除的返回数据 ,网关反馈信息
|
/// </summary>
|
public RemoveDeviceToZoneAllData removeDeviceToZoneAllData;
|
/// <summary>
|
/// 将设备从防区中移除的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class RemoveDeviceToZoneAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 将设备从防区中移除的返回数据
|
/// </summary>
|
public RemoveDeviceToZoneResponseData removeDeviceToZoneResponseData;
|
}
|
|
/// <summary>
|
/// 将设备从防区中移除的返回数据
|
/// </summary>
|
public RemoveDeviceToZoneResponseData removeDeviceToZoneResponseData;
|
/// <summary>
|
/// 将设备从防区中移除的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveDeviceToZoneResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// <para>1：添加失败。（局部布防列表id不存在）</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 安防设备列表(Result=0时存在)
|
/// </summary>
|
public List<RemoveDeviceListResponseObj> RemoveDeviceList = new List<RemoveDeviceListResponseObj>();
|
|
}
|
|
/// <summary>
|
/// 将设备从防区中移除的数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveDeviceListResponseObj
|
{
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 设备被移除状态
|
/// </summary>
|
public int Status;
|
}
|
|
/// <summary>
|
/// 将设备从防区中移除的数据
|
/// </summary>
|
public RemoveEqToZoneData removeEqToZoneData;
|
/// <summary>
|
/// 将设备从防区中移除的数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveEqToZoneData
|
{
|
/// <summary>
|
/// 局部设防列表id
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 安防设备列表
|
/// </summary>
|
public List<RemoveDeviceListObj> RemoveDeviceList = new List<RemoveDeviceListObj>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
}
|
|
/// <summary>
|
/// 将设备从防区中移除的数据
|
/// </summary>
|
[System.Serializable]
|
public class RemoveDeviceListObj
|
{
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
}
|
#endregion
|
|
//#region 获取防区信息.
|
/////<summary >
|
///// 获取防区信息.(仅用于主网关接口）
|
///// </summary>
|
//public static async System.Threading.Tasks.Task<GetZoneInfoResponAllData> GetZoneInfoAsync()
|
//{
|
// return await System.Threading.Tasks.Task.Run(async () =>
|
// {
|
// var d = new GetZoneInfoResponAllData { };
|
// if (ZbGateway.MainGateWay == null)
|
// {
|
// d.errorMessageBase = "当前没有主网关";
|
// return d;
|
// }
|
|
// Action<string, string> action = (topic, message) =>
|
// {
|
// var gatewayID = topic.Split('/')[0];
|
// var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
// if (topic == gatewayID + "/" + "Error_Respon")
|
// {
|
// var gatewayTemp = new ZbGateway() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), CurrentGateWayId = ZbGateway.MainGateWay.GwId };
|
// var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
// if (temp == null)
|
// {
|
// d.errorMessageBase = "网关错误回复，且数据是空";
|
// }
|
// else
|
// {
|
// d.errorResponData = temp;
|
// d.errorMessageBase = ErrorMess(temp.Error);
|
// }
|
// }
|
|
// if (topic == gatewayID + "/" + "Security/GetZoneInfo_Respon")
|
// {
|
// var security = new Safeguard() { DataID = jobject.Value<int>("Data_ID"), GateWayId = ZbGateway.MainGateWay.CurrentGateWayId };
|
// security.getZoneInfoResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetZoneInfoResponData>(jobject["Data"].ToString());
|
// if (security.getZoneInfoResponData == null)
|
// {
|
// d.errorMessageBase = "网关返回的数据为空";
|
// }
|
// else
|
// {
|
// d.getZoneInfoResponData = security.getZoneInfoResponData;
|
// System.Console.WriteLine($"收到通知后的主题_{topic}");
|
// }
|
// }
|
// };
|
// ZbGateway.MainGateWay.Actions += action;
|
// System.Console.WriteLine("Security/GetZoneInfo_Actions 启动" + System.DateTime.Now.ToString());
|
|
// var jObject = new Newtonsoft.Json.Linq.JObject() {
|
// { "Cluster_ID", 0 },
|
// { "Command", 4017 }
|
// };
|
// ZbGateway.MainGateWay?.Send("Security/GetZoneInfo", jObject.ToString());
|
|
// var dateTime = DateTime.Now;
|
// while ((DateTime.Now - dateTime).TotalMilliseconds < 1000)
|
// {
|
// await System.Threading.Tasks.Task.Delay(10);
|
// if (d.getZoneInfoResponData != null)
|
// {
|
// break;
|
// }
|
// }
|
// if ((DateTime.Now - dateTime).TotalMilliseconds > 10000)
|
// {
|
// d.errorMessageBase = " 回复超时，请重新操作";
|
// }
|
// ZbGateway.MainGateWay.Actions -= action;
|
// System.Console.WriteLine("Security/GetZoneInfo_Actions 退出" + System.DateTime.Now.ToString());
|
|
// return d;
|
// });
|
//}
|
|
///// <summary>
|
///// 获取防区信息返回的数据,网关反馈信息
|
///// </summary>
|
//public GetZoneInfoResponAllData getZoneInfoResponAllData;
|
///// <summary>
|
///// 获取防区信息返回的数据,网关反馈信息
|
///// </summary>
|
//[System.Serializable]
|
//public class GetZoneInfoResponAllData
|
//{
|
// /// <summary>
|
// /// 错误信息
|
// /// </summary>
|
// public string errorMessageBase;
|
// /// <summary>
|
// /// 网关信息错误反馈
|
// /// <para>当网关接收到客户端信息后，出现以下异常情况将反馈错误。</para>
|
// /// </summary>
|
// public ErrorResponData errorResponData;
|
// /// <summary>
|
// /// 获取防区信息返回的数据
|
// /// </summary>
|
// public GetZoneInfoResponData getZoneInfoResponData;
|
|
//}
|
|
///// <summary>
|
///// 获取防区信息返回的数据
|
///// </summary>
|
//public GetZoneInfoResponData getZoneInfoResponData;
|
///// <summary>
|
///// 获取防区信息返回的数据
|
///// </summary>
|
//[System.Serializable]
|
//public class GetZoneInfoResponData
|
//{
|
// /// <summary>
|
// /// 防区总数
|
// /// </summary>
|
// public int ZoneNum;
|
|
// /// <summary>
|
// /// 防区信息列表
|
// /// </summary>
|
// public List<ZoneInfoListData> ZoneList = new List<ZoneInfoListData>();
|
//}
|
///// <summary>
|
///// 防区信息列表数据
|
///// </summary>
|
//public class ZoneInfoListData
|
//{
|
// /// <summary>
|
// ///局部设防列表id
|
// /// </summary>
|
// public int ZoneId;
|
|
// /// <summary>
|
// /// 布防防区名称 ，最大32个字符
|
// /// </summary>
|
// public string ZoneName;
|
|
// /// <summary>
|
// /// 防区类型:
|
// ///<para>1：24小时防区。</para>
|
// ///<para>2：24小时静音防区。</para>
|
// ///<para>3：出入防区。</para>
|
// ///<para>4：内部防区。</para>
|
// ///<para>5：跟随防区。</para>
|
// ///<para>6：周界防区。</para>
|
// ///<para>7：周界延时防区。</para>
|
// /// </summary>
|
// public int ZoneType;
|
|
// /// <summary>
|
// /// 是否允许旁路
|
// ///<para>0：不允许旁路</para>
|
// ///<para>1：允许旁路</para>
|
// ///<para>若类型为24小时防区或24小时静音防区将不允许旁路，该字段将被忽略。</para>
|
// /// </summary>
|
// public int Bypass;
|
|
// /// <summary>
|
// /// 是否允许弹性旁路：
|
// ///<para>0：不允许弹性旁路</para>
|
// ///<para>1：允许弹性旁路</para>
|
// ///<para>若类型为24小时防区或24小时静音防区将不允许弹性旁路，该字段将被忽略。</para>
|
// /// </summary>
|
// public int ElasticBypass;
|
//}
|
//#endregion
|
|
#region 15通过防区ID查看防区设备列表.；
|
///<summary >
|
/// 通过防区ID查看防区设备列表.(仅用于主网关接口）
|
/// <para>zoneId:布防模式id</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<GetZoneDeviceListByIdResponAllData> getZoneDeviceListByIdAsync(int zoneId)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
GetZoneDeviceListByIdResponAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new GetZoneDeviceListByIdResponAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new GetZoneDeviceListByIdResponAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new GetZoneDeviceListByIdResponAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
if (topic == gatewayID + "/" + "Security/GetZoneDeviceListById_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var getZoneDeviceListByIdResponData = Newtonsoft.Json.JsonConvert.DeserializeObject<GetZoneDeviceListByIdResponData>(jobject["Data"].ToString());
|
if (getZoneDeviceListByIdResponData != null)
|
{
|
d = new GetZoneDeviceListByIdResponAllData { getZoneDeviceListByIdResponData = getZoneDeviceListByIdResponData };
|
}
|
System.Console.WriteLine($"UI已收到通知的主题_{topic}");
|
}
|
else
|
{
|
d = new GetZoneDeviceListByIdResponAllData { };
|
var r = new GetZoneDeviceListByIdResponData();
|
r.Result = result;
|
d.getZoneDeviceListByIdResponData = r;
|
System.Console.WriteLine("已收到通知返回");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/GetZoneDeviceListById_Actions 启动" + System.DateTime.Now.ToString());
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4018 }
|
};
|
var data = new JObject { { "ZoneId", zoneId } };
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/GetZoneDeviceListById", jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new GetZoneDeviceListByIdResponAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/GetZoneDeviceListById_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 通过防区ID查看防区设备列表的数据,网关反馈信息
|
/// </summary>
|
public GetZoneDeviceListByIdResponAllData getZoneDeviceListByIdResponAllData;
|
/// <summary>
|
/// 通过布防模式ID查看模式信息的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class GetZoneDeviceListByIdResponAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 通过布防模式ID查看模式信息返回的数据
|
/// </summary>
|
public GetZoneDeviceListByIdResponData getZoneDeviceListByIdResponData;
|
}
|
|
/// <summary>
|
/// 通过防区ID查看防区设备列表返回的数据
|
/// </summary>
|
public GetZoneDeviceListByIdResponData getZoneDeviceListByIdResponData;
|
/// <summary>
|
/// 通过防区ID查看防区设备列表返回的数据
|
/// </summary>
|
[System.Serializable]
|
public class GetZoneDeviceListByIdResponData
|
{
|
/// <summary>
|
/// 0：默认
|
///<para>1：失败，布防模式不存在</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 防区id
|
///<para>1：24小时防区。</para>
|
///<para>2：24小时静音防区。</para>
|
///<para>3：出入防区。</para>
|
///<para>4：内部防区。</para>
|
///<para>5：周界防区。v
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 防区名称 ，最大32个字符
|
/// </summary>
|
public string ZoneName;
|
|
/// <summary>
|
/// 是否禁用信息推送：
|
///<para>0：不禁用</para>
|
///<para>1：禁用</para>
|
///<para>当防区的信息推送被禁用时，防区被触发时不会发送18小节的”防区被触发是报告”的主题信息。</para>
|
/// </summary>
|
public int IsDisablePushMessage = 0;
|
|
/// <summary>
|
/// 安防设备列表
|
///<para> (Result=0时值有效)</para>
|
/// </summary>
|
public List<ZoneDeviceListData> DeviceList = new List<ZoneDeviceListData>();
|
|
}
|
|
/// <summary>
|
/// 通过防区ID查看防区设备列表的数据
|
/// </summary>
|
[System.Serializable]
|
public class ZoneDeviceListData
|
{
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 设备上报的状态是否为瞬间状态，用于配合下面的TriggerZoneStatus值使用。
|
///<pata>0：非瞬间状态，该设备上报的安防状态可持续，直到状态被改变会再次报告安防状态信息。如门磁设备的开状态和关状态（开和关状态是能持续的）。</pata>
|
///<pata>1：表示安防状态为瞬间量，设备警告激活状态才上报安防信息，设备恢复常态不发送通知。如人体红外传感器（当有人时触发警告，但人走了后，不会发送消除警告信息。无法知道人还在不在）</pata>
|
/// </summary>
|
public int MomentStatus;
|
/// <summary>
|
/// <pata>当MomentStatus为0时，安防设备被触发上报安防信息的ZoneStatus值和TriggerZoneStatus进行与运算（&）结果不为0时激活防区警报，为0时解除激活。例如门磁设备，如果有人开门入侵将激活防区报警，可将TriggerZoneStatus设置为17，开门时上报的ZoneStatus值为1，（17 & 1）>0，此时说明有入侵，防区将被激活，发送警告信息到客户端和服务器并执行设定的警戒动作。</pata>
|
/// <pata>当MomentStatus为1时，说明安防设备的激活状态只是瞬间的，只有在上报ZoneStatus值（和TriggerZoneStatus相与不为0时）的瞬间激活，激活后将立即自动恢复为常态。</pata>
|
/// <pata>设置布防时，如果安防设备被触发，防区处于警告状态，要解除激活才能布防成功。如果上面MomentStatus为0，则需要安防设备再次上报的ZoneStatus值和TriggerZoneStatus值进行与运算结果为0才能解除激活状态 。如果MomentStatus为1，则说明设备已经自动恢复常态，布防可以成功。</pata>
|
/// <pata>如门磁设备关门时上报的ZoneStatus值为32，（32&1）=0。则说明门已经关上，防区激活状态将解除，可对防区进行布防。如果MomentStatus为1，则忽略该设备的最近警告状态进行布防。</pata>
|
/// </summary>
|
public int TriggerZoneStatus;
|
|
/// <summary>
|
/// 是否旁路
|
///<para>0：不旁路</para>
|
///<para>1：旁路</para>
|
/// </summary>
|
public int IsBypass = 999;
|
}
|
|
#endregion
|
|
#region 24*执行安防模式动作.
|
/// <summary>
|
/// *执行安防模式动作（需要管理员权限）.
|
///<para>modeId:布防模式ID</para>
|
///<para>actionType:动作类型</para>
|
///<para>1：布防成功指示动作</para>
|
///<para>2：布防失败指示动作</para>
|
///<para>3：撤防成功指示动作</para>
|
///<para>4：撤防失败指示动作</para>
|
///<para>loginToken:登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。</para>
|
///</summary>
|
public static async System.Threading.Tasks.Task<ActionTestResponseAllData> ActionTestAsync(int modeId, int actionType, string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
ActionTestResponseAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new ActionTestResponseAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new ActionTestResponseAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new ActionTestResponseAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var securityTemp = new Safeguard() { Time = jobject.Value<int>("Time"), DataID = jobject.Value<int>("Data_ID"), GateWayId = mainGateway.GwId };
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new ActionTestResponseAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/ActionTest_Respon")
|
{
|
var actionTestResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<ActionTestResponseData>(jobject["Data"].ToString());
|
if (actionTestResponseData != null)
|
{
|
d = new ActionTestResponseAllData { actionTestResponseData = actionTestResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
|
}
|
else
|
{
|
d = new ActionTestResponseAllData { errorMessageBase = "网关返回的数据为空" };
|
System.Console.WriteLine($"回复数据为空");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine("Security/ActionTest_Actions 启动" + System.DateTime.Now.ToString());
|
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4027}
|
};
|
var data = new JObject
|
{
|
{ "ModeId", modeId },
|
{ "ActionType", actionType},
|
{ "LoginToken", loginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/ActionTest", jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new ActionTestResponseAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
mainGateway.Actions -= action;
|
System.Console.WriteLine("Security/ActionTest_Actions 退出" + System.DateTime.Now.ToString());
|
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 执行安防模式动作返回的数据,网关反馈信息
|
/// </summary>
|
public ActionTestResponseAllData actionTestResponseAllData;
|
/// <summary>
|
/// 执行安防模式动作返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class ActionTestResponseAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 执行安防模式动作返回的数据
|
/// </summary>
|
public ActionTestResponseData actionTestResponseData;
|
|
}
|
|
/// <summary>
|
/// 执行安防模式动作返回的数据
|
/// </summary>
|
public ActionTestResponseData actionTestResponseData;
|
/// <summary>
|
/// 执行安防模式动作返回的数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class ActionTestResponseData
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，安防模式不存在</para>
|
/// </summary>
|
public int Result = 999;
|
/// <summary>
|
/// 安防模式id
|
/// </summary>
|
public int ModeId;
|
/// <summary>
|
/// 1：布防成功指示动作
|
///<para>2：布防失败指示动作。</para>
|
///<para>3：撤防成功指示动作。</para>
|
///<para>4：撤防失败指示动作</para>
|
/// </summary>
|
public int ActionType;
|
}
|
|
/// <summary>
|
/// 执行安防模式动作(仅用于主网关接口）
|
///<para>modeId:布防模式ID</para>
|
///<para>actionType:动作类型</para>
|
///<para>1：布防成功指示动作</para>
|
///<para>2：布防失败指示动作</para>
|
///<para>3：撤防成功指示动作</para>
|
///<para>4：撤防失败指示动作</para>
|
/// </summary>
|
public static void ActionTest(int modeId, int actionType)
|
{
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
return;
|
}
|
|
Action<string, string> action = (topic, message) => { };
|
|
mainGateway.Actions += action;
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4027}
|
};
|
var data = new JObject
|
{
|
{ "ModeId", modeId },
|
{ "ActionType", actionType}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/ActionTest", jObject.ToString());
|
mainGateway.Actions -= action;
|
}
|
#endregion
|
|
#region 18防区被触发时报告
|
/// <summary>
|
/// 防区被触发时报告
|
/// </summary>
|
public ZoneTriggerReportData zoneTriggerReportData;
|
/// <summary>
|
/// 防区被触发时报告
|
/// <para>布防模式下的非旁路防区被触发时将反馈触发信息</para>
|
/// </summary>
|
[System.Serializable]
|
public class ZoneTriggerReportData
|
{
|
/// <summary>
|
/// 防区id
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 是否为强迫密码撤防触发静音防区
|
///<para>0：不是</para>
|
///<para>1：是</para>
|
/// </summary>
|
public int ForceToWithdraw;
|
|
/// <summary>
|
/// 触发设备的mac地址，当ForceToWithdraw为0时存在
|
/// </summary>
|
public string MacAddr;
|
|
/// <summary>
|
/// 触发设备的端口号，当ForceToWithdraw为0时存在
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
///触发设备上报的ZoneStatus值，当ForceToWithdraw为0时存在
|
/// </summary>
|
public int ZoneStatus;
|
|
}
|
#endregion
|
|
#region 19模式安防动作被最终激活时发送报警信息
|
/// <summary>
|
/// 防区被触发时报告
|
/// </summary>
|
public ModeTriggerReportData modeTriggerReportData;
|
/// <summary>
|
/// 模式安防动作被最终激活时发送报警信息
|
/// <para>如延时防区被触发延时过后还没撤防、周界防区被触发、出入防区没触发却触发了内部防区等情况都将激活模式安防动作，将发送以下给警报。</para>
|
/// </summary>
|
[System.Serializable]
|
public class ModeTriggerReportData
|
{
|
/// <summary>
|
/// 当前布防模式id
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 报警时最后被激活的防区
|
/// </summary>
|
public string ModeName;
|
|
/// <summary>
|
/// 报警时最后被激活的防区
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 是否为强迫密码撤防触发静音防区
|
///<para>0：不是</para>
|
///<para>1：是</para>
|
/// </summary>
|
public int ForceToWithdraw;
|
|
/// <summary>
|
/// 报警设备的mac地址(ForceToWithdraw为0时才存在)
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 报警设备的端口号(ForceToWithdraw为0时才存在)
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 报警设备的名称 (ForceToWithdraw为0时才存在)
|
/// </summary>
|
public string DeviceName;
|
/// <summary>
|
/// 报警设备上报的ZoneStatus值
|
/// </summary>
|
public int ZoneStatus;
|
/// <summary>
|
/// 信息推送目标
|
/// </summary>
|
public List<PushTargetInfo> PushTarget = new List<PushTargetInfo>();
|
|
}
|
#endregion
|
|
#region 25通过外部方式布防撤防成功时报告
|
/// <summary>
|
/// 通过外部方式布防撤防成功时报告
|
/// </summary>
|
public EnOrWithdrawSucceedReportData enOrWithdrawSucceedReportData;
|
/// <summary>
|
/// 通过外部方式布防撤防成功时报告
|
/// <para>当用户通过外部方式（非app或云端操作，如逻辑触发执行撤防布防，按键操作布防撤防）进行布防撤防成功</para>
|
/// </summary>
|
[System.Serializable]
|
public class EnOrWithdrawSucceedReportData
|
{
|
/// <summary>
|
/// 0：布防成功
|
///<para>1：撤防成功</para>
|
/// </summary>
|
public int EnOrWithdraw;
|
|
/// <summary>
|
/// 安防模式id。
|
/// </summary>
|
public int ModeId;
|
|
/// <summary>
|
/// 外部布撤防方式：
|
///<para>0：执行逻辑动作</para>
|
///<para>1：按键操作</para>
|
/// </summary>
|
public int OperationWay;
|
}
|
#endregion
|
|
#region 26*对防区安防设备进行旁路或撤销旁路;
|
/// <summary>
|
/// *对防区安防设备进行旁路或撤销旁路（需要管理员权限）.
|
/// </summary>
|
/// <returns>The device to zone async.</returns>
|
/// <param name="removeEqToZoneData">将设备从防区中移除的数据.</param>
|
public static async System.Threading.Tasks.Task<EqByPassAllData> EqByPassAllDataAsync(EqByPassData eqByPassData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
EqByPassAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new EqByPassAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new EqByPassAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new EqByPassAllData { errorMessageBase = ErrorMess(temp.Error), errorResponData = temp };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new EqByPassAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/EqByPass_Respon")
|
{
|
var result = Newtonsoft.Json.JsonConvert.DeserializeObject<int>(jobject["Data"]["Result"].ToString());
|
if (result == 0)
|
{
|
var eqByPassResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<EqByPassResponseData>(jobject["Data"].ToString());
|
if (eqByPassResponseData != null)
|
{
|
d = new EqByPassAllData { eqByPassResponseData = eqByPassResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
}
|
else
|
{
|
var r = new EqByPassResponseData();
|
r.Result = result;
|
d = new EqByPassAllData { eqByPassResponseData = r };
|
|
System.Console.WriteLine("已收到通知返回");
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/EqByPass_Actions启动_{System.DateTime.Now.ToString()}");
|
|
try
|
{
|
if (eqByPassData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4029 } };
|
|
var data = new JObject
|
{
|
{ "ZoneId", eqByPassData.ZoneId },
|
{ "MacAddr", eqByPassData.MacAddr },
|
{ "Epoint", eqByPassData.Epoint },
|
{ "IsByPass", eqByPassData.IsByPass},
|
{ "LoginToken", eqByPassData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/EqByPass"), jObject.ToString());
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new EqByPassAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/EqByPass_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 对防区安防设备进行旁路或撤销旁路的返回数据 ,网关反馈信息
|
/// </summary>
|
public EqByPassAllData eqByPassAllData;
|
/// <summary>
|
/// 对防区安防设备进行旁路或撤销旁路的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class EqByPassAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 对防区安防设备进行旁路或撤销旁路的返回数据
|
/// </summary>
|
public EqByPassResponseData eqByPassResponseData;
|
}
|
|
/// <summary>
|
/// 对防区安防设备进行旁路或撤销旁路的返回数据
|
/// </summary>
|
public EqByPassResponseData eqByPassResponseData;
|
/// <summary>
|
/// 对防区安防设备进行旁路或撤销旁路的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class EqByPassResponseData
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，防区不存在</para>
|
///<para>2：失败，设备不在防区中</para>
|
///<para>3：失败，系统当前处于撤防状态。</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 防区id。
|
///<para>1：24小时防区。</para>
|
///<para>2：24小时静音防区。</para>
|
///<para>3：出入防区。</para>
|
///<para>4：内部防区。</para>
|
///<para>5：周界防区。</para>
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 0：不旁路
|
///<para>1：旁路设备</para>
|
/// </summary>
|
public int IsByPass;
|
|
}
|
|
/// <summary>
|
/// 对防区安防设备进行旁路或撤销旁路的数据
|
/// </summary>
|
public EqByPassData eqByPassData;
|
/// <summary>
|
/// 将设备从防区中移除的数据
|
/// </summary>
|
[System.Serializable]
|
public class EqByPassData
|
{
|
/// <summary>
|
/// 防区id。
|
///<para>1：24小时防区。</para>
|
///<para>2：24小时静音防区。</para>
|
///<para>3：出入防区。</para>
|
///<para>4：内部防区。</para>
|
///<para>5：周界防区。</para>
|
/// </summary>
|
public int ZoneId;
|
|
/// <summary>
|
/// 设备mac地址
|
/// </summary>
|
public string MacAddr;
|
/// <summary>
|
/// 设备端口号
|
/// </summary>
|
public int Epoint;
|
/// <summary>
|
/// 0：不旁路
|
///<para>1：旁路设备</para>
|
/// </summary>
|
public int IsByPass = 999;
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
}
|
#endregion
|
|
#region 27*添加防区报警目标;
|
/// <summary>
|
/// *添加防区报警目标（需要管理员权限）.
|
/// </summary>
|
public static async System.Threading.Tasks.Task<AddZoneActionAllData> AddZoneActionAsync(AddZoneActionData addZoneActionData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AddZoneActionAllData d = null;
|
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new AddZoneActionAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new AddZoneActionAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new AddZoneActionAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new AddZoneActionAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AddZoneAction_Respon")
|
{
|
var addZoneActionResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<AddZoneActionResponseData>(jobject["Data"].ToString());
|
if (addZoneActionResponseData != null)
|
{
|
d = new AddZoneActionAllData { addZoneActionResponseData = addZoneActionResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new AddZoneActionAllData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/AddZoneAction_Actions启动_{System.DateTime.Now.ToString()}");
|
|
try
|
{
|
if (addZoneActionData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4030 } };
|
var actionsList = new JArray { };
|
foreach (var act in addZoneActionData.Actions)
|
{
|
if (act.Type == 0)
|
{
|
var taskList = new JArray { };
|
foreach (var taskInfo in act.TaskList)
|
{
|
var tInfo = new JObject{
|
{ "TaskType", taskInfo.TaskType},
|
{ "Data1", taskInfo.Data1},
|
{ "Data2",taskInfo.Data2}
|
};
|
taskList.Add(tInfo);
|
}
|
|
var a = new JObject {
|
{ "Type",act.Type},
|
{ "DeviceAddr", act.DeviceAddr} ,
|
{ "Epoint",act.Epoint} ,
|
{ "TaskList", taskList}
|
};
|
actionsList.Add(a);
|
}
|
else if (act.Type == 1)
|
{
|
var b = new JObject {
|
{ "Type",act.Type},
|
{ "ScenesId", act.ScenesId}
|
};
|
actionsList.Add(b);
|
}
|
}
|
var data = new JObject
|
{
|
{ "ActionType", addZoneActionData.ActionType },
|
{ "Actions", actionsList},
|
{ "LoginToken", addZoneActionData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/AddZoneAction"), jObject.ToString());
|
}
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new AddZoneActionAllData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/AddZoneAction_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 添加防区报警目标的返回数据 ,网关反馈信息
|
/// </summary>
|
public AddZoneActionAllData addZoneActionAllData;
|
/// <summary>
|
/// 添加防区报警目标的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AddZoneActionAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 添加防区报警目标的返回数据
|
/// </summary>
|
public AddZoneActionResponseData addZoneActionResponseData;
|
}
|
|
/// <summary>
|
/// 添加防区报警目标的返回数据
|
/// </summary>
|
public AddZoneActionResponseData addZoneActionResponseData;
|
/// <summary>
|
/// 添加防区报警目标的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class AddZoneActionResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// <para>1：失败，ActionType不存在</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 1：24小时防区触发动作。
|
///<para>2：24小时静音防区触发动作。</para>
|
///<para>3：其他防区（出入防区、内部防区、周界防区）触发动作。</para>
|
/// </summary>
|
public int ActionType;
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<AlarmActionResponseObj> Actions = new List<AlarmActionResponseObj>();
|
|
}
|
|
/// <summary>
|
/// 添加防区报警目标的数据
|
/// </summary>
|
[System.Serializable]
|
public class AlarmActionResponseObj
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，设备或场景不存在</para>
|
/// </summary>
|
public string Status;
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
///<para>2：信息推送</para>
|
/// </summary>
|
public string Type;
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 动作参数列表。（当Type=0和Status = 0时存在）
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo>();
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
/// <summary>
|
/// 设备或场景名称，Status = 0时存在
|
/// </summary>
|
public string ESName;
|
}
|
|
/// <summary>
|
/// 添加防区报警目标的数据
|
/// </summary>
|
public AddZoneActionData addZoneActionData;
|
/// <summary>
|
/// 将设备从防区中移除的数据
|
/// </summary>
|
[System.Serializable]
|
public class AddZoneActionData
|
{
|
/// <summary>
|
/// 1：24小时防区触发动作。
|
///<para>2：24小时静音防区触发动作。</para>
|
///<para>3：其他防区（出入防区、内部防区、周界防区）触发动作。</para>
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<AlarmActionObj> Actions = new List<AlarmActionObj>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
|
}
|
|
/// <summary>
|
/// 添加防区报警目标的数据
|
/// </summary>
|
[System.Serializable]
|
public class AlarmActionObj
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public int Type;
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 动作参数列表。（当Type=0和Status = 0时存在）
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo>();
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
}
|
|
#endregion
|
|
#region 28*删除防区报警目;
|
/// <summary>
|
/// *删除防区报警目标（需要管理员权限）.
|
/// </summary>
|
public static async System.Threading.Tasks.Task<DelZoneActionResposeAllData> DelZoneActionAsync(DelZoneActionData delZoneActionData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
DelZoneActionResposeAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new DelZoneActionResposeAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new DelZoneActionResposeAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new DelZoneActionResposeAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new DelZoneActionResposeAllData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/DelZoneAction_Respon")
|
{
|
var delZoneActionResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<DelZoneActionResponseData>(jobject["Data"].ToString());
|
if (delZoneActionResponseData != null)
|
{
|
d = new DelZoneActionResposeAllData { delZoneActionResponseData = delZoneActionResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new DelZoneActionResposeAllData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/DelZoneAction_Actions启动_{System.DateTime.Now.ToString()}");
|
|
try
|
{
|
if (delZoneActionData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4031 } };
|
var actionsList = new JArray { };
|
foreach (var act in delZoneActionData.Actions)
|
{
|
if (act.Type == 0)
|
{
|
var a = new JObject {
|
{ "Type",act.Type},
|
{ "DeviceAddr", act.DeviceAddr} ,
|
{ "Epoint",act.Epoint}
|
};
|
actionsList.Add(a);
|
}
|
else if (act.Type == 1)
|
{
|
var b = new JObject {
|
{ "Type",act.Type},
|
{ "ScenesId", act.ScenesId}
|
};
|
actionsList.Add(b);
|
}
|
}
|
var data = new JObject
|
{
|
{ "ActionType", delZoneActionData.ActionType },
|
{ "Actions", actionsList},
|
{ "LoginToken", delZoneActionData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/DelZoneAction"), jObject.ToString());
|
}
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new DelZoneActionResposeAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/DelZoneAction_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 删除防区报警目标的返回数据 ,网关反馈信息
|
/// </summary>
|
public DelZoneActionResposeAllData delZoneActionResposeAllData;
|
/// <summary>
|
/// 删除防区报警目标的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class DelZoneActionResposeAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 删除防区报警目标的返回数据
|
/// </summary>
|
public DelZoneActionResponseData delZoneActionResponseData;
|
}
|
|
/// <summary>
|
/// 删除防区报警目标的返回数据
|
/// </summary>
|
public DelZoneActionResponseData delZoneActionResponseData;
|
/// <summary>
|
/// 删除防区报警目标的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class DelZoneActionResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：成功</para>
|
/// <para>1：失败，ActionType不存在</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 1：24小时防区触发动作。
|
///<para>2：24小时静音防区触发动作。</para>
|
///<para>3：其他防区（出入防区、内部防区、周界防区）触发动作。</para>
|
/// </summary>
|
public int ActionType;
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<DelAlarmActionResponseObj> Actions = new List<DelAlarmActionResponseObj>();
|
|
}
|
|
/// <summary>
|
/// 删除防区报警目标的数据
|
/// </summary>
|
[System.Serializable]
|
public class DelAlarmActionResponseObj
|
{
|
/// <summary>
|
/// 0：成功
|
///<para>1：失败，设备或场景不存在</para>
|
/// </summary>
|
public string Status;
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public string Type;
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
}
|
|
/// <summary>
|
/// 删除防区报警目标的数据
|
/// </summary>
|
public DelZoneActionData delZoneActionData;
|
/// <summary>
|
/// 删除防区报警目标的数据
|
/// </summary>
|
[System.Serializable]
|
public class DelZoneActionData
|
{
|
/// <summary>
|
/// 1：24小时防区触发动作。
|
///<para>2：24小时静音防区触发动作。</para>
|
///<para>3：其他防区（出入防区、内部防区、周界防区）触发动作。</para>
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<DelAlarmActionObj> Actions = new List<DelAlarmActionObj>();
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
}
|
|
/// <summary>
|
/// 删除防区报警目标的数据
|
/// </summary>
|
[System.Serializable]
|
public class DelAlarmActionObj
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public int Type;
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
}
|
#endregion
|
|
#region 29查看防区报警目标;
|
/// <summary>
|
/// 查看防区报警目标
|
/// <para>1：24小时防区触发动作。</para>
|
/// <para>2：24小时静音防区触发动作。</para>
|
/// <para>3：其他防区（出入防区、内部防区、周界防区）触发动作。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<CatZoneActionResposeAllData> CatZoneActionAsync(int actionType)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
CatZoneActionResposeAllData d = null;
|
var mainGateWay = ZbGateway.MainGateWay;
|
if (mainGateWay == null)
|
{
|
d = new CatZoneActionResposeAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new CatZoneActionResposeAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new CatZoneActionResposeAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/CatZoneAction_Respon")
|
{
|
var catZoneActionResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<CatZoneActionResponseData>(jobject["Data"].ToString());
|
if (catZoneActionResponseData != null)
|
{
|
d = new CatZoneActionResposeAllData { catZoneActionResponseData = catZoneActionResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new CatZoneActionResposeAllData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateWay.Actions += action;
|
System.Console.WriteLine($"Security/CatZoneAction_Actions启动_{System.DateTime.Now.ToString()}");
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4032 }
|
};
|
var data = new JObject
|
{
|
{ "ActionType", actionType }
|
};
|
jObject.Add("Data", data);
|
mainGateWay.Send("Security/CatZoneAction", jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new CatZoneActionResposeAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateWay.Actions -= action;
|
System.Console.WriteLine($"Security/CatZoneAction_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 查看防区报警目标的返回数据 ,网关反馈信息
|
/// </summary>
|
public CatZoneActionResposeAllData catZoneActionResposeAllData;
|
/// <summary>
|
/// 查看防区报警目标的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class CatZoneActionResposeAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 查看防区报警目标的返回数据
|
/// </summary>
|
public CatZoneActionResponseData catZoneActionResponseData;
|
}
|
|
/// <summary>
|
/// 查看防区报警目标的返回数据
|
/// </summary>
|
public CatZoneActionResponseData catZoneActionResponseData;
|
/// <summary>
|
/// 查看防区报警目标的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class CatZoneActionResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// <para>1：失败，ActionType不存在</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 1：24小时防区触发动作。
|
///<para>2：24小时静音防区触发动作。</para>
|
///<para>3：其他防区（出入防区、内部防区、周界防区）触发动作。</para>
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 是否禁用信息推送：
|
///<para>0：不禁用</para>
|
///<para>1：禁用</para>
|
///<para>当防区的信息推送被禁用时，防区被触发时不会发送18小节的”防区被触发是报告”的主题信息。</para>
|
/// </summary>
|
public int IsDisablePushMessage = 999;
|
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<CatActionResponseObj> Actions = new List<CatActionResponseObj>();
|
|
}
|
|
/// <summary>
|
/// 查看防区报警目标的数据
|
/// </summary>
|
[System.Serializable]
|
public class CatActionResponseObj
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>0：节点设备动作</para>
|
///<para>1：打开场景</para>
|
/// </summary>
|
public int Type;
|
/// <summary>
|
/// 设备mac地址 ，
|
///<para>当Type=0时存在。</para>
|
/// </summary>
|
public string DeviceAddr;
|
|
/// <summary>
|
/// 设备端口号
|
///<para>设备端口号 和mac地址共同标识唯一的zigbee设备 数值范围0-255。 当Type=0时存在。</para>
|
/// </summary>
|
public int Epoint;
|
|
/// <summary>
|
/// 动作参数列表。（当Type=0时存在）
|
/// </summary>
|
public List<TaskListInfo> TaskList = new List<TaskListInfo>();
|
|
|
/// <summary>
|
/// 场景ID 。当Type=1时存在
|
/// </summary>
|
public int ScenesId;
|
|
/// <summary>
|
/// 设备或场景名称(当Type=0 或Type=1时存在。)
|
/// </summary>
|
public string ESName;
|
}
|
|
#endregion
|
|
#region 30*设置胁迫状态下被通知的联系号码;
|
/// <summary>
|
/// *设置胁迫状态下被通知的联系号码（需要管理员权限）.
|
/// </summary>
|
public static async System.Threading.Tasks.Task<SetCoercePhoneNumberAllResponseData> SetCoercePhoneNumberAsync(SetCoercePhoneNumberData setCoercePhoneNumberData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
SetCoercePhoneNumberAllResponseData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new SetCoercePhoneNumberAllResponseData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new SetCoercePhoneNumberAllResponseData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new SetCoercePhoneNumberAllResponseData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new SetCoercePhoneNumberAllResponseData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AddZoneAction_Respon")
|
{
|
var setCoercePhoneNumberResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<SetCoercePhoneNumberResponseData>(jobject["Data"].ToString());
|
if (setCoercePhoneNumberResponseData != null)
|
{
|
d = new SetCoercePhoneNumberAllResponseData { setCoercePhoneNumberResponseData = setCoercePhoneNumberResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new SetCoercePhoneNumberAllResponseData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/AddZoneAction(设置胁迫状态下的电话号码）_Actions启动_{System.DateTime.Now.ToString()}");
|
try
|
{
|
if (setCoercePhoneNumberData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4030 } };
|
var actionsList = new JArray { };
|
foreach (var act in setCoercePhoneNumberData.Actions)
|
{
|
if (act.Type == 2)
|
{
|
var pushTargetList = new JArray { };
|
foreach (var pushInfo in act.PushTarget)
|
{
|
var pInfo = new JObject{
|
{ "PushNumber", pushInfo.PushNumber}
|
};
|
pushTargetList.Add(pInfo);
|
}
|
var c = new JObject {
|
{ "Type",act.Type},
|
{ "PushTarget", pushTargetList}
|
};
|
actionsList.Add(c);
|
}
|
}
|
var data = new JObject
|
{
|
{ "ActionType", 253},
|
{ "Actions", actionsList},
|
{ "LoginToken", setCoercePhoneNumberData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/AddZoneAction"), jObject.ToString());
|
}
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new SetCoercePhoneNumberAllResponseData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/AddZoneAction(设置胁迫状态下的电话号码）_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// *设置胁迫状态下被通知的联系号码的备注（需要管理员权限）. -2:主网关丢失
|
/// </summary>
|
/// <param name="strPhone">地区码-联系方式</param>
|
/// <param name="strNote">备注,最大63byte</param>
|
/// <returns></returns>
|
public static async System.Threading.Tasks.Task<SetCoercePhoneNumberResponseData> SetCoercePhoneNumberNoteAsync(string strPhone, string strNote)
|
{
|
SetCoercePhoneNumberResponseData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new SetCoercePhoneNumberResponseData();
|
d.Result = -2;
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
if (topic == gatewayID + "/" + "Security/AddPushNumberNote_Respon")
|
{
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
d = Newtonsoft.Json.JsonConvert.DeserializeObject<SetCoercePhoneNumberResponseData>(jobject["Data"].ToString());
|
}
|
};
|
|
mainGateway.Actions += action;
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4038 } };
|
var data = new JObject
|
{
|
{ "ActionType", 253},
|
{ "LoginToken", Shared.Phone.HdlSafeguardLogic.Current.GetLoginToken()},
|
{ "PushNumber", strPhone},
|
{ "PushNumberNote", strNote}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send("Security/AddPushNumberNote", jObject.ToString());
|
}
|
catch { }
|
|
int timeOut = 0;
|
while (timeOut <= 60)
|
{
|
await System.Threading.Tasks.Task.Delay(50);
|
if (d != null)
|
{
|
break;
|
}
|
timeOut++;
|
}
|
|
mainGateway.Actions -= action;
|
return d;
|
}
|
|
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的返回数据 ,网关反馈信息
|
/// </summary>
|
public SetCoercePhoneNumberAllResponseData setCoercePhoneNumberAllResponseData;
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class SetCoercePhoneNumberAllResponseData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
public SetCoercePhoneNumberResponseData setCoercePhoneNumberResponseData;
|
}
|
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
public SetCoercePhoneNumberResponseData setCoercePhoneNumberResponseData;
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class SetCoercePhoneNumberResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 类型
|
/// </summary>
|
public int ActionType;
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<PushTargetActionResponseObj> Actions = new List<PushTargetActionResponseObj>();
|
|
}
|
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的数据
|
/// </summary>
|
[System.Serializable]
|
public class PushTargetActionResponseObj
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>2：信息推送</para>
|
/// </summary>
|
public string Type;
|
|
/// <summary>
|
/// 信息推送目标,当Type=2时存在。
|
/// </summary>
|
public List<PushTargetInfo> PushTarget = new List<PushTargetInfo>();
|
}
|
|
/// <summary>
|
/// 任务列表中的数据
|
/// </summary>
|
[System.Serializable]
|
public class PushTargetInfo
|
{
|
/// <summary>
|
/// 推送信息的目标手机号码
|
///</summary>
|
public string PushNumber;
|
/// <summary>
|
/// 备注信息
|
/// </summary>
|
public string PushNumberNote;
|
}
|
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的数据
|
/// </summary>
|
public SetCoercePhoneNumberData setCoercePhoneNumberData;
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的数据
|
/// </summary>
|
[System.Serializable]
|
public class SetCoercePhoneNumberData
|
{
|
/// <summary>
|
/// 动作类型
|
/// 设置胁迫状态下被通知的联系号码的数据
|
/// </summary>
|
//public int ActionType = 253;
|
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<PushTargetActionObj> Actions = new List<PushTargetActionObj>();
|
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
|
}
|
|
/// <summary>
|
/// 设置胁迫状态下被通知的联系号码的数据
|
/// </summary>
|
[System.Serializable]
|
public class PushTargetActionObj
|
{
|
/// <summary>
|
/// 动作类型
|
///<para>2：信息推送</para>
|
/// </summary>
|
public int Type;
|
|
/// <summary>
|
/// 信息推送目标,当Type=2时存在。
|
/// </summary>
|
public List<PushTargetInfo> PushTarget = new List<PushTargetInfo>();
|
}
|
#endregion
|
|
#region 31*删除胁迫状态下被通知的联系号码；
|
/// <summary>
|
/// *删除胁迫状态下被通知的联系号码（需要管理员权限）.
|
/// </summary>
|
public static async System.Threading.Tasks.Task<DelCoercePhoneNumberAllResponseData> DelCoercePhoneNumberAsync(DelCoercePhoneNumberData delCoercePhoneNumberData)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
DelCoercePhoneNumberAllResponseData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new DelCoercePhoneNumberAllResponseData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new DelCoercePhoneNumberAllResponseData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new DelCoercePhoneNumberAllResponseData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
d = new DelCoercePhoneNumberAllResponseData { };
|
if (temp == null)
|
{
|
d.errorMessageBase = "网关错误回复，且数据是空";
|
}
|
else
|
{
|
if (temp.Error == 1)
|
{
|
d.errorMessageBase = "网关不是主网关，无法进行该操作。";
|
}
|
else if (temp.Error == 2)
|
{
|
d.errorMessageBase = "该操作需要安防管理员权限，需先以管理员身份进行登陆。";
|
|
}
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
d.errorResponData = temp;
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/DelZoneAction_Respon")
|
{
|
var delCoercePhoneNumberResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<DelCoercePhoneNumberResponseData>(jobject["Data"].ToString());
|
if (delCoercePhoneNumberResponseData != null)
|
{
|
d = new DelCoercePhoneNumberAllResponseData { delCoercePhoneNumberResponseData = delCoercePhoneNumberResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new DelCoercePhoneNumberAllResponseData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/AddZoneAction(删除胁迫状态下的电话号码）_Actions启动_{System.DateTime.Now.ToString()}");
|
try
|
{
|
if (delCoercePhoneNumberData != null)
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4031 } };
|
var actionsList = new JArray { };
|
foreach (var act in delCoercePhoneNumberData.Actions)
|
{
|
if (act.Type == 2)
|
{
|
var pushTargetList = new JArray { };
|
foreach (var pushInfo in act.PushTarget)
|
{
|
var pInfo = new JObject{
|
{ "PushNumber", pushInfo.PushNumber}
|
};
|
pushTargetList.Add(pInfo);
|
}
|
var c = new JObject {
|
{ "Type",act.Type},
|
{ "PushTarget", pushTargetList}
|
};
|
actionsList.Add(c);
|
}
|
}
|
var data = new JObject
|
{
|
{ "ActionType", 253},
|
{ "Actions", actionsList},
|
{ "LoginToken", delCoercePhoneNumberData.LoginToken}
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/DelZoneAction"), jObject.ToString());
|
}
|
}
|
catch { }
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new DelCoercePhoneNumberAllResponseData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/AddZoneAction(删除胁迫状态下的电话号码）_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 删除胁迫状态下被通知的联系号码的返回数据 ,网关反馈信息
|
/// </summary>
|
public DelCoercePhoneNumberAllResponseData delCoercePhoneNumberAllResponseData;
|
/// <summary>
|
/// 删除胁迫状态下被通知的联系号码的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class DelCoercePhoneNumberAllResponseData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 删除胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
public DelCoercePhoneNumberResponseData delCoercePhoneNumberResponseData;
|
}
|
|
/// <summary>
|
/// 删除胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
public DelCoercePhoneNumberResponseData delCoercePhoneNumberResponseData;
|
/// <summary>
|
/// 删除胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class DelCoercePhoneNumberResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 类型
|
/// </summary>
|
public int ActionType;
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<PushTargetActionResponseObj> Actions = new List<PushTargetActionResponseObj>();
|
|
}
|
/// <summary>
|
/// 删除胁迫状态下被通知的联系号码的数据
|
/// </summary>
|
public DelCoercePhoneNumberData delCoercePhoneNumberData;
|
/// <summary>
|
/// 删除胁迫状态下被通知的联系号码的数据
|
/// </summary>
|
[System.Serializable]
|
public class DelCoercePhoneNumberData
|
{
|
/// <summary>
|
/// 动作类型
|
/// </summary>
|
//public int ActionType = 253;
|
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<PushTargetActionObj> Actions = new List<PushTargetActionObj>();
|
|
/// <summary>
|
/// 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。
|
/// </summary>
|
public string LoginToken;
|
|
}
|
#endregion
|
|
#region 32查看胁迫状态下被通知的联系人;
|
/// <summary>
|
/// 查看胁迫状态下被通知的联系号码
|
/// </summary>
|
public static async System.Threading.Tasks.Task<CheckCoercePhoneNumberAllResponseData> CheckCoercePhoneNumberAsync(int actionType = 253)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
CheckCoercePhoneNumberAllResponseData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new CheckCoercePhoneNumberAllResponseData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new CheckCoercePhoneNumberAllResponseData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new CheckCoercePhoneNumberAllResponseData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/CatZoneAction_Respon")
|
{
|
var checkCoercePhoneNumberResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<CheckCoercePhoneNumberResponseData>(jobject["Data"].ToString());
|
if (checkCoercePhoneNumberResponseData != null)
|
{
|
d = new CheckCoercePhoneNumberAllResponseData { checkCoercePhoneNumberResponseData = checkCoercePhoneNumberResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new CheckCoercePhoneNumberAllResponseData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/CatZoneAction(查看胁迫状态下的电话号码）_Actions启动_{System.DateTime.Now.ToString()}");
|
try
|
{
|
var jObject = new JObject { { "Cluster_ID", 0 }, { "Command", 4032 } };
|
var actionsList = new JArray { };
|
var data = new JObject
|
{
|
{ "ActionType", actionType }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/CatZoneAction"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new CheckCoercePhoneNumberAllResponseData { errorMessageBase = " 回复超时，请重新操作" };
|
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/CatZoneAction(查看胁迫状态下的电话号码）_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 查看胁迫状态下被通知的联系号码的返回数据 ,网关反馈信息
|
/// </summary>
|
public CheckCoercePhoneNumberAllResponseData checkCoercePhoneNumberAllResponseData;
|
/// <summary>
|
/// 查看胁迫状态下被通知的联系号码的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class CheckCoercePhoneNumberAllResponseData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 查看胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
public CheckCoercePhoneNumberResponseData checkCoercePhoneNumberResponseData;
|
}
|
|
/// <summary>
|
/// 查看胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
public CheckCoercePhoneNumberResponseData checkCoercePhoneNumberResponseData;
|
/// <summary>
|
/// 查看胁迫状态下被通知的联系号码的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class CheckCoercePhoneNumberResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：默认</para>
|
/// <para>1：失败，ActionType不存在</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 类型
|
/// </summary>
|
public int ActionType;
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<PushTargetActionResponseObj> Actions = new List<PushTargetActionResponseObj>();
|
|
}
|
|
#endregion
|
|
#region 33胁迫密码撤防时短信推送;
|
/// <summary>
|
/// 胁迫密码撤防时短信推送
|
/// <para>当使用胁迫密码撤防时，网关将发送该信息到云端。（仅向云端发送）</para>
|
/// </summary>
|
public CoercedPWDWithdrawReportData coercedPWDWithdrawReportData;
|
/// <summary>
|
/// 胁迫密码撤防时短信推送
|
/// <para>当用户通过外部方式（非app或云端操作，如逻辑触发执行撤防布防，按键操作布防撤防）进行布防撤防成功</para>
|
/// </summary>
|
[System.Serializable]
|
public class CoercedPWDWithdrawReportData
|
{
|
/// <summary>
|
/// 253：胁迫密码撤防触发推送短信
|
/// </summary>
|
public int ActionType;
|
|
/// <summary>
|
/// 报警目标列表
|
/// </summary>
|
public List<PushTargetActionResponseObj> Actions = new List<PushTargetActionResponseObj>();
|
|
}
|
#endregion
|
|
#region 34禁用或启用防区被触发时信息推送.
|
/// <summary>
|
/// 查看防区报警目标
|
/// <para>ZoneType:防区ID。</para>
|
/// <para>1：24小时防区。</para>
|
///<para>2：24小时静音防区。</para>
|
///<para>3：其他防区</para>
|
/// <para>isDisablePushMessage:是否禁用防区被触发时信息推送</para>
|
///<para>0：不禁用</para>
|
///<para>1：禁用</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<DisablePushMessageResposeAllData> DisablePushMessageAsync(int zoneType, int isDisablePushMessage)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
DisablePushMessageResposeAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new DisablePushMessageResposeAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new DisablePushMessageResposeAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new DisablePushMessageResposeAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/DisablePushMessage_Respon")
|
{
|
var disablePushMessageResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<DisablePushMessageResponseData>(jobject["Data"].ToString());
|
if (disablePushMessageResponseData != null)
|
{
|
d = new DisablePushMessageResposeAllData { disablePushMessageResponseData = disablePushMessageResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new DisablePushMessageResposeAllData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/DisablePushMessage_Actions启动_{System.DateTime.Now.ToString()}");
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4034 }
|
};
|
var data = new JObject
|
{
|
{ "ZoneType", zoneType },
|
{ "IsDisablePushMessage", isDisablePushMessage }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/DisablePushMessage"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new DisablePushMessageResposeAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/DisablePushMessage_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 查看防区报警目标的返回数据 ,网关反馈信息
|
/// </summary>
|
public DisablePushMessageResposeAllData disablePushMessageResposeAllData;
|
/// <summary>
|
/// 查看防区报警目标的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class DisablePushMessageResposeAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 查看防区报警目标的返回数据
|
/// </summary>
|
public DisablePushMessageResponseData disablePushMessageResponseData;
|
}
|
|
/// <summary>
|
/// 查看防区报警目标的返回数据
|
/// </summary>
|
public DisablePushMessageResponseData disablePushMessageResponseData;
|
/// <summary>
|
/// 查看防区报警目标的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class DisablePushMessageResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：正常</para>
|
/// <para>1：防区不存在</para>
|
/// </summary>
|
public int Result = 999;
|
|
/// <summary>
|
/// 防区ID
|
/// <para>1：24小时防区。</para>
|
///<para>2：24小时静音防区。</para>
|
///<para>其它防区。</para>
|
/// </summary>
|
public int ZoneType;
|
/// <summary>
|
/// 是否禁用防区被触发时信息推送
|
///<para>0：不禁用</para>
|
///<para>1：禁用</para>
|
/// </summary>
|
public int IsDisablePushMessage;
|
|
}
|
#endregion
|
|
#region 35 退出管理员登陆(app通过该指令将退出管理员登陆，原来的“LoginToken”字段将失效。)
|
/// <summary>
|
/// 退出管理员登陆(app通过该指令将退出管理员登陆，原来的“LoginToken”字段将失效。)
|
///<para>loginToken: 登陆标识，最大32个字符。由app自动生成的唯一标识。与管理员登陆指令的“LoginToken”一致，否则将返回“Security/Error_Respon”错误。</para>
|
/// </summary>
|
public static async System.Threading.Tasks.Task<AdminLogOutResposeAllData> AdminLogOutAsync(string loginToken)
|
{
|
return await System.Threading.Tasks.Task.Run(async () =>
|
{
|
AdminLogOutResposeAllData d = null;
|
var mainGateway = ZbGateway.MainGateWay;
|
if (mainGateway == null)
|
{
|
d = new AdminLogOutResposeAllData { errorMessageBase = "当前没有主网关" };
|
return d;
|
}
|
Action<string, string> action = (topic, message) =>
|
{
|
var gatewayID = topic.Split('/')[0];
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(message);
|
|
if (topic == gatewayID + "/" + "Error_Respon")
|
{
|
var temp = Newtonsoft.Json.JsonConvert.DeserializeObject<CommonDevice.ErrorResponData>(jobject["Data"].ToString());
|
|
if (temp == null)
|
{
|
d = new AdminLogOutResposeAllData { errorMessageBase = "网关错误回复，且数据是空" };
|
}
|
else
|
{
|
d = new AdminLogOutResposeAllData { errorResponData = temp, errorMessageBase = ErrorMess(temp.Error) };
|
}
|
}
|
|
if (topic == gatewayID + "/" + "Security/AdminLogOut_Respon")
|
{
|
var adminLogOutResponseData = Newtonsoft.Json.JsonConvert.DeserializeObject<AdminLogOutResponseData>(jobject["Data"].ToString());
|
if (adminLogOutResponseData != null)
|
{
|
d = new AdminLogOutResposeAllData { adminLogOutResponseData = adminLogOutResponseData };
|
System.Console.WriteLine($"UI收到通知后的主题_{topic}");
|
}
|
else
|
{
|
d = new AdminLogOutResposeAllData { errorMessageBase = "网关回复数据是空" };
|
}
|
}
|
};
|
mainGateway.Actions += action;
|
System.Console.WriteLine($"Security/AdminLogOut_Actions启动_{System.DateTime.Now.ToString()}");
|
try
|
{
|
var jObject = new Newtonsoft.Json.Linq.JObject() {
|
{ "Cluster_ID", 0 },
|
{ "Command", 4035 }
|
};
|
var data = new JObject
|
{
|
{ "LoginToken", loginToken }
|
};
|
jObject.Add("Data", data);
|
mainGateway.Send(("Security/AdminLogOut"), jObject.ToString());
|
}
|
catch { }
|
|
var dateTime = DateTime.Now;
|
while ((DateTime.Now - dateTime).TotalMilliseconds < WaitReceiveDataTime)
|
{
|
await System.Threading.Tasks.Task.Delay(10);
|
if (d != null)
|
{
|
break;
|
}
|
}
|
if ((DateTime.Now - dateTime).TotalMilliseconds > WaitReceiveDataTime)
|
{
|
d = new AdminLogOutResposeAllData { errorMessageBase = " 回复超时，请重新操作" };
|
}
|
|
mainGateway.Actions -= action;
|
System.Console.WriteLine($"Security/AdminLogOut_Actions 退出_{System.DateTime.Now.ToString()}");
|
return d;
|
});
|
}
|
|
/// <summary>
|
/// 退出管理员登陆的返回数据 ,网关反馈信息
|
/// </summary>
|
public DisablePushMessageResposeAllData adminLogOutResposeAllData;
|
/// <summary>
|
/// 退出管理员登陆的返回数据,网关反馈信息
|
/// </summary>
|
[System.Serializable]
|
public class AdminLogOutResposeAllData : CommonDevice.ErrorResponCommon
|
{
|
/// <summary>
|
/// 退出管理员登陆的返回数据
|
/// </summary>
|
public AdminLogOutResponseData adminLogOutResponseData;
|
}
|
|
/// <summary>
|
/// 退出管理员登陆的返回数据
|
/// </summary>
|
public AdminLogOutResponseData adminLogOutResponseData;
|
/// <summary>
|
/// 退出管理员登陆的返回数据
|
/// </summary>
|
[System.Serializable]
|
public class AdminLogOutResponseData
|
{
|
/// <summary>
|
/// 返回结果
|
/// <para>0：成功</para>
|
/// <para>1：错误，不存在该“LoginToken”。</para>
|
/// </summary>
|
public int Result = -1;
|
}
|
#endregion
|
}
|
}
|
