private static void starter()
{
log.Info("[MQTT]Service Start ...");
MqttServiceContainer container = MqttServiceContainer.Instance;
List <RetDeviceInfo> deviceInfo = new List <RetDeviceInfo>();
DeviceMonitoringApi deviceApi = new DeviceMonitoringApi();
var retDevice = deviceApi.GetAllDeviceList(new GetDeviceInfoParameter()
{
Status = "1"
});
if (retDevice.Code == -1)
{
log.Error("获取设备信息失败： " + retDevice.Msg);
return;
}
else
{
deviceInfo = retDevice.Data;
}
foreach (var item in deviceInfo)
{
StartUpDeviceService(item);
}
log.Info("[MQTT]Service Started Success!");
return;
}
/// <summary>
/// 启动设备的MQTT监听服务
/// </summary>
/// <param name="item"></param>
public static void StartUpDeviceService(RetDeviceInfo item)
{
// 物接入
if (item.ConnectType == "0")
{
//判断物接入的方式
IoTHubConfigurationModel model = new IoTHubConfigurationModel();
model.ID = long.Parse(item.IoTHubID);
DeviceMonitoringApi deviceApi = new DeviceMonitoringApi();
var conf = deviceApi.GetIoTHubConnection(model);
if (conf.Code == -1)
{
//throw new Exception("获取IoTHub连接信息失败" + conf.Msg);
log.Error("获取IoTHub连接信息失败" + conf.Msg + " ;model ID" + model.ID);
return;
}
RetIoTHubConfiguration connectInfo = (RetIoTHubConfiguration)conf.Data;
long ioTHubID = long.Parse(item.IoTHubID);
//====================
//=====直接接入=======
//====================
if (connectInfo.Type == "1")
{
try
{
MqttClientService service = MqttServiceContainer.Instance.GetMqttServiceByConnectID(ioTHubID);
//订阅该设备下的相关属性TOPIC
BatchSubMessage(item, service);
log.InfoFormat("[MQTT] Device: {0},Service Enable.", item.Name);
}
catch (Exception e)
{
log.Error("获取MQTT Client出错:" + e.Message, e);
}
}
//==========================
//==研华网关的设备直连方式==
//==========================
else if (connectInfo.Type == "3")
{
try
{
MqttClientService service = MqttServiceContainer.Instance.GetMqttServiceByConnectID(ioTHubID);
//订阅该设备下的相关属性TOPIC
//todo: 暂时使用remark字段存储订阅的topic
service.SubscribeMessage(item.Remark);
log.InfoFormat("[MQTT] Device: {0},Service Enable.", item.Name);
}
catch (Exception e)
{
log.Error("获取MQTT Client出错:" + e.Message, e);
}
}
}
}
public IHttpActionResult GetHistoryAlertPoliciesDataList(HistoryAlertPoliciesModel parameter)
{
UserApi api = new UserApi();
var userApi = api.GetUserInfoByToken();
parameter.OrgID = userApi.Data.OrgID.ToString();
DeviceMonitoringApi deviceList = new DeviceMonitoringApi();
var deviceApi = deviceList.GetDeviceList(new GetDeviceInfoParameter());
var list = deviceApi.Data;
HistoryAlertPoliciesBLL device = new HistoryAlertPoliciesBLL();
var get = device.GetHistoryAlertPoliciesDataList(parameter, list);
return(InspurJson <List <RetHistoryAlertPolicies> >(get));
}
public IHttpActionResult GetAlarmReportDetailDataList(AlarmReportItemModel parameter)
{
UserApi api = new UserApi();
var userApi = api.GetUserInfoByToken();
parameter.OrgID = userApi.Data.OrgID.ToString();
DeviceMonitoringApi deviceList = new DeviceMonitoringApi();
var deviceApi = deviceList.GetDeviceList(new GetDeviceInfoParameter());
var list = deviceApi.Data;
AlarmReportInfoBLL device = new AlarmReportInfoBLL();
var get = device.GetAlarmReportDetailDataList(parameter, list);
return(InspurJson <RetAlarmReportDetail>(get));
}
public IHttpActionResult GetAlertPoliciesList(AlertPoliciesModel parameter)
{
UserApi api = new UserApi();
var userApi = api.GetUserInfoByToken();
parameter.OrgID = userApi.Data.OrgID.ToString();
DeviceMonitoringApi deviceList = new DeviceMonitoringApi();
var deviceApi = deviceList.GetDeviceList(new GetDeviceInfoParameter());
var list = deviceApi.Data;
AlertPoliciesInfoBLL device = new AlertPoliciesInfoBLL();
var get = device.GetAlertPoliciesList(parameter, list);
List <GetDeviceDataParameter> DataList = new List <GetDeviceDataParameter>();
try
{
foreach (var item in get.Data)
{
var model = new GetDeviceDataParameter();
model.ID = item.ID;
model.DeviceID = item.DeviceID;
model.DeviceItemID = item.DeviceItemId;
model.DataConnectID = item.DataConnectID;
model.TagMap = JsonConvert.SerializeObject(item.TagList);
DataList.Add(model);
}
}
catch
{
}
var data = deviceList.GetDeviceCurrentData(DataList);
if (data.Data.Count > 0)
{
foreach (var item in get.Data)
{
foreach (var returnitem in data.Data)
{
if (null == returnitem)
{
item.CurrentData = "暂无数据";
}
else if (returnitem.ID == item.ID)
{
item.CurrentData = returnitem.Value;
}
}
}
}
return(InspurJson <List <RetAlertPolicies> >(get));
}
public RetIoTHubConfiguration GetConnectInfoById(string ioTHubID)
{
IoTHubConfigurationModel model = new IoTHubConfigurationModel();
model.ID = long.Parse(ioTHubID);
DeviceMonitoringApi deviceApi = new DeviceMonitoringApi();
var conf = deviceApi.GetIoTHubConnection(model);
if (conf.Code == -1)
{
//throw new Exception("获取IoTHub连接信息失败" + conf.Msg);
log.Error("获取IoTHub连接信息失败" + conf.Msg + " ;model ID" + model.ID);
return(null);
}
RetIoTHubConfiguration connectInfo = (RetIoTHubConfiguration)conf.Data;
return(connectInfo);
}
/// <summary>
/// 根据物接入ID获取一个新的client serivce
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
private MqttClientService GetNewMqttServiceByConnectID(long id)
{
DeviceMonitoringApi deviceApi = new DeviceMonitoringApi();
IoTHubConfigurationModel model = new IoTHubConfigurationModel();
model.ID = id;
var conf = deviceApi.GetIoTHubConnection(model);
if (conf.Code == -1)
{
throw new Exception("获取IoTHub连接信息失败" + conf.Msg);
}
RetIoTHubConfiguration connectInfo = (RetIoTHubConfiguration)conf.Data;
string[] ipPort = connectInfo.Url.Replace("http://", "").Replace("HTTP://", "").Split(':');
string ip = ipPort[0];
int port;
try
{
port = ipPort.Count() > 1 ? Int32.Parse(ipPort[1].Replace("/", "")) : 1883; //1883是MQTT Server默认端口
}
catch (Exception)
{
log.Error("[MQTT]获取mqtt server端口号失败: " + connectInfo.Url);
throw new Exception("[MQTT]获取mqtt server端口号失败");
}
MqttClientService mqttService = new MqttClientService(ip, port, connectInfo.UserName, connectInfo.Password);
mqttService.OnMqttConnectNotify += MqttService_OnMqttConnectNotify;
if (connectInfo.Type == "1")//直连
{
mqttService.OnMqttMessageNotify += MqttService_OnMqttMessageNotify;
}
else if (connectInfo.Type == "3")
{
// 研华网关的接入方式
mqttService.OnMqttMessageNotify += MqttService_OnYanhuaMessageNotify;
}
mqttService.Connect();
container.Add(id, mqttService);
return(mqttService);
}
/// <summary>
/// 将实时数据记录到TSDB
/// </summary>
/// <param name="deviceInfo"></param>
/// <param name="itemInfo"></param>
private void RecordToTsdb(RetDeviceInfo deviceInfo, RetDeviceItemInfo itemInfo, string curValue, DateTime now)
{
decimal value;
try
{
value = Convert.ToDecimal(curValue);
// 如果不能转成数字，则不存储到TSDB中。
}
catch (Exception e)
{
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
return;
}
DeviceMonitoringApi deviceApi = new DeviceMonitoringApi();
IoTHubConfigurationModel parameter = new IoTHubConfigurationModel();
parameter.ID = long.Parse(deviceInfo.DataConnectID);
var retDataConnect = deviceApi.GetDataConnect(parameter);
if (retDataConnect.Code == -1)
{
log.Error("获取数据连接数据出错，ID:" + deviceInfo.DataConnectID);
return;
}
RetDataConnectConfiguration dataConnect = retDataConnect.Data;
Dictionary <string, string> tagMap = new Dictionary <string, string>();
foreach (var tag in deviceInfo.TagList)
{
tagMap.Add(tag.Key, tag.Value);
}
try
{
OpentsdbClient client = new OpentsdbClient("http://" + dataConnect.ServerAddress + ":" + dataConnect.ServerPort);
client.putData(itemInfo.PropertyLabel, now, value, tagMap);
}
catch (Exception)
{
return;
}
}
/// <summary>
/// 通用的监听方法
/// 工作内容：
/// 1.根据Topic获取设备及属性实例。Topic规则：DeviceLabel/PropertyLabel
/// 2.查询是否命中报警策略，如果有则记录报警信息
/// 3.将实时数据保存到默认的TSDB数据库中
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MqttService_OnMqttMessageNotify(object sender, MqttMessageNotifyEventArgs e)
{
log.InfoFormat("[MQTT]收到消息：客户端：{0},主题：{1},消息：{2},Qos：{3},保留：{4}",
e.ClientId, e.MqttApplicationMessage.Topic, Encoding.UTF8.GetString(e.MqttApplicationMessage.Payload), e.MqttApplicationMessage.QualityOfServiceLevel, e.MqttApplicationMessage.Retain);
string[] topicArry = e.MqttApplicationMessage.Topic.Split('/');
if (topicArry.Length == 2)
{
string deviceLabel = topicArry[0];
string propertyLabel = topicArry[1];
DateTime now = DateTime.Now;
DeviceMonitoringApi deviceMonitoringApi = new DeviceMonitoringApi();
GetDeviceInfoParameter par = new GetDeviceInfoParameter();
RetDeviceInfo deviceInfo = null;
RetDeviceItemInfo itemInfo = null;
par.DeviceLabel = deviceLabel;
var resDeviceInfo = deviceMonitoringApi.GetDeviceInfo(par);
if (resDeviceInfo.Code != -1)
{
deviceInfo = resDeviceInfo.Data;
itemInfo = deviceInfo.DeviceItems.Find(s => s.PropertyLabel == propertyLabel);
if (null == itemInfo)
{
log.ErrorFormat("根据Topic获取设备属性信息出错，无法匹配报警策略，deviceLabel{0},propertyLabel{1}", deviceLabel, propertyLabel);
return;
}
}
else
{
log.Error("根据deviceLabel获取设备信息失败" + resDeviceInfo.Msg);
return;
}
//异步处理报警逻辑
AsyncHandleAlarmPolicies(deviceInfo, itemInfo, Encoding.UTF8.GetString(e.MqttApplicationMessage.Payload), now);
//保存到TSDB
RecordToTsdb(deviceInfo, itemInfo, Encoding.UTF8.GetString(e.MqttApplicationMessage.Payload), now);
}
else
{
log.ErrorFormat("解析TOPIC：{0} 失败，不符合规则", e.MqttApplicationMessage.Topic);
}
}
/// <summary>
/// 启用设备
/// </summary>
/// <param name="deviceId"></param>
public void EnableDevice(long deviceId)
{
DeviceMonitoringApi deviceMonitoringApi = new DeviceMonitoringApi();
GetDeviceInfoParameter par = new GetDeviceInfoParameter();
par.ID = deviceId.ToString();
RetDeviceInfo deviceInfo = null;
var resDeviceInfo = deviceMonitoringApi.GetDeviceInfo(par);
if (resDeviceInfo.Code != -1)
{
deviceInfo = resDeviceInfo.Data;
StartUpDeviceService(deviceInfo);
}
else
{
log.Error("获取设备信息出错：" + resDeviceInfo.Msg);
return;
}
}
/// <summary>
/// 禁用设备的处理
/// </summary>
/// <param name="id"></param>
public void DisableDeivce(long deviceId)
{
DeviceMonitoringApi deviceMonitoringApi = new DeviceMonitoringApi();
GetDeviceInfoParameter par = new GetDeviceInfoParameter();
par.ID = deviceId.ToString();
RetDeviceInfo deviceInfo = null;
var resDeviceInfo = deviceMonitoringApi.GetDeviceInfo(par);
if (resDeviceInfo.Code != -1)
{
deviceInfo = resDeviceInfo.Data;
if (MqttServiceContainer.Instance.IsClientExist(long.Parse(deviceInfo.IoTHubID)))
{
RetIoTHubConfiguration connectInfo = GetConnectInfoById(deviceInfo.IoTHubID);
if (null != connectInfo)
{
if (connectInfo.Type == "1")
{
//设备直连，删除Topics
BatchUnsubMessage(deviceInfo, MqttServiceContainer.Instance.GetMqttServiceByConnectID(long.Parse(deviceInfo.IoTHubID)));
}
else if (connectInfo.Type == "3")
{
//研华网关，删除remark中的topic
MqttServiceContainer.Instance.GetMqttServiceByConnectID(long.Parse(deviceInfo.IoTHubID)).UnsubscribeMessage(deviceInfo.Remark);
}
}
log.InfoFormat("[MQTT] Device {0},Service Disable.", deviceInfo.Name);
}
}
else
{
log.Error("获取设备信息出错：" + resDeviceInfo.Msg);
return;
}
}
public IHttpActionResult GetRealTimeMonitorList(RealTimeMonitorModel model)
{
List <GetDeviceDataParameter> list = new List <GetDeviceDataParameter>();
List <RetRelTime> listRel = new List <RetRelTime>();
DeviceMonitoringApi device = new DeviceMonitoringApi();
var deviceList = device.GetDeviceList(new GetDeviceInfoParameter());
var devicelist = deviceList.Data;
if (devicelist != null)
{
foreach (var i in devicelist)
{
var deviceParam = new RetRelTime();
deviceParam.ID = i.ID;
deviceParam.Name = i.Name;
if (i.TagList.Count != 0)
{
var tag = new RetRelTimeTag();
tag.Key = i.TagList[0].Key;
tag.Value = i.TagList[0].Value;
List <RetRelTimeTag> listtag = new List <RetRelTimeTag>();
listtag.Add(tag);
deviceParam.TagList = listtag;
}
List <RetDeviceItems> deviceItems = new List <RetDeviceItems>();
foreach (var iteminfo in i.DeviceItems)
{
RetDeviceItems items = new RetDeviceItems();
items.DeviceItemID = iteminfo.ID;
items.DeviceItemName = iteminfo.Name;
deviceItems.Add(items);
}
deviceParam.DeviceItems = deviceItems;
deviceParam.DataConnectID = i.DataConnectID;
listRel.Add(deviceParam);
}
}
UserApi api = new UserApi();
var userApi = api.GetUserInfoByToken();
model.OrgID = userApi.Data.OrgID.ToString();
HomeConfigurationBLL config = new HomeConfigurationBLL();
var get = config.GetRealTimeMonitorList(model, listRel);
if (get.Data != null)
{
foreach (var item in get.Data)
{
if (item.ChartType == "2")
{
var param = new GetDeviceDataParameter();
param.DeviceID = item.DeviceID;
param.DeviceItemID = item.DeviceItemID;
param.DataConnectID = item.DataConnectID;
param.TagMap = JsonConvert.SerializeObject(item.TagList);
list.Add(param);
}
}
}
var deviceApi = device.GetDeviceCurrentData(list);
if (deviceApi.Data != null && deviceApi.Data.Count > 0)
{
foreach (var item in get.Data)
{
foreach (var returnitem in deviceApi.Data)
{
if (item != null && returnitem != null)
{
if (item.DeviceItemID.Equals(returnitem.DeviceItemId))
{
if (returnitem.Value != null && !"".Equals(returnitem.Value))
{
item.Value = returnitem.Value;
}
else
{
item.Value = "暂无数据";
}
}
}
}
}
}
return(InspurJson <List <RetRealTimeMonitor> >(get));
}
/// <summary>
/// 物接入（研华网关方式）
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void MqttService_OnYanhuaMessageNotify(object sender, MqttMessageNotifyEventArgs e)
{
try
{
log.InfoFormat("[MQTT]收到消息：客户端：{0},主题：{1},消息：{2},Qos：{3},保留：{4}",
e.ClientId, e.MqttApplicationMessage.Topic, Encoding.UTF8.GetString(e.MqttApplicationMessage.Payload), e.MqttApplicationMessage.QualityOfServiceLevel, e.MqttApplicationMessage.Retain);
string[] topicArry = e.MqttApplicationMessage.Topic.Split('/');
string orgId = topicArry[0]; //组织ID
//报文转换为对象
YanHuaPayload yanhuaPayload;
try
{
yanhuaPayload = JsonHelper.JsonToEntity <YanHuaPayload>(Encoding.UTF8.GetString(e.MqttApplicationMessage.Payload));
}
catch (Exception ex)
{
// 转换对象失败，报文格式不对，直接放弃
log.ErrorFormat("[MQTT]解析报文格式失败：{0},{1}", ex.Message, ex.StackTrace);
return;
}
foreach (var payVal in yanhuaPayload.values)
{
try
{
DateTime uploadtime = DateTime.ParseExact(payVal.time, "yyyyMMdd-HH:mm:ss", CultureInfo.InvariantCulture);
DeviceMonitoringApi deviceMonitoringApi = new DeviceMonitoringApi();
GetDeviceInfoParameter par = new GetDeviceInfoParameter();
RetDeviceInfo deviceInfo = null;
RetDeviceItemInfo itemInfo = null;
par.OrgID = orgId;
par.Phone = payVal.device_ip;
var resDeviceInfo = deviceMonitoringApi.GetDeviceInfo(par);
if (resDeviceInfo.Code != -1)
{
deviceInfo = resDeviceInfo.Data;
itemInfo = deviceInfo.DeviceItems.Find(s => s.Name == payVal.operationValue);
if (null == itemInfo)
{
log.ErrorFormat("根据Topic获取设备属性信息出错，device_ip{0},name{1}", payVal.device_ip, payVal.name);
continue;
}
}
else
{
log.Error("根据deviceLabel获取设备信息失败" + resDeviceInfo.Msg);
continue;
}
//处理报警逻辑
AsyncHandleAlarmPolicies(deviceInfo, itemInfo, payVal.data, uploadtime);
//保存到TSDB
RecordToTsdb(deviceInfo, itemInfo, payVal.data, uploadtime);
}
catch (Exception ex)
{
log.ErrorFormat("内部错误：{0},{1}", ex.Message, ex.StackTrace);
continue;
}
}
}
catch (Exception ex)
{
log.ErrorFormat("内部错误：{0},{1}", ex.Message, ex.StackTrace);
return;
}
}
