提交健身房设备代码

alien-entity/src/main/java/shop/alien/entity/store/vo/FitnessEquipmentCategoryDetailVo.java

@@ -0,0 +1,43 @@
+package shop.alien.entity.store.vo;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import shop.alien.entity.store.FitnessEquipmentInfo;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 健身设备分类详情视图对象（用于用户端查询）
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@ApiModel(value = "FitnessEquipmentCategoryDetailVo对象", description = "健身设备分类详情视图对象（用于用户端查询）")
+public class FitnessEquipmentCategoryDetailVo implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty(value = "门店ID")
+    private Integer storeId;
+
+    @ApiModelProperty(value = "设施分类(1:有氧区, 2:力量区, 3:单功能机械区)")
+    private Integer facilityCategory;
+
+    @ApiModelProperty(value = "设施分类名称")
+    private String facilityCategoryName;
+
+    @ApiModelProperty(value = "该分类下的图片列表（轮播图）")
+    private List<String> imageList;
+
+    @ApiModelProperty(value = "设备类型汇总列表（包含各子分类的设备数量和设备列表）")
+    private List<FitnessEquipmentTypeSummaryVo> equipmentTypeList;
+
+    @ApiModelProperty(value = "设备列表（已废弃，设备列表已放入equipmentTypeList中）")
+    private List<FitnessEquipmentInfo> equipmentList;
+}
+

alien-entity/src/main/java/shop/alien/entity/store/vo/FitnessEquipmentTypeSummaryVo.java

@@ -0,0 +1,37 @@
+package shop.alien.entity.store.vo;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import shop.alien.entity.store.FitnessEquipmentInfo;
+
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 健身设备类型汇总视图对象
+ *
+ * @author system
+ * @since 2025-01-XX
+ */
+@Data
+@JsonInclude(JsonInclude.Include.NON_NULL)
+@ApiModel(value = "FitnessEquipmentTypeSummaryVo对象", description = "健身设备类型汇总视图对象")
+public class FitnessEquipmentTypeSummaryVo implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @ApiModelProperty(value = "设备类型(1:心肺训练, 2:核心训练, 3:臀腿训练, 4:上肢训练, 5:全身训练, 6:其他)")
+    private Integer equipmentType;
+
+    @ApiModelProperty(value = "设备类型名称")
+    private String equipmentTypeName;
+
+    @ApiModelProperty(value = "该类型下的设备数量")
+    private Integer equipmentCount;
+
+    @ApiModelProperty(value = "该类型下的设备列表")
+    private List<FitnessEquipmentInfo> equipmentList;
+}
+

alien-store/src/main/java/shop/alien/store/controller/SportsEquipmentFacilityController.java

@@ -7,6 +7,7 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.web.bind.annotation.*;
 import shop.alien.entity.result.R;
 import shop.alien.entity.store.SportsEquipmentFacility;
+import shop.alien.entity.store.vo.FitnessEquipmentCategoryDetailVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityCategorySummaryVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityCategoryVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityVo;
@@ -220,5 +221,80 @@ public class SportsEquipmentFacilityController {
             return R.fail(e.getMessage());
         }
     }
