package com.ruoyi.device.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.device.mapper.MaintenanceItemMapper;
|
import com.ruoyi.device.pojo.MaintenanceItem;
|
import com.ruoyi.device.service.MaintenanceItemService;
|
import lombok.RequiredArgsConstructor;
|
import org.apache.commons.lang3.StringUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.List;
|
|
@Service
|
@RequiredArgsConstructor
|
public class MaintenanceItemServiceImpl
|
extends ServiceImpl<MaintenanceItemMapper, MaintenanceItem>
|
implements MaintenanceItemService {
|
|
private static final List<String> VALID_FREQUENCIES = List.of(
|
"DAILY",
|
"WEEKLY",
|
"MONTHLY",
|
"QUARTERLY",
|
"ALL"
|
);
|
|
private final MaintenanceItemMapper maintenanceItemMapper;
|
|
@Override
|
public List<MaintenanceItem> listActive() {
|
return list(new LambdaQueryWrapper<MaintenanceItem>()
|
.eq(MaintenanceItem::getDeleted, 0)
|
.eq(MaintenanceItem::getIsActive, 1)
|
.orderByAsc(MaintenanceItem::getSortNum)
|
.orderByAsc(MaintenanceItem::getId));
|
}
|
|
@Override
|
public List<MaintenanceItem> list(MaintenanceItem query) {
|
LambdaQueryWrapper<MaintenanceItem> wrapper = buildQueryWrapper(query, false)
|
.orderByDesc(MaintenanceItem::getId);
|
return maintenanceItemMapper.selectList(wrapper);
|
}
|
|
@Override
|
public Page<MaintenanceItem> page(
|
long pageNum,
|
long pageSize,
|
boolean includeCommon,
|
MaintenanceItem query
|
) {
|
long safePageNum = Math.max(pageNum, 1);
|
long safePageSize = Math.min(Math.max(pageSize, 1), 100);
|
|
LambdaQueryWrapper<MaintenanceItem> wrapper = buildQueryWrapper(query, includeCommon)
|
.orderByAsc(MaintenanceItem::getSortNum)
|
.orderByAsc(MaintenanceItem::getId);
|
return maintenanceItemMapper.selectPage(new Page<>(safePageNum, safePageSize), wrapper);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void createItem(MaintenanceItem item) {
|
if (!isValid(item)) {
|
throw new ServiceException("保养项目、保养内容和频率不能为空或无效");
|
}
|
|
normalize(item);
|
item.setDeleted(0);
|
if (existsName(item, null)) {
|
throw new ServiceException("该设备和频率下已存在同名保养内容");
|
}
|
|
if (maintenanceItemMapper.insert(item) <= 0) {
|
throw new ServiceException("新增保养项目失败");
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void updateItem(MaintenanceItem item) {
|
if (item == null || item.getId() == null || !isValid(item)) {
|
throw new ServiceException("保养项目、保养内容和频率不能为空或无效");
|
}
|
|
MaintenanceItem existingItem = maintenanceItemMapper.selectById(item.getId());
|
if (existingItem == null || Integer.valueOf(1).equals(existingItem.getDeleted())) {
|
throw new ServiceException("保养项目不存在");
|
}
|
|
normalize(item);
|
if (existsName(item, item.getId())) {
|
throw new ServiceException("该设备和频率下已存在同名保养内容");
|
}
|
|
existingItem.setItemProject(item.getItemProject());
|
existingItem.setItemName(item.getItemName());
|
existingItem.setDeviceLedgerId(item.getDeviceLedgerId());
|
existingItem.setFrequencyType(item.getFrequencyType());
|
existingItem.setSortNum(item.getSortNum() == null ? 0 : item.getSortNum());
|
existingItem.setIsActive(item.getIsActive() == null ? existingItem.getIsActive() : item.getIsActive());
|
existingItem.setRemarks(item.getRemarks());
|
|
if (maintenanceItemMapper.updateById(existingItem) <= 0) {
|
throw new ServiceException("修改保养项目失败");
|
}
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void deleteItem(Long id) {
|
if (id == null) {
|
throw new ServiceException("保养项目编号不能为空");
|
}
|
|
MaintenanceItem item = maintenanceItemMapper.selectById(id);
|
if (item == null || Integer.valueOf(1).equals(item.getDeleted())) {
|
throw new ServiceException("保养项目不存在");
|
}
|
|
item.setDeleted(1);
|
item.setIsActive(0);
|
if (maintenanceItemMapper.updateById(item) <= 0) {
|
throw new ServiceException("删除保养项目失败");
|
}
|
}
|
|
private LambdaQueryWrapper<MaintenanceItem> buildQueryWrapper(
|
MaintenanceItem query,
|
boolean includeCommon
|
) {
|
MaintenanceItem filter = query == null ? new MaintenanceItem() : query;
|
LambdaQueryWrapper<MaintenanceItem> wrapper = new LambdaQueryWrapper<MaintenanceItem>()
|
.eq(MaintenanceItem::getDeleted, 0);
|
|
if (StringUtils.isNotBlank(filter.getItemName())) {
|
wrapper.like(MaintenanceItem::getItemName, filter.getItemName().trim());
|
}
|
if (StringUtils.isNotBlank(filter.getItemProject())) {
|
wrapper.like(MaintenanceItem::getItemProject, filter.getItemProject().trim());
|
}
|
if (filter.getIsActive() != null) {
|
wrapper.eq(MaintenanceItem::getIsActive, filter.getIsActive());
|
}
|
if (filter.getDeviceLedgerId() != null) {
|
if (includeCommon) {
|
wrapper.and(condition -> condition
|
.eq(MaintenanceItem::getDeviceLedgerId, filter.getDeviceLedgerId())
|
.or()
|
.isNull(MaintenanceItem::getDeviceLedgerId));
|
} else {
|
wrapper.eq(MaintenanceItem::getDeviceLedgerId, filter.getDeviceLedgerId());
|
}
|
}
|
if (StringUtils.isNotBlank(filter.getFrequencyType())) {
|
if (includeCommon) {
|
wrapper.and(condition -> condition
|
.eq(MaintenanceItem::getFrequencyType, filter.getFrequencyType())
|
.or()
|
.eq(MaintenanceItem::getFrequencyType, "ALL"));
|
} else {
|
wrapper.eq(MaintenanceItem::getFrequencyType, filter.getFrequencyType());
|
}
|
}
|
|
return wrapper;
|
}
|
|
private boolean isValid(MaintenanceItem item) {
|
return item != null
|
&& StringUtils.isNotBlank(item.getItemProject())
|
&& StringUtils.isNotBlank(item.getItemName())
|
&& StringUtils.isNotBlank(item.getFrequencyType())
|
&& VALID_FREQUENCIES.contains(item.getFrequencyType());
|
}
|
|
private void normalize(MaintenanceItem item) {
|
item.setItemProject(item.getItemProject().trim());
|
item.setItemName(item.getItemName().trim());
|
item.setSortNum(item.getSortNum() == null ? 0 : item.getSortNum());
|
item.setIsActive(item.getIsActive() == null ? 1 : item.getIsActive());
|
}
|
|
private boolean existsName(MaintenanceItem item, Long excludedId) {
|
LambdaQueryWrapper<MaintenanceItem> wrapper = new LambdaQueryWrapper<MaintenanceItem>()
|
.eq(MaintenanceItem::getDeleted, 0)
|
.eq(MaintenanceItem::getItemName, item.getItemName())
|
.eq(MaintenanceItem::getFrequencyType, item.getFrequencyType());
|
|
if (item.getDeviceLedgerId() == null) {
|
wrapper.isNull(MaintenanceItem::getDeviceLedgerId);
|
} else {
|
wrapper.eq(MaintenanceItem::getDeviceLedgerId, item.getDeviceLedgerId());
|
}
|
if (excludedId != null) {
|
wrapper.ne(MaintenanceItem::getId, excludedId);
|
}
|
|
return maintenanceItemMapper.selectCount(wrapper) > 0;
|
}
|
}
|
