/// <summary>
/// 通过id删除历史报警列表记录数据
/// </summary>
public ReturnItem <RetHistoryAlertPolicies> DelHistoryAlertPoliciesData(HistoryAlertPoliciesModel parameter)
{
ReturnItem <RetHistoryAlertPolicies> r = new ReturnItem <RetHistoryAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
A_AlarmHistory delalert = alert.Set <A_AlarmHistory>().Where(a => a.ID == parameter.ID).FirstOrDefault();
if (delalert != null)
{
var entry = alert.Entry(delalert);
//设置该对象的状态为删除
entry.State = EntityState.Deleted;
alert.SaveChanges();
//保存修改
r.Msg = "信息删除成功";
r.Code = 0;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 新增历史报警策略
/// </summary>
public ReturnItem <RetHistoryAlertPolicies> AddHistoryAlertPolicies(HistoryAlertPoliciesModel parameter)
{
ReturnItem <RetHistoryAlertPolicies> r = new ReturnItem <RetHistoryAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
//新增历史报警策略
A_AlarmHistory newalert = new A_AlarmHistory()
{
DeviceID = Convert.ToInt32(parameter.DeviceID),
DeviceItemID = Convert.ToInt32(parameter.DeviceItemID),
StrategyID = Convert.ToInt32(parameter.StrategyID),
Value = parameter.Value,
AlarmTime = parameter.AlarmTime,
EndTime = parameter.EndTime,
OrgID = Convert.ToInt32(parameter.OrgID),
};
alert.A_AlarmHistory.Add(newalert);
alert.SaveChanges();
r.Msg = "报警策略新增成功";
r.Code = 0;
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 获取报警策略个数
/// </summary>
/// <returns>成功返回设备列表,失败返回Null.</returns>
public ReturnItem <string> GetAlertPoliciesNum(AlertPoliciesModel parameter)
{
ReturnItem <string> r = new ReturnItem <string>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var OrgID = Convert.ToInt32(parameter.OrgID);
var get = alert.A_AlarmStrategy.Where(s => s.OrgID == OrgID).ToList();
if (get == null)
{
r.Msg = "报警策略信息获取成功";
r.Code = 0;
r.Data = "0";
return(r);
}
if (get != null)
{
r.Msg = "报警策略信息获取成功";
r.Code = 0;
r.Data = get.Count().ToString();
return(r);
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 删除报警策略信息
/// </summary>
public ReturnItem <RetAlertPolicies> DeleteAlertPolicies(AlertPoliciesModel parameter)
{
ReturnItem <RetAlertPolicies> r = new ReturnItem <RetAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var delete = alert.A_AlarmStrategy.Where(s => s.ID == parameter.ID).FirstOrDefault();
if (delete != null)
{
var entry = alert.Entry(delete);
//设置该对象的状态为删除
entry.State = EntityState.Deleted;
alert.SaveChanges();
//保存修改
}
r.Msg = "报警策略信息删除成功";
r.Code = 0;
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 更新报警策略信息
/// </summary>
public ReturnItem <RetAlertPolicies> UpdateAlertPolicies(AlertPoliciesModel parameter)
{
ReturnItem <RetAlertPolicies> r = new ReturnItem <RetAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var alertInfo = alert.A_AlarmStrategy.Where(s => s.ID == parameter.ID).FirstOrDefault();
if (alertInfo == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "未找到该设备";
return(r);
}
if (alertInfo != null)
{
string TagMap = "";
if (parameter.TagList.Count > 0)
{
TagMap = JsonConvert.SerializeObject(parameter.TagList);
}
alertInfo.StrategyName = parameter.StrategyName;
alertInfo.DeviceID = Convert.ToInt32(parameter.DeviceID);
alertInfo.DataConnectID = Convert.ToInt32(parameter.DataConnectID);
alertInfo.TagMap = TagMap;
alertInfo.DeviceItemId = Convert.ToInt32(parameter.DeviceItemId);
alertInfo.Compare = parameter.Compare;
alertInfo.Threshold = parameter.Threshold;
alertInfo.Remark = parameter.Remark;
alertInfo.UpdateTime = DateTime.Now;
alertInfo.UpdateUserId = parameter.UpdateUserId;
alertInfo.Interval = Convert.ToInt32(parameter.Interval);
if (parameter.Active == "1")
{
alertInfo.Active = true;
}
else if (parameter.Active == "0")
{
alertInfo.Active = false;
}
alertInfo.OrgID = Convert.ToInt32(parameter.OrgID);
alert.SaveChanges();
r.Msg = "报警策略更新成功";
r.Code = 0;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 处理报警逻辑(汉王数据接入使用)
/// 1.是否命中报警策略
/// 2.记录流水
/// 3.发送消息
/// </summary>
/// <param name="deviceInfo"></param>
/// <param name="itemInfo"></param>
/// <param name="curValue"></param>
/// <param name="now"></param>
/// <returns></returns>
private Task <int> HandleAlarmPolicies1(RetDeviceInfo deviceInfo, RetDeviceItemInfo itemInfo, string curValue, DateTime now)
{
int result = -1;
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
var alertInfo = alert.A_AlarmStrategy.Where(s => (s.DeviceID == deviceInfo.ID) && (s.DeviceItemId == itemInfo.ID) && (s.Active == true)).FirstOrDefault();
if (null != alertInfo)
{
if (isHitPolicies(curValue, alertInfo.Compare, alertInfo.Threshold))
{
log.InfoFormat("[MQTT]Hit Policies,topic:{0}/{1},curValue:{2},compare:{3},theshold:{4}.", deviceInfo.DeviceLabel, itemInfo.PropertyLabel, curValue, alertInfo.Compare, alertInfo.Threshold);
HistoryAlertPoliciesBLL historyBLL = new HistoryAlertPoliciesBLL();
HistoryAlertPoliciesModel model = new HistoryAlertPoliciesModel()
{
DeviceID = deviceInfo.ID.ToString(),
DeviceItemID = itemInfo.ID.ToString(),
StrategyID = alertInfo.ID.ToString(),
Value = curValue,
AlarmTime = now,
EndTime = now.AddSeconds(1),
OrgID = alertInfo.OrgID.ToString(),
};
historyBLL.AddHistoryAlertPolicies(model);
// 发送消息通知
UserApi api = new UserApi();
GetMessageInfoParameter messageModel = new GetMessageInfoParameter()
{
Type = "2", // 报警预警
Tittle = "【设备报警通知】" + deviceInfo.Name + itemInfo.Name + "报警！",
Text = "<p>您好：</p><p class='ql-indent-1'>" + deviceInfo.Name + "（设备）" + itemInfo.Name + "（属性）当前数值为" + curValue + "，已触发预设报警策略，请及时处理异常！</p><p><br></p><p class='ql-align-right'>设备在线监测平台</p>",
OrgID = alertInfo.OrgID.ToString()
};
var userApi = api.AddAlarmMessage(messageModel);
if (userApi.Code != 0)
{
log.ErrorFormat(userApi.Data);
}
}
}
}
return(new Task <int>(() => result));
}
/// <summary>
/// 获取历史报警列表记录数据
/// </summary>
/// <returns>成功返回报警记录,失败返回Null.</returns>
public ReturnItem <List <RetHistoryAlertPolicies> > GetHistoryAlertPoliciesDataList(HistoryAlertPoliciesModel parameter, List <RetDeviceInfo> Info)
{
ReturnItem <List <RetHistoryAlertPolicies> > r = new ReturnItem <List <RetHistoryAlertPolicies> >();
List <RetHistoryAlertPolicies> listinfo = new List <RetHistoryAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var alertList = alert.A_AlarmHistory.Join(alert.A_AlarmStrategy, x => x.StrategyID, x => x.ID, (a, b) => new { a, b }).AsQueryable();
if (parameter.StrategyName != null && !"".Equals(parameter.StrategyName))
{
alertList = alertList.Where(x => x.b.StrategyName.IndexOf(parameter.StrategyName) >= 0);
}
if (parameter.DeviceID != null && parameter.DeviceID != "")
{
if (parameter.DeviceItemIDList != null)
{
if (parameter.DeviceItemIDList.Count > 0)
{
var DeviceID = Convert.ToInt32(parameter.DeviceID);
alertList = alertList.Where(s => s.a.DeviceID == DeviceID && parameter.DeviceItemIDList.Contains(s.a.DeviceItemID.ToString()));
}
}
else
{
var DeviceID = Convert.ToInt32(parameter.DeviceID);
alertList = alertList.Where(s => s.a.DeviceID == DeviceID);
}
}
alertList = alertList.OrderByDescending(s => s.a.AlarmTime);
if (parameter.OrgID != null && !"".Equals(parameter.OrgID))
{
var OrgId = Convert.ToInt32(parameter.OrgID);
alertList = alertList.Where(x => x.a.OrgID == OrgId);
}
if (alertList == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "没有数据";
return(r);
}
if (alertList != null)
{
r.Count = alertList.Count();
if (parameter.PageIndex != 0 && parameter.PageSize != 0)
{
alertList = alertList.Skip((parameter.PageIndex - 1) * parameter.PageSize).Take(parameter.PageSize);
}
var list = alertList.ToList();
var compareValue = "";
foreach (var item in list)
{
if ("1".Equals(item.b.Compare))
{
compareValue = "＞";
}
else if ("2".Equals(item.b.Compare))
{
compareValue = "≥";
}
else if ("3".Equals(item.b.Compare))
{
compareValue = "＝";
}
else if ("4".Equals(item.b.Compare))
{
compareValue = "＜";
}
else if ("5".Equals(item.b.Compare))
{
compareValue = "≤";
}
else if ("6".Equals(item.b.Compare))
{
compareValue = "≠";
}
var alertinfo = new RetHistoryAlertPolicies();
alertinfo.ID = item.a.ID;
alertinfo.DeviceID = item.a.DeviceID.ToString();
alertinfo.DeviceItemID = item.a.DeviceItemID.ToString();
alertinfo.StrategyID = item.a.StrategyID.ToString();
alertinfo.StrategyName = item.b.StrategyName;
alertinfo.Value = item.a.Value;
alertinfo.AlarmTime = item.a.AlarmTime;
alertinfo.EndTime = item.a.EndTime;
alertinfo.OrgID = item.a.OrgID.ToString();
alertinfo.Compare = item.b.Compare;
if (Info != null)
{
foreach (var DeviceInfo in Info)
{
if (DeviceInfo.ID == item.a.DeviceID)
{
foreach (var DeviceItemInfo in DeviceInfo.DeviceItems)
{
if (DeviceItemInfo.ID == item.a.DeviceItemID)
{
alertinfo.DeviceName = DeviceInfo.Name;
alertinfo.DeviceItemName = DeviceItemInfo.Name;
alertinfo.StrategyValue = DeviceItemInfo.Name + compareValue + item.b.Threshold;
listinfo.Add(alertinfo);
}
}
}
}
}
}
r.Msg = "历史报警信息获取成功";
r.Code = 0;
r.Data = listinfo;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
return(r);
}
}
return(r);
}
/// <summary>
/// 获取统计报警信息列表
/// </summary>
/// <returns>成功返回列表,失败返回Null.</returns>
public ReturnItem <List <RetAlarmReport> > GetAlarmReportList(AlarmReportModel parameter, List <RetDeviceInfo> Info)
{
ReturnItem <List <RetAlarmReport> > r = new ReturnItem <List <RetAlarmReport> >();
List <RetAlarmReport> listinfo = new List <RetAlarmReport>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var alertList = alert.A_AlarmHistory.AsQueryable();
if (parameter.OrgID.ToString() != null && parameter.OrgID.ToString() != "")
{
var OrgID = Convert.ToInt32(parameter.OrgID);
alertList = alertList.Where(s => s.OrgID == OrgID);
}
var list = alertList.GroupBy(a => a.DeviceID).Select(g => (new { DeviceID = g.Key })).ToList();
if (list == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "未找到统计报警信息";
return(r);
}
if (list != null)
{
List <long> idlist = new List <long>();
foreach (var id in list)
{
idlist.Add(id.DeviceID);
}
var TimeList = alert.A_AlarmHistory.AsQueryable();
// 报表周期
if (parameter.StartTime != null && parameter.StartTime != "" && parameter.EndTime != null && parameter.EndTime != "")
{
var StartTime = Convert.ToDateTime(parameter.StartTime);
var EndTime = Convert.ToDateTime(parameter.EndTime);
TimeList = TimeList.Where(s => s.AlarmTime >= StartTime && s.EndTime <= EndTime);
}
TimeList = TimeList.Where(s => idlist.Contains(s.DeviceID));
foreach (var item in list)
{
var alertinfo = new RetAlarmReport();
alertinfo.DeviceID = item.DeviceID.ToString();
// 报警次数、报警总时长
Double time = 0;
int num = 0;
List <string> data = new List <string>();
foreach (var info in TimeList)
{
if (item.DeviceID == info.DeviceID)
{
time += (info.EndTime - info.AlarmTime).Value.TotalSeconds;
num++;
}
}
alertinfo.AlarmNumber = num.ToString();
data.Add(num.ToString());
alertinfo.TotalTime = time.ToString();
data.Add(time.ToString());
alertinfo.AlertData = data;
// 设备名称
foreach (var DeviceInfo in Info)
{
if (DeviceInfo.ID == item.DeviceID)
{
if (DeviceInfo.Name.IndexOf(parameter.DeviceName) >= 0)
{
// 设备分组
if (parameter.GroupIDList != null && parameter.GroupIDList.Count > 0)
{
if (parameter.GroupIDList.Count() == 1 && parameter.GroupIDList[0] == null)
{
parameter.GroupIDList[0] = "0";
}
if (parameter.GroupIDList.Contains(DeviceInfo.GroupID))
{
alertinfo.DeviceName = DeviceInfo.Name;
if (num > 0 && time > 0)
{
// 报警次数
if (parameter.StartNumber != "" && parameter.EndNumber != "")
{
if (num >= Convert.ToInt32(parameter.StartNumber) && num <= Convert.ToInt32(parameter.EndNumber))
{
listinfo.Add(alertinfo);
}
}
else
{
listinfo.Add(alertinfo);
}
}
}
}
else
{
alertinfo.DeviceName = DeviceInfo.Name;
if (num > 0 && time > 0)
{
// 报警次数
if (parameter.StartNumber != "" && parameter.EndNumber != "")
{
if (num >= Convert.ToInt32(parameter.StartNumber) && num <= Convert.ToInt32(parameter.EndNumber))
{
listinfo.Add(alertinfo);
}
}
else
{
listinfo.Add(alertinfo);
}
}
}
}
}
}
}
r.Count = listinfo.Count;
r.Msg = "报警策略信息获取成功";
r.Code = 0;
r.Data = listinfo;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 查看单个设备属性报警信息数据列表
/// </summary>
/// <returns>成功返回报警记录,失败返回Null.</returns>
public ReturnItem <RetAlarmReportDetail> GetAlarmReportDetailDataList(AlarmReportItemModel parameter, List <RetDeviceInfo> Info)
{
ReturnItem <RetAlarmReportDetail> r = new ReturnItem <RetAlarmReportDetail>();
RetAlarmReportDetail detail = new RetAlarmReportDetail();
List <RetAlarmReportItem> listinfo = new List <RetAlarmReportItem>();
List <RetChartInfo> listchartinfo = new List <RetChartInfo>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var alertList = alert.A_AlarmHistory.AsQueryable();
if (parameter.AlarmTime != null && !"".Equals(parameter.AlarmTime))
{
alertList = alertList.Where(x => x.AlarmTime >= parameter.AlarmTime);
}
if (parameter.EndTime != null && !"".Equals(parameter.EndTime))
{
alertList = alertList.Where(x => x.EndTime <= parameter.EndTime);
}
if (parameter.OrgID != null && !"".Equals(parameter.OrgID))
{
var OrgId = Convert.ToInt32(parameter.OrgID);
alertList = alertList.Where(x => x.OrgID == OrgId);
}
if (parameter.DeviceID != null && !"".Equals(parameter.DeviceID))
{
if (parameter.DeviceItemIDList.Count > 0)
{
var DeviceID = Convert.ToInt32(parameter.DeviceID);
alertList = alertList.Where(s => s.DeviceID == DeviceID && parameter.DeviceItemIDList.Contains(s.DeviceItemID.ToString()));
}
else
{
var DeviceID = Convert.ToInt32(parameter.DeviceID);
alertList = alertList.Where(s => s.DeviceID == DeviceID);
}
}
alertList = alertList.OrderByDescending(s => s.AlarmTime);
if (alertList == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "没有数据";
return(r);
}
if (alertList != null)
{
r.Count = alertList.Count();
if (parameter.PageIndex != 0 && parameter.PageSize != 0)
{
alertList = alertList.Skip((parameter.PageIndex - 1) * parameter.PageSize).Take(parameter.PageSize);
}
List <A_AlarmHistory> list = alertList.ToList <A_AlarmHistory>();
List <string> compareValue = new List <string>();
foreach (var item in list)
{
var alertinfo = new RetAlarmReportItem();
alertinfo.ID = item.ID;
alertinfo.DeviceID = item.DeviceID.ToString();
alertinfo.DeviceItemID = item.DeviceItemID.ToString();
alertinfo.StrategyID = item.StrategyID.ToString();
alertinfo.Value = item.Value;
alertinfo.AlarmTime = item.AlarmTime;
alertinfo.EndTime = item.EndTime;
alertinfo.OrgID = item.OrgID.ToString();
var chartinfo = new RetChartInfo();
foreach (var DeviceInfo in Info)
{
if (DeviceInfo.ID == item.DeviceID)
{
foreach (var DeviceItemInfo in DeviceInfo.DeviceItems)
{
if (DeviceItemInfo.ID == item.DeviceItemID)
{
alertinfo.DeviceName = DeviceInfo.Name;
alertinfo.DeviceItemName = DeviceItemInfo.Name;
listinfo.Add(alertinfo);
if (compareValue == null || (compareValue != null && !compareValue.Exists(x => x == item.DeviceItemID.ToString())))
{
compareValue.Add(item.DeviceItemID.ToString());
chartinfo.DeviceItemName = DeviceItemInfo.Name;
chartinfo.DeviceItemID = DeviceItemInfo.ID;
listchartinfo.Add(chartinfo);
}
}
}
}
}
}
detail.AlarmReportItem = listinfo;
detail.ChartInfo = listchartinfo;
r.Msg = "统计属性报警信息获取成功";
r.Code = 0;
r.Data = detail;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
return(r);
}
}
return(r);
}
/// <summary>
/// 新增报警策略列表
/// </summary>
/// <param name="parameter"></param>
/// <returns></returns>
//public ReturnItem<List<RetAlertPolicies>> AddAlertPoliciesInfoList(AlertPoliciesListModel parameter)
//{
// ReturnItem<List<RetAlertPolicies>> r = new ReturnItem<List<RetAlertPolicies>>();
// using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
// {
// try
// {
// var message = alert.A_AlarmStrategy.Where(s => s.StrategyName == parameter.StrategyName).FirstOrDefault();
// if (message != null)
// {
// r.Data = null;
// r.Code = -1;
// r.Msg = "报警策略已存在";
// return r;
// }
// if (message == null)
// {
// foreach (var item in parameter.Property)
// {
// string TagMap = "";
// if (item.TagList.Count > 0)
// {
// TagMap = JsonConvert.SerializeObject(item.TagList);
// }
// //新增报警策略
// A_AlarmStrategy newalert = new A_AlarmStrategy()
// {
// StrategyName = parameter.StrategyName,
// DeviceID = Convert.ToInt32(item.DeviceID),
// DataConnectID = Convert.ToInt32(item.DataConnectID),
// DeviceItemId = Convert.ToInt32(item.DeviceItemId),
// Compare = item.Compare,
// Threshold = item.Threshold,
// Remark = parameter.Remark,
// CreateUserID = parameter.CreateUserID,
// CreateTime = DateTime.Now,
// Interval = Convert.ToInt32(parameter.Interval),
// OrgID = Convert.ToInt32(parameter.OrgID),
// };
// if (TagMap != "")
// {
// newalert.TagMap = TagMap;
// }
// if (parameter.Active == "1")
// {
// newalert.Active = true;
// }
// else if (parameter.Active == "0")
// {
// newalert.Active = false;
// }
// alert.A_AlarmStrategy.Add(newalert);
// alert.SaveChanges();
// r.Msg = "报警策略新增成功";
// r.Code = 0;
// }
// }
// }
// catch (Exception e)
// {
// r.Msg = "内部错误请重试";
// log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
// r.Code = -1;
// }
// }
// return r;
//}
/// <summary>
/// 利用ID获取报警策略信息
/// </summary>
/// <returns>成功返回用户信息,失败返回Null.</returns>
public ReturnItem <RetAlertPolicies> GetAlertPoliciesInfoByID(AlertPoliciesModel parameter)
{
ReturnItem <RetAlertPolicies> r = new ReturnItem <RetAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var alertInfo = alert.A_AlarmStrategy.Where(x => x.ID == parameter.ID).FirstOrDefault();
if (alertInfo == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "未找到设备";
return(r);
}
if (alertInfo != null)
{
r.Msg = "设备模板获取成功";
r.Code = 0;
r.Data = new RetAlertPolicies()
{
ID = alertInfo.ID.ToString(),
StrategyName = alertInfo.StrategyName,
DeviceID = alertInfo.DeviceID.ToString(),
DataConnectID = alertInfo.DataConnectID.ToString(),
DeviceItemId = alertInfo.DeviceItemId.ToString(),
Compare = alertInfo.Compare,
Threshold = alertInfo.Threshold,
Remark = alertInfo.Remark,
CreateUserID = alertInfo.CreateUserID.ToString(),
CreateTime = alertInfo.CreateTime,
UpdateUserId = alertInfo.UpdateUserId.ToString(),
UpdateTime = alertInfo.UpdateTime,
Interval = alertInfo.Interval.ToString(),
OrgID = alertInfo.OrgID.ToString()
};
if (alertInfo.Active == true)
{
r.Data.Active = "1";
}
else if (alertInfo.Active == false)
{
r.Data.Active = "0";
}
// 获取TagList
List <RetTagMap> taglist = new List <RetTagMap>();
if (alertInfo.TagMap != "" && alertInfo.TagMap != null)
{
taglist = JsonConvert.DeserializeObject <List <RetTagMap> >(alertInfo.TagMap);
}
r.Data.TagList = taglist;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 获取报警策略列表
/// </summary>
/// <returns>成功返回设备列表,失败返回Null.</returns>
public ReturnItem <List <RetAlertPolicies> > GetAlertPoliciesList(AlertPoliciesModel parameter, List <RetDeviceInfo> Info)
{
ReturnItem <List <RetAlertPolicies> > r = new ReturnItem <List <RetAlertPolicies> >();
List <RetAlertPolicies> listinfo = new List <RetAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var alertList = alert.A_AlarmStrategy.AsQueryable();
if (parameter.StrategyName != null && parameter.StrategyName != "")
{
alertList = alertList.Where(s => s.StrategyName.IndexOf(parameter.StrategyName) >= 0);
}
if (parameter.DeviceID != null && parameter.DeviceID != "")
{
if (parameter.DeviceItemIDList.Count > 0)
{
var DeviceID = Convert.ToInt32(parameter.DeviceID);
alertList = alertList.Where(s => s.DeviceID == DeviceID && parameter.DeviceItemIDList.Contains(s.DeviceItemId.ToString()));
}
else
{
var DeviceID = Convert.ToInt32(parameter.DeviceID);
alertList = alertList.Where(s => s.DeviceID == DeviceID);
}
}
if (parameter.OrgID.ToString() != null && parameter.OrgID.ToString() != "")
{
var OrgID = Convert.ToInt32(parameter.OrgID);
alertList = alertList.Where(s => s.OrgID == OrgID);
}
alertList = alertList.OrderByDescending(s => s.CreateTime);
if (alertList == null)
{
r.Data = null;
r.Code = -1;
r.Msg = "未找到报警策略";
return(r);
}
if (alertList != null)
{
List <A_AlarmStrategy> list = alertList.ToList <A_AlarmStrategy>();
foreach (var item in list)
{
var alertinfo = new RetAlertPolicies();
alertinfo.ID = item.ID.ToString();
alertinfo.StrategyName = item.StrategyName;
alertinfo.DeviceID = item.DeviceID.ToString();
alertinfo.DataConnectID = item.DataConnectID.ToString();
// 获取TagList
List <RetTagMap> taglist = new List <RetTagMap>();
if (item.TagMap != "" && item.TagMap != null)
{
taglist = JsonConvert.DeserializeObject <List <RetTagMap> >(item.TagMap);
}
alertinfo.TagList = taglist;
alertinfo.DeviceItemId = item.DeviceItemId.ToString();
alertinfo.Compare = item.Compare;
alertinfo.Threshold = item.Threshold;
alertinfo.Remark = item.Remark;
alertinfo.CreateTime = item.CreateTime;
alertinfo.CreateUserID = item.CreateUserID.ToString();
alertinfo.UpdateTime = item.UpdateTime;
alertinfo.UpdateUserId = item.UpdateUserId.ToString();
alertinfo.Interval = item.Interval.ToString();
alertinfo.Active = item.Active.ToString();
alertinfo.OrgID = item.OrgID.ToString();
foreach (var DeviceInfo in Info)
{
if (DeviceInfo.ID == item.DeviceID)
{
foreach (var DeviceItemInfo in DeviceInfo.DeviceItems)
{
if (DeviceItemInfo.ID == item.DeviceItemId)
{
alertinfo.DeviceName = DeviceInfo.Name;
alertinfo.DeviceItemName = DeviceItemInfo.Name;
listinfo.Add(alertinfo);
}
}
}
}
}
r.Count = listinfo.Count();
r.Msg = "报警策略信息获取成功";
r.Code = 0;
r.Data = listinfo;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
/// <summary>
/// 新增报警策略
/// </summary>
public ReturnItem <RetAlertPolicies> AddAlertPoliciesInfo(AlertPoliciesModel parameter)
{
ReturnItem <RetAlertPolicies> r = new ReturnItem <RetAlertPolicies>();
using (AlertPoliciesEntities alert = new AlertPoliciesEntities())
{
try
{
var message = alert.A_AlarmStrategy.Where(s => s.StrategyName == parameter.StrategyName).FirstOrDefault();
if (message != null)
{
r.Data = null;
r.Code = -1;
r.Msg = "报警策略已存在";
return(r);
}
if (message == null)
{
string TagMap = "";
if (parameter.TagList.Count > 0)
{
TagMap = JsonConvert.SerializeObject(parameter.TagList);
}
//新增报警策略
A_AlarmStrategy newalert = new A_AlarmStrategy()
{
StrategyName = parameter.StrategyName,
DeviceID = Convert.ToInt32(parameter.DeviceID),
DataConnectID = Convert.ToInt32(parameter.DataConnectID),
DeviceItemId = Convert.ToInt32(parameter.DeviceItemId),
Compare = parameter.Compare,
Threshold = parameter.Threshold,
Remark = parameter.Remark,
CreateUserID = parameter.CreateUserID,
CreateTime = DateTime.Now,
Interval = Convert.ToInt32(parameter.Interval),
OrgID = Convert.ToInt32(parameter.OrgID),
};
if (TagMap != "")
{
newalert.TagMap = TagMap;
}
if (parameter.Active == "1")
{
newalert.Active = true;
}
else if (parameter.Active == "0")
{
newalert.Active = false;
}
alert.A_AlarmStrategy.Add(newalert);
alert.SaveChanges();
r.Msg = "报警策略新增成功";
r.Code = 0;
}
}
catch (Exception e)
{
r.Msg = "内部错误请重试";
log.ErrorFormat("内部错误：{0},{1}", e.Message, e.StackTrace);
r.Code = -1;
}
}
return(r);
}
