Intelliconnect Service Style

IntelliConnect Service Style

Use this skill when implementing backend service/serviceimpl code in IntelliConnect. Prefer PUT/update flows that identify the target row by id.

Workflow

1. Read existing nearby examples before editing:
   • src/main/java/top/rslly/iot/services/agent/*ServiceImpl.java
   • src/main/java/top/rslly/iot/services/thingsModel/*ServiceImpl.java
   • matching dao/, models/, and param/request/ files.
2. Prefer the existing repository/service naming style over new abstractions.
3. Add or update the request DTO in top.rslly.iot.param.request when the service method accepts input from controller code.
4. Add derived Spring Data repository methods for simple lookups and pageable queries.
5. Use database-backed pagination for paged APIs; do not manually paginate non-empty lists in the service.
6. Use streams for simple collection projection, but avoid repeated repository calls and mutation-heavy stream code.
7. Keep controller permission checks outside mutating service methods when the repository pattern already uses SafetyServiceImpl wrappers.
8. Before implementing any delete path, inspect all related tables/repositories and decide whether the correct behavior is dependency failure or cascade delete.
9. If the dependency policy is not already obvious from nearby code, ask the user whether to return HAS_DEPENDENCIES or delete related records too.
10. Compile with JDK 21 after edits:

$env:JAVA_HOME='C:\Users\Lenovo\.jdks\ms-21.0.9'; $env:Path="$env:JAVA_HOME\bin;$env:Path"; .\mvnw.cmd -q -DskipTests compile

Service Interface Pattern

Use interfaces under the same service package as the implementation.

Common method shape:

List<Entity> findAllById(int id);

List<Entity> findAllByProductId(int productId);

JsonResult<?> getThing(String token);

JsonResult<?> postThing(ThingParam param);

JsonResult<?> updateThing(ThingParam param);

JsonResult<?> deleteThing(int id);

Use String token for list getters that need user-specific filtering. Do not pass token into post, update, or delete when controller/SafetyService will authorize the operation before calling the service.

Implementation Pattern

Use @Service, @Resource, @Transactional(rollbackFor = Exception.class), JsonResult<?>, ResultTool, and ResultCode to match the repo.

For get... (String token), keep the whole role-based flow in one method, like other impls:

String tokenDeal = token.replace(JwtTokenUtil.TOKEN_PREFIX, "");
String role = JwtTokenUtil.getUserRole(tokenDeal);
String username = JwtTokenUtil.getUsername(tokenDeal);
List<Entity> result;
if (role.equals("ROLE_" + "wx_user")) {
  if (wxUserRepository.findAllByName(username).isEmpty()) {
    return ResultTool.fail(ResultCode.COMMON_FAIL);
  }
  // collect records through wx product binds
} else if (!role.equals("[ROLE_admin]")) {
  if (userRepository.findAllByUsername(username).isEmpty()) {
    return ResultTool.fail(ResultCode.COMMON_FAIL);
  }
  // collect records through user product binds
} else {
  result = repository.findAll();
}
if (result.isEmpty()) {
  return ResultTool.fail(ResultCode.COMMON_FAIL);
} else
  return ResultTool.success(result);

Do not split this into a helper unless the surrounding codebase already does so for the same type of service. Do not return null; return ResultTool.fail(ResultCode.COMMON_FAIL).

Collection Style

Use streams for simple one-step projections from repository results, especially when extracting ids for scoped queries:

List<Integer> productIdList = userProductBindRepository.findAllByUserId(userId)
    .stream()
    .map(UserProductBindEntity::getProductId)
    .toList();

Prefer .toList() on Java 21 when the result is only passed to another method or returned. Use new ArrayList<>(...) or collect(Collectors.toList()) only when later code must mutate the list.

Do not use streams for code that needs side effects, complex branching, or repository calls per item. Prefer one repository query returning all needed rows, then a simple map(...).toList() if only a field is needed.

Avoid duplicate repository calls. Store the result list once before checking it:

List<WxUserEntity> wxUserEntityList = wxUserRepository.findAllByName(username);
if (wxUserEntityList.isEmpty()) {
  return ResultTool.fail(ResultCode.COMMON_FAIL);
}
String appid = wxUserEntityList.getFirst().getAppid();

Pagination Pattern

For paged APIs, use Spring Data Pageable/Page and push pagination into the repository/database. Do not manually page non-empty data with List.subList(...), stream skip/limit, loops, or in-memory sorting in the service.

Controller methods should accept pageNum and pageSize with @Min(1) validation, then pass them to the service. Services should build PageRequest.of(pageNum - 1, pageSize, Sort.by(...)) and call a repository method returning Page<Entity>.

Use derived repository methods for scoped paging, including permission-filtered ID lists:

Page<ProductEntity> findAllByIdIn(List<Integer> ids, Pageable pageable);

If there are no authorized ids, returning new PageImpl<>(List.of(), pageable, 0) is acceptable. Do not use PageImpl to wrap a manually sliced non-empty result list when a repository query can page it.

For permission-filtered pagination, first collect the authorized ids with simple stream projection, then pass the ids to a pageable repository method. If the id list is empty, return an empty page instead of querying with IN ().

List<Integer> productIdList = wxProductBindRepository.findAllByAppidAndOpenid(appid, openid)
    .stream()
    .map(WxProductBindEntity::getProductId)
    .toList();
Page<ProductEntity> result = productIdList.isEmpty() ? emptyProductPage(pageable)
    : productRepository.findAllByIdIn(productIdList, pageable);