feat: 设备台账上传图片

gongchunyi

12 小时以前 1db111fdf6c65fa1debadf648e4c22bd466744f8

feat: 设备台账上传图片

 src/main/java/com/ruoyi/common/enums/FileNameType.java

@@ -19,7 +19,8 @@
    INSPECTION(12),//巡检 生产前
    EQUIPMENT_WARRANTY(13),   //  设备保修
    EQUIPMENT_REPAIR_PROBLEM(14),   // 设备报修-设备问题图片
    EQUIPMENT_REPAIR_MAINTAIN(15);  // 设备报修-维修完成图片
    EQUIPMENT_REPAIR_MAINTAIN(15),  // 设备报修-维修完成图片
    EQUIPMENT_LEDGER(16);           // 设备台账图片

    private final int value;


 src/main/java/com/ruoyi/device/controller/DeviceLedgerController.java

@@ -11,6 +11,7 @@
import com.ruoyi.device.service.IDeviceLedgerService;
import com.ruoyi.framework.aspectj.lang.annotation.Anonymous;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.sales.pojo.CommonFile;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
@@ -66,7 +67,7 @@
    @DeleteMapping("/{ids}")
    @ApiOperation("删除设备台账")
    public AjaxResult delete(@PathVariable("ids") ArrayList<Long> ids) {
        boolean b = deviceLedgerService.removeBatchByIds(ids);
        boolean b = deviceLedgerService.deleteLedgerAndFiles(ids);
        if (!b) {
            return AjaxResult.error("删除失败");
        }
@@ -109,4 +110,24 @@
        deviceLedger.setCreateTime(deviceLedger.getUpdateTime().plusMonths(1));//下次维护时间
        return AjaxResult.success(deviceLedger);
    }
    @PostMapping("/uploadFile")
    @ApiOperation("设备台账-附件上传")
    public AjaxResult uploadFile(MultipartFile file, Long deviceLedgerId, Integer fileType) {
        deviceLedgerService.uploadFile(file, deviceLedgerId, fileType);
        return AjaxResult.success();
    }

    @GetMapping("/file/{deviceLedgerId}")
    @ApiOperation("设备台账-文件列表")
    public AjaxResult getFiles(@PathVariable("deviceLedgerId") Long deviceLedgerId) {
        java.util.List<CommonFile> list = deviceLedgerService.getFiles(deviceLedgerId);
        return AjaxResult.success(list);
    }

    @DeleteMapping("/file/{fileId}")
    @ApiOperation("设备台账-删除文件")
    public AjaxResult deleteFile(@PathVariable("fileId") Long fileId) {
        deviceLedgerService.deleteFile(fileId);
        return AjaxResult.success();
    }
}

 src/main/java/com/ruoyi/device/service/IDeviceLedgerService.java

@@ -6,10 +6,13 @@
import com.ruoyi.device.dto.DeviceLedgerDto;
import com.ruoyi.device.pojo.DeviceLedger;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.sales.pojo.CommonFile;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Collection;
import java.util.List;

public interface IDeviceLedgerService  extends IService<DeviceLedger> {
    IPage<DeviceLedgerDto> queryPage(Page page, DeviceLedgerDto deviceLedger);
@@ -23,4 +26,12 @@
    void export(HttpServletResponse response, Long[] ids);

    Boolean importData(MultipartFile file) throws IOException;

    void uploadFile(MultipartFile file, Long deviceLedgerId, Integer fileType);

    List<CommonFile> getFiles(Long deviceLedgerId);

    void deleteFile(Long fileId);

    boolean deleteLedgerAndFiles(Collection<Long> ids);
}

 src/main/java/com/ruoyi/device/service/impl/DeviceLedgerServiceImpl.java

@@ -4,6 +4,8 @@
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.enums.FileNameType;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
@@ -12,27 +14,34 @@
import com.ruoyi.device.mapper.DeviceLedgerMapper;
import com.ruoyi.device.pojo.DeviceLedger;
import com.ruoyi.device.service.IDeviceLedgerService;
import com.ruoyi.other.service.TempFileService;
import com.ruoyi.production.mapper.ProductProcessMapper;
import com.ruoyi.production.pojo.ProductProcess;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.project.system.domain.SysUser;
import com.ruoyi.project.system.mapper.SysUserMapper;
import com.ruoyi.sales.mapper.CommonFileMapper;
import com.ruoyi.sales.pojo.CommonFile;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Service
@AllArgsConstructor
@Slf4j
public class DeviceLedgerServiceImpl  extends ServiceImpl<DeviceLedgerMapper, DeviceLedger> implements IDeviceLedgerService {
public class DeviceLedgerServiceImpl extends ServiceImpl<DeviceLedgerMapper, DeviceLedger> implements IDeviceLedgerService {

