using Microsoft.AspNetCore.Mvc;
|
using System.Net;
|
using System.Net.Http.Headers;
|
using Microsoft.Extensions.Hosting.Internal;
|
using Microsoft.AspNetCore.Http.Extensions;
|
using IStation.Untity;
|
using Furion.DynamicApiController;
|
using System.ComponentModel.DataAnnotations;
|
using Mapster;
|
using IStation.Calculation;
|
using IStation.Model;
|
using Microsoft.AspNetCore.Authorization;
|
|
namespace IStation.Application
|
{
|
/// <summary>
|
/// MonitorRealRecord
|
/// </summary>
|
[Route("Run/MonitorRealRecord")]
|
[ApiDescriptionSettings("Run", Name = "监测实时记录", Order = 990)]
|
public class MonitorRealRecord_Controller : IDynamicApiController
|
{
|
//服务
|
private readonly Service.MonitorRealRecord _service = new Service.MonitorRealRecord();
|
|
#region 获取最近记录
|
|
#region 通过 MonitorPointID 获取
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取最近一条数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
/// <param name="input">入参</param>
|
/// <returns>列表（振动数据为多条）</returns>
|
[Route("GetLastRecordByMonitorPointID@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointID_V1_0([FromQuery][Required] MonitorPointIDUnderCorpInput input)
|
{
|
var list = _service.GetLastRecord(input.CorpID, input.MonitorPointID);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取最近一条数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
/// <param name="input">入参</param>
|
/// <returns>列表（振动数据为多条）</returns>
|
[AllowAnonymous]
|
[Route("GetLastRecordByMonitorPointID@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointID_V1_1([FromQuery][Required] MonitorPointIDUnderCorpInput input)
|
{
|
var list = _service.GetLastRecord(input.CorpID, input.MonitorPointID);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取最近一条数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
/// <param name="input">入参</param>
|
/// <returns>列表（振动数据为多条）</returns>
|
[Route("GetLastRecordByMonitorPointID@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointID_V2_0([FromQuery][Required] MonitorPointIDUnderCorpInput input)
|
{
|
var corpId = input.CorpID;
|
var monitorPointId = input.MonitorPointID;
|
var list = _service.GetLastRecord(corpId, monitorPointId);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(corpId, monitorPointId);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取最近一条数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
/// <param name="input">入参</param>
|
/// <returns>列表（振动数据为多条）</returns>
|
[AllowAnonymous]
|
[Route("GetLastRecordByMonitorPointID@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointID_V2_1([FromQuery][Required] MonitorPointIDUnderCorpInput input)
|
{
|
var corpId = input.CorpID;
|
var monitorPointId = input.MonitorPointID;
|
var list = _service.GetLastRecord(corpId, monitorPointId);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(corpId, monitorPointId);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 通过 MonitorPointIds 获取
|
|
/// <summary>
|
/// 通过 MonitorPointIds 获取最近一条数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
/// <param name="input">入参</param>
|
/// <returns>列表（振动测点为多条）</returns>
|
[Route("GetLastRecordByMonitorPointIds@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointIds_V1_0([FromQuery][Required] MonitorPointIdsUnderCorpInput input)
|
{
|
var ids = LongListHelper.ToList(input.MonitorPointIds);
|
var list = _service.GetLastRecord(input.CorpID, ids);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointIds 获取最近一条数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)(不需要验证token)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetLastRecordByMonitorPointIds@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointIds_V1_1([FromQuery][Required] MonitorPointIdsUnderCorpInput input)
|
{
|
var ids = LongListHelper.ToList(input.MonitorPointIds);
|
var list = _service.GetLastRecord(input.CorpID, ids);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointIds 获取最近一条数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
/// <param name="input">入参</param>
|
/// <returns>列表（振动测点为多条）</returns>
|
[Route("GetLastRecordByMonitorPointIds@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointIds_V2_0([FromQuery][Required] MonitorPointIdsUnderCorpInput input)
|
{
|
var corpId = input.CorpID;
|
var monitorPointIds = LongListHelper.ToList(input.MonitorPointIds);
|
var list = _service.GetLastRecord(input.CorpID, monitorPointIds);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitorList = new Service.MonitorPoint().GetExSignalWithSignalTypeByIds(corpId, monitorPointIds);
|
var vmList = list.Select(x =>
|
{
|
var monitor = monitorList.Find(t => t.ID == x.MonitorPointID);
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointIds 获取最近一条数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
/// <param name="input">入参</param>
|
/// <returns>列表（振动测点为多条）</returns>
|
[AllowAnonymous]
|
[Route("GetLastRecordByMonitorPointIds@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointIds_V2_1([FromQuery][Required] MonitorPointIdsUnderCorpInput input)
|
{
|
var corpId = input.CorpID;
|
var monitorPointIds = LongListHelper.ToList(input.MonitorPointIds);
|
var list = _service.GetLastRecord(input.CorpID, monitorPointIds);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitorList = new Service.MonitorPoint().GetExSignalWithSignalTypeByIds(corpId, monitorPointIds);
|
var vmList = list.Select(x =>
|
{
|
var monitor = monitorList.Find(t => t.ID == x.MonitorPointID);
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointIds 获取最近一条数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)(调试专用)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetLastRecordByMonitorPointIds@Debug")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordByMonitorPointIds_Debug([FromQuery][Required] MonitorPointIdsUnderCorpInput input)
|
{
|
var ids = LongListHelper.ToList(input.MonitorPointIds);
|
var list = _service.GetLastRecord(input.CorpID, ids);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 通过 SignalID 获取
|
|
/// <summary>
|
/// 通过 SignalID 获取最近一条数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetLastRecordBySignalID@V1.0")]
|
[HttpGet]
|
public MonitorRealRecordDto GetLastRecordBySignalID_V1_0([FromQuery][Required] SignalIDUnderCorpInput input)
|
{
|
var model = _service.GetLastRecord(input.CorpID, input.MonitorPointID, input.SignalID);
|
var vm = model == null ? null : new MonitorRealRecordDto(model);
|
return vm;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取最近一条数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetLastRecordBySignalID@V1.1")]
|
[HttpGet]
|
public MonitorRealRecordDto GetLastRecordBySignalID_V1_1([FromQuery][Required] SignalIDUnderCorpInput input)
|
{
|
var model = _service.GetLastRecord(input.CorpID, input.MonitorPointID, input.SignalID);
|
var vm = model == null ? null : new MonitorRealRecordDto(model);
|
return vm;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取最近一条数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetLastRecordBySignalID@V2.0")]
|
[HttpGet]
|
public MonitorRealRecordDto GetLastRecordBySignalID_V2_0([FromQuery][Required] SignalIDUnderCorpInput input)
|
{
|
var corpId = input.CorpID;
|
var monitorPointId = input.MonitorPointID;
|
var signalId = input.SignalID;
|
var model = _service.GetLastRecord(corpId, monitorPointId, signalId);
|
if (model == null)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(corpId, signalId);
|
var vm = new MonitorRealRecordDto(model, signal);
|
return vm;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取最近一条数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetLastRecordBySignalID@V2.1")]
|
[HttpGet]
|
public MonitorRealRecordDto GetLastRecordBySignalID_V2_1([FromQuery][Required] SignalIDUnderCorpInput input)
|
{
|
var corpId = input.CorpID;
|
var monitorPointId = input.MonitorPointID;
|
var signalId = input.SignalID;
|
var model = _service.GetLastRecord(corpId, monitorPointId, signalId);
|
if (model == null)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(corpId, signalId);
|
var vm = new MonitorRealRecordDto(model, signal);
|
return vm;
|
}
|
|
#endregion
|
|
#region 通过 SignalIds 获取
|
|
/// <summary>
|
/// 通过 SignalIds 获取最近一条数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetLastRecordBySignalIds@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordBySignalIds_V1_0([FromQuery][Required] SignalIdsUnderCorpInput input)
|
{
|
var ids = LongListHelper.ToList(input.SignalIds);
|
var list = _service.GetLastRecord(input.CorpID, input.MonitorPointID, ids);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalIds 获取最近一条数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetLastRecordBySignalIds@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordBySignalIds_V1_1([FromQuery][Required] SignalIdsUnderCorpInput input)
|
{
|
var ids = LongListHelper.ToList(input.SignalIds);
|
var list = _service.GetLastRecord(input.CorpID, input.MonitorPointID, ids);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalIds 获取最近一条数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetLastRecordBySignalIds@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordBySignalIds_V2_0([FromQuery][Required] SignalIdsUnderCorpInput input)
|
{
|
var ids = LongListHelper.ToList(input.SignalIds);
|
var list = _service.GetLastRecord(input.CorpID, input.MonitorPointID, ids);
|
if (list == null || list.Count < 1)
|
return default;
|
var signalList = new Service.Signal().GetExSignalTypeBySignalIds(input.CorpID, ids);
|
var vmList = list.Select(x => new MonitorRealRecordDto(x, signalList?.Find(t => t.ID == x.SignalID))).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalIds 获取最近一条数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetLastRecordBySignalIds@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetLastRecordBySignalIds_V2_1([FromQuery][Required] SignalIdsUnderCorpInput input)
|
{
|
var ids = LongListHelper.ToList(input.SignalIds);
|
var list = _service.GetLastRecord(input.CorpID, input.MonitorPointID, ids);
|
if (list == null || list.Count < 1)
|
return default;
|
var signalList = new Service.Signal().GetExSignalTypeBySignalIds(input.CorpID, ids);
|
var vmList = list.Select(x => new MonitorRealRecordDto(x, signalList?.Find(t => t.ID == x.SignalID))).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#endregion
|
|
#region 通过测点标识获取
|
|
#region 获取某天的数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetByMonitorPointIDOfDay@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDay_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetByMonitorPointIDOfDay@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDay_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetByMonitorPointIDOfDay@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDay_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetByMonitorPointIDOfDay@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDay_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取某天固定数量的数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetFixedByMonitorPointIDOfDay@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDay_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedByMonitorPointIDOfDay@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDay_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetFixedByMonitorPointIDOfDay@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDay_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedByMonitorPointIDOfDay@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDay_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取某天的内容数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的内容数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetContentByMonitorPointIDOfDay@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDay_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的内容数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentByMonitorPointIDOfDay@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDay_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的内容数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetContentByMonitorPointIDOfDay@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDay_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天的内容数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentByMonitorPointIDOfDay@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDay_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取某天固定数量的内容数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的内容数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetFixedContentByMonitorPointIDOfDay@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDay_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的内容数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedContentByMonitorPointIDOfDay@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDay_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的内容数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetFixedContentByMonitorPointIDOfDay@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDay_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取某天固定数量的内容数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedContentByMonitorPointIDOfDay@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDay_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime Day,
|
int Fixed = 10000
|
)
|
{
|
var list = _service.GetFixedContentByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取日期区间内的数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetByMonitorPointIDOfDayRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDayRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetByMonitorPointIDOfDayRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDayRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetByMonitorPointIDOfDayRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDayRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetByMonitorPointIDOfDayRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfDayRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取日期区间内固定数量的数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetFixedByMonitorPointIDOfDayRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDayRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedByMonitorPointIDOfDayRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDayRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetFixedByMonitorPointIDOfDayRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDayRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedByMonitorPointIDOfDayRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfDayRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取日期区间内的内容数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的内容数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetContentByMonitorPointIDOfDayRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDayRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的内容数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentByMonitorPointIDOfDayRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDayRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的内容数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetContentByMonitorPointIDOfDayRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDayRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内的内容数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentByMonitorPointIDOfDayRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfDayRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取日期区间内固定数量的内容数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的内容数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetFixedContentByMonitorPointIDOfDayRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDayRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的内容数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedContentByMonitorPointIDOfDayRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDayRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的内容数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetFixedContentByMonitorPointIDOfDayRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDayRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取日期区间内固定数量的内容数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedContentByMonitorPointIDOfDayRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfDayRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartDay,
|
[Required]
|
DateTime EndDay,
|
int Fixed = 10000
|
)
|
{
|
if (StartDay.Date > EndDay.Date)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取时间区间内的数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetByMonitorPointIDOfTimeRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfTimeRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetByMonitorPointIDOfTimeRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfTimeRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetByMonitorPointIDOfTimeRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfTimeRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetByMonitorPointIDOfTimeRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetByMonitorPointIDOfTimeRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取时间区间内固定数量的数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetFixedByMonitorPointIDOfTimeRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfTimeRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedByMonitorPointIDOfTimeRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfTimeRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetFixedByMonitorPointIDOfTimeRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfTimeRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedByMonitorPointIDOfTimeRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetFixedByMonitorPointIDOfTimeRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取时间区间内的内容数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的内容数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetContentByMonitorPointIDOfTimeRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfTimeRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的内容数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentByMonitorPointIDOfTimeRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfTimeRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的内容数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetContentByMonitorPointIDOfTimeRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfTimeRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内的内容数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentByMonitorPointIDOfTimeRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetContentByMonitorPointIDOfTimeRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
|
#endregion
|
|
#region 获取时间区间内固定数量的内容数据
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的内容数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetFixedContentByMonitorPointIDOfTimeRange@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfTimeRange_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的内容数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedContentByMonitorPointIDOfTimeRange@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfTimeRange_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
var vmList = list?.Select(x => new MonitorRealRecordSignalContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的内容数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetFixedContentByMonitorPointIDOfTimeRange@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfTimeRange_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 MonitorPointID 获取时间区间内固定数量的内容数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetFixedContentByMonitorPointIDOfTimeRange@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordSignalContentDto> GetFixedContentByMonitorPointIDOfTimeRange_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required]
|
DateTime StartTime,
|
[Required]
|
DateTime EndTime,
|
int Fixed = 10000
|
)
|
{
|
if (StartTime > EndTime)
|
{
|
return default;
|
}
|
var list = _service.GetFixedContentByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime, Fixed);
|
if (list == null || list.Count < 1)
|
return default;
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(CorpID, MonitorPointID);
|
var vmList = list.Select(x =>
|
{
|
var signal = monitor.SignalList.Find(t => t.ID == x.SignalID);
|
var vm = new MonitorRealRecordSignalContentDto(x, signal);
|
return vm;
|
}).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#endregion
|
|
#region 通过信号标识获取
|
|
#region 获取某天的数据
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetBySignalIDOfDay@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetBySignalIDOfDay_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetBySignalIDOfDay@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetBySignalIDOfDay_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetBySignalIDOfDay@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetBySignalIDOfDay_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(CorpID,SignalID);
|
var vmList = list.Select(x => new MonitorRealRecordDto(x,signal)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetBySignalIDOfDay@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordDto> GetBySignalIDOfDay_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(CorpID, SignalID);
|
var vmList = list.Select(x => new MonitorRealRecordDto(x, signal)).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取某天的内容数据
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的内容数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetContentBySignalIDOfDay@V1.0")]
|
[HttpGet]
|
public List<MonitorRealRecordContentDto> GetContentBySignalIDOfDay_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的内容数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentBySignalIDOfDay@V1.1")]
|
[HttpGet]
|
public List<MonitorRealRecordContentDto> GetContentBySignalIDOfDay_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
var vmList = list?.Select(x => new MonitorRealRecordContentDto(x)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的内容数据(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[Route("GetContentBySignalIDOfDay@V2.0")]
|
[HttpGet]
|
public List<MonitorRealRecordContentDto> GetContentBySignalIDOfDay_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(CorpID,SignalID);
|
var vmList = list?.Select(x => new MonitorRealRecordContentDto(x, signal)).ToList();
|
return vmList;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某天的内容数据(不需要验证Token)(已进行单位换算，使用的是信号显示单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetContentBySignalIDOfDay@V2.1")]
|
[HttpGet]
|
public List<MonitorRealRecordContentDto> GetContentBySignalIDOfDay_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime Day
|
)
|
{
|
var list = _service.GetContentBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
|
if (list == null || list.Count < 1)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(CorpID, SignalID);
|
var vmList = list?.Select(x => new MonitorRealRecordContentDto(x, signal)).ToList();
|
return vmList;
|
}
|
|
#endregion
|
|
#region 获取某一时刻的数据
|
|
/// <summary>
|
/// 通过 SignalID 获取某一时刻的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetBySignalIDOfDataTime@V1.0")]
|
[HttpGet]
|
public MonitorRealRecordDto GetBySignalIDOfDataTime_V1_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime DataTime
|
)
|
{
|
var model = _service.GetBySignalIDOfDataTime(CorpID, MonitorPointID, SignalID, DataTime);
|
if (model == null)
|
return default;
|
var vm = new MonitorRealRecordDto(model);
|
return vm;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某一时刻的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetBySignalIDOfDataTime@V1.1")]
|
[HttpGet]
|
public MonitorRealRecordDto GetBySignalIDOfDataTime_V1_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime DataTime
|
)
|
{
|
var model = _service.GetBySignalIDOfDataTime(CorpID, MonitorPointID, SignalID, DataTime);
|
if (model == null)
|
return default;
|
var vm = new MonitorRealRecordDto(model);
|
return vm;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某一时刻的数据(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[Route("GetBySignalIDOfDataTime@V2.0")]
|
[HttpGet]
|
public MonitorRealRecordDto GetBySignalIDOfDataTime_V2_0
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime DataTime
|
)
|
{
|
var model = _service.GetBySignalIDOfDataTime(CorpID, MonitorPointID, SignalID, DataTime);
|
if (model == null)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(CorpID, SignalID);
|
var vm = new MonitorRealRecordDto(model, signal);
|
return vm;
|
}
|
|
/// <summary>
|
/// 通过 SignalID 获取某一时刻的数据(不需要验证Token)(未进行显示单位转换，使用的是系统默认单位)
|
/// </summary>
|
[AllowAnonymous]
|
[Route("GetBySignalIDOfDataTime@V2.1")]
|
[HttpGet]
|
public MonitorRealRecordDto GetBySignalIDOfDataTime_V2_1
|
(
|
[Required, Range(1, long.MaxValue, ErrorMessage = "CorpID 必须大于0")]
|
long CorpID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "MonitorPointID 必须大于0")]
|
long MonitorPointID,
|
[Required, Range(1, long.MaxValue, ErrorMessage = "SignalID 必须大于0")]
|
long SignalID,
|
[Required]
|
DateTime DataTime
|
)
|
{
|
var model = _service.GetBySignalIDOfDataTime(CorpID, MonitorPointID, SignalID, DataTime);
|
if (model == null)
|
return default;
|
var signal = new Service.Signal().GetExSignalTypeByID(CorpID, SignalID);
|
var vm = new MonitorRealRecordDto(model, signal);
|
return vm;
|
}
|
|
#endregion
|
|
#endregion
|
|
#region 补录数据
|
|
/// <summary>
|
/// 补录一条（已弃用，请使用 监测实时记录(管理)下相关接口）
|
/// </summary>
|
[Route("InsertSupplement@V1.0")]
|
[HttpPost]
|
public bool InsertSupplement([Required] SupplementMonitorRealRecordInput input)
|
{
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(input.CorpID, input.MonitorPointID);
|
if (monitor.CronType != Model.Monitor.eCronType.Real)
|
{
|
return false;
|
}
|
var bol = false;
|
switch (monitor.MonitorType)
|
{
|
case Model.eMonitorType.General:
|
{
|
var signal = monitor.SignalList?.FirstOrDefault();
|
if (signal != null)
|
{
|
var data_status = new List<string>();
|
var data_value = MonitorHandleHelper.Handle(monitor, signal, lastRecord: null, input.SrcTime, input.SrcValue, data_status);
|
if (!string.IsNullOrEmpty(data_value))
|
{
|
var record = new Model.MonitorRealRecordPure();
|
record.CorpID = input.CorpID;
|
record.MonitorPointID = input.MonitorPointID;
|
record.SignalID = signal.ID;
|
record.RecordType = monitor.MonitorType;
|
record.SrcTime = input.SrcTime;
|
record.SrcValue = input.SrcValue;
|
record.DataTime = input.DataTime;
|
record.DataValue = data_value;
|
record.DataStatus = data_status;
|
bol = _service.InsertSupplement(record);
|
}
|
}
|
}
|
break;
|
case Model.eMonitorType.Vibration:
|
{
|
var sub_record_list = AddMonitorSubRecordInput.ToList(input.SrcValue);
|
if (sub_record_list != null && sub_record_list.Count > 0)
|
{
|
var record_list = new List<Model.MonitorRealRecordPure>();
|
foreach (var sub_record in sub_record_list)
|
{
|
var signal = monitor.SignalList?.FirstOrDefault(x => x.ID == sub_record.SignalID);
|
if (signal == null)
|
continue;
|
var data_status = new List<string>();
|
var data_value = MonitorHandleHelper.Handle(monitor, signal, lastRecord: null, input.SrcTime, sub_record.SrcValue, data_status);
|
if (string.IsNullOrEmpty(data_value))
|
continue;
|
var record = new Model.MonitorRealRecordPure();
|
record.CorpID = input.CorpID;
|
record.MonitorPointID = input.MonitorPointID;
|
record.SignalID = signal.ID;
|
record.RecordType = monitor.MonitorType;
|
record.SrcTime = input.SrcTime;
|
record.SrcValue = sub_record.SrcValue;
|
record.DataTime = input.DataTime;
|
record.DataValue = data_value;
|
record.DataStatus = data_status;
|
record_list.Add(record);
|
}
|
if (record_list.Count > 0)
|
{
|
bol = _service.InsertsSupplement(record_list);
|
}
|
}
|
}
|
break;
|
default: break;
|
}
|
|
return bol;
|
}
|
|
/// <summary>
|
/// 补录多条（已弃用，请使用 监测实时记录(管理)下相关接口）
|
/// </summary>
|
[Route("InsertsSupplement@V1.0")]
|
[HttpPost]
|
public bool InsertsSupplement([Required] List<SupplementMonitorRealRecordInput> list)
|
{
|
var corpIds = list.Select(x => x.CorpID).Distinct().ToList();
|
if (corpIds.Count > 1)
|
{
|
return false;
|
}
|
|
var record_list = new List<Model.MonitorRealRecordPure>();
|
foreach (var item in list)
|
{
|
var monitor = new Service.MonitorPoint().GetExSignalWithSignalTypeByID(item.CorpID, item.MonitorPointID);
|
if (monitor == null)
|
{
|
continue;
|
}
|
if (monitor.CronType != Model.Monitor.eCronType.Real)
|
{
|
continue;
|
}
|
switch (monitor.MonitorType)
|
{
|
case Model.eMonitorType.General:
|
{
|
var signal = monitor.SignalList?.FirstOrDefault();
|
if (signal != null)
|
{
|
var data_status = new List<string>();
|
var data_value = MonitorHandleHelper.Handle(monitor, signal, lastRecord: null, item.SrcTime, item.SrcValue, data_status);
|
if (!string.IsNullOrEmpty(data_value))
|
{
|
var record = new Model.MonitorRealRecordPure();
|
record.CorpID = item.CorpID;
|
record.MonitorPointID = item.MonitorPointID;
|
record.SignalID = signal.ID;
|
record.RecordType = monitor.MonitorType;
|
record.SrcTime = item.SrcTime;
|
record.SrcValue = item.SrcValue;
|
record.DataTime = item.DataTime;
|
record.DataValue = data_value;
|
record.DataStatus = data_status;
|
record_list.Add(record);
|
}
|
}
|
}
|
break;
|
case Model.eMonitorType.Vibration:
|
{
|
var sub_record_list = AddMonitorSubRecordInput.ToList(item.SrcValue);
|
if (sub_record_list != null && sub_record_list.Count > 0)
|
{
|
foreach (var sub_record in sub_record_list)
|
{
|
var signal = monitor.SignalList?.FirstOrDefault(x => x.ID == sub_record.SignalID);
|
if (signal == null)
|
continue;
|
var data_status = new List<string>();
|
var data_value = MonitorHandleHelper.Handle(monitor, signal, lastRecord: null, item.SrcTime, sub_record.SrcValue, data_status);
|
if (string.IsNullOrEmpty(data_value))
|
continue;
|
var record = new Model.MonitorRealRecordPure();
|
record.CorpID = item.CorpID;
|
record.MonitorPointID = item.MonitorPointID;
|
record.SignalID = signal.ID;
|
record.RecordType = monitor.MonitorType;
|
record.SrcTime = item.SrcTime;
|
record.SrcValue = item.SrcValue;
|
record.DataTime = item.DataTime;
|
record.DataValue = data_value;
|
record.DataStatus = data_status;
|
record_list.Add(record);
|
}
|
}
|
}
|
break;
|
default: break;
|
}
|
}
|
|
if (record_list.Count < 1)
|
{
|
return false;
|
}
|
var bol = _service.InsertsSupplement(record_list);
|
return bol;
|
}
|
|
#endregion
|
|
|
|
}
|
}
|