+
+    /**
+     * 查询失败消息
+     */
+    private static final String QUERY_FAIL_MSG = "查询失败";
+    
+    /**
+     * 门店ID无效消息
+     */
+    private static final String INVALID_STORE_ID_MSG = "门店ID不能为空且必须大于0";
+    
+    /**
+     * 设施分类无效消息
+     */
+    private static final String INVALID_FACILITY_CATEGORY_MSG = "设施分类无效，必须为1(有氧区)、2(力量区)或3(单功能机械区)";
+    
+    /**
+     * 最小有效值
+     */
+    private static final int MIN_VALID_VALUE = 1;
+    
+    /**
+     * 最大设施分类编号
+     */
+    private static final int MAX_FACILITY_CATEGORY = 3;
+    
+    @ApiOperation("查询分类的设备详情（用户端）- 包含图片列表、各子分类的设备数量汇总、设备列表。facilityCategory为空时返回所有分类，equipmentType为空时返回所有类型")
+    @ApiOperationSupport(order = 11)
+    @ApiImplicitParams({
+            @ApiImplicitParam(name = "storeId", value = "门店ID", dataType = "Integer", paramType = "query", required = true),
+            @ApiImplicitParam(name = "facilityCategory", value = "设施分类(1:有氧区, 2:力量区, 3:单功能机械区)，可选，为空时返回所有分类", dataType = "Integer", paramType = "query", required = false),
+            @ApiImplicitParam(name = "equipmentType", value = "设备类型(1:心肺训练, 2:核心训练, 3:臀腿训练, 4:上肢训练, 5:全身训练, 6:其他)，可选，为空时返回所有类型", dataType = "Integer", paramType = "query", required = false)
+    })
+    @GetMapping("/categoryDetail")
+    public R<List<FitnessEquipmentCategoryDetailVo>> getCategoryDetail(
+            @RequestParam("storeId") Integer storeId,
+            @RequestParam(required = false) Integer facilityCategory,
+            @RequestParam(required = false) Integer equipmentType) {
+        log.info("查询分类的设备详情（用户端），storeId={}，facilityCategory={}，equipmentType={}", 
+                storeId, facilityCategory, equipmentType);
+        try {
+            // 参数验证
+            if (storeId == null || storeId < MIN_VALID_VALUE) {
+                log.warn("查询分类详情失败，门店ID无效：{}", storeId);
+                return R.fail(INVALID_STORE_ID_MSG);
+            }
+            
+            // 如果facilityCategory不为空，验证其有效性
+            if (facilityCategory != null && (facilityCategory < MIN_VALID_VALUE || facilityCategory > MAX_FACILITY_CATEGORY)) {
+                log.warn("查询分类详情失败，设施分类无效：{}", facilityCategory);
+                return R.fail(INVALID_FACILITY_CATEGORY_MSG);
+            }
+            
+            List<FitnessEquipmentCategoryDetailVo> resultList = facilityService.getCategoryDetail(storeId, facilityCategory, equipmentType);
+            
+            // 统计总设备数量（从equipmentTypeList中统计）
+            int totalEquipmentCount = 0;
+            if (resultList != null) {
+                for (FitnessEquipmentCategoryDetailVo vo : resultList) {
+                    if (vo.getEquipmentTypeList() != null) {
+                        totalEquipmentCount += vo.getEquipmentTypeList().stream()
+                                .mapToInt(typeVo -> typeVo.getEquipmentList() != null ? typeVo.getEquipmentList().size() : 0)
+                                .sum();
+                    }
+                }
+            }
+            log.info("查询分类详情成功，storeId={}，facilityCategory={}，equipmentType={}，返回分类数量：{}，总设备数量：{}", 
+                    storeId, facilityCategory, equipmentType, resultList != null ? resultList.size() : 0, totalEquipmentCount);
+            return R.data(resultList);
+        } catch (Exception e) {
+            log.error("查询分类详情异常，storeId={}，facilityCategory={}，equipmentType={}，异常信息：{}", 
+                    storeId, facilityCategory, equipmentType, e.getMessage(), e);
+            return R.fail(QUERY_FAIL_MSG + "：" + e.getMessage());
+        }
+    }
 }
 

alien-store/src/main/java/shop/alien/store/service/SportsEquipmentFacilityService.java

@@ -3,6 +3,7 @@ package shop.alien.store.service;
 import com.baomidou.mybatisplus.core.metadata.IPage;
 import com.baomidou.mybatisplus.extension.service.IService;
 import shop.alien.entity.store.SportsEquipmentFacility;
+import shop.alien.entity.store.vo.FitnessEquipmentCategoryDetailVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityCategorySummaryVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityCategoryVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityVo;
@@ -95,5 +96,18 @@ public interface SportsEquipmentFacilityService extends IService<SportsEquipment
      * @return boolean
      */
     boolean saveCategoryImages(Integer storeId, Integer facilityCategory, List<String> imageList);
+
+    /**
+     * 查询分类的设备详情（用户端）
+     * 包含图片列表、各子分类的设备数量汇总、设备列表
+     * 如果facilityCategory为空，返回所有分类的数据
+     * 如果equipmentType为空，返回该分类下所有类型的数据
+     *
+     * @param storeId          门店ID，不能为空且必须大于0
+     * @param facilityCategory 设施分类(1:有氧区, 2:力量区, 3:单功能机械区)，可选，为空时返回所有分类
+     * @param equipmentType    设备类型(1:心肺训练, 2:核心训练, 3:臀腿训练, 4:上肢训练, 5:全身训练, 6:其他)，可选，为空时返回所有类型
+     * @return 分类详情列表，不会返回null
+     */
+    List<FitnessEquipmentCategoryDetailVo> getCategoryDetail(Integer storeId, Integer facilityCategory, Integer equipmentType);
 }
 

alien-store/src/main/java/shop/alien/store/service/impl/SportsEquipmentFacilityServiceImpl.java

@@ -14,6 +14,8 @@ import org.apache.commons.lang3.StringUtils;
 import shop.alien.entity.store.FitnessEquipmentInfo;
 import shop.alien.entity.store.SportsEquipmentFacility;
 import shop.alien.entity.store.StoreImg;
+import shop.alien.entity.store.vo.FitnessEquipmentCategoryDetailVo;
+import shop.alien.entity.store.vo.FitnessEquipmentTypeSummaryVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityCategorySummaryVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityCategoryVo;
 import shop.alien.entity.store.vo.SportsEquipmentFacilityVo;
@@ -82,6 +84,26 @@ public class SportsEquipmentFacilityServiceImpl extends ServiceImpl<SportsEquipm
      * 设施分类名称映射
      */
     private static final String[] FACILITY_CATEGORY_NAMES = {"", "有氧区", "力量区", "单功能机械区"};
+    
+    /**
+     * 设备类型名称映射
+     */
+    private static final String[] EQUIPMENT_TYPE_NAMES = {"", "心肺训练", "核心训练", "臀腿训练", "上肢训练", "全身训练", "其他"};
+    
+    /**
+     * 最大设备类型编号
+     */
+    private static final int MAX_EQUIPMENT_TYPE = 6;
+    
+    /**
+     * 最小设备类型编号
+     */
+    private static final int MIN_EQUIPMENT_TYPE = 1;
+    
+    /**
+     * 最大设施分类编号
+     */
+    private static final int MAX_FACILITY_CATEGORY = 3;
 
     @Override
     public IPage<SportsEquipmentFacilityVo> getPageList(Integer pageNum, Integer pageSize, Integer storeId, Integer facilityCategory) {
@@ -555,5 +577,282 @@ public class SportsEquipmentFacilityServiceImpl extends ServiceImpl<SportsEquipm
 
         return true;
     }
+
+    /**
+     * 查询分类的设备详情（用户端）
+     * 包含图片列表、各子分类的设备数量汇总、设备列表
+     * 通过fitnessEquipmentIds关联FitnessEquipmentInfo信息
+     * 如果facilityCategory为空，返回所有分类的数据
+     * 如果equipmentType为空，返回该分类下所有类型的数据
+     *
+     * @param storeId          门店ID，不能为空且必须大于0
+     * @param facilityCategory 设施分类(1:有氧区, 2:力量区, 3:单功能机械区)，可选，为空时返回所有分类
+     * @param equipmentType    设备类型(1:心肺训练, 2:核心训练, 3:臀腿训练, 4:上肢训练, 5:全身训练, 6:其他)，可选，为空时返回所有类型
+     * @return 分类详情列表，不会返回null
+     */
+    @Override
+    public List<FitnessEquipmentCategoryDetailVo> getCategoryDetail(Integer storeId, Integer facilityCategory, Integer equipmentType) {
+        log.info("查询分类的设备详情（用户端），storeId={}，facilityCategory={}，equipmentType={}", 
+                storeId, facilityCategory, equipmentType);
+        
+        // 参数验证
+        if (!isValidStoreId(storeId)) {
+            log.warn("查询分类详情失败，门店ID无效：{}", storeId);
+            return new ArrayList<>();
+        }
+        
+        try {
+            List<FitnessEquipmentCategoryDetailVo> resultList = new ArrayList<>();
+            
+            // 如果facilityCategory为空，返回所有分类的数据
+            if (facilityCategory == null) {
+                for (int category = MIN_CATEGORY_NUM; category < FACILITY_CATEGORY_NAMES.length; category++) {
+                    FitnessEquipmentCategoryDetailVo detailVo = buildCategoryDetailVo(storeId, category, equipmentType);
+                    resultList.add(detailVo);
+                }
+            } else {
+                // 验证facilityCategory有效性
+                if (!isValidFacilityCategory(facilityCategory)) {
+                    log.warn("查询分类详情失败，设施分类无效：{}", facilityCategory);
+                    return new ArrayList<>();
+                }
+                // 返回指定分类的数据
+                FitnessEquipmentCategoryDetailVo detailVo = buildCategoryDetailVo(storeId, facilityCategory, equipmentType);
+                resultList.add(detailVo);
+            }
+            
+            log.info("查询分类详情成功，storeId={}，facilityCategory={}，equipmentType={}，返回分类数量：{}", 
+                    storeId, facilityCategory, equipmentType, resultList.size());
+            return resultList;
+        } catch (Exception e) {
+            log.error("查询分类详情异常，storeId={}，facilityCategory={}，equipmentType={}，异常信息：{}", 
+                    storeId, facilityCategory, equipmentType, e.getMessage(), e);
+            throw new RuntimeException("查询分类详情异常：" + e.getMessage(), e);
+        }
+    }
+    
+    /**
+     * 构建单个分类的详情VO对象
+     *
+     * @param storeId          门店ID
+     * @param facilityCategory 设施分类
+     * @param equipmentType    设备类型，可选，如果传入则只返回该类型的设备列表
+     * @return 分类详情VO对象
+     */
+    private FitnessEquipmentCategoryDetailVo buildCategoryDetailVo(Integer storeId, Integer facilityCategory, Integer equipmentType) {
+        FitnessEquipmentCategoryDetailVo detailVo = buildBaseCategoryDetailVo(storeId, facilityCategory);
+        
+        // 查询并设置设备相关信息
+        List<FitnessEquipmentInfo> allEquipmentList = queryCategoryEquipmentList(storeId, facilityCategory);
+        
+        // 如果传入了equipmentType，只筛选该类型的设备
+        List<FitnessEquipmentInfo> filteredEquipmentList = filterAndSortEquipmentList(allEquipmentList, equipmentType);
+        
+        // 构建设备类型汇总列表（包含设备列表）
+        List<FitnessEquipmentTypeSummaryVo> equipmentTypeList = buildEquipmentTypeSummaryList(filteredEquipmentList);
+        detailVo.setEquipmentTypeList(equipmentTypeList);
+        
+        // 查询并设置图片列表
+        List<String> imageList = queryCategoryImageList(storeId, facilityCategory);
+        detailVo.setImageList(imageList);
+        
+        int totalEquipmentCount = equipmentTypeList.stream()
+                .mapToInt(vo -> vo.getEquipmentList() != null ? vo.getEquipmentList().size() : 0)
+                .sum();
+        log.debug("构建分类详情VO完成，storeId={}，facilityCategory={}，equipmentType={}，设备数量：{}", 
+                storeId, facilityCategory, equipmentType, totalEquipmentCount);
+        return detailVo;
+    }
+    
+    /**
+     * 验证门店ID是否有效
+     *
+     * @param storeId 门店ID
+     * @return true表示有效，false表示无效
+     */
+    private boolean isValidStoreId(Integer storeId) {
+        return storeId != null && storeId >= MIN_VALID_ID;
+    }
+    
+    /**
+     * 验证设施分类是否有效
+     *
+     * @param facilityCategory 设施分类
+     * @return true表示有效，false表示无效
+     */
+    private boolean isValidFacilityCategory(Integer facilityCategory) {
+        return facilityCategory != null 
+                && facilityCategory >= MIN_CATEGORY_NUM 
+                && facilityCategory <= MAX_FACILITY_CATEGORY
+                && facilityCategory < FACILITY_CATEGORY_NAMES.length;
+    }
+    
+    /**
+     * 构建基础分类详情VO对象
+     *
+     * @param storeId          门店ID
+     * @param facilityCategory 设施分类
+     * @return 基础分类详情VO对象
+     */
+    private FitnessEquipmentCategoryDetailVo buildBaseCategoryDetailVo(Integer storeId, Integer facilityCategory) {
+        FitnessEquipmentCategoryDetailVo detailVo = new FitnessEquipmentCategoryDetailVo();
+        detailVo.setStoreId(storeId);
+        detailVo.setFacilityCategory(facilityCategory);
+        if (isValidFacilityCategory(facilityCategory)) {
+            detailVo.setFacilityCategoryName(FACILITY_CATEGORY_NAMES[facilityCategory]);
+        }
+        return detailVo;
+    }
+    
+    /**
+     * 查询分类下的设备列表
+     *
+     * @param storeId          门店ID
+     * @param facilityCategory 设施分类
+     * @return 设备信息列表
+     */
+    private List<FitnessEquipmentInfo> queryCategoryEquipmentList(Integer storeId, Integer facilityCategory) {
+        // 查询该分类下的设备列表
+        List<SportsEquipmentFacility> facilityList = queryFacilityListByCategory(storeId, facilityCategory);
+        
+        // 收集并解析fitnessEquipmentIds
+        List<Integer> fitnessEquipmentIdList = collectFitnessEquipmentIds(facilityList, storeId, facilityCategory);
+        
+        // 查询所有有效的FitnessEquipmentInfo列表
+        return queryAllFitnessEquipmentInfo(fitnessEquipmentIdList, storeId, facilityCategory);
+    }
+    
+    /**
+     * 根据设备类型筛选并排序设备列表
+     *
+     * @param allEquipmentList 所有设备列表
+     * @param equipmentType    设备类型，可选
+     * @return 筛选并排序后的设备列表
+     */
+    private List<FitnessEquipmentInfo> filterAndSortEquipmentList(List<FitnessEquipmentInfo> allEquipmentList, 
+                                                                   Integer equipmentType) {
+        List<FitnessEquipmentInfo> filteredList;
+        
+        if (isValidEquipmentType(equipmentType)) {
+            // 根据equipmentType筛选设备
+            filteredList = allEquipmentList.stream()
+                    .filter(info -> equipmentType.equals(info.getEquipmentType()))
+                    .sorted(this::compareBySortOrder)
+                    .collect(Collectors.toList());
+        } else {
+            // 如果equipmentType为空或无效，返回所有设备
+            filteredList = allEquipmentList.stream()
+                    .sorted(this::compareBySortOrder)
+                    .collect(Collectors.toList());
+        }
+        
+        return filteredList;
+    }
+    
+    /**
+     * 验证设备类型是否有效
+     *
+     * @param equipmentType 设备类型
+     * @return true表示有效，false表示无效
+     */
+    private boolean isValidEquipmentType(Integer equipmentType) {
+        return equipmentType != null 
+                && equipmentType >= MIN_EQUIPMENT_TYPE 
+                && equipmentType <= MAX_EQUIPMENT_TYPE;
+    }
+    
+    /**
+     * 查询所有有效的FitnessEquipmentInfo列表
+     *
+     * @param fitnessEquipmentIdList 设备ID列表
+     * @param storeId                门店ID（用于日志）
+     * @param facilityCategory       设施分类（用于日志）
+     * @return 过滤后的设备信息列表，不会返回null
+     */
+    private List<FitnessEquipmentInfo> queryAllFitnessEquipmentInfo(List<Integer> fitnessEquipmentIdList, 
+                                                                     Integer storeId, Integer facilityCategory) {
+        if (CollectionUtils.isEmpty(fitnessEquipmentIdList)) {
+            log.debug("设备ID列表为空，返回空列表，storeId={}，facilityCategory={}", storeId, facilityCategory);
+            return new ArrayList<>();
+        }
+        
+        try {
+            List<FitnessEquipmentInfo> allEquipmentList = new ArrayList<>(
+                    fitnessEquipmentInfoService.listByIds(fitnessEquipmentIdList));
+            
+            // 过滤掉已删除和禁用的设备
+            List<FitnessEquipmentInfo> validList = allEquipmentList.stream()
+                    .filter(this::isValidFitnessEquipment)
+                    .collect(Collectors.toList());
+            
+            log.debug("查询FitnessEquipmentInfo列表完成，原始数量：{}，有效数量：{}，storeId={}，facilityCategory={}", 
+                    allEquipmentList.size(), validList.size(), storeId, facilityCategory);
+            return validList;
+        } catch (Exception e) {
+            log.error("查询FitnessEquipmentInfo列表异常，facilityCategory={}，storeId={}，异常信息：{}", 
+                    facilityCategory, storeId, e.getMessage(), e);
+            return new ArrayList<>();
+        }
+    }
+    
+    /**
+     * 构建设备类型汇总列表
+     * 按equipmentType分组统计各类型的设备数量，并将设备列表放入对应的汇总项中
+     *
+     * @param equipmentList 设备列表
+     * @return 设备类型汇总列表，不会返回null
+     */
+    private List<FitnessEquipmentTypeSummaryVo> buildEquipmentTypeSummaryList(List<FitnessEquipmentInfo> equipmentList) {
+        List<FitnessEquipmentTypeSummaryVo> typeSummaryList = new ArrayList<>();
+        
+        if (CollectionUtils.isEmpty(equipmentList)) {
+            log.debug("设备列表为空，返回空汇总列表");
+            return typeSummaryList;
+        }
+        
+        // 按equipmentType分组统计数量和设备列表
+        for (int type = MIN_EQUIPMENT_TYPE; type <= MAX_EQUIPMENT_TYPE; type++) {
+            final Integer equipmentType = Integer.valueOf(type);
+            
+            // 筛选该类型下的设备并排序
+            List<FitnessEquipmentInfo> typeEquipmentList = equipmentList.stream()
+                    .filter(info -> info.getEquipmentType() != null && equipmentType.equals(info.getEquipmentType()))
+                    .sorted(this::compareBySortOrder)
+                    .collect(Collectors.toList());
+            
+            if (!CollectionUtils.isEmpty(typeEquipmentList)) {
+                FitnessEquipmentTypeSummaryVo typeSummaryVo = createEquipmentTypeSummaryVo(
+                        equipmentType, typeEquipmentList.size(), typeEquipmentList);
+                typeSummaryList.add(typeSummaryVo);
+            }
+        }
+        
+        log.debug("构建设备类型汇总列表完成，汇总类型数量：{}，总设备数量：{}", 
+                typeSummaryList.size(), equipmentList.size());
+        return typeSummaryList;
+    }
+    
+    /**
+     * 创建设备类型汇总VO对象
+     *
+     * @param equipmentType    设备类型
+     * @param count            设备数量
+     * @param equipmentList    设备列表
+     * @return 设备类型汇总VO对象
+     */
+    private FitnessEquipmentTypeSummaryVo createEquipmentTypeSummaryVo(Integer equipmentType, Integer count, 
+                                                                       List<FitnessEquipmentInfo> equipmentList) {
+        FitnessEquipmentTypeSummaryVo typeSummaryVo = new FitnessEquipmentTypeSummaryVo();
+        typeSummaryVo.setEquipmentType(equipmentType);
+        
+        if (equipmentType >= MIN_EQUIPMENT_TYPE && equipmentType <= MAX_EQUIPMENT_TYPE 
+                && equipmentType < EQUIPMENT_TYPE_NAMES.length) {
+            typeSummaryVo.setEquipmentTypeName(EQUIPMENT_TYPE_NAMES[equipmentType]);
+        }
+        
+        typeSummaryVo.setEquipmentCount(count);
+        typeSummaryVo.setEquipmentList(equipmentList);
+        return typeSummaryVo;
+    }
 }