|
|
// ============================================================================
|
|
|
// 【文件说明】HwProductInfoService.cs - 产品信息业务服务类
|
|
|
// ============================================================================
|
|
|
// 这个服务类负责处理产品信息的业务逻辑，包括：
|
|
|
// - 产品信息的 CRUD 操作
|
|
|
// - 产品与明细的关联查询
|
|
|
// - 产品明细树形结构的构建
|
|
|
//
|
|
|
// 【核心知识点】
|
|
|
// 1. LINQ GroupBy 分组操作
|
|
|
// 2. 递归树构建算法
|
|
|
// 3. 扁平数据转树形结构
|
|
|
// ============================================================================
|
|
|
|
|
|
namespace Admin.NET.Plugin.HwPortal;
|
|
|
|
|
|
/// <summary>
|
|
|
/// 产品信息业务服务类。
|
|
|
/// <para>
|
|
|
/// 【服务职责】
|
|
|
/// 产品信息服务负责：
|
|
|
/// 1. 基础 CRUD：增删改查
|
|
|
/// 2. 关联查询：产品 + 明细的 JOIN 查询
|
|
|
/// 3. 数据转换：扁平结果集转树形结构
|
|
|
/// </para>
|
|
|
/// </summary>
|
|
|
public class HwProductInfoService : ITransient
|
|
|
{
|
|
|
/// <summary>
|
|
|
/// MyBatis 映射器名称。
|
|
|
/// </summary>
|
|
|
private const string Mapper = "HwProductInfoMapper";
|
|
|
|
|
|
/// <summary>
|
|
|
/// MyBatis 执行器。
|
|
|
/// </summary>
|
|
|
private readonly HwPortalMyBatisExecutor _executor;
|
|
|
|
|
|
/// <summary>
|
|
|
/// 构造函数（依赖注入）。
|
|
|
/// </summary>
|
|
|
/// <param name="executor">MyBatis 执行器</param>
|
|
|
public HwProductInfoService(HwPortalMyBatisExecutor executor)
|
|
|
{
|
|
|
_executor = executor;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 根据产品ID查询产品信息。
|
|
|
/// </summary>
|
|
|
/// <param name="productInfoId">产品ID</param>
|
|
|
/// <returns>产品实体</returns>
|
|
|
public Task<HwProductInfo> SelectHwProductInfoByProductInfoId(long productInfoId)
|
|
|
{
|
|
|
// 【匿名对象传参】
|
|
|
// new { productInfoId } 创建一个包含 productInfoId 属性的匿名对象。
|
|
|
// 编译器自动推断类型，比 Java 的 HashMap 更简洁。
|
|
|
return _executor.QuerySingleAsync<HwProductInfo>(Mapper, "selectHwProductInfoByProductInfoId", new { productInfoId });
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 查询产品列表。
|
|
|
/// </summary>
|
|
|
/// <param name="input">查询条件</param>
|
|
|
/// <returns>产品列表</returns>
|
|
|
public Task<List<HwProductInfo>> SelectHwProductInfoList(HwProductInfo input)
|
|
|
{
|
|
|
// 【空合并运算符 ??】
|
|
|
// input ?? new HwProductInfo()：如果 input 为 null，创建默认对象。
|
|
|
return _executor.QueryListAsync<HwProductInfo>(Mapper, "selectHwProductInfoList", input ?? new HwProductInfo());
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 新增产品信息。
|
|
|
/// </summary>
|
|
|
/// <param name="input">产品数据</param>
|
|
|
/// <returns>影响行数</returns>
|
|
|
public async Task<int> InsertHwProductInfo(HwProductInfo input)
|
|
|
{
|
|
|
// 【静态工具类调用】
|
|
|
// HwPortalContextHelper.Now() 获取当前时间。
|
|
|
// 这是"上下文助手"模式：封装了请求上下文相关的操作。
|
|
|
//
|
|
|
// 对比 Java Spring：
|
|
|
// Java 通常用 new Date() 或 LocalDateTime.now()。
|
|
|
// 这里封装一层的好处：可以统一控制时间来源（如测试时 mock）。
|
|
|
input.CreateTime = HwPortalContextHelper.Now();
|
|
|
|
|
|
long identity = await _executor.InsertReturnIdentityAsync(Mapper, "insertHwProductInfo", input);
|
|
|
|
|
|
// 回填自增主键。
|
|
|
input.ProductInfoId = identity;
|
|
|
|
|
|
return identity > 0 ? 1 : 0;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 更新产品信息。
|
|
|
/// </summary>
|
|
|
/// <param name="input">产品数据</param>
|
|
|
/// <returns>影响行数</returns>
|
|
|
public Task<int> UpdateHwProductInfo(HwProductInfo input)
|
|
|
{
|
|
|
input.UpdateTime = HwPortalContextHelper.Now();
|
|
|
return _executor.ExecuteAsync(Mapper, "updateHwProductInfo", input);
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 批量删除产品信息。
|
|
|
/// </summary>
|
|
|
/// <param name="productInfoIds">产品ID数组</param>
|
|
|
/// <returns>影响行数</returns>
|
|
|
public Task<int> DeleteHwProductInfoByProductInfoIds(long[] productInfoIds)
|
|
|
{
|
|
|
return _executor.ExecuteAsync(Mapper, "deleteHwProductInfoByProductInfoIds", new { array = productInfoIds });
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 查询产品信息及其明细列表（关联查询）。
|
|
|
/// <para>
|
|
|
/// 【核心算法：扁平数据转树形结构】
|
|
|
/// 这个方法展示了如何把"扁平的 JOIN 结果"转换成"树形的对象结构"。
|
|
|
///
|
|
|
/// 步骤：
|
|
|
/// 1. 执行 SQL JOIN 查询，得到扁平结果集
|
|
|
/// 2. 按 ProductInfoId 分组
|
|
|
/// 3. 每组的第一行作为产品主数据
|
|
|
/// 4. 每组的所有行作为明细列表
|
|
|
/// 5. 如果配置模式是树形（13），递归构建明细树
|
|
|
/// </para>
|
|
|
/// </summary>
|
|
|
/// <param name="input">查询条件</param>
|
|
|
/// <returns>产品列表（包含明细）</returns>
|
|
|
public async Task<List<HwProductInfo>> SelectHwProductInfoJoinDetailList(HwProductInfo input)
|
|
|
{
|
|
|
// 【第一步：查询扁平结果集】
|
|
|
// SQL JOIN 查询返回的是扁平结构：
|
|
|
// 产品1 | 明细1
|
|
|
// 产品1 | 明细2
|
|
|
// 产品1 | 明细3
|
|
|
// 产品2 | 明细4
|
|
|
// 产品2 | 明细5
|
|
|
//
|
|
|
// 每行包含产品字段 + 明细字段。
|
|
|
List<HwProductInfoJoinDetailRow> rows = await _executor.QueryListAsync<HwProductInfoJoinDetailRow>(Mapper, "selectHwProductInfoJoinDetailList", input ?? new HwProductInfo());
|
|
|
|
|
|
// 【第二步：LINQ GroupBy 分组转换】
|
|
|
// rows.GroupBy(row => row.ProductInfoId)
|
|
|
// 按 ProductInfoId 分组，相同 ProductInfoId 的行归为一组。
|
|
|
//
|
|
|
// .Select(group => { ... })
|
|
|
// 对每个分组进行转换，生成一个 HwProductInfo 对象。
|
|
|
//
|
|
|
// 对比 Java Stream：
|
|
|
// Java 写法：
|
|
|
// rows.stream()
|
|
|
// .collect(Collectors.groupingBy(HwProductInfoJoinDetailRow::getProductInfoId))
|
|
|
// .entrySet().stream()
|
|
|
// .map(entry -> {
|
|
|
// HwProductInfoJoinDetailRow first = entry.getValue().get(0);
|
|
|
// HwProductInfo product = new HwProductInfo();
|
|
|
// product.setProductInfoId(first.getProductInfoId());
|
|
|
// // ... 更多字段
|
|
|
// product.setDetailList(entry.getValue().stream()
|
|
|
// .map(row -> {
|
|
|
// HwProductInfoDetail detail = new HwProductInfoDetail();
|
|
|
// // ... 字段映射
|
|
|
// return detail;
|
|
|
// })
|
|
|
// .collect(Collectors.toList()));
|
|
|
// return product;
|
|
|
// })
|
|
|
// .collect(Collectors.toList());
|
|
|
//
|
|
|
// C# 的 LINQ 更简洁，特别是对象初始化器语法。
|
|
|
List<HwProductInfo> products = rows
|
|
|
.GroupBy(row => row.ProductInfoId)
|
|
|
.Select(group =>
|
|
|
{
|
|
|
// group.First() 获取分组中的第一行。
|
|
|
// 第一行的产品字段就是该产品的数据。
|
|
|
HwProductInfoJoinDetailRow first = group.First();
|
|
|
|
|
|
// 【对象初始化器】
|
|
|
// new HwProductInfo { ... } 直接在创建时赋值。
|
|
|
HwProductInfo product = new()
|
|
|
{
|
|
|
ProductInfoId = first.ProductInfoId,
|
|
|
ConfigTypeId = first.ConfigTypeId,
|
|
|
TabFlag = first.TabFlag,
|
|
|
ConfigModal = first.ConfigModal,
|
|
|
ProductInfoEtitle = first.ProductInfoEtitle,
|
|
|
ProductInfoCtitle = first.ProductInfoCtitle,
|
|
|
ProductInfoOrder = first.ProductInfoOrder,
|
|
|
CreateTime = first.CreateTime,
|
|
|
CreateBy = first.CreateBy,
|
|
|
UpdateTime = first.UpdateTime,
|
|
|
UpdateBy = first.UpdateBy,
|
|
|
ParentId = first.ParentId,
|
|
|
ConfigTypeName = first.ConfigTypeName,
|
|
|
|
|
|
// 【嵌套 LINQ：构建明细列表】
|
|
|
// group.Where(...).Select(...).ToList()
|
|
|
// 从当前分组中筛选出明细行，转换为明细对象列表。
|
|
|
//
|
|
|
// .Where(item => item.SubProductInfoDetailId.HasValue)
|
|
|
// 过滤掉没有明细的行（SubProductInfoDetailId 为 null）。
|
|
|
HwProductInfoDetailList = group
|
|
|
.Where(item => item.SubProductInfoDetailId.HasValue)
|
|
|
.Select(item => new HwProductInfoDetail
|
|
|
{
|
|
|
ProductInfoDetailId = item.SubProductInfoDetailId,
|
|
|
ParentId = item.SubParentId,
|
|
|
ProductInfoId = item.SubProductInfoId,
|
|
|
ProductInfoDetailTitle = item.SubProductInfoDetailTitle,
|
|
|
ProductInfoDetailDesc = item.SubProductInfoDetailDesc,
|
|
|
ProductInfoDetailOrder = item.SubProductInfoDetailOrder,
|
|
|
ProductInfoDetailPic = item.SubProductInfoDetailPic,
|
|
|
Ancestors = item.SubAncestors,
|
|
|
CreateTime = item.SubCreateTime,
|
|
|
CreateBy = item.SubCreateBy,
|
|
|
UpdateTime = item.SubUpdateTime,
|
|
|
UpdateBy = item.SubUpdateBy,
|
|
|
ConfigModel = item.ConfigModel
|
|
|
})
|
|
|
.ToList()
|
|
|
};
|
|
|
return product;
|
|
|
})
|
|
|
.ToList();
|
|
|
|
|
|
// 【第三步：判断是否需要构建树形结构】
|
|
|
// string.Equals(a, b, StringComparison.Ordinal)
|
|
|
// Ordinal 表示"按字节比较"，最快但区分大小写。
|
|
|
//
|
|
|
// 对比 Java：
|
|
|
// Java: a.equals(b) 或 a.equalsIgnoreCase(b)
|
|
|
// C#: string.Equals(a, b) 或 a == b（等价于 Equals）
|
|
|
if (string.Equals(input?.ConfigModal, HwPortalConstants.ProductInfoConfigModalTree, StringComparison.Ordinal))
|
|
|
{
|
|
|
// 配置模式 13 要求把明细转换成树形结构。
|
|
|
// .Where(u => u.HwProductInfoDetailList.Count > 0) 筛选有明细的产品。
|
|
|
foreach (HwProductInfo productInfo in products.Where(u => u.HwProductInfoDetailList.Count > 0))
|
|
|
{
|
|
|
productInfo.HwProductInfoDetailList = BuildProductInfoDetailTree(productInfo.HwProductInfoDetailList);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 【额外判断：明细内部的配置模式】
|
|
|
// 除了主查询条件，还需要检查每个明细的 ConfigModel。
|
|
|
// 这是源代码的业务规则，保持原行为。
|
|
|
foreach (HwProductInfo productInfo in products)
|
|
|
{
|
|
|
foreach (HwProductInfoDetail detail in productInfo.HwProductInfoDetailList)
|
|
|
{
|
|
|
if (string.Equals(detail.ConfigModel, HwPortalConstants.ProductInfoConfigModalTree, StringComparison.Ordinal))
|
|
|
{
|
|
|
productInfo.HwProductInfoDetailList = BuildProductInfoDetailTree(productInfo.HwProductInfoDetailList);
|
|
|
break; // 找到一个就跳出，避免重复构建。
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return products;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 查询产品信息关联列表。
|
|
|
/// </summary>
|
|
|
/// <param name="input">查询条件</param>
|
|
|
/// <returns>产品列表</returns>
|
|
|
public Task<List<HwProductInfo>> SelectHwProductInfoJoinList(HwProductInfo input)
|
|
|
{
|
|
|
return _executor.QueryListAsync<HwProductInfo>(Mapper, "selectHwProductInfoJoinList", input ?? new HwProductInfo());
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 构建产品明细树形结构。
|
|
|
/// <para>
|
|
|
/// 【树形结构构建算法】
|
|
|
/// 这是一个经典的"扁平列表转树形结构"算法：
|
|
|
///
|
|
|
/// 输入：扁平的节点列表，每个节点有 parentId 指向父节点
|
|
|
/// 输出：树形结构，顶级节点包含 children 子节点
|
|
|
///
|
|
|
/// 算法步骤：
|
|
|
/// 1. 找出所有顶级节点（parentId 为空/0/不在列表中）
|
|
|
/// 2. 对每个顶级节点，递归查找子节点
|
|
|
/// 3. 子节点再递归查找孙节点，直到叶子节点
|
|
|
///
|
|
|
/// 对比 Java 若依：
|
|
|
/// 若依的 TreeBuildUtils.buildTree() 做同样的事情。
|
|
|
/// 这是若依框架的标准树构建算法。
|
|
|
/// </para>
|
|
|
/// </summary>
|
|
|
/// <param name="productInfoDetails">扁平的明细列表</param>
|
|
|
/// <returns>树形结构的明细列表</returns>
|
|
|
public List<HwProductInfoDetail> BuildProductInfoDetailTree(List<HwProductInfoDetail> productInfoDetails)
|
|
|
{
|
|
|
// 【收集所有节点 ID】
|
|
|
// 用于判断某个 parentId 是否在列表中。
|
|
|
//
|
|
|
// .Select(item => item.ProductInfoDetailId) 提取所有 ID。
|
|
|
// .ToList() 转换为列表。
|
|
|
List<HwProductInfoDetail> returnList = new();
|
|
|
List<long?> tempList = productInfoDetails.Select(item => item.ProductInfoDetailId).ToList();
|
|
|
|
|
|
// 【遍历查找顶级节点】
|
|
|
foreach (HwProductInfoDetail detail in productInfoDetails)
|
|
|
{
|
|
|
// 【顶级节点判定】
|
|
|
// 满足以下任一条件即为顶级节点：
|
|
|
// 1. !detail.ParentId.HasValue：parentId 为 null
|
|
|
// 2. detail.ParentId == 0：parentId 为 0
|
|
|
// 3. !tempList.Contains(detail.ParentId)：parentId 不在列表中（父节点不存在）
|
|
|
if (!detail.ParentId.HasValue || detail.ParentId == 0 || !tempList.Contains(detail.ParentId))
|
|
|
{
|
|
|
// 找到顶级节点后，递归构建其子树。
|
|
|
RecursionFn(productInfoDetails, detail);
|
|
|
returnList.Add(detail);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 如果没找到顶级节点，返回原列表（兜底处理）。
|
|
|
return returnList.Count == 0 ? productInfoDetails : returnList;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 递归构建子树。
|
|
|
/// <para>
|
|
|
/// 【递归算法说明】
|
|
|
/// 递归是一种"自己调用自己"的编程技巧。
|
|
|
///
|
|
|
/// 这里的递归逻辑：
|
|
|
/// 1. 找出当前节点的所有直接子节点
|
|
|
/// 2. 把子节点挂到当前节点的 Children 属性
|
|
|
/// 3. 对每个子节点，递归执行步骤 1-2
|
|
|
///
|
|
|
/// 终止条件：节点没有子节点（HasChild 返回 false）
|
|
|
/// </para>
|
|
|
/// </summary>
|
|
|
/// <param name="list">所有节点列表</param>
|
|
|
/// <param name="current">当前节点</param>
|
|
|
private static void RecursionFn(List<HwProductInfoDetail> list, HwProductInfoDetail current)
|
|
|
{
|
|
|
// 找出当前节点的所有直接子节点。
|
|
|
List<HwProductInfoDetail> childList = GetChildList(list, current);
|
|
|
|
|
|
// 把子节点挂到当前节点。
|
|
|
// Children 和 HwProductInfoDetailList 都设置，兼容不同的访问方式。
|
|
|
current.Children = childList;
|
|
|
current.HwProductInfoDetailList = childList;
|
|
|
|
|
|
// 【递归调用】
|
|
|
// 对每个有子节点的子节点，继续递归构建子树。
|
|
|
// .Where(child => HasChild(list, child)) 筛选有子节点的节点。
|
|
|
foreach (HwProductInfoDetail child in childList.Where(child => HasChild(list, child)))
|
|
|
{
|
|
|
RecursionFn(list, child);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 获取当前节点的直接子节点列表。
|
|
|
/// </summary>
|
|
|
/// <param name="list">所有节点列表</param>
|
|
|
/// <param name="current">当前节点</param>
|
|
|
/// <returns>子节点列表</returns>
|
|
|
private static List<HwProductInfoDetail> GetChildList(List<HwProductInfoDetail> list, HwProductInfoDetail current)
|
|
|
{
|
|
|
// 【LINQ Where 过滤】
|
|
|
// item.ParentId.Value == current.ProductInfoDetailId.Value
|
|
|
// 条件：item 的 parentId 等于 current 的 id。
|
|
|
//
|
|
|
// .HasValue 检查可空类型是否有值（不为 null）。
|
|
|
// .Value 获取可空类型的实际值。
|
|
|
//
|
|
|
// 对比 Java：
|
|
|
// Java: list.stream().filter(item -> item.getParentId() != null && current.getProductInfoDetailId() != null && item.getParentId().equals(current.getProductInfoDetailId())).collect(Collectors.toList());
|
|
|
//
|
|
|
// C# 的可空类型处理更优雅。
|
|
|
return list.Where(item => item.ParentId.HasValue && current.ProductInfoDetailId.HasValue && item.ParentId.Value == current.ProductInfoDetailId.Value).ToList();
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
/// 判断当前节点是否有子节点。
|
|
|
/// </summary>
|
|
|
/// <param name="list">所有节点列表</param>
|
|
|
/// <param name="current">当前节点</param>
|
|
|
/// <returns>是否有子节点</returns>
|
|
|
private static bool HasChild(List<HwProductInfoDetail> list, HwProductInfoDetail current)
|
|
|
{
|
|
|
return GetChildList(list, current).Count > 0;
|
|
|
}
|
|
|
}
|