admin/JiShe.CollectBus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

完善IOTDB Provider封装

Browse Source
This commit is contained in:
ChenYi 2025-04-03 15:38:31 +08:00
parent e1d4126db0
commit 5772ce906d
11 changed files with 1252 additions and 103 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/JiShe.CollectBus.Application/Samples/SampleAppService.cs
View File

@ -25,15 +25,14 @@ public class SampleAppService : CollectBusAppService, ISampleAppService
ElectricityMeter meter = new ElectricityMeter()
{
SystemName = "Energy",
DeviceId = "402440506"
,
DeviceId = "402440506",
DeviceType = "Ammeter",
Current = 10,
MeterModel = "DDZY-1980",
ProjectCode = "10059",
Voltage = 10
};
await _iotDBProvider.InsertAsync(meter);
await _iotDBProvider.InsertAsync(meter,2);
}
public Task<SampleDto> GetAsync()

28
src/JiShe.CollectBus.Common/AttributeInfo/NumericalOrderAttribute.cs Normal file
View File

@ -0,0 +1,28 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Common.AttributeInfo
{
/// <summary>
/// 排序序号
/// </summary>
public class NumericalOrderAttribute : Attribute
{
/// <summary>
/// 序号
/// </summary>
public int Index { get; set; }
/// <summary>
/// 排序序号
/// </summary>
/// <param name="index"></param>
public NumericalOrderAttribute(int index)
{
Index = index;
}
}
}

68
src/JiShe.CollectBus.Common/Extensions/EnumExtensions.cs Normal file
View File

@ -0,0 +1,68 @@
using System;
namespace JiShe.CollectBus.Common.Extensions
{
public static class EnumExtensions
{
/// <summary>
/// 将枚举转换为<string, int>字典
/// </summary>
/// <typeparam name="TEnum"></typeparam>
/// <returns></returns>
public static Dictionary<string, int> ToDictionary<TEnum>() where TEnum : Enum
{
return Enum.GetValues(typeof(TEnum))
.Cast<TEnum>()
.ToDictionary(
e => e.ToString(),
e => Convert.ToInt32(e)
);
}
/// <summary>
/// 将枚举转换为<string, int>字典
/// </summary>
/// <typeparam name="TEnum"></typeparam>
/// <returns></returns>
public static Dictionary<string, TEnum> ToEnumDictionary<TEnum>() where TEnum : Enum
{
return Enum.GetValues(typeof(TEnum))
.Cast<TEnum>()
.ToDictionary(
e => e.ToString(),
e => e
);
}
/// <summary>
/// 将枚举转换为<int, string>字典
/// </summary>
/// <typeparam name="TEnum"></typeparam>
/// <returns></returns>
public static Dictionary<int, string> ToValueNameDictionary<TEnum>() where TEnum : Enum
{
return Enum.GetValues(typeof(TEnum))
.Cast<TEnum>()
.ToDictionary(
e => Convert.ToInt32(e),
e => e.ToString()
);
}
/// <summary>
/// 将枚举转换为<TEnum, string>字典
/// </summary>
/// <typeparam name="TEnum"></typeparam>
/// <returns></returns>
public static Dictionary<TEnum, string> ToEnumNameDictionary<TEnum>() where TEnum : Enum
{
return Enum.GetValues(typeof(TEnum))
.Cast<TEnum>()
.ToDictionary(
e => e,
e => e.ToString()
);
}
}
}

764
src/JiShe.CollectBus.Common/Helpers/CommonHelper.cs Normal file
View File

@ -0,0 +1,764 @@
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using JiShe.CollectBus.Common.AttributeInfo;
namespace JiShe.CollectBus.Common.Helpers
{
public static class CommonHelper
{
/// <summary>
/// 获得无符号GUID
/// </summary>
/// <returns></returns>
public static string GetGUID()
{
return Guid.NewGuid().ToString("N");
}
/// <summary>
/// 获取时间戳
/// </summary>
/// <param name="isSeconds">是否返回秒，false返回毫秒</param>
/// <returns></returns>
public static long GetTimeStampTen(bool isSeconds)
{
if (isSeconds)
{
return DateTimeOffset.UtcNow.ToUnixTimeSeconds();
}
else
{
return DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
}
}
/// <summary>
/// 获取指定长度的随机数
/// </summary>
/// <param name="length"></param>
/// <returns></returns>
public static string GetRandomNumber(int length = 8)
{
if (length <= 8)
{
length = 8;
}
if (length > 31)
{
length = 32;
}
var randomArray = RandomNumberGenerator.GetBytes(length);
StringBuilder stringBuilder = new StringBuilder();
foreach (var item in randomArray)
{
stringBuilder.Append(item);
}
return stringBuilder.ToString().Substring(0, length);
}
/// <summary>
/// C#反射遍历对象属性获取键值对
/// </summary>
/// <typeparam name="T">对象类型</typeparam>
/// <param name="model">对象</param>
public static Dictionary<string, object> GetClassProperties<T>(T model)
{
Type t = model.GetType();
List<PropertyInfo> propertyList = new List<PropertyInfo>();
PropertyInfo[] tempPropertyList = t.GetProperties();
if (tempPropertyList != null && tempPropertyList.Length > 0)
{
propertyList.AddRange(tempPropertyList);
}
var parentPropertyInfo = t.BaseType?.GetProperties();
if (parentPropertyInfo != null && parentPropertyInfo.Length > 0)
{
foreach (var item in parentPropertyInfo)
{
if (!propertyList.Any(d => d.Name == item.Name)) //如果子类已经包含父类的属性或者字段，跳过不处理
{
propertyList.Add(item);
}
}
}
Dictionary<string, object> resultData = new Dictionary<string, object>();
foreach (PropertyInfo item in propertyList)
{
resultData.Add(item.Name, item.GetValue(model, null));
}
return resultData;
}
/// <summary>
/// C#反射遍历对象属性，将键值对赋值给属性
/// </summary>
public static object SetClassProperties(string typeModel, Dictionary<string, object> keyValues)
{
if (keyValues.Count <= 0)
{
return null;
}
Type tType = Type.GetType(typeModel);
PropertyInfo[] PropertyList = tType.GetProperties();
object objModel = tType.Assembly.CreateInstance(tType.FullName);
foreach (PropertyInfo item in PropertyList)
{
if (keyValues.ContainsKey(item.Name))
{
object objectValue = keyValues[item.Name];
item.SetValue(objModel, objectValue);
}
}
return objModel;
}
/// <summary>
/// 取得某月的第一天
/// </summary>
/// <param name="datetime">要取得月份第一天的时间</param>
/// <returns></returns>
public static DateTime FirstDayOfMonth(this DateTime datetime)
{
return datetime.AddDays(1 - datetime.Day);
}
///<summary>
/// 取得某月的最后一天
/// </summary>
/// <param name="datetime">要取得月份最后一天的时间</param>
/// <returns></returns>
public static DateTime LastDayOfMonth(this DateTime datetime)
{
return datetime.AddDays(1 - datetime.Day).AddMonths(1).AddDays(-1);
}
/// <summary>
/// 取得某月第一天0点以及最后一天的23:59:59时间范围
/// </summary>
/// <param name="datetime"></param>
/// <returns></returns>
public static Tuple<DateTime, DateTime> GetMonthDateRange(this DateTime datetime)
{
var lastDayOfMonthDate = LastDayOfMonth(datetime);
return new Tuple<DateTime, DateTime>(datetime.FirstDayOfMonth(), new DateTime(lastDayOfMonthDate.Year, lastDayOfMonthDate.Month, lastDayOfMonthDate.Day, 23, 59, 59));
}
/// <summary>
/// 取得某一天0点到当月最后一天的23:59:59时间范围
/// </summary>
/// <param name="datetime"></param>
/// <returns></returns>
public static Tuple<DateTime, DateTime> GetCurrentDateToLastDayRange(this DateTime datetime)
{
var lastDayOfMonthDate = LastDayOfMonth(datetime);
return new Tuple<DateTime, DateTime>(datetime.Date, new DateTime(lastDayOfMonthDate.Year, lastDayOfMonthDate.Month, lastDayOfMonthDate.Day, 23, 59, 59));
}
/// <summary>
/// 取得某一天0点到23:59:59时间范围
/// </summary>
/// <param name="datetime"></param>
/// <returns></returns>
public static Tuple<DateTime, DateTime> GetCurrentDateRange(this DateTime datetime)
{
return new Tuple<DateTime, DateTime>(datetime.Date, new DateTime(datetime.Year, datetime.Month, datetime.Day, 23, 59, 59));
}
/// <summary>
/// 获取指定枚举的所有 Attribute 说明以及value组成的键值对
/// </summary>
/// <param name="type">对象类</param>
/// <param name="getPropertie">false获取字段、true获取属性</param>
/// <returns></returns>
public static List<SelectResult> GetEnumAttributeList(Type type, bool getPropertie = false)
{
if (type == null)
{
return null;
}
List<SelectResult> selectResults = new List<SelectResult>();
List<MemberInfo> memberInfos = new List<MemberInfo>();
if (getPropertie == false)
{
FieldInfo[] fieldArray = type.GetFields();
if (null == fieldArray || fieldArray.Length <= 0)
{
return null;
}
memberInfos.AddRange(fieldArray);
//获取父类的字段
var parentFieldInfo = type.BaseType?.GetFields();
if (parentFieldInfo != null && parentFieldInfo.Length > 0)
{
foreach (var item in parentFieldInfo)
{
if (!memberInfos.Any(d => d.Name == item.Name)) //如果子类已经包含父类的属性或者字段，跳过不处理
{
memberInfos.Add(item);
}
}
}
}
else
{
PropertyInfo[] properties = type.GetProperties();
if (null == properties || properties.Length <= 0)
{
return null;
}
memberInfos.AddRange(properties);
//获取父类的属性
var parentPropertyInfo = type.BaseType?.GetProperties();
if (parentPropertyInfo != null && parentPropertyInfo.Length > 0)
{
foreach (var item in parentPropertyInfo)
{
if (!memberInfos.Any(d => d.Name == item.Name)) //如果子类已经包含父类的属性或者字段，跳过不处理
{
memberInfos.Add(item);
}
}
}
}
foreach (var item in memberInfos)
{
DescriptionAttribute[] EnumAttributes =
(DescriptionAttribute[])item.GetCustomAttributes(typeof(DescriptionAttribute), false);
dynamic infoObject = null;
if (getPropertie == false)
{
infoObject = (FieldInfo)item;
}
else
{
infoObject = (PropertyInfo)item;
}
if (EnumAttributes.Length > 0)
{
SelectResult selectResult = new SelectResult()
{
Key = Convert.ToInt32(infoObject.GetValue(null)).ToString(),
Value = EnumAttributes[0].Description,
};
selectResults.Add(selectResult);
}
DisplayAttribute[] DisplayAttributes =
(DisplayAttribute[])item.GetCustomAttributes(typeof(DisplayAttribute), false);
if (DisplayAttributes.Length > 0)
{
SelectResult selectResult =
selectResults.FirstOrDefault(e => e.Key == Convert.ToInt32(infoObject.GetValue(null)).ToString());
if (selectResult != null)
{
selectResult.SecondValue = DisplayAttributes[0].Name;
}
}
}
return selectResults;
}
/// <summary>
/// 获取指定枚举的所有 Attribute 说明以及value组成的键值对
/// </summary>
/// <param name="type">对象类</param>
/// <param name="thirdAttributeType">第三个标签类型</param>
/// <param name="thirdAttributePropertieName">第三个标签类型取值名称</param>
/// <param name="getPropertie">false获取字段、true获取属性</param>
/// <returns></returns>
public static List<SelectResult> GetEnumAttributeListWithThirdValue(Type type, Type thirdAttributeType, string thirdAttributePropertieName, bool getPropertie = false)
{
if (type == null)
{
return null;
}
List<SelectResult> selectResults = new List<SelectResult>();
List<MemberInfo> memberInfos = new List<MemberInfo>();
if (getPropertie == false)
{
FieldInfo[] EnumInfo = type.GetFields();
if (null == EnumInfo || EnumInfo.Length <= 0)
{
return null;
}
memberInfos.AddRange(EnumInfo);
var parentFieldInfo = type.BaseType?.GetFields();
if (parentFieldInfo != null && parentFieldInfo.Length > 0)
{
memberInfos.AddRange(parentFieldInfo);
}
}
else
{
PropertyInfo[] EnumInfo = type.GetProperties();
if (null == EnumInfo || EnumInfo.Length <= 0)
{
return null;
}
memberInfos.AddRange(EnumInfo);
var parentPropertyInfo = type.BaseType?.GetProperties();
if (parentPropertyInfo != null && parentPropertyInfo.Length > 0)
{
memberInfos.AddRange(parentPropertyInfo);
}
}
foreach (var item in memberInfos)
{
var thirdAttributes = item.
GetCustomAttributes(thirdAttributeType, false);
if (thirdAttributes == null || thirdAttributes.Length <= 0)
{
continue;
}
DescriptionAttribute[] descriptionAttributes = (DescriptionAttribute[])item.
GetCustomAttributes(typeof(DescriptionAttribute), false);
dynamic infoObject = null;
if (getPropertie == false)
{
infoObject = (FieldInfo)item;
}
else
{
infoObject = (PropertyInfo)item;
}
if (descriptionAttributes.Length > 0)
{
SelectResult selectResult = new SelectResult()
{
Key = infoObject.Name,
Value = descriptionAttributes[0].Description,
};
selectResults.Add(selectResult);
}
DisplayAttribute[] displayAttributes = (DisplayAttribute[])item.
GetCustomAttributes(typeof(DisplayAttribute), false);
if (displayAttributes.Length > 0)
{
SelectResult selectResult = selectResults.FirstOrDefault(e => e.Key == infoObject.Name);
if (selectResult != null)
{
selectResult.SecondValue = displayAttributes[0].Name;
}
}
if (thirdAttributes.Length > 0 && !string.IsNullOrWhiteSpace(thirdAttributePropertieName))
{
foreach (var attr in thirdAttributes)
{
// 使用反射获取特性的属性值
var properties = thirdAttributeType.GetProperties();
foreach (var prop in properties)
{
// 假设你要获取特性的某个属性值，例如 TypeName
if (prop.Name == thirdAttributePropertieName)
{
object value = prop.GetValue(attr);
SelectResult selectResult = selectResults.FirstOrDefault(e => e.Key == infoObject.Name);
if (selectResult != null)
{
selectResult.ThirdValue = value?.ToString(); // 将属性值赋给 ThirdValue
}
break; // 如果找到了需要的属性，可以跳出循环
}
}
}
}
}
return selectResults;
}
/// <summary>
/// 获取指定类、指定常量值的Description说明
/// 包含直接继承的父级字段
/// </summary>
/// <param name="t">对象类</param>
/// <param name="getPropertie"></param>
/// <returns></returns>
public static List<Tuple<string, string, int>> GetTypeDescriptionListToTuple(Type t, bool getPropertie = false)
{
if (t == null)
{
return null;
}
List<MemberInfo> memberInfos = new List<MemberInfo>();
if (getPropertie == false)
{
FieldInfo[] fieldInfo = t.GetFields();
if (null == fieldInfo || fieldInfo.Length <= 0)
{
return null;
}
memberInfos.AddRange(fieldInfo);
var parentFieldInfo = t.BaseType?.GetFields();
if (parentFieldInfo != null && parentFieldInfo.Length > 0)
{
foreach (var item in parentFieldInfo)
{
if (!memberInfos.Any(d => d.Name == item.Name)) //如果子类已经包含父类的属性或者字段，跳过不处理
{
memberInfos.Add(item);
}
}
}
}
else
{
PropertyInfo[] fieldInfo = t.GetProperties();
if (null == fieldInfo || fieldInfo.Length <= 0)
{
return null;
}
memberInfos.AddRange(fieldInfo);
var parentPropertyInfo = t.BaseType?.GetProperties();
if (parentPropertyInfo != null && parentPropertyInfo.Length > 0)
{
foreach (var item in parentPropertyInfo)
{
if (!memberInfos.Any(d => d.Name == item.Name)) //如果子类已经包含父类的属性或者字段，跳过不处理
{
memberInfos.Add(item);
}
}
}
}
List<Tuple<string, string, int>> tuples = new List<Tuple<string, string, int>>();
foreach (var item in memberInfos)
{
DescriptionAttribute[] descriptionAttribute =
(DescriptionAttribute[])item.GetCustomAttributes(typeof(DescriptionAttribute), false);
NumericalOrderAttribute[] indexAttributes =
(NumericalOrderAttribute[])item.GetCustomAttributes(typeof(NumericalOrderAttribute), false);
if (descriptionAttribute.Length > 0 && indexAttributes.Length > 0)
{
Tuple<string, string, int> tuple = new Tuple<string, string, int>(item.Name,
descriptionAttribute[0].Description, indexAttributes[0].Index);
tuples.Add(tuple);
}
}
return tuples;
}
/// <summary>
/// 获取指定类、指定常量值的常量说明
/// </summary>
/// <param name="fieldName">常量字段名称</param>
///<param name="getPropertie">属性还是字段</param>
/// <returns></returns>
public static string GetTypeDescriptionName<T>(string fieldName, bool getPropertie = false)
{
if (string.IsNullOrEmpty(fieldName))
{
return "";
}
MemberInfo memberInfo = null;
if (getPropertie == false)
{
memberInfo = typeof(T).GetField(fieldName);
}
else
{
memberInfo = typeof(T).GetProperty(fieldName);
}
if (null == memberInfo)
{
return "";
}
DescriptionAttribute[] EnumAttributes =
(DescriptionAttribute[])memberInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (EnumAttributes.Length <= 0)
{
return "";
}
return EnumAttributes[0].Description;
}
/// <summary>
/// 获取指定命名空间下指定常量值的常量说明
/// </summary>
/// <param name="fieldName">常量字段名称</param>
/// <param name="assemblyName">命名空间，主要用来找到对应程序集</param>
///<param name="getPropertie">属性还是字段</param>
/// <returns></returns>
public static string GetTypeDescriptionName(string fieldName, string assemblyName, bool getPropertie = false)
{
if (string.IsNullOrWhiteSpace(fieldName) || string.IsNullOrWhiteSpace(assemblyName))
{
return null;
}
string desc = "";
foreach (var item in GetEnumList(assemblyName))
{
desc = GetTypeDescriptionName(item, fieldName, getPropertie);
if (!string.IsNullOrEmpty(desc))
{
break;
}
}
return desc;
}
/// <summary>
/// 获取指定类、指定常量值的常量说明
/// </summary>
/// <param name="t">对象类</param>
/// <param name="fieldName">常量字段名称</param>
///<param name="getPropertie">属性还是字段</param>
/// <returns></returns>
public static string GetTypeDescriptionName(this Type t, string fieldName, bool getPropertie = false)
{
if (string.IsNullOrWhiteSpace(fieldName))
{
return "";
}
MemberInfo memberInfo = null;
if (getPropertie == false)
{
memberInfo = t.GetField(fieldName);
}
else
{
memberInfo = t.GetProperty(fieldName);
}
if (null != memberInfo)
{
DescriptionAttribute[] EnumAttributes =
(DescriptionAttribute[])memberInfo.GetCustomAttributes(typeof(DescriptionAttribute), false);
if (EnumAttributes.Length > 0)
{
return EnumAttributes[0].Description;
}
}
return "";
}
/// <summary>
/// 扩展方法，获得枚举值集合
///</summary>
///<returns>枚举的DisplayName</returns>
public static List<T> GetEnumList<T>() where T : Enum
{
List<T> enumList = new List<T>();
foreach (T value in Enum.GetValues(typeof(T)))
{
enumList.Add(value);
}
return enumList;
}
private static List<Type> GetEnumList(string assemblyName)
{
if (!String.IsNullOrEmpty(assemblyName))
{
Assembly assembly = Assembly.Load(assemblyName);
List<Type> ts = assembly.GetTypes().Where(x => x.GetTypeInfo().IsClass).ToList();
return ts;
}
return new List<Type>();
}
/// <summary>
/// 扩展方法，获得枚举的Display值
///</summary>
///<param name="value">枚举值</param>
///<param name="nameInstead">当枚举值没有定义DisplayNameAttribute，是否使用枚举名代替，默认是使用</param>
///<param name="getPropertie">属性还是字段</param>
///<returns>枚举的DisplayName</returns>
public static string GetDisplayName(this Enum value, Boolean nameInstead = true, bool getPropertie = false)
{
Type type = value.GetType();
string name = Enum.GetName(type, value);
if (name == null)
{
return null;
}
DisplayAttribute attribute = null;
if (getPropertie == false)
{
attribute = Attribute.GetCustomAttribute(type.GetField(name), typeof(DisplayAttribute)) as DisplayAttribute;
}
else
{
attribute =
Attribute.GetCustomAttribute(type.GetProperty(name), typeof(DisplayAttribute)) as DisplayAttribute;
}
if (attribute == null && nameInstead == true)
{
return name;
}
return attribute == null ? null : attribute.Name;
}
/// <summary>
/// 获取枚举的描述信息
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static string GetEnumDescription(this Enum value)
{
var name = value.ToString();
var field = value.GetType().GetField(name);
if (field == null) return name;
var att = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute), false);
return att == null ? field.Name : ((DescriptionAttribute)att).Description;
}
/// <summary>
/// 将传入的字符串中间部分字符替换成特殊字符
/// </summary>
/// <param name="value">需要替换的字符串</param>
/// <param name="startLen">前保留长度</param>
/// <param name="endLen">尾保留长度</param>
/// <param name="specialChar">特殊字符</param>
/// <returns>被特殊字符替换的字符串</returns>
public static string ReplaceWithSpecialChar(this string value, int startLen = 1, int endLen = 1,
char specialChar = '*')
{
if (string.IsNullOrEmpty(value))
{
return value;
}
try
{
if (value.Length <= startLen + endLen)
{
var temStartVal = value.Substring(0, startLen);
return $"{temStartVal}{"".PadLeft(endLen, specialChar)}";
}
if (value.Length == 10 && endLen == 1)
{
endLen = 3;
}
var startVal = value.Substring(0, startLen);
var endVal = value.Substring(value.Length - endLen);
if (value.Length == 2)
{
endVal = "";
}
value = $"{startVal}{endVal.PadLeft(value.Length - startLen, specialChar)}";
}
catch (Exception)
{
throw;
}
return value;
}
/// <summary>
/// Linux下字体名称转换
/// </summary>
/// <param name="fontValue"></param>
/// <returns></returns>
public static string GetLinuxFontFamily(this string fontValue)
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
if (fontValue == "楷体")
{
fontValue = "KaiTi";
}
else if (fontValue == "隶书")
{
fontValue = "LiSu";
}
else if (fontValue == "宋体")
{
fontValue = "SimSun";
}
else if (fontValue == "微软雅黑")
{
fontValue = "Microsoft YaHei";
}
else if (fontValue == "新宋体")
{
fontValue = "NSimSun";
}
else if (fontValue == "仿宋")
{
fontValue = "FangSong";
}
else if (fontValue == "黑体")
{
fontValue = "SimHei";
}
}
return fontValue;
}
}
}

28
src/JiShe.CollectBus.Common/Helpers/JsonHelper.cs
View File

@ -123,4 +123,32 @@ namespace JiShe.CollectBus.Common.Helpers
writer.WriteStringValue(value.ToString(_dateFormatString));
}
}
/// <summary>
/// Unix格式时间格式化
/// </summary>
public class UnixTimeConverter : JsonConverter<DateTime>
{
public override DateTime Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType == JsonTokenType.String)
{
if (long.TryParse(reader.GetString(), out long timestamp))
return DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
}
if (reader.TokenType == JsonTokenType.Number)
{
long timestamp = reader.GetInt64();
return DateTimeOffset.FromUnixTimeSeconds(timestamp).DateTime;
}
return reader.GetDateTime();
}
public override void Write(Utf8JsonWriter writer, DateTime value, JsonSerializerOptions options)
{
long timestamp = new DateTimeOffset(value).ToUnixTimeSeconds();
writer.WriteStringValue(timestamp.ToString());
}
}
}

35
src/JiShe.CollectBus.Common/Helpers/SelectResult.cs Normal file
View File

@ -0,0 +1,35 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace JiShe.CollectBus.Common.Helpers
{
/// <summary>
/// 下拉框选项元素
/// </summary>
public class SelectResult
{
/// <summary>
/// 下拉框 键
/// </summary>
public string Key { get; set; }
/// <summary>
/// 下拉框 值
/// </summary>
public string Value { get; set; }
/// <summary>
/// 下拉框 值2
/// </summary>
public string SecondValue { get; set; }
/// <summary>
/// 下拉框 值3
/// </summary>
public object ThirdValue { get; set; }
}
}

15
src/JiShe.CollectBus.IoTDBProvider/Interface/IIoTDBProvider.cs
View File

@ -16,16 +16,27 @@ namespace JiShe.CollectBus.IoTDBProvider
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <param name="buildTabletMode">构建表模型方式，1 根据实体《T》直接显示指定Tag，2根据实体《T》的名称指定表名</param>
/// <returns></returns>
Task InsertAsync<T>(T entity) where T : IoTEntity;
Task InsertAsync<T>(T entity, int buildTabletMode) where T : IoTEntity;
/// <summary>
/// 批量插入数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entities"></param>
/// <param name="buildTabletMode">构建表模型方式，1 根据实体《T》直接显示指定Tag，2根据实体《T》的名称指定表名</param>
/// <returns></returns>
Task BatchInsertAsync<T>(IEnumerable<T> entities) where T : IoTEntity;
Task BatchInsertAsync<T>(IEnumerable<T> entities, int buildTabletMode) where T : IoTEntity;
/// <summary>
/// 删除数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="options"></param>
/// <returns></returns>
Task<object> DeleteAsync<T>(QueryOptions options) where T : IoTEntity;
/// <summary>
/// 查询数据

3
src/JiShe.CollectBus.IoTDBProvider/JiShe.CollectBus.IoTDBProvider.csproj
View File

@ -10,4 +10,7 @@
<PackageReference Include="Apache.IoTDB" Version="2.0.1" />
<PackageReference Include="Volo.Abp" Version="8.3.3" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\JiShe.CollectBus.Common\JiShe.CollectBus.Common.csproj" />
</ItemGroup>
</Project>

5
src/JiShe.CollectBus.IoTDBProvider/Options/QueryOptions.cs
View File

@ -11,6 +11,11 @@ namespace JiShe.CollectBus.IoTDBProvider
/// </summary>
public class QueryOptions
{
/// <summary>
/// 表名或标签名
/// </summary>
public required string TableNameOrTagName { get; set; }
/// <summary>
/// 分页
/// </summary>

8
src/JiShe.CollectBus.IoTDBProvider/Provider/DeviceMetadata.cs
View File

@ -13,17 +13,17 @@ namespace JiShe.CollectBus.IoTDBProvider
public class DeviceMetadata
{
/// <summary>
/// 测量值集合，用于构建Table的测量值，也就是field参数
/// 测量值集合，用于构建Table的测量值，也就是columnNames参数
/// </summary>
public List<string> Measurements { get; } = new();
public List<string> ColumnNames { get; } = new();
/// <summary>
/// 列类型集合，用于构建Table的列类型，也就是columnCategory参数
/// 列类型集合，用于构建Table的列类型，也就是columnCategories参数
/// </summary>
public List<ColumnCategory> ColumnCategories { get; } = new();
/// <summary>
/// 值类型集合，用于构建Table的值类型，也就是dataType参数
/// 值类型集合，用于构建Table的值类型，也就是dataTypes参数
/// </summary>
public List<TSDataType>DataTypes { get; } = new();
}

396
src/JiShe.CollectBus.IoTDBProvider/Provider/IoTDBProvider.cs
View File

@ -1,5 +1,8 @@
using Apache.IoTDB;
using Apache.IoTDB.DataStructure;
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Common.Helpers;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Concurrent;
@ -19,8 +22,9 @@ namespace JiShe.CollectBus.IoTDBProvider
private readonly IoTDBOptions _options;
private readonly TableSessionPool _sessionPool;
private static readonly ConcurrentDictionary<Type, DeviceMetadata> _metadataCache = new();
private readonly ILogger<IoTDBProvider> _logger;
public IoTDBProvider(IOptions<IoTDBOptions> options)
public IoTDBProvider(IOptions<IoTDBOptions> options, ILogger<IoTDBProvider> logger)
{
_options = options.Value;
@ -32,58 +36,20 @@ namespace JiShe.CollectBus.IoTDBProvider
.Build();
_sessionPool.Open(false).Wait();
_logger = logger;
}
/// <summary>
/// 获取设备元数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
private DeviceMetadata GetMetadata<T>() where T : IoTEntity
{
return _metadataCache.GetOrAdd(typeof(T), type =>
{
var metadata = new DeviceMetadata();
foreach (var prop in type.GetProperties())
{
//标签列
var attrTAG = prop.GetCustomAttribute<TAGColumnAttribute>();
if (attrTAG != null)
{
metadata.ColumnCategories.Add(ColumnCategory.TAG);
}
//属性列
var attrATTRIBUTE = prop.GetCustomAttribute<ATTRIBUTEColumnAttribute>();
if (attrATTRIBUTE != null)
{
metadata.ColumnCategories.Add(ColumnCategory.ATTRIBUTE);
}
//数据列
var attrFIELD = prop.GetCustomAttribute<FIELDColumnAttribute>();
if (attrFIELD != null)
{
metadata.ColumnCategories.Add(ColumnCategory.FIELD);
metadata.Measurements.Add(prop.Name);
metadata.DataTypes.Add(GetDataTypeFromStr(prop.PropertyType.Name));
}
}
return metadata;
});
}
/// <summary>
/// 插入数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public async Task InsertAsync<T>(T entity) where T : IoTEntity
public async Task InsertAsync<T>(T entity, int buildTabletMode) where T : IoTEntity
{
var metadata = GetMetadata<T>();
var tablet = BuildTablet(new[] { entity }, metadata);
var tablet = BuildTablet(new[] { entity }, metadata, buildTabletMode);
await _sessionPool.InsertAsync(tablet);
}
@ -93,58 +59,46 @@ namespace JiShe.CollectBus.IoTDBProvider
/// <typeparam name="T"></typeparam>
/// <param name="entities"></param>
/// <returns></returns>
public async Task BatchInsertAsync<T>(IEnumerable<T> entities) where T : IoTEntity
public async Task BatchInsertAsync<T>(IEnumerable<T> entities, int buildTabletMode) where T : IoTEntity
{
var metadata = GetMetadata<T>();
var metadata = GetMetadata<T>();
var batchSize = 1000;
var batches = entities.Chunk(batchSize);
foreach (var batch in batches)
{
var tablet = BuildTablet(batch, metadata);
var tablet = BuildTablet(batch, metadata, buildTabletMode);
await _sessionPool.InsertAsync(tablet);
}
}
/// <summary>
/// 构建表模型
/// 删除数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entities"></param>
/// <param name="metadata"></param>
/// <param name="options"></param>
/// <returns></returns>
private Tablet BuildTablet<T>(IEnumerable<T> entities, DeviceMetadata metadata) where T : IoTEntity
public async Task<object> DeleteAsync<T>(QueryOptions options) where T : IoTEntity
{
var deviceId = DevicePathBuilder.GetDeviceId(entities.First());
var timestamps = new List<long>();
var values = new List<List<object>>();
var query = BuildDeleteSQL<T>(options);
var sessionDataSet = await _sessionPool.ExecuteQueryStatementAsync(query);
foreach (var entity in entities)
if (!sessionDataSet.HasNext())
{
timestamps.Add(entity.Timestamps);
var rowValues = new List<object>();
foreach (var measurement in metadata.Measurements)
{
var value = typeof(T).GetProperty(measurement)?.GetValue(entity);
if(value == null)
{
throw new Exception($"{nameof(BuildTablet)} 构建表模型{typeof(T).Name}时，属性{measurement}值为空，不符合IoTDB设计标准，请赋值以后重新处理。");
}
rowValues.Add(value);
}
values.Add(rowValues);
_logger.LogWarning($"{typeof(T).Name} 删除数据时，没有返回受影响记录数量。");
return 0;
}
return new Tablet(
deviceId,
metadata.Measurements,
metadata.DataTypes,
values,
timestamps
);
//获取唯一结果行
var row = sessionDataSet.Next();
return row.Values[0];
}
/// <summary>
/// 查询数据
/// </summary>
@ -153,7 +107,7 @@ namespace JiShe.CollectBus.IoTDBProvider
/// <returns></returns>
public async Task<PagedResult<T>> QueryAsync<T>(QueryOptions options) where T : IoTEntity, new()
{
var query = BuildQuery<T>(options);
var query = BuildQuerySQL<T>(options);
var sessionDataSet = await _sessionPool.ExecuteQueryStatementAsync(query);
var result = new PagedResult<T>
@ -165,18 +119,75 @@ namespace JiShe.CollectBus.IoTDBProvider
return result;
}
/// <summary>
/// 构建表模型
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entities">表实体</param>
/// <param name="metadata">设备元数据</param>
/// <param name="buildTabletMode">构建表模型方式，1 根据实体《T》直接显示指定Tag，2根据实体《T》的名称指定表名</param>
/// <returns></returns>
private Tablet BuildTablet<T>(IEnumerable<T> entities, DeviceMetadata metadata, int buildTabletMode) where T : IoTEntity
{
var timestamps = new List<long>();
var values = new List<List<object>>();
foreach (var entity in entities)
{
timestamps.Add(entity.Timestamps);
var rowValues = new List<object>();
foreach (var measurement in metadata.ColumnNames)
{
var value = typeof(T).GetProperty(measurement)?.GetValue(entity);
if (value == null)
{
throw new Exception($"{nameof(BuildTablet)} 构建表模型{typeof(T).Name}时，属性{measurement}值为空，不符合IoTDB设计标准，请赋值以后重新处理。");
}
rowValues.Add(value);
}
values.Add(rowValues);
}
if (buildTabletMode == 1)
{
return new Tablet(
DevicePathBuilder.GetDeviceId(entities.First()),
metadata.ColumnNames,
metadata.ColumnCategories,
metadata.DataTypes,
values,
timestamps
);
}
else if (buildTabletMode == 2)
{
return new Tablet(
DevicePathBuilder.GetTableName<T>(),
metadata.ColumnNames,
metadata.ColumnCategories,
metadata.DataTypes,
values,
timestamps
);
}
else
{
throw new Exception($"{nameof(BuildTablet)} 构建表模型{typeof(T).Name}时，buildTabletMode参数值不正确，请赋值以后重新处理。");
}
}
/// <summary>
/// 构建查询语句
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="options"></param>
/// <returns></returns>
private string BuildQuery<T>(QueryOptions options) where T : IoTEntity
private string BuildQuerySQL<T>(QueryOptions options) where T : IoTEntity
{
var metadata = GetMetadata<T>();
var sb = new StringBuilder("SELECT ");
sb.AppendJoin(", ", metadata.Measurements);
sb.Append($" FROM {DevicePathBuilder.GetTableName<T>()}");
sb.AppendJoin(", ", metadata.ColumnNames);
sb.Append($" FROM {options.TableNameOrTagName}");
if (options.Conditions.Any())
{
@ -188,6 +199,30 @@ namespace JiShe.CollectBus.IoTDBProvider
return sb.ToString();
}
/// <summary>
/// 构建删除语句
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="options"></param>
/// <returns></returns>
private string BuildDeleteSQL<T>(QueryOptions options) where T : IoTEntity
{
var metadata = GetMetadata<T>();
var sb = new StringBuilder("DELETE ");
sb.Append($" FROM {options.TableNameOrTagName}");
sb.AppendJoin(", ", metadata.ColumnNames);
if (options.Conditions.Any())
{
sb.Append(" WHERE ");
sb.AppendJoin(" AND ", options.Conditions.Select(TranslateCondition));
}
return sb.ToString();
}
/// <summary>
/// 将查询条件转换为SQL语句
/// </summary>
@ -213,7 +248,7 @@ namespace JiShe.CollectBus.IoTDBProvider
/// <returns></returns>
private async Task<int> GetTotalCount<T>(QueryOptions options) where T : IoTEntity
{
var countQuery = $"SELECT COUNT(*) FROM {DevicePathBuilder.GetTableName<T>()}";
var countQuery = $"SELECT COUNT(*) FROM {options.TableNameOrTagName}";
if (options.Conditions.Any())
{
countQuery += " WHERE " + string.Join(" AND ", options.Conditions.Select(TranslateCondition));
@ -246,7 +281,7 @@ namespace JiShe.CollectBus.IoTDBProvider
};
foreach (var measurement in metadata.Measurements)
foreach (var measurement in metadata.ColumnNames)
{
var value = record.Values;
@ -263,7 +298,7 @@ namespace JiShe.CollectBus.IoTDBProvider
}
return results;
}
/// <summary>
/// 释放资源
/// </summary>
@ -272,23 +307,196 @@ namespace JiShe.CollectBus.IoTDBProvider
_sessionPool?.Close().Wait();
}
private TSDataType GetDataTypeFromStr(string str)
/// <summary>
/// 获取设备元数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
private DeviceMetadata GetMetadata<T>() where T : IoTEntity
{
return str switch
return _metadataCache.GetOrAdd(typeof(T), type =>
{
"BOOLEAN" => TSDataType.BOOLEAN,
"INT32" => TSDataType.INT32,
"INT64" => TSDataType.INT64,
"FLOAT" => TSDataType.FLOAT,
"DOUBLE" => TSDataType.DOUBLE,
"TEXT" => TSDataType.TEXT,
"NULLTYPE" => TSDataType.NONE,
"TIMESTAMP" => TSDataType.TIMESTAMP,
"DATE" => TSDataType.DATE,
"BLOB" => TSDataType.BLOB,
"STRING" => TSDataType.STRING,
_ => TSDataType.STRING
};
var columns = CollectColumnMetadata(type);
var metadata = BuildDeviceMetadata(columns);
return metadata;
});
//return _metadataCache.GetOrAdd(typeof(T), type =>
//{
// var metadata = new DeviceMetadata();
// List<Tuple<string, ColumnCategory, TSDataType>> columns = new();
// foreach (var prop in type.GetProperties())
// {
// //标签列
// var attrTAG = prop.GetCustomAttribute<TAGColumnAttribute>();
// if (attrTAG != null)
// {
// columns.Add(Tuple.Create(prop.PropertyType.Name, ColumnCategory.TAG, GetDataTypeFromStr(prop.PropertyType.Name)));
// continue;
// }
// //属性列
// var attrATTRIBUTE = prop.GetCustomAttribute<ATTRIBUTEColumnAttribute>();
// if (attrATTRIBUTE != null)
// {
// columns.Add(Tuple.Create(prop.PropertyType.Name, ColumnCategory.ATTRIBUTE, GetDataTypeFromStr(prop.PropertyType.Name)));
// continue;
// }
// //数据列
// var attrFIELD = prop.GetCustomAttribute<FIELDColumnAttribute>();
// if (attrFIELD != null)
// {
// columns.Add(Tuple.Create(prop.PropertyType.Name, ColumnCategory.FIELD, GetDataTypeFromStr(prop.PropertyType.Name)));
// }
// }
// var columnCategories = EnumExtensions.ToEnumDictionary<ColumnCategory>();
// foreach (var item in columnCategories)
// {
// if (item.Value == ColumnCategory.TAG)
// {
// metadata.ColumnNames.AddRange(columns.Where(d => d.Item2 == ColumnCategory.FIELD).Select(d => d.Item1).ToList());
// metadata.ColumnCategories.AddRange(columns.Where(d => d.Item2 == ColumnCategory.TAG).Select(d => d.Item2).ToList());
// metadata.DataTypes.AddRange(columns.Where(d => d.Item2 == ColumnCategory.TAG).Select(d => d.Item3).ToList());
// }
// else if (item.Value == ColumnCategory.ATTRIBUTE)
// {
// metadata.ColumnNames.AddRange(columns.Where(d => d.Item2 == ColumnCategory.ATTRIBUTE).Select(d => d.Item1).ToList());
// metadata.ColumnCategories.AddRange(columns.Where(d => d.Item2 == ColumnCategory.ATTRIBUTE).Select(d => d.Item2).ToList());
// metadata.DataTypes.AddRange(columns.Where(d => d.Item2 == ColumnCategory.ATTRIBUTE).Select(d => d.Item3).ToList());
// }
// else if (item.Value == ColumnCategory.FIELD)
// {
// metadata.ColumnNames.AddRange(columns.Where(d => d.Item2 == ColumnCategory.FIELD).Select(d => d.Item1).ToList());
// metadata.ColumnCategories.AddRange(columns.Where(d => d.Item2 == ColumnCategory.FIELD).Select(d => d.Item2).ToList());
// metadata.DataTypes.AddRange(columns.Where(d => d.Item2 == ColumnCategory.FIELD).Select(d => d.Item3).ToList());
// }
// }
// return metadata;
//});
}
/// <summary>
/// 获取设备元数据的列
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private List<ColumnInfo> CollectColumnMetadata(Type type)
{
var columns = new List<ColumnInfo>();
foreach (var prop in type.GetProperties())
{
//按优先级顺序检查属性，避免重复反射
ColumnInfo? column = prop.GetCustomAttribute<TAGColumnAttribute>() is not null ? new ColumnInfo(
name: prop.Name, //使用属性名
category: ColumnCategory.TAG,
dataType: GetDataTypeFromTypeName(prop.PropertyType.Name)
) : prop.GetCustomAttribute<ATTRIBUTEColumnAttribute>() is not null ? new ColumnInfo(
prop.Name,
ColumnCategory.ATTRIBUTE,
GetDataTypeFromTypeName(prop.PropertyType.Name)
) : prop.GetCustomAttribute<FIELDColumnAttribute>() is not null ? new ColumnInfo(
prop.Name,
ColumnCategory.FIELD,
GetDataTypeFromTypeName(prop.PropertyType.Name)
) : null;
if (column.HasValue)
{
columns.Add(column.Value);
}
}
return columns;
}
/// <summary>
/// 构建设备元数据
/// </summary>
/// <param name="columns"></param>
/// <returns></returns>
private DeviceMetadata BuildDeviceMetadata(List<ColumnInfo> columns)
{
var metadata = new DeviceMetadata();
//按业务逻辑顺序处理（TAG -> FIELD -> ATTRIBUTE）
var groupedColumns = columns
.GroupBy(c => c.Category)
.ToDictionary(g => g.Key, g => g.ToList());
ProcessCategory(groupedColumns, ColumnCategory.TAG, metadata);
ProcessCategory(groupedColumns, ColumnCategory.ATTRIBUTE, metadata);
ProcessCategory(groupedColumns, ColumnCategory.FIELD, metadata);
return metadata;
}
/// <summary>
/// 处理不同列类型的逻辑
/// </summary>
/// <param name="groupedColumns"></param>
/// <param name="category"></param>
/// <param name="metadata"></param>
private void ProcessCategory(IReadOnlyDictionary<ColumnCategory, List<ColumnInfo>> groupedColumns, ColumnCategory category, DeviceMetadata metadata)
{
if (groupedColumns.TryGetValue(category, out var cols))
{
metadata.ColumnNames.AddRange(cols.Select(c => c.Name));
metadata.ColumnCategories.AddRange(cols.Select(c => c.Category));
metadata.DataTypes.AddRange(cols.Select(c => c.DataType));
}
}
/// <summary>
/// 数据列结构
/// </summary>
private readonly struct ColumnInfo
{
public string Name { get; }
public ColumnCategory Category { get; }
public TSDataType DataType { get; }
public ColumnInfo(string name, ColumnCategory category, TSDataType dataType)
{
Name = name;
Category = category;
DataType = dataType;
}
}
/// <summary>
/// 根据类型名称获取对应的 IoTDB 数据类型
/// </summary>
/// <param name="typeName">类型名称（不区分大小写）</param>
/// <returns>对应的 TSDataType，默认返回 TSDataType.STRING</returns>
private TSDataType GetDataTypeFromTypeName(string typeName)
{
if (string.IsNullOrWhiteSpace(typeName))
return TSDataType.STRING;
return DataTypeMap.TryGetValue(typeName.Trim(), out var dataType)
? dataType
: TSDataType.STRING;
}
/// <summary>
/// 根据类型名称获取 IoTDB 数据类型
/// </summary>
private readonly IReadOnlyDictionary<string, TSDataType> DataTypeMap =
new Dictionary<string, TSDataType>(StringComparer.OrdinalIgnoreCase)
{
["BOOLEAN"] = TSDataType.BOOLEAN,
["INT32"] = TSDataType.INT32,
["INT64"] = TSDataType.INT64,
["FLOAT"] = TSDataType.FLOAT,
["DOUBLE"] = TSDataType.DOUBLE,
["TEXT"] = TSDataType.TEXT,
["NULLTYPE"] = TSDataType.NONE,
["TIMESTAMP"] = TSDataType.TIMESTAMP,
["DATE"] = TSDataType.DATE,
["BLOB"] = TSDataType.BLOB,
["STRING"] = TSDataType.STRING
};
}
}