/// <summary>
/// 获取单元格的过滤器特性
/// </summary>
/// <typeparam name="T">过滤器特性类型</typeparam>
/// <param name="cell">单元格</param>
/// <param name="typeFilterInfo">类型过滤器信息</param>
public static T GetFilterAttribute <T>(this ICell cell, TypeFilterInfo typeFilterInfo) where T : FilterAttributeBase
{
return(typeFilterInfo.PropertyFilterInfos
.SingleOrDefault(x =>
x.PropertyName.Equals(cell.PropertyName, StringComparison.CurrentCultureIgnoreCase))?.Filters
?.SingleOrDefault(x => x.GetType() == typeof(T)) as T);
}
/// <summary>
/// Excel表头与模板类匹配获取所有过滤器
/// </summary>
/// <typeparam name="TTemplate"></typeparam>
/// <param name="headerRow"></param>
/// <returns></returns>
public static List <IFilter> CreateFilters <TTemplate>(ExcelHeaderRow headerRow)
{
Type templateType = typeof(TTemplate);
var key = templateType;
if (Table[key] != null)
{
return((List <IFilter>)Table[key]);
}
List <IFilter> filters = new List <IFilter>();
List <BaseFilterAttribute> attrs = new List <BaseFilterAttribute>();
TypeFilterInfo typeFilterInfo = TypeFilterInfoFactory.CreateInstance(typeof(TTemplate), headerRow);
typeFilterInfo.PropertyFilterInfos.ForEach(a => a.FilterAttrs.ForEach(f => attrs.Add(f)));
attrs.Distinct(new FilterAttributeComparer()).ToList().ForEach
(a =>
{
var filter = FilterFactory.CreateInstance(a.GetType());
if (filter != null)
{
filters.Add(filter);
}
});
Table[key] = filters;
return(filters);
}
/// <summary>
/// 创建模板类的过滤器集合
/// </summary>
/// <returns></returns>
public static List <IFilter> CreateFilters <TExcelTemplate>() where TExcelTemplate : class, new()
{
List <IFilter> filterList = new List <IFilter>();
TypeFilterInfo typeFilterInfo = TypeFilterInfoFactory.CreateInstance <TExcelTemplate>();
var attrs = typeFilterInfo.PropertyFilterInfos.SelectMany(pfi => pfi.Filters).ToList();
attrs.Distinct(new BaseFilterAttrEqualCompare()).ToList().ForEach(bfa =>
{
var filter = FilterFactory.CreateInstance(bfa);
if (filter != null)
{
filterList.Add(filter);
}
});
return(filterList);
}
/// <summary>
/// 创建 模板类过滤信息
/// </summary>
/// <typeparam name="TExcelTemplate">Excel配置模板类</typeparam>
/// <returns>模板类过滤信息</returns>
public static TypeFilterInfo CreateInstance <TExcelTemplate>()
where TExcelTemplate : class, new()
{
TypeFilterInfo typeFilterInfo = new TypeFilterInfo();
var propertys = typeof(TExcelTemplate).GetProperties().Where(p => p.IsDefined(typeof(ColNameAttribute))).ToList();
propertys.ForEach(p =>
{
typeFilterInfo.PropertyFilterInfos.Add(new PropertyFilterInfo
{
PropertyName = p?.Name,
Filters = p.GetCustomAttributes <BaseFilterAttribute>().ToList()
});
});
return(typeFilterInfo);
}
/// <summary>
/// 获取模板类过滤器信息
/// </summary>
/// <param name="importType">导入模板类</param>
/// <param name="excelHeaderRow">Excel表头</param>
/// <returns>过滤器信息</returns>
public static TypeFilterInfo CreateInstance(Type importType, ExcelHeaderRow excelHeaderRow)
{
if (importType == null)
{
throw new ArgumentNullException("importDTOType");
}
if (excelHeaderRow == null)
{
throw new ArgumentNullException("excelHeaderRow");
}
var key = importType;
if (Table[key] != null)
{
return((TypeFilterInfo)Table[key]);
}
TypeFilterInfo typeFilterInfo = new TypeFilterInfo()
{
PropertyFilterInfos = new List <PropertyFilterInfo>()
{
}
};
IEnumerable <PropertyInfo> props = importType.GetProperties().ToList().Where(p => p.IsDefined(typeof(ColNameAttribute)));
props.ToList().ForEach(p =>
{
typeFilterInfo.PropertyFilterInfos.Add(
new PropertyFilterInfo
{
PropertyName = p.Name,
FilterAttrs = p.GetCustomAttributes <BaseFilterAttribute>()?.ToList()
});
});
Table[key] = typeFilterInfo;
return(typeFilterInfo);
}
/// <summary>
/// 创建类型过滤器信息实例
/// </summary>
/// <param name="type">类型</param>
public static TypeFilterInfo CreateInstance(Type type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (TypeFilterDict.ContainsKey(type))
{
return(TypeFilterDict[type]);
}
var typeFilterInfo = new TypeFilterInfo();
var props = type.GetProperties().Where(x => x.IsDefined(typeof(ColumnNameAttribute))).ToList();
props.ForEach(item =>
{
typeFilterInfo.PropertyFilterInfos.Add(new PropertyFilterInfo()
{
PropertyName = item.Name,
Filters = item.GetCustomAttributes <FilterAttributeBase>().ToList()
});
});
TypeFilterDict[type] = typeFilterInfo;
return(typeFilterInfo);
}
/// <summary>
/// 获取某单元格的某校验类型集合
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="col"></param>
/// <param name="typeFilterInfo"></param>
/// <returns></returns>
public static List <T> GetFilterAttrs <T>(this ExcelDataCol col, TypeFilterInfo typeFilterInfo)
where T : BaseFilterAttribute
{
return(typeFilterInfo.PropertyFilterInfos.SingleOrDefault(a => a.PropertyName.Equals(col.PropertyName, StringComparison.CurrentCultureIgnoreCase))?.
FilterAttrs?.Where(e => e.GetType() == typeof(T)).Cast <T>().ToList());
}
/// <summary>
/// 获取该属性的指定的特性
/// </summary>
/// <typeparam name="TAttribute"></typeparam>
/// <param name="excelDataCol"></param>
/// <param name="typeFilterInfo"></param>
/// <returns></returns>
public static TAttribute GetAttribute <TAttribute>(this ExcelDataCol excelDataCol, TypeFilterInfo typeFilterInfo)
where TAttribute : BaseFilterAttribute
{
PropertyFilterInfo propertyFilter = typeFilterInfo.PropertyFilterInfos.FirstOrDefault(pfi => pfi.PropertyName == excelDataCol.PropertyName);
if (propertyFilter == null)
{
return(null);
}
var basefilterAttr = propertyFilter.Filters.FirstOrDefault(f => f.GetType() == typeof(TAttribute));
return((TAttribute)basefilterAttr);
}