    @Autowired
    private DeviceLedgerMapper deviceLedgerMapper;
@@ -54,13 +63,13 @@
            return processCheckResult;
        }
        LambdaQueryWrapper<DeviceLedger> deviceLedgerLambdaQueryWrapper = new LambdaQueryWrapper<>();
        deviceLedgerLambdaQueryWrapper.eq(DeviceLedger::getDeviceName,deviceLedger.getDeviceName());
        deviceLedgerLambdaQueryWrapper.eq(DeviceLedger::getDeviceName, deviceLedger.getDeviceName());
        if (this.count(deviceLedgerLambdaQueryWrapper) > 0) {
            return AjaxResult.error("设备名称已存在");
        }
        boolean save = this.save(deviceLedger);
        if (save){
            return AjaxResult.success();
        if (save) {
            return AjaxResult.success("添加成功", deviceLedger.getId());
        }
        return AjaxResult.error();
    }
@@ -102,22 +111,22 @@
            ArrayList<DeviceLedgerExeclDto> deviceLedgerExeclDtos = new ArrayList<>();
            supplierManageList.stream().forEach(deviceLedger -> {
                DeviceLedgerExeclDto deviceLedgerExeclDto = new DeviceLedgerExeclDto();
                BeanUtils.copyProperties(deviceLedger,deviceLedgerExeclDto);
                BeanUtils.copyProperties(deviceLedger, deviceLedgerExeclDto);
                deviceLedgerExeclDto.setCreateUser(sysUserMapper.selectUserById(Long.valueOf(deviceLedger.getCreateUser().toString())).getUserName());
                deviceLedgerExeclDtos.add(deviceLedgerExeclDto);
            });
            ExcelUtil<DeviceLedgerExeclDto> util = new ExcelUtil<DeviceLedgerExeclDto>(DeviceLedgerExeclDto.class);
            util.exportExcel(response, deviceLedgerExeclDtos, "设备台账导出");
        }else  {
        } else {
            ArrayList<Long> arrayList = new ArrayList<>();
            Arrays.stream(ids).map(id -> {
                return arrayList.add( id);
                return arrayList.add(id);
            });
            List<DeviceLedger> supplierManageList = deviceLedgerMapper.selectBatchIds(arrayList);
            ArrayList<DeviceLedgerExeclDto> deviceLedgerExeclDtos = new ArrayList<>();
            supplierManageList.stream().forEach(deviceLedger -> {
                DeviceLedgerExeclDto deviceLedgerExeclDto = new DeviceLedgerExeclDto();
                BeanUtils.copyProperties(deviceLedger,deviceLedgerExeclDto);
                BeanUtils.copyProperties(deviceLedger, deviceLedgerExeclDto);
                deviceLedgerExeclDto.setCreateUser(sysUserMapper.selectUserById(Long.valueOf(deviceLedger.getCreateUser().toString())).getUserName());
                deviceLedgerExeclDtos.add(deviceLedgerExeclDto);
            });
@@ -134,15 +143,87 @@
        userList.forEach(c -> {
            DeviceLedger deviceLedger = new DeviceLedger();
            SysUser sysUser = sysUserMapper.selectUserByUserName(c.getCreateUser());
            if (sysUser!=null) {
            if (sysUser != null) {
                deviceLedger.setCreateUser(sysUser.getUserId().intValue());
            }else {
            } else {
                deviceLedger.setCreateUser(SecurityUtils.getUserId().intValue());
            }
            BeanUtils.copyProperties(c,deviceLedger);
            BeanUtils.copyProperties(c, deviceLedger);
            deviceLedgerMapper.insert(deviceLedger);
        });

        return true;
    }

    @Autowired
    private CommonFileMapper commonFileMapper;

    @Autowired
    private TempFileService tempFileService;

    @Override
    public void uploadFile(MultipartFile file, Long deviceLedgerId, Integer fileType) {
        if (file == null || file.isEmpty()) {
            throw new ServiceException("上传失败,文件不能为空");
        }
        if (deviceLedgerId == null || deviceLedgerId <= 0) {
            throw new ServiceException("上传失败,设备台账ID不能为空");
        }
        int resolvedType = (fileType == null) ? FileNameType.EQUIPMENT_LEDGER.getValue() : fileType;

        try {
            tempFileService.uploadByCommon(file, resolvedType, deviceLedgerId);
        } catch (Exception e) {
            throw new ServiceException("上传失败," + e.getMessage());
        }
    }

    @Override
    public List<CommonFile> getFiles(Long deviceLedgerId) {
        if (deviceLedgerId == null || deviceLedgerId <= 0) {
            return Collections.emptyList();
        }

        return commonFileMapper.selectList(new LambdaQueryWrapper<CommonFile>()
                .eq(CommonFile::getCommonId, deviceLedgerId)
                .eq(CommonFile::getType, FileNameType.EQUIPMENT_LEDGER.getValue())
                .orderByAsc(CommonFile::getId));
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteFile(Long fileId) {
        if (fileId == null || fileId <= 0) {
            throw new ServiceException("删除失败,传入数据异常");
        }
        CommonFile commonFile = commonFileMapper.selectById(fileId);
        if (commonFile == null) {
            throw new ServiceException("删除失败,文件不存在");
        }
        try {
            if (commonFile.getUrl() != null && !commonFile.getUrl().isEmpty()) {
                Files.deleteIfExists(Paths.get(commonFile.getUrl()));
            }
        } catch (Exception e) {
            log.error("设备台账文件删除失败: {}", e.getMessage());
            throw new ServiceException("删除失败," + e.getMessage());
        }
        commonFileMapper.deleteById(fileId);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean deleteLedgerAndFiles(java.util.Collection<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            throw new ServiceException("删除失败,请传入要删除的数据");
        }

        java.util.List<CommonFile> fileList = commonFileMapper.selectList(new LambdaQueryWrapper<CommonFile>()
                .in(CommonFile::getCommonId, ids)
                .eq(CommonFile::getType, FileNameType.EQUIPMENT_LEDGER.getValue()));
        for (CommonFile commonFile : fileList) {
            deleteFile(commonFile.getId());
        }
        return this.removeBatchByIds(ids);
    }
}