住掉无用的仓库管理代码(防类名冲突)、start模块添加tms模块依赖

cuilei

2025-05-06 4a42e8745fe27cf8edf500eaa5b2d65e080c09b0

住掉无用的仓库管理代码(防类名冲突)、start模块添加tms模块依赖

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/base/controller/WarehouseController.java

@@ -1,772 +1,772 @@
package org.jeecg.modules.base.controller;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.jeecg.common.system.query.QueryGenerator;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.system.base.controller.JeecgController;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.base.entity.*;
import org.jeecg.modules.base.service.*;
import org.jeecg.modules.quartz.entity.QuartzJob;
import org.jeecg.modules.quartz.service.IQuartzJobService;
import org.jeecg.common.system.base.entity.DataVersion;
import org.jeecg.modules.system.service.IDataVersionService;
import org.jeecg.modules.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;

import java.text.ParseException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

import org.jeecg.common.util.oConvertUtils;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.aspect.annotation.AutoLog;
import org.apache.shiro.SecurityUtils;
import org.jeecg.common.system.vo.LoginUser;
import org.jeecgframework.poi.excel.ExcelImportUtil;
import org.jeecgframework.poi.excel.def.NormalExcelConstants;
import org.jeecgframework.poi.excel.entity.ExportParams;
import org.jeecgframework.poi.excel.entity.ImportParams;
import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import java.io.IOException;
import java.util.stream.Collectors;

 /**
 * @Description: 仓库
 * @Author: jeecg-boot
 * @Date:   2022-11-07
 * @Version: V1.0
 */
@Api(tags="仓库管理")
@RestController
    @RequestMapping("/base/warehouse")
@Slf4j
public class WarehouseController extends JeecgController<Warehouse, IWarehouseService> {

    @Autowired
    private IWarehouseService warehouseService;

    @Autowired
    private IWarehouseClientService warehouseClientService;

    @Autowired
    private IEnterpriseService enterpriseService;

    @Autowired
    private ISysUserService sysUserService;

    @Autowired
    private IDataVersionService dataVersionService;

    @Autowired
    private IQuartzJobService quartzJobService;

     @Autowired
    private IWarehouseAreaService warehouseAreaService;

     @Autowired
    private IWarehouseLocationService warehouseLocationService;


    /*---------------------------------主表处理-begin-------------------------------------*/
     /**
      * 获取初始信息
      *
      *
      */
     @GetMapping("/getWarehouseInfo")
     public Result<?> getFactoryInfo(){
         Map<String,Object> infoMap = new HashMap<>(2);
         LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//         infoMap.put("enterpriseId",loginUser.getEnterpriseId());
//         infoMap.put("version",warehouseService.getInitVersion());
         return Result.OK(infoMap);
     }
    /**
     * 表单校验
     */
    @GetMapping("/check")
    public Result<?> check(@RequestParam(name="name",required = false) String name,
                           @RequestParam(name="enterpriseId",required = false) String enterpriseId,
                           @RequestParam(name="version",required = false) Integer version
                           ){
        QueryWrapper<Warehouse> queryWrapper = new QueryWrapper<>();
        if(!StringUtils.isBlank(name)){
            queryWrapper.eq("name",name);
        }
        if(!StringUtils.isBlank(enterpriseId)){
            queryWrapper.eq("enterprise_id",enterpriseId);
        }
        if(version!=null){
            queryWrapper.eq("version",version);
        }
        queryWrapper.eq("del_flag","0");
        return Result.OK(warehouseService.list(queryWrapper));
    }
    /**
     * 分页列表查询
     * @param map
     * @param pageNo
     * @param pageSize
     * @param version
     * @param enterpriseId
     * @return
     */
    //@AutoLog(value = "仓库-分页列表查询")
    @ApiOperation(value="仓库-分页列表查询", notes="仓库-分页列表查询")
    @GetMapping("/list")
    public Result<?> list(Map map,
                          @RequestParam(name ="pageNo", defaultValue="1") Integer pageNo,
                          @RequestParam(name ="pageSize", defaultValue="10") Integer pageSize,
                          @RequestParam(name = "enterpriseId",required = false) String enterpriseId,
                          @RequestParam(name="version",required = false) Integer version){
        Page<Map<String,Object>> page = new Page(pageNo, pageSize);
        IPage<Map<String,Object>> pageList = warehouseService.getWarehouseList(page,version,enterpriseId);
        return Result.OK(pageList);
    }
     /**
      * 获取当前生效版本和上一次生效版本的版本号
      *
      * @return
      */
     @GetMapping("/getNowAndLastUsableVersion")
     public Result<?> getNowAndLastUsableVersion(){
         return Result.OK(warehouseService.getNowAndLastUsableVersion());
     }
     /**
      * 获取所有版本号
      *
      *
      */
     @GetMapping("/getVersionList")
     public Result<?> getAllVersion(){
         return Result.OK(warehouseService.getVersionList());
     }
     /**
      * 根据版本获取版本号
      * @param version
      * @return
      *
      */
     @GetMapping("/getVersionStatusByVersion")
     public Result<?> getVersionStatusByVersion(@RequestParam(value = "version",required = false) Integer version){
         return Result.OK(warehouseService.getVersionStatusByVersion(version));
     }
     /**
      *
      * 查该版本是否为历史版本
      *
      */
     @GetMapping(value = "/getUpdateVersionPermission")
     public Result<?> getUpdatePermission(@RequestParam("version") Integer version){
         List<String> usableEnterpriseIds = enterpriseService.getUsableIdList();
         return Result.OK(warehouseService.list(new QueryWrapper<Warehouse>()
                 .in("enterprise_id",usableEnterpriseIds)
                 .eq("version",version)
                 .eq("del_flag",0)));
     }
     /**
      *
      * 查当前生效企业下有无仓库历史版本
      *
      */
     @GetMapping(value = "/getNewVersionPermission")
     public Result<?> getNewVersionPermission(){
         List<String> usableEnterpriseIds = enterpriseService.getUsableIdList();
         return Result.OK(warehouseService.list(new QueryWrapper<Warehouse>().in("enterprise_id",usableEnterpriseIds).eq("del_flag",0)));
     }
     /**
      * 维护升版
      * 需要一次完成
      * @param
      * @return
      */
     @PostMapping("/updateVersionForChange")
     @Transactional
     public  Result<?> updateVersionForChange(){
         Set<Integer> set =  warehouseService.getVersionList();
         return Result.OK(set.stream().findFirst().get()+1);
     }
    /**
     *   添加
     * @param map
     * @return
     */
    @AutoLog(value = "仓库-添加")
    @ApiOperation(value="仓库-添加", notes="仓库-添加")
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:add")
    @PostMapping(value = "/add")
    public Result<String> add(@RequestBody Map<String,Object> map) {
        Warehouse warehouse = new Warehouse();
        warehouse.setCode(String.valueOf(map.get("code")))
                .setName(String.valueOf(map.get("name")))
                .setVersion(Integer.parseInt(String.valueOf(map.get("version"))))
                .setEnterpriseId(String.valueOf(map.get("enterpriseId")))
                .setRemark(String.valueOf(map.get("remark")))
                .setStatus(String.valueOf(map.get("status")))
                .setDelFlag(0);
        warehouseService.save(warehouse);
        QueryWrapper<Warehouse> queryWrapper = new QueryWrapper<Warehouse>()
                .eq("code",warehouse.getCode())
                .eq("version",warehouse.getVersion())
                .eq("del_flag",0);
        Warehouse selectWarehouse = warehouseService.getOne(queryWrapper,true);
        DataVersion dataVersion = new DataVersion();
        dataVersion.setBusinessId(selectWarehouse.getId())
                .setBusinessType("仓库管理")
                .setVersion(selectWarehouse.getVersion())
                .setVersionStatus(String.valueOf(map.get("versionStatus")))
                .setDelFlag(0)
                .setEffectiveType("0")
                .setIsLastUsable("0");
        dataVersionService.save(dataVersion);
        QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>()
                .eq("business_id",selectWarehouse.getId()).eq("del_flag",0);
        DataVersion selectDataVersion = dataVersionService.getOne(queryWrapper1,true);
        selectWarehouse.setDataVersionId(selectDataVersion.getId());
        warehouseService.saveOrUpdate(selectWarehouse);
        return Result.OK("添加成功！");
    }
     /**
      * 升版
      * 需要一次完成
      * @param map
      * @param
      * @return
      */
     @PostMapping("/updateVersion")
     @Transactional
     public  Result<?> updateVersion(@RequestBody Map<String,Object> map){
         Integer version = Integer.parseInt((String)map.get("version"));
         //获取升版数据
         List<Warehouse> list = warehouseService.list(new QueryWrapper<Warehouse>()
                 .eq("version",version)
                 .eq("del_flag",0));
         //获取升版数据的版本信息
         QueryWrapper<DataVersion> queryWrapper = new QueryWrapper<DataVersion>()
                 .in("business_id", list.stream().map(Warehouse::getId).collect(Collectors.toList()))
                 .eq("del_flag",0);
         List<DataVersion> dataVersionList = dataVersionService.list(queryWrapper);
         Set<Integer> set =  warehouseService.getVersionList();
         Optional<Integer> maxVersion = set.stream().findFirst();
         list.stream().forEach(warehouse -> {
             warehouse.setId("");
             warehouse.setVersion(maxVersion.get()+1);
         });
         warehouseService.saveBatch(list);
         List<Warehouse> newList = warehouseService
                 .list(new QueryWrapper<Warehouse>()
                         .eq("version",maxVersion.get()+1));
         List<DataVersion> newDataVersionList = new ArrayList<>();
         for(int i=0;i<newList.size();i++){
             DataVersion dataVersion = new DataVersion();
             for(int j=0;j<list.size();j++){
                 for(int k=0;k<dataVersionList.size();k++){
                     if(list.get(j).getCode().equals(newList.get(i).getCode())
                             &&list.get(j).getDataVersionId().equals(dataVersionList.get(k).getId())) {
                         dataVersion
                                 .setVersion(maxVersion.get() + 1)
                                 .setVersionStatus("1")
                                 .setBusinessId(newList.get(i).getId())
                                 .setDelFlag(0)
                                 .setSourceVersionId(dataVersionList.get(k).getId())
                                 .setBusinessType("仓库管理")
                                 .setIsLastUsable("0");
                     }
                 }
             }
             newDataVersionList.add(dataVersion);
         }
         dataVersionService.saveBatch(newDataVersionList);
         List<String> dataVersionBusinessIdList = newDataVersionList.stream().map(DataVersion::getBusinessId).collect(Collectors.toList());
         QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>().in("business_id",dataVersionBusinessIdList).eq("del_flag",0);
         List<DataVersion> selectDataVersionList = dataVersionService.list(queryWrapper1);
         for(int i=0;i<newList.size();i++){
             for(int j=0;j<selectDataVersionList.size();j++){
                 if(newList.get(i).getId().equals(selectDataVersionList.get(j).getBusinessId())){
                     newList.get(i).setDataVersionId(selectDataVersionList.get(j).getId());
                 }
             }
         }
         warehouseService.updateBatchById(newList);
         return Result.OK(maxVersion.get()+1);
     }
     /**
      * 生效
      * 需要一次性完成
      * @param
      * @param map
      * @return
      */
     @PostMapping("/updateVersionStatusToUsable")
     @Transactional
     public Result<?> updateVersionStatusToUsable(@RequestBody Map<String,Object> map){
         Date date = new Date(System.currentTimeMillis());
         QuartzJob quartzJob = quartzJobService.getOne(new QueryWrapper<QuartzJob>()
                 .eq("job_class_name","org.jeecg.modules.quartz.job.WarehouseSetUsableJob"),true);
         if(ObjectUtils.isNotNull(quartzJob)){
             quartzJobService.deleteAndStopJob(quartzJob);
         }
         Integer version = Integer.parseInt((String)map.get("version"));
         //获取上次生效版本并将其是否上次生效位置置为否
         List<Warehouse> lastUsableList = warehouseService.getLastUsableList();
         if(CollectionUtils.isNotEmpty(lastUsableList)){
             QueryWrapper<DataVersion> queryWrapper2 = new QueryWrapper<DataVersion>()
                     .in("business_id",lastUsableList.stream()
                             .map(Warehouse::getId)
                             .collect(Collectors.toList()));
             List<DataVersion> lastUsableVersionList = dataVersionService.list(queryWrapper2);
             lastUsableVersionList.stream().forEach(dataVersion -> {
                 dataVersion
                         .setIsLastUsable("0");
             });
             dataVersionService.updateBatchById(lastUsableVersionList);
         }
         //获取生效版本及版本信息并将其置为失效
         List<Warehouse> usableList = warehouseService.getUsableList();
         if(CollectionUtils.isNotEmpty(usableList)){
             QueryWrapper<DataVersion> queryWrapper = new QueryWrapper<DataVersion>()
                     .in("business_id",usableList.stream()
                             .map(Warehouse::getId)
                             .collect(Collectors.toList()));
             List<DataVersion> usableDataVersionList = dataVersionService.list(queryWrapper);
             usableDataVersionList.stream().forEach(dataVersion -> {
                 dataVersion
                         .setVersionStatus("3")
                         .setIsLastUsable("1")
                         .setExpiredTime(date);
             });
             dataVersionService.updateBatchById(usableDataVersionList);
         }
         //获取待生效版本及版本信息并将其置为生效
         QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>()
                 .in("business_id",warehouseService.list(new QueryWrapper<Warehouse>()
                         .eq("version",version)
                         .eq("del_flag",0))
                         .stream().map(Warehouse::getId)
                         .collect(Collectors.toList()));
         List<DataVersion> dataVersionList = dataVersionService.list(queryWrapper1);
         dataVersionList.stream().forEach(dataVersion -> {
             dataVersion.setVersionStatus("2")
                     .setEffectiveType("2")
                     .setEffectiveTime(date)
                     .setIsLastUsable("0");
         });
         //存入数据库
         dataVersionService.updateBatchById(dataVersionList);
         return  Result.OK("生效成功");
     }
     /**
      * 定时生效
      * 需要一次性完成
      * @param quartzJob
      * @param
      * @return
      */
     @PostMapping("/updateVersionStatusToUsableBySetTime")
     @Transactional
     public Result<?> updateVersionStatusToUsableBySetTime(@RequestBody QuartzJob quartzJob) throws ParseException {
         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
         DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("ss mm HH dd MM ? yyyy");
         String jobClassName = quartzJob.getJobClassName();
         String time = quartzJob.getCronExpression();
         System.out.println(time);
         LocalDateTime localDateTime = LocalDateTime.parse(time,dateTimeFormatter);
         String cronStr=dateTimeFormatter1.format(localDateTime);
         quartzJob.setCronExpression(cronStr);
         QueryWrapper<QuartzJob> queryWrapper = new QueryWrapper();
         queryWrapper.eq("JOB_CLASS_NAME",jobClassName);
         List<QuartzJob> quartzJobs = quartzJobService.list(queryWrapper);
         if(CollectionUtils.isEmpty(quartzJobs)){
             quartzJobService.saveAndScheduleJob(quartzJob);
             quartzJobs = quartzJobService.list(queryWrapper);
             quartzJob.setId(quartzJobs.get(0).getId());
             quartzJobService.resumeJob(quartzJob);
             return  Result.OK(quartzJob);
         }else{
             quartzJob.setId(quartzJobs.get(0).getId());
             quartzJobService.resumeJob(quartzJob);
             return Result.OK(quartzJob);
         }

     }

    /**
     *  编辑
     * @param warehouse
     * @return
     */
    @AutoLog(value = "仓库-编辑")
    @ApiOperation(value="仓库-编辑", notes="仓库-编辑")
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:edit")
    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> edit(@RequestBody Warehouse warehouse) {
        warehouseService.updateById(warehouse);
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     * @param id
     * @return
     */
    @AutoLog(value = "仓库-通过id删除")
    @ApiOperation(value="仓库-通过id删除", notes="仓库-通过id删除")
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:delete")
    @DeleteMapping(value = "/delete")
    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
        dataVersionService.update(new UpdateWrapper<DataVersion>()
                .set("del_flag",1)
                .eq("business_id",id));
        UpdateWrapper updateWrapper = new UpdateWrapper();
        updateWrapper.set("del_flag","1");
        updateWrapper.eq("id",id);
        warehouseService.update(updateWrapper);
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     * @param ids
     * @return
     */
    @AutoLog(value = "仓库-批量删除")
    @ApiOperation(value="仓库-批量删除", notes="仓库-批量删除")
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:deleteBatch")
    @DeleteMapping(value = "/deleteBatch")
    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
        dataVersionService.update(new UpdateWrapper<DataVersion>()
                .set("del_flag",1)
                .in("business_id",Arrays.asList(ids.split(","))));
        warehouseService
                .update(new UpdateWrapper<Warehouse>()
                        .in("id",Arrays.asList(ids.split(","))).set("del_flag",1));
        return Result.OK("批量删除成功!");
    }

    /**
     * 导出
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:exportXls")
    @RequestMapping(value = "/exportXls")
    public ModelAndView exportXls(HttpServletRequest request, Warehouse warehouse) {
        return super.exportXls(request, warehouse, Warehouse.class, "仓库");
    }

    /**
     * 导入
     * @return
     */
    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:importExcel")
    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
        return super.importExcel(request, response, Warehouse.class);
    }
    /*---------------------------------主表处理-end-------------------------------------*/


    /*--------------------------------子表处理-仓库服务对象-begin----------------------------------------------*/
     /**
      * 通过主表ID查询
      * @return
      */
     @GetMapping("/checkWarehouseClient")
     public Result<?> checkClient(
                                  @RequestParam(name="clientId",required = false) String clientId,
                                  @RequestParam(name="warehouseId") String warehouseId){
         QueryWrapper<WarehouseClient> queryWrapper = new QueryWrapper<>();
         if(!StringUtils.isBlank(clientId)){
             queryWrapper.eq("client_id",clientId);
         }
         if(!StringUtils.isBlank(warehouseId)){
             queryWrapper.eq("warehouse_id",warehouseId);
         }
         queryWrapper.eq("del_flag","0");
         return Result.OK(warehouseClientService.list(queryWrapper));
     }
     /**
     * 通过主表ID查询
     * @return
     */
    //@AutoLog(value = "仓库服务对象-通过主表ID查询")
    @ApiOperation(value="仓库服务对象-通过主表ID查询", notes="仓库服务对象-通过主表ID查询")
    @GetMapping(value = "/listWarehouseClientByMainId")
    public Result<IPage<WarehouseClient>> listWarehouseClientByMainId(WarehouseClient warehouseClient,
                                                    @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
                                                    @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
                                                    HttpServletRequest req) {
        QueryWrapper<WarehouseClient> queryWrapper = QueryGenerator.initQueryWrapper(warehouseClient, req.getParameterMap());
        queryWrapper.eq("del_flag",0);
        Page<WarehouseClient> page = new Page<WarehouseClient>(pageNo, pageSize);
        IPage<WarehouseClient> pageList = warehouseClientService.page(page, queryWrapper);
        return Result.OK(pageList);
    }

    /**
     * 添加
     * @param map
     * @return
     */
    @AutoLog(value = "仓库服务对象-添加")
    @ApiOperation(value="仓库服务对象-添加", notes="仓库服务对象-添加")
    @PostMapping(value = "/addWarehouseClient")
    public Result<String> addWarehouseClient(@RequestBody Map<String,Object> map) {
        List<Map<String,Object>> addDepartIds = (List<Map<String, Object>>) map.get("addDepartIds");
        List<Map<String,Object>> addFactoryIds = (List<Map<String, Object>>) map.get("addFactoryIds");
        String warehouseId = (String) map.get("warehouseId");
        if(CollectionUtils.isNotEmpty(addDepartIds)){
            List<WarehouseClient> warehouseClients=new ArrayList<>();
            addDepartIds.forEach(departMap->{
                WarehouseClient warehouseClient = new WarehouseClient();
                warehouseClient.setClientId((String) departMap.get("id"))
                        .setWarehouseId(warehouseId)
                        .setCode((String) departMap.get("orgCode"))
                        .setName((String) departMap.get("departName"))
                        .setElementType("组织部门")
                        .setDelFlag(0);
                warehouseClients.add(warehouseClient);
            });
            warehouseClientService.saveBatch(warehouseClients);
        }

        if(CollectionUtils.isNotEmpty(addFactoryIds)){
            List<WarehouseClient> warehouseClients=new ArrayList<>();
            addFactoryIds.forEach(factoryMap->{
                WarehouseClient warehouseClient = new WarehouseClient();
                warehouseClient.setClientId((String) factoryMap.get("id"))
                        .setWarehouseId(warehouseId)
                        .setCode((String) factoryMap.get("code"))
                        .setName((String) factoryMap.get("name"))
                        .setElementType("工厂")
                        .setDelFlag(0);
                warehouseClients.add(warehouseClient);
            });
            warehouseClientService.saveBatch(warehouseClients);
        }
        return Result.OK("添加成功！");
    }

    /**
     * 编辑
     * @param map
     * @return
     */
    @AutoLog(value = "仓库服务对象-编辑")
    @ApiOperation(value="仓库服务对象-编辑", notes="仓库服务对象-编辑")
    @RequestMapping(value = "/editWarehouseClient", method = {RequestMethod.PUT,RequestMethod.POST})
    public Result<String> editWarehouseClient(@RequestBody Map<String,Object> map) {
        List<Map<String,Object>> addDepartIds = (List<Map<String, Object>>) map.get("addDepartIds");
        List<Map<String,Object>> addFactoryIds = (List<Map<String, Object>>) map.get("addFactoryIds");
        String id = (String) map.get("id");
        if(CollectionUtils.isNotEmpty(addDepartIds)){
            UpdateWrapper<WarehouseClient> updateWrapper = new UpdateWrapper<WarehouseClient>()
                    .eq("id",id)
                    .set("code",(String)addDepartIds.get(0).get("orgCode"))
                    .set("name",(String) addDepartIds.get(0).get("departName"));
            warehouseClientService.update(updateWrapper);
        }

        if(CollectionUtils.isNotEmpty(addFactoryIds)){
            UpdateWrapper<WarehouseClient> updateWrapper = new UpdateWrapper<WarehouseClient>()
                    .eq("id",id)
                    .set("code",(String)addFactoryIds.get(0).get("code"))
                    .set("name",(String)addFactoryIds.get(0).get("name"));
            warehouseClientService.update(updateWrapper);
        }
        return Result.OK("编辑成功!");
    }

    /**
     * 通过id删除
     * @param id
     * @return
     */
    @AutoLog(value = "仓库服务对象-通过id删除")
    @ApiOperation(value="仓库服务对象-通过id删除", notes="仓库服务对象-通过id删除")
    @DeleteMapping(value = "/deleteWarehouseClient")
    public Result<String> deleteWarehouseClient(@RequestParam(name="id",required=true) String id) {
        warehouseClientService.update( new UpdateWrapper<WarehouseClient>()
                .set("del_flag",1)
                .eq("id",id));
        return Result.OK("删除成功!");
    }

    /**
     * 批量删除
     * @param ids
     * @return
     */
    @AutoLog(value = "仓库服务对象-批量删除")
    @ApiOperation(value="仓库服务对象-批量删除", notes="仓库服务对象-批量删除")
    @DeleteMapping(value = "/deleteBatchWarehouseClient")
    public Result<String> deleteBatchWarehouseClient(@RequestParam(name="ids",required=true) String ids) {
        warehouseClientService.update(new UpdateWrapper<WarehouseClient>()
                .in("id",Arrays.asList(ids.split(",")))
                .set("del_flag",1));
        return Result.OK("删除成功");
    }

    /**
     * 导出
     * @return
     */
    @RequestMapping(value = "/exportWarehouseClient")
    public ModelAndView exportWarehouseClient(HttpServletRequest request, WarehouseClient warehouseClient) {
         // Step.1 组装查询条件
         QueryWrapper<WarehouseClient> queryWrapper = QueryGenerator.initQueryWrapper(warehouseClient, request.getParameterMap());
         LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();

         // Step.2 获取导出数据
         List<WarehouseClient> pageList = warehouseClientService.list(queryWrapper);
         List<WarehouseClient> exportList = null;

         // 过滤选中数据
         String selections = request.getParameter("selections");
         if (oConvertUtils.isNotEmpty(selections)) {
             List<String> selectionList = Arrays.asList(selections.split(","));
             exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
         } else {
             exportList = pageList;
         }

         // Step.3 AutoPoi 导出Excel
         ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
         //此处设置的filename无效,前端会重更新设置一下
         mv.addObject(NormalExcelConstants.FILE_NAME, "仓库服务对象");
         mv.addObject(NormalExcelConstants.CLASS, WarehouseClient.class);
         mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("仓库服务对象报表", "导出人:" + sysUser.getRealname(), "仓库服务对象"));
         mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
         return mv;
    }

    /**
     * 导入
     * @return
     */
    @RequestMapping(value = "/importWarehouseClient/{mainId}")
    public Result<?> importWarehouseClient(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
         MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
         Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
         for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
       // 获取上传文件对象
             MultipartFile file = entity.getValue();
             ImportParams params = new ImportParams();
             params.setTitleRows(2);
             params.setHeadRows(1);
             params.setNeedSave(true);
             try {
                 List<WarehouseClient> list = ExcelImportUtil.importExcel(file.getInputStream(), WarehouseClient.class, params);
                 for (WarehouseClient temp : list) {
                    temp.setWarehouseId(mainId);
                 }
                 long start = System.currentTimeMillis();
                 warehouseClientService.saveBatch(list);
                 log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
                 return Result.OK("文件导入成功！数据行数：" + list.size());
             } catch (Exception e) {
                 log.error(e.getMessage(), e);
                 return Result.error("文件导入失败:" + e.getMessage());
             } finally {
                 try {
                     file.getInputStream().close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
         return Result.error("文件导入失败！");
    }
    @GetMapping("/enterpriseList")
    public Result<?> getEnterpriseList(){
        return Result.OK(enterpriseService.getEnterpriseListByPid(new Page<>(),1,"0"));
    }

    /*--------------------------------子表处理-仓库服务对象-end----------------------------------------------*/



     /**
      *   仓库管理  新增
      *   qsw
      */
     @PostMapping(value = "/addWarehouse")
     public Result<String> addWarehouse(@RequestBody Warehouse warehouse) {
         warehouseService.save(warehouse);
         return Result.OK("添加成功！");
     }


     /**
      * 分页列表查询
      * qsw
      */
     @GetMapping(value = "/find")
     public Result<IPage<Warehouse>> queryPageList(Warehouse warehouse,
                                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
                                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
                                                   HttpServletRequest req) {
         QueryWrapper<Warehouse> queryWrapper = QueryGenerator.initQueryWrapper(warehouse, req.getParameterMap());
         Page<Warehouse> page = new Page<Warehouse>(pageNo, pageSize);
         IPage<Warehouse> pageList = warehouseService.page(page, queryWrapper);
         return Result.OK(pageList);
     }

     /**
      * 通过id删除
      * @param id
      * @return
      * qsw
      */
     @AutoLog(value = "仓库-通过id删除")
     @ApiOperation(value="仓库-通过id删除", notes="仓库-通过id删除")
     //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:delete")
     @DeleteMapping(value = "/deleteWarehouseAreaLocation")
     public Result<String> deleteWarehouseAreaLocation(@RequestParam(name="id",required=true) String id) {

         List<WarehouseLocation> warehouseLocations = warehouseLocationService.lambdaQuery()
                 .eq(WarehouseLocation::getWarehouseId, id).eq(WarehouseLocation::getDelFlag, 0)
                 .list();
         for (WarehouseLocation warehouseLocation : warehouseLocations) {
             warehouseLocationService.removeById(warehouseLocation);
         }

         List<WarehouseArea> warehouseAreas = warehouseAreaService.lambdaQuery()
                 .eq(WarehouseArea::getWarehouseId, id)
                 .eq(WarehouseArea::getDelFlag, 0).list();
         for (WarehouseArea warehouseArea : warehouseAreas) {
             warehouseAreaService.removeById(warehouseArea);
         }
         warehouseService.removeById(id);
         return Result.OK("删除成功!");
     }

     /**
      * 通过id查询
      *qsw
      */
     @GetMapping(value = "/queryById")
     public Result<Warehouse> queryById(@RequestParam(name="id",required=true) String id) {
         Warehouse warehouse = warehouseService.getById(id);
         if(warehouse ==null) {
             return Result.error("未找到对应数据");
         }
         return Result.OK(warehouse);
     }

}
//package org.jeecg.modules.base.controller;
//
//import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
//import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
//import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
//import com.baomidou.mybatisplus.core.toolkit.StringUtils;
//import org.jeecg.common.system.query.QueryGenerator;
//import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
//import com.baomidou.mybatisplus.core.metadata.IPage;
//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
//import lombok.extern.slf4j.Slf4j;
//import org.jeecg.common.system.base.controller.JeecgController;
//import org.jeecg.common.api.vo.Result;
//import org.jeecg.modules.base.entity.*;
//import org.jeecg.modules.base.service.*;
//import org.jeecg.modules.quartz.entity.QuartzJob;
//import org.jeecg.modules.quartz.service.IQuartzJobService;
//import org.jeecg.common.system.base.entity.DataVersion;
//import org.jeecg.modules.system.service.IDataVersionService;
//import org.jeecg.modules.system.service.ISysUserService;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.transaction.annotation.Transactional;
//import org.springframework.web.bind.annotation.*;
//import javax.servlet.http.HttpServletRequest;
//import javax.servlet.http.HttpServletResponse;
//import org.springframework.web.servlet.ModelAndView;
//
//import java.text.ParseException;
//import java.time.LocalDateTime;
//import java.time.format.DateTimeFormatter;
//import java.util.*;
//
//import org.jeecg.common.util.oConvertUtils;
//import io.swagger.annotations.Api;
//import io.swagger.annotations.ApiOperation;
//import org.jeecg.common.aspect.annotation.AutoLog;
//import org.apache.shiro.SecurityUtils;
//import org.jeecg.common.system.vo.LoginUser;
//import org.jeecgframework.poi.excel.ExcelImportUtil;
//import org.jeecgframework.poi.excel.def.NormalExcelConstants;
//import org.jeecgframework.poi.excel.entity.ExportParams;
//import org.jeecgframework.poi.excel.entity.ImportParams;
//import org.jeecgframework.poi.excel.view.JeecgEntityExcelView;
//import org.springframework.web.multipart.MultipartFile;
//import org.springframework.web.multipart.MultipartHttpServletRequest;
//import java.io.IOException;
//import java.util.stream.Collectors;
//
// /**
// * @Description: 仓库
// * @Author: jeecg-boot
// * @Date:   2022-11-07
// * @Version: V1.0
// */
//@Api(tags="仓库管理")
//@RestController
//    @RequestMapping("/base/warehouse")
//@Slf4j
//public class WarehouseController extends JeecgController<Warehouse, IWarehouseService> {
//
//    @Autowired
//    private IWarehouseService warehouseService;
//
//    @Autowired
//    private IWarehouseClientService warehouseClientService;
//
//    @Autowired
//    private IEnterpriseService enterpriseService;
//
//    @Autowired
//    private ISysUserService sysUserService;
//
//    @Autowired
//    private IDataVersionService dataVersionService;
//
//    @Autowired
//    private IQuartzJobService quartzJobService;
//
//     @Autowired
//    private IWarehouseAreaService warehouseAreaService;
//
//     @Autowired
//    private IWarehouseLocationService warehouseLocationService;
//
//
//    /*---------------------------------主表处理-begin-------------------------------------*/
//     /**
//      * 获取初始信息
//      *
//      *
//      */
//     @GetMapping("/getWarehouseInfo")
//     public Result<?> getFactoryInfo(){
//         Map<String,Object> infoMap = new HashMap<>(2);
//         LoginUser loginUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
////         infoMap.put("enterpriseId",loginUser.getEnterpriseId());
////         infoMap.put("version",warehouseService.getInitVersion());
//         return Result.OK(infoMap);
//     }
//    /**
//     * 表单校验
//     */
//    @GetMapping("/check")
//    public Result<?> check(@RequestParam(name="name",required = false) String name,
//                           @RequestParam(name="enterpriseId",required = false) String enterpriseId,
//                           @RequestParam(name="version",required = false) Integer version
//                           ){
//        QueryWrapper<Warehouse> queryWrapper = new QueryWrapper<>();
//        if(!StringUtils.isBlank(name)){
//            queryWrapper.eq("name",name);
//        }
//        if(!StringUtils.isBlank(enterpriseId)){
//            queryWrapper.eq("enterprise_id",enterpriseId);
//        }
//        if(version!=null){
//            queryWrapper.eq("version",version);
//        }
//        queryWrapper.eq("del_flag","0");
//        return Result.OK(warehouseService.list(queryWrapper));
//    }
//    /**
//     * 分页列表查询
//     * @param map
//     * @param pageNo
//     * @param pageSize
//     * @param version
//     * @param enterpriseId
//     * @return
//     */
//    //@AutoLog(value = "仓库-分页列表查询")
//    @ApiOperation(value="仓库-分页列表查询", notes="仓库-分页列表查询")
//    @GetMapping("/list")
//    public Result<?> list(Map map,
//                          @RequestParam(name ="pageNo", defaultValue="1") Integer pageNo,
//                          @RequestParam(name ="pageSize", defaultValue="10") Integer pageSize,
//                          @RequestParam(name = "enterpriseId",required = false) String enterpriseId,
//                          @RequestParam(name="version",required = false) Integer version){
//        Page<Map<String,Object>> page = new Page(pageNo, pageSize);
//        IPage<Map<String,Object>> pageList = warehouseService.getWarehouseList(page,version,enterpriseId);
//        return Result.OK(pageList);
//    }
//     /**
//      * 获取当前生效版本和上一次生效版本的版本号
//      *
//      * @return
//      */
//     @GetMapping("/getNowAndLastUsableVersion")
//     public Result<?> getNowAndLastUsableVersion(){
//         return Result.OK(warehouseService.getNowAndLastUsableVersion());
//     }
//     /**
//      * 获取所有版本号
//      *
//      *
//      */
//     @GetMapping("/getVersionList")
//     public Result<?> getAllVersion(){
//         return Result.OK(warehouseService.getVersionList());
//     }
//     /**
//      * 根据版本获取版本号
//      * @param version
//      * @return
//      *
//      */
//     @GetMapping("/getVersionStatusByVersion")
//     public Result<?> getVersionStatusByVersion(@RequestParam(value = "version",required = false) Integer version){
//         return Result.OK(warehouseService.getVersionStatusByVersion(version));
//     }
//     /**
//      *
//      * 查该版本是否为历史版本
//      *
//      */
//     @GetMapping(value = "/getUpdateVersionPermission")
//     public Result<?> getUpdatePermission(@RequestParam("version") Integer version){
//         List<String> usableEnterpriseIds = enterpriseService.getUsableIdList();
//         return Result.OK(warehouseService.list(new QueryWrapper<Warehouse>()
//                 .in("enterprise_id",usableEnterpriseIds)
//                 .eq("version",version)
//                 .eq("del_flag",0)));
//     }
//     /**
//      *
//      * 查当前生效企业下有无仓库历史版本
//      *
//      */
//     @GetMapping(value = "/getNewVersionPermission")
//     public Result<?> getNewVersionPermission(){
//         List<String> usableEnterpriseIds = enterpriseService.getUsableIdList();
//         return Result.OK(warehouseService.list(new QueryWrapper<Warehouse>().in("enterprise_id",usableEnterpriseIds).eq("del_flag",0)));
//     }
//     /**
//      * 维护升版
//      * 需要一次完成
//      * @param
//      * @return
//      */
//     @PostMapping("/updateVersionForChange")
//     @Transactional
//     public  Result<?> updateVersionForChange(){
//         Set<Integer> set =  warehouseService.getVersionList();
//         return Result.OK(set.stream().findFirst().get()+1);
//     }
//    /**
//     *   添加
//     * @param map
//     * @return
//     */
//    @AutoLog(value = "仓库-添加")
//    @ApiOperation(value="仓库-添加", notes="仓库-添加")
//    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:add")
//    @PostMapping(value = "/add")
//    public Result<String> add(@RequestBody Map<String,Object> map) {
//        Warehouse warehouse = new Warehouse();
//        warehouse.setCode(String.valueOf(map.get("code")))
//                .setName(String.valueOf(map.get("name")))
//                .setVersion(Integer.parseInt(String.valueOf(map.get("version"))))
//                .setEnterpriseId(String.valueOf(map.get("enterpriseId")))
//                .setRemark(String.valueOf(map.get("remark")))
//                .setStatus(String.valueOf(map.get("status")))
//                .setDelFlag(0);
//        warehouseService.save(warehouse);
//        QueryWrapper<Warehouse> queryWrapper = new QueryWrapper<Warehouse>()
//                .eq("code",warehouse.getCode())
//                .eq("version",warehouse.getVersion())
//                .eq("del_flag",0);
//        Warehouse selectWarehouse = warehouseService.getOne(queryWrapper,true);
//        DataVersion dataVersion = new DataVersion();
//        dataVersion.setBusinessId(selectWarehouse.getId())
//                .setBusinessType("仓库管理")
//                .setVersion(selectWarehouse.getVersion())
//                .setVersionStatus(String.valueOf(map.get("versionStatus")))
//                .setDelFlag(0)
//                .setEffectiveType("0")
//                .setIsLastUsable("0");
//        dataVersionService.save(dataVersion);
//        QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>()
//                .eq("business_id",selectWarehouse.getId()).eq("del_flag",0);
//        DataVersion selectDataVersion = dataVersionService.getOne(queryWrapper1,true);
//        selectWarehouse.setDataVersionId(selectDataVersion.getId());
//        warehouseService.saveOrUpdate(selectWarehouse);
//        return Result.OK("添加成功！");
//    }
//     /**
//      * 升版
//      * 需要一次完成
//      * @param map
//      * @param
//      * @return
//      */
//     @PostMapping("/updateVersion")
//     @Transactional
//     public  Result<?> updateVersion(@RequestBody Map<String,Object> map){
//         Integer version = Integer.parseInt((String)map.get("version"));
//         //获取升版数据
//         List<Warehouse> list = warehouseService.list(new QueryWrapper<Warehouse>()
//                 .eq("version",version)
//                 .eq("del_flag",0));
//         //获取升版数据的版本信息
//         QueryWrapper<DataVersion> queryWrapper = new QueryWrapper<DataVersion>()
//                 .in("business_id", list.stream().map(Warehouse::getId).collect(Collectors.toList()))
//                 .eq("del_flag",0);
//         List<DataVersion> dataVersionList = dataVersionService.list(queryWrapper);
//         Set<Integer> set =  warehouseService.getVersionList();
//         Optional<Integer> maxVersion = set.stream().findFirst();
//         list.stream().forEach(warehouse -> {
//             warehouse.setId("");
//             warehouse.setVersion(maxVersion.get()+1);
//         });
//         warehouseService.saveBatch(list);
//         List<Warehouse> newList = warehouseService
//                 .list(new QueryWrapper<Warehouse>()
//                         .eq("version",maxVersion.get()+1));
//         List<DataVersion> newDataVersionList = new ArrayList<>();
//         for(int i=0;i<newList.size();i++){
//             DataVersion dataVersion = new DataVersion();
//             for(int j=0;j<list.size();j++){
//                 for(int k=0;k<dataVersionList.size();k++){
//                     if(list.get(j).getCode().equals(newList.get(i).getCode())
//                             &&list.get(j).getDataVersionId().equals(dataVersionList.get(k).getId())) {
//                         dataVersion
//                                 .setVersion(maxVersion.get() + 1)
//                                 .setVersionStatus("1")
//                                 .setBusinessId(newList.get(i).getId())
//                                 .setDelFlag(0)
//                                 .setSourceVersionId(dataVersionList.get(k).getId())
//                                 .setBusinessType("仓库管理")
//                                 .setIsLastUsable("0");
//                     }
//                 }
//             }
//             newDataVersionList.add(dataVersion);
//         }
//         dataVersionService.saveBatch(newDataVersionList);
//         List<String> dataVersionBusinessIdList = newDataVersionList.stream().map(DataVersion::getBusinessId).collect(Collectors.toList());
//         QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>().in("business_id",dataVersionBusinessIdList).eq("del_flag",0);
//         List<DataVersion> selectDataVersionList = dataVersionService.list(queryWrapper1);
//         for(int i=0;i<newList.size();i++){
//             for(int j=0;j<selectDataVersionList.size();j++){
//                 if(newList.get(i).getId().equals(selectDataVersionList.get(j).getBusinessId())){
//                     newList.get(i).setDataVersionId(selectDataVersionList.get(j).getId());
//                 }
//             }
//         }
//         warehouseService.updateBatchById(newList);
//         return Result.OK(maxVersion.get()+1);
//     }
//     /**
//      * 生效
//      * 需要一次性完成
//      * @param
//      * @param map
//      * @return
//      */
//     @PostMapping("/updateVersionStatusToUsable")
//     @Transactional
//     public Result<?> updateVersionStatusToUsable(@RequestBody Map<String,Object> map){
//         Date date = new Date(System.currentTimeMillis());
//         QuartzJob quartzJob = quartzJobService.getOne(new QueryWrapper<QuartzJob>()
//                 .eq("job_class_name","org.jeecg.modules.quartz.job.WarehouseSetUsableJob"),true);
//         if(ObjectUtils.isNotNull(quartzJob)){
//             quartzJobService.deleteAndStopJob(quartzJob);
//         }
//         Integer version = Integer.parseInt((String)map.get("version"));
//         //获取上次生效版本并将其是否上次生效位置置为否
//         List<Warehouse> lastUsableList = warehouseService.getLastUsableList();
//         if(CollectionUtils.isNotEmpty(lastUsableList)){
//             QueryWrapper<DataVersion> queryWrapper2 = new QueryWrapper<DataVersion>()
//                     .in("business_id",lastUsableList.stream()
//                             .map(Warehouse::getId)
//                             .collect(Collectors.toList()));
//             List<DataVersion> lastUsableVersionList = dataVersionService.list(queryWrapper2);
//             lastUsableVersionList.stream().forEach(dataVersion -> {
//                 dataVersion
//                         .setIsLastUsable("0");
//             });
//             dataVersionService.updateBatchById(lastUsableVersionList);
//         }
//         //获取生效版本及版本信息并将其置为失效
//         List<Warehouse> usableList = warehouseService.getUsableList();
//         if(CollectionUtils.isNotEmpty(usableList)){
//             QueryWrapper<DataVersion> queryWrapper = new QueryWrapper<DataVersion>()
//                     .in("business_id",usableList.stream()
//                             .map(Warehouse::getId)
//                             .collect(Collectors.toList()));
//             List<DataVersion> usableDataVersionList = dataVersionService.list(queryWrapper);
//             usableDataVersionList.stream().forEach(dataVersion -> {
//                 dataVersion
//                         .setVersionStatus("3")
//                         .setIsLastUsable("1")
//                         .setExpiredTime(date);
//             });
//             dataVersionService.updateBatchById(usableDataVersionList);
//         }
//         //获取待生效版本及版本信息并将其置为生效
//         QueryWrapper<DataVersion> queryWrapper1 = new QueryWrapper<DataVersion>()
//                 .in("business_id",warehouseService.list(new QueryWrapper<Warehouse>()
//                         .eq("version",version)
//                         .eq("del_flag",0))
//                         .stream().map(Warehouse::getId)
//                         .collect(Collectors.toList()));
//         List<DataVersion> dataVersionList = dataVersionService.list(queryWrapper1);
//         dataVersionList.stream().forEach(dataVersion -> {
//             dataVersion.setVersionStatus("2")
//                     .setEffectiveType("2")
//                     .setEffectiveTime(date)
//                     .setIsLastUsable("0");
//         });
//         //存入数据库
//         dataVersionService.updateBatchById(dataVersionList);
//         return  Result.OK("生效成功");
//     }
//     /**
//      * 定时生效
//      * 需要一次性完成
//      * @param quartzJob
//      * @param
//      * @return
//      */
//     @PostMapping("/updateVersionStatusToUsableBySetTime")
//     @Transactional
//     public Result<?> updateVersionStatusToUsableBySetTime(@RequestBody QuartzJob quartzJob) throws ParseException {
//         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
//         DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("ss mm HH dd MM ? yyyy");
//         String jobClassName = quartzJob.getJobClassName();
//         String time = quartzJob.getCronExpression();
//         System.out.println(time);
//         LocalDateTime localDateTime = LocalDateTime.parse(time,dateTimeFormatter);
//         String cronStr=dateTimeFormatter1.format(localDateTime);
//         quartzJob.setCronExpression(cronStr);
//         QueryWrapper<QuartzJob> queryWrapper = new QueryWrapper();
//         queryWrapper.eq("JOB_CLASS_NAME",jobClassName);
//         List<QuartzJob> quartzJobs = quartzJobService.list(queryWrapper);
//         if(CollectionUtils.isEmpty(quartzJobs)){
//             quartzJobService.saveAndScheduleJob(quartzJob);
//             quartzJobs = quartzJobService.list(queryWrapper);
//             quartzJob.setId(quartzJobs.get(0).getId());
//             quartzJobService.resumeJob(quartzJob);
//             return  Result.OK(quartzJob);
//         }else{
//             quartzJob.setId(quartzJobs.get(0).getId());
//             quartzJobService.resumeJob(quartzJob);
//             return Result.OK(quartzJob);
//         }
//
//     }
//
//    /**
//     *  编辑
//     * @param warehouse
//     * @return
//     */
//    @AutoLog(value = "仓库-编辑")
//    @ApiOperation(value="仓库-编辑", notes="仓库-编辑")
//    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:edit")
//    @RequestMapping(value = "/edit", method = {RequestMethod.PUT,RequestMethod.POST})
//    public Result<String> edit(@RequestBody Warehouse warehouse) {
//        warehouseService.updateById(warehouse);
//        return Result.OK("编辑成功!");
//    }
//
//    /**
//     * 通过id删除
//     * @param id
//     * @return
//     */
//    @AutoLog(value = "仓库-通过id删除")
//    @ApiOperation(value="仓库-通过id删除", notes="仓库-通过id删除")
//    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:delete")
//    @DeleteMapping(value = "/delete")
//    public Result<String> delete(@RequestParam(name="id",required=true) String id) {
//        dataVersionService.update(new UpdateWrapper<DataVersion>()
//                .set("del_flag",1)
//                .eq("business_id",id));
//        UpdateWrapper updateWrapper = new UpdateWrapper();
//        updateWrapper.set("del_flag","1");
//        updateWrapper.eq("id",id);
//        warehouseService.update(updateWrapper);
//        return Result.OK("删除成功!");
//    }
//
//    /**
//     * 批量删除
//     * @param ids
//     * @return
//     */
//    @AutoLog(value = "仓库-批量删除")
//    @ApiOperation(value="仓库-批量删除", notes="仓库-批量删除")
//    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:deleteBatch")
//    @DeleteMapping(value = "/deleteBatch")
//    public Result<String> deleteBatch(@RequestParam(name="ids",required=true) String ids) {
//        dataVersionService.update(new UpdateWrapper<DataVersion>()
//                .set("del_flag",1)
//                .in("business_id",Arrays.asList(ids.split(","))));
//        warehouseService
//                .update(new UpdateWrapper<Warehouse>()
//                        .in("id",Arrays.asList(ids.split(","))).set("del_flag",1));
//        return Result.OK("批量删除成功!");
//    }
//
//    /**
//     * 导出
//     * @return
//     */
//    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:exportXls")
//    @RequestMapping(value = "/exportXls")
//    public ModelAndView exportXls(HttpServletRequest request, Warehouse warehouse) {
//        return super.exportXls(request, warehouse, Warehouse.class, "仓库");
//    }
//
//    /**
//     * 导入
//     * @return
//     */
//    //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:importExcel")
//    @RequestMapping(value = "/importExcel", method = RequestMethod.POST)
//    public Result<?> importExcel(HttpServletRequest request, HttpServletResponse response) {
//        return super.importExcel(request, response, Warehouse.class);
//    }
//    /*---------------------------------主表处理-end-------------------------------------*/
//
//
//    /*--------------------------------子表处理-仓库服务对象-begin----------------------------------------------*/
//     /**
//      * 通过主表ID查询
//      * @return
//      */
//     @GetMapping("/checkWarehouseClient")
//     public Result<?> checkClient(
//                                  @RequestParam(name="clientId",required = false) String clientId,
//                                  @RequestParam(name="warehouseId") String warehouseId){
//         QueryWrapper<WarehouseClient> queryWrapper = new QueryWrapper<>();
//         if(!StringUtils.isBlank(clientId)){
//             queryWrapper.eq("client_id",clientId);
//         }
//         if(!StringUtils.isBlank(warehouseId)){
//             queryWrapper.eq("warehouse_id",warehouseId);
//         }
//         queryWrapper.eq("del_flag","0");
//         return Result.OK(warehouseClientService.list(queryWrapper));
//     }
//     /**
//     * 通过主表ID查询
//     * @return
//     */
//    //@AutoLog(value = "仓库服务对象-通过主表ID查询")
//    @ApiOperation(value="仓库服务对象-通过主表ID查询", notes="仓库服务对象-通过主表ID查询")
//    @GetMapping(value = "/listWarehouseClientByMainId")
//    public Result<IPage<WarehouseClient>> listWarehouseClientByMainId(WarehouseClient warehouseClient,
//                                                    @RequestParam(name = "pageNo", defaultValue = "1") Integer pageNo,
//                                                    @RequestParam(name = "pageSize", defaultValue = "10") Integer pageSize,
//                                                    HttpServletRequest req) {
//        QueryWrapper<WarehouseClient> queryWrapper = QueryGenerator.initQueryWrapper(warehouseClient, req.getParameterMap());
//        queryWrapper.eq("del_flag",0);
//        Page<WarehouseClient> page = new Page<WarehouseClient>(pageNo, pageSize);
//        IPage<WarehouseClient> pageList = warehouseClientService.page(page, queryWrapper);
//        return Result.OK(pageList);
//    }
//
//    /**
//     * 添加
//     * @param map
//     * @return
//     */
//    @AutoLog(value = "仓库服务对象-添加")
//    @ApiOperation(value="仓库服务对象-添加", notes="仓库服务对象-添加")
//    @PostMapping(value = "/addWarehouseClient")
//    public Result<String> addWarehouseClient(@RequestBody Map<String,Object> map) {
//        List<Map<String,Object>> addDepartIds = (List<Map<String, Object>>) map.get("addDepartIds");
//        List<Map<String,Object>> addFactoryIds = (List<Map<String, Object>>) map.get("addFactoryIds");
//        String warehouseId = (String) map.get("warehouseId");
//        if(CollectionUtils.isNotEmpty(addDepartIds)){
//            List<WarehouseClient> warehouseClients=new ArrayList<>();
//            addDepartIds.forEach(departMap->{
//                WarehouseClient warehouseClient = new WarehouseClient();
//                warehouseClient.setClientId((String) departMap.get("id"))
//                        .setWarehouseId(warehouseId)
//                        .setCode((String) departMap.get("orgCode"))
//                        .setName((String) departMap.get("departName"))
//                        .setElementType("组织部门")
//                        .setDelFlag(0);
//                warehouseClients.add(warehouseClient);
//            });
//            warehouseClientService.saveBatch(warehouseClients);
//        }
//
//        if(CollectionUtils.isNotEmpty(addFactoryIds)){
//            List<WarehouseClient> warehouseClients=new ArrayList<>();
//            addFactoryIds.forEach(factoryMap->{
//                WarehouseClient warehouseClient = new WarehouseClient();
//                warehouseClient.setClientId((String) factoryMap.get("id"))
//                        .setWarehouseId(warehouseId)
//                        .setCode((String) factoryMap.get("code"))
//                        .setName((String) factoryMap.get("name"))
//                        .setElementType("工厂")
//                        .setDelFlag(0);
//                warehouseClients.add(warehouseClient);
//            });
//            warehouseClientService.saveBatch(warehouseClients);
//        }
//        return Result.OK("添加成功！");
//    }
//
//    /**
//     * 编辑
//     * @param map
//     * @return
//     */
//    @AutoLog(value = "仓库服务对象-编辑")
//    @ApiOperation(value="仓库服务对象-编辑", notes="仓库服务对象-编辑")
//    @RequestMapping(value = "/editWarehouseClient", method = {RequestMethod.PUT,RequestMethod.POST})
//    public Result<String> editWarehouseClient(@RequestBody Map<String,Object> map) {
//        List<Map<String,Object>> addDepartIds = (List<Map<String, Object>>) map.get("addDepartIds");
//        List<Map<String,Object>> addFactoryIds = (List<Map<String, Object>>) map.get("addFactoryIds");
//        String id = (String) map.get("id");
//        if(CollectionUtils.isNotEmpty(addDepartIds)){
//            UpdateWrapper<WarehouseClient> updateWrapper = new UpdateWrapper<WarehouseClient>()
//                    .eq("id",id)
//                    .set("code",(String)addDepartIds.get(0).get("orgCode"))
//                    .set("name",(String) addDepartIds.get(0).get("departName"));
//            warehouseClientService.update(updateWrapper);
//        }
//
//        if(CollectionUtils.isNotEmpty(addFactoryIds)){
//            UpdateWrapper<WarehouseClient> updateWrapper = new UpdateWrapper<WarehouseClient>()
//                    .eq("id",id)
//                    .set("code",(String)addFactoryIds.get(0).get("code"))
//                    .set("name",(String)addFactoryIds.get(0).get("name"));
//            warehouseClientService.update(updateWrapper);
//        }
//        return Result.OK("编辑成功!");
//    }
//
//    /**
//     * 通过id删除
//     * @param id
//     * @return
//     */
//    @AutoLog(value = "仓库服务对象-通过id删除")
//    @ApiOperation(value="仓库服务对象-通过id删除", notes="仓库服务对象-通过id删除")
//    @DeleteMapping(value = "/deleteWarehouseClient")
//    public Result<String> deleteWarehouseClient(@RequestParam(name="id",required=true) String id) {
//        warehouseClientService.update( new UpdateWrapper<WarehouseClient>()
//                .set("del_flag",1)
//                .eq("id",id));
//        return Result.OK("删除成功!");
//    }
//
//    /**
//     * 批量删除
//     * @param ids
//     * @return
//     */
//    @AutoLog(value = "仓库服务对象-批量删除")
//    @ApiOperation(value="仓库服务对象-批量删除", notes="仓库服务对象-批量删除")
//    @DeleteMapping(value = "/deleteBatchWarehouseClient")
//    public Result<String> deleteBatchWarehouseClient(@RequestParam(name="ids",required=true) String ids) {
//        warehouseClientService.update(new UpdateWrapper<WarehouseClient>()
//                .in("id",Arrays.asList(ids.split(",")))
//                .set("del_flag",1));
//        return Result.OK("删除成功");
//    }
//
//    /**
//     * 导出
//     * @return
//     */
//    @RequestMapping(value = "/exportWarehouseClient")
//    public ModelAndView exportWarehouseClient(HttpServletRequest request, WarehouseClient warehouseClient) {
//         // Step.1 组装查询条件
//         QueryWrapper<WarehouseClient> queryWrapper = QueryGenerator.initQueryWrapper(warehouseClient, request.getParameterMap());
//         LoginUser sysUser = (LoginUser) SecurityUtils.getSubject().getPrincipal();
//
//         // Step.2 获取导出数据
//         List<WarehouseClient> pageList = warehouseClientService.list(queryWrapper);
//         List<WarehouseClient> exportList = null;
//
//         // 过滤选中数据
//         String selections = request.getParameter("selections");
//         if (oConvertUtils.isNotEmpty(selections)) {
//             List<String> selectionList = Arrays.asList(selections.split(","));
//             exportList = pageList.stream().filter(item -> selectionList.contains(item.getId())).collect(Collectors.toList());
//         } else {
//             exportList = pageList;
//         }
//
//         // Step.3 AutoPoi 导出Excel
//         ModelAndView mv = new ModelAndView(new JeecgEntityExcelView());
//         //此处设置的filename无效,前端会重更新设置一下
//         mv.addObject(NormalExcelConstants.FILE_NAME, "仓库服务对象");
//         mv.addObject(NormalExcelConstants.CLASS, WarehouseClient.class);
//         mv.addObject(NormalExcelConstants.PARAMS, new ExportParams("仓库服务对象报表", "导出人:" + sysUser.getRealname(), "仓库服务对象"));
//         mv.addObject(NormalExcelConstants.DATA_LIST, exportList);
//         return mv;
//    }
//
//    /**
//     * 导入
//     * @return
//     */
//    @RequestMapping(value = "/importWarehouseClient/{mainId}")
//    public Result<?> importWarehouseClient(HttpServletRequest request, HttpServletResponse response, @PathVariable("mainId") String mainId) {
//         MultipartHttpServletRequest multipartRequest = (MultipartHttpServletRequest) request;
//         Map<String, MultipartFile> fileMap = multipartRequest.getFileMap();
//         for (Map.Entry<String, MultipartFile> entity : fileMap.entrySet()) {
//       // 获取上传文件对象
//             MultipartFile file = entity.getValue();
//             ImportParams params = new ImportParams();
//             params.setTitleRows(2);
//             params.setHeadRows(1);
//             params.setNeedSave(true);
//             try {
//                 List<WarehouseClient> list = ExcelImportUtil.importExcel(file.getInputStream(), WarehouseClient.class, params);
//                 for (WarehouseClient temp : list) {
//                    temp.setWarehouseId(mainId);
//                 }
//                 long start = System.currentTimeMillis();
//                 warehouseClientService.saveBatch(list);
//                 log.info("消耗时间" + (System.currentTimeMillis() - start) + "毫秒");
//                 return Result.OK("文件导入成功！数据行数：" + list.size());
//             } catch (Exception e) {
//                 log.error(e.getMessage(), e);
//                 return Result.error("文件导入失败:" + e.getMessage());
//             } finally {
//                 try {
//                     file.getInputStream().close();
//                 } catch (IOException e) {
//                     e.printStackTrace();
//                 }
//             }
//         }
//         return Result.error("文件导入失败！");
//    }
//    @GetMapping("/enterpriseList")
//    public Result<?> getEnterpriseList(){
//        return Result.OK(enterpriseService.getEnterpriseListByPid(new Page<>(),1,"0"));
//    }
//
//    /*--------------------------------子表处理-仓库服务对象-end----------------------------------------------*/
//
//
//
//     /**
//      *   仓库管理  新增
//      *   qsw
//      */
//     @PostMapping(value = "/addWarehouse")
//     public Result<String> addWarehouse(@RequestBody Warehouse warehouse) {
//         warehouseService.save(warehouse);
//         return Result.OK("添加成功！");
//     }
//
//
//     /**
//      * 分页列表查询
//      * qsw
//      */
//     @GetMapping(value = "/find")
//     public Result<IPage<Warehouse>> queryPageList(Warehouse warehouse,
//                                                   @RequestParam(name="pageNo", defaultValue="1") Integer pageNo,
//                                                   @RequestParam(name="pageSize", defaultValue="10") Integer pageSize,
//                                                   HttpServletRequest req) {
//         QueryWrapper<Warehouse> queryWrapper = QueryGenerator.initQueryWrapper(warehouse, req.getParameterMap());
//         Page<Warehouse> page = new Page<Warehouse>(pageNo, pageSize);
//         IPage<Warehouse> pageList = warehouseService.page(page, queryWrapper);
//         return Result.OK(pageList);
//     }
//
//     /**
//      * 通过id删除
//      * @param id
//      * @return
//      * qsw
//      */
//     @AutoLog(value = "仓库-通过id删除")
//     @ApiOperation(value="仓库-通过id删除", notes="仓库-通过id删除")
//     //@RequiresPermissions("org.jeecg.modules.demo:mom_base_warehouse:delete")
//     @DeleteMapping(value = "/deleteWarehouseAreaLocation")
//     public Result<String> deleteWarehouseAreaLocation(@RequestParam(name="id",required=true) String id) {
//
//         List<WarehouseLocation> warehouseLocations = warehouseLocationService.lambdaQuery()
//                 .eq(WarehouseLocation::getWarehouseId, id).eq(WarehouseLocation::getDelFlag, 0)
//                 .list();
//         for (WarehouseLocation warehouseLocation : warehouseLocations) {
//             warehouseLocationService.removeById(warehouseLocation);
//         }
//
//         List<WarehouseArea> warehouseAreas = warehouseAreaService.lambdaQuery()
//                 .eq(WarehouseArea::getWarehouseId, id)
//                 .eq(WarehouseArea::getDelFlag, 0).list();
//         for (WarehouseArea warehouseArea : warehouseAreas) {
//             warehouseAreaService.removeById(warehouseArea);
//         }
//         warehouseService.removeById(id);
//         return Result.OK("删除成功!");
//     }
//
//     /**
//      * 通过id查询
//      *qsw
//      */
//     @GetMapping(value = "/queryById")
//     public Result<Warehouse> queryById(@RequestParam(name="id",required=true) String id) {
//         Warehouse warehouse = warehouseService.getById(id);
//         if(warehouse ==null) {
//             return Result.error("未找到对应数据");
//         }
//         return Result.OK(warehouse);
//     }
//
//}

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/base/mapper/WarehouseMapper.java

@@ -1,59 +1,59 @@
package org.jeecg.modules.base.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.base.entity.Warehouse;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;

/**
 * @Description: 仓库
 * @Author: jeecg-boot
 * @Date:   2022-11-07
 * @Version: V1.0
 */
@Repository
public interface WarehouseMapper extends BaseMapper<Warehouse> {
    /**
     * 获取版本仓库列表
     * @param page
     * @param enterpriseId
     * @param version
     * @return
     */
    List<Map<String,Object>> getWarehouseList(Page<Map<String,Object>> page,
                                            @Param("version") Integer version,
                                            @Param("enterpriseId") String enterpriseId);
    /**
     * 获取所有版本号
     * @param
     *
     * @return
     */
    List<Integer> getAllVersion();
    /**
     * 获取最后一次生效列表
     * @return
     */
    List<Warehouse> getLastUsableList();
    /**
     * 获取当前生效列表
     * @return
     */
    List<Warehouse> getUsableList();
    /**
     * 获取版本状态根据版本号
     * @return
     */
    List<String> getVersionStatusByVersion(Integer veison);

    /**
     * 通过仓库名称查询仓库信息
     * @param name
     * @return
     */
    public Warehouse getByName(@Param("name") String name);
}
//package org.jeecg.modules.base.mapper;
//
//import com.baomidou.mybatisplus.core.mapper.BaseMapper;
//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
//import org.apache.ibatis.annotations.Param;
//import org.jeecg.modules.base.entity.Warehouse;
//import org.springframework.stereotype.Repository;
//
//import java.util.List;
//import java.util.Map;
//
///**
// * @Description: 仓库
// * @Author: jeecg-boot
// * @Date:   2022-11-07
// * @Version: V1.0
// */
//@Repository
//public interface WarehouseMapper extends BaseMapper<Warehouse> {
//    /**
//     * 获取版本仓库列表
//     * @param page
//     * @param enterpriseId
//     * @param version
//     * @return
//     */
//    List<Map<String,Object>> getWarehouseList(Page<Map<String,Object>> page,
//                                            @Param("version") Integer version,
//                                            @Param("enterpriseId") String enterpriseId);
//    /**
//     * 获取所有版本号
//     * @param
//     *
//     * @return
//     */
//    List<Integer> getAllVersion();
//    /**
//     * 获取最后一次生效列表
//     * @return
//     */
//    List<Warehouse> getLastUsableList();
//    /**
//     * 获取当前生效列表
//     * @return
//     */
//    List<Warehouse> getUsableList();
//    /**
//     * 获取版本状态根据版本号
//     * @return
//     */
//    List<String> getVersionStatusByVersion(Integer veison);
//
//    /**
//     * 通过仓库名称查询仓库信息
//     * @param name
//     * @return
//     */
//    public Warehouse getByName(@Param("name") String name);
//}

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/base/service/IWarehouseService.java

@@ -1,98 +1,98 @@
package org.jeecg.modules.base.service;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.base.entity.Warehouse;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @Description: 仓库
 * @Author: jeecg-boot
 * @Date: 2022-11-07
 * @Version: V1.0
 */
public interface IWarehouseService extends IService<Warehouse> {
    /**
     * 获取版本列表
     *
     * @param page
     * @param enterpriseId
     * @param version
     * @return
     */
    Page<Map<String, Object>> getWarehouseList(Page<Map<String, Object>> page,
                                               Integer version,
                                               String enterpriseId);

    /**
     * 获取初始版本号
     *
     * @return
     */
    public Integer getInitVersion();

    /**
     * 删除一对多
     *
     * @param id
     */
    public void delMain(String id);

    /**
     * 批量删除一对多
     *
     * @param idList
     */
    public void delBatchMain(Collection<? extends Serializable> idList);

    /**
     * 获取所有版本号
     *
     * @param
     * @return
     */
    public Set<Integer> getVersionList();

    /**
     * 获取最后一次生效列表
     *
     * @return
     */
    List<Warehouse> getLastUsableList();

    /**
     * 获取当前生效列表
     *
     * @return
     */
    List<Warehouse> getUsableList();

    /**
     * 查当前生效版本和上次生效版本
     *
     * @return
     */
    Map<String, Object> getNowAndLastUsableVersion();

    /**
     * 获取版本状态根据版本号
     *
     * @param version
     * @return
     */
    List<String> getVersionStatusByVersion(Integer version);


    /**
     * 根据仓库名称查询
     *
     * @param name 名称
     * @return Warehouse
     */
    public Warehouse getByName(String name);
}
//package org.jeecg.modules.base.service;
//
//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
//import com.baomidou.mybatisplus.extension.service.IService;
//import org.jeecg.modules.base.entity.Warehouse;
//
//import java.io.Serializable;
//import java.util.Collection;
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//
///**
// * @Description: 仓库
// * @Author: jeecg-boot
// * @Date: 2022-11-07
// * @Version: V1.0
// */
//public interface IWarehouseService extends IService<Warehouse> {
//    /**
//     * 获取版本列表
//     *
//     * @param page
//     * @param enterpriseId
//     * @param version
//     * @return
//     */
//    Page<Map<String, Object>> getWarehouseList(Page<Map<String, Object>> page,
//                                               Integer version,
//                                               String enterpriseId);
//
//    /**
//     * 获取初始版本号
//     *
//     * @return
//     */
//    public Integer getInitVersion();
//
//    /**
//     * 删除一对多
//     *
//     * @param id
//     */
//    public void delMain(String id);
//
//    /**
//     * 批量删除一对多
//     *
//     * @param idList
//     */
//    public void delBatchMain(Collection<? extends Serializable> idList);
//
//    /**
//     * 获取所有版本号
//     *
//     * @param
//     * @return
//     */
//    public Set<Integer> getVersionList();
//
//    /**
//     * 获取最后一次生效列表
//     *
//     * @return
//     */
//    List<Warehouse> getLastUsableList();
//
//    /**
//     * 获取当前生效列表
//     *
//     * @return
//     */
//    List<Warehouse> getUsableList();
//
//    /**
//     * 查当前生效版本和上次生效版本
//     *
//     * @return
//     */
//    Map<String, Object> getNowAndLastUsableVersion();
//
//    /**
//     * 获取版本状态根据版本号
//     *
//     * @param version
//     * @return
//     */
//    List<String> getVersionStatusByVersion(Integer version);
//
//
//    /**
//     * 根据仓库名称查询
//     *
//     * @param name 名称
//     * @return Warehouse
//     */
//    public Warehouse getByName(String name);
//}

 lxzn-module-system/lxzn-system-biz/src/main/java/org/jeecg/modules/base/service/impl/WarehouseServiceImpl.java

@@ -1,106 +1,106 @@
package org.jeecg.modules.base.service.impl;

import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.jeecg.modules.base.entity.FactoryModel;
import org.jeecg.modules.base.entity.Warehouse;
import org.jeecg.modules.base.mapper.WarehouseClientMapper;
import org.jeecg.modules.base.mapper.WarehouseMapper;
import org.jeecg.modules.base.service.IWarehouseService;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.io.Serializable;
import java.util.*;

/**
 * @Description: 仓库
 * @Author: jeecg-boot
 * @Date:   2022-11-07
 * @Version: V1.0
 */
@Service
public class WarehouseServiceImpl extends ServiceImpl<WarehouseMapper, Warehouse> implements IWarehouseService {

    @Autowired
    private WarehouseMapper warehouseMapper;
    @Autowired
    private WarehouseClientMapper warehouseClientMapper;

    @Override
    public Page<Map<String, Object>> getWarehouseList(Page<Map<String, Object>> page, Integer version, String enterpriseId) {
        return page.setRecords(warehouseMapper.getWarehouseList(page,version,enterpriseId));
    }

    @Override
    public Integer getInitVersion() {
        List<Warehouse> usableVersionList = warehouseMapper.getUsableList();
        Set<Integer> allVersionList = getVersionList();
        if(CollectionUtils.isNotEmpty(usableVersionList)){
            return usableVersionList.get(0).getVersion();
        }else if(CollectionUtils.isNotEmpty(allVersionList)){
            return allVersionList.stream().findFirst().get();
        }
        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delMain(String id) {
        warehouseClientMapper.deleteByMainId(id);
        warehouseMapper.deleteById(id);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void delBatchMain(Collection<? extends Serializable> idList) {
        for(Serializable id:idList) {
            warehouseClientMapper.deleteByMainId(id.toString());
            warehouseMapper.deleteById(id);
        }
    }

    @Override
    public Set<Integer> getVersionList() {
        Set<Integer> set = new TreeSet<Integer>(Comparator.reverseOrder());
        set.addAll(warehouseMapper.getAllVersion());
        return set;
    }

    @Override
    public List<Warehouse> getLastUsableList() {
        return warehouseMapper.getLastUsableList();
    }

    @Override
    public List<Warehouse> getUsableList() {
        return warehouseMapper.getUsableList();
    }

    @Override
    public Map<String, Object> getNowAndLastUsableVersion() {
        List<Warehouse> usableList = warehouseMapper.getUsableList();
        List<Warehouse> lastUsableList = warehouseMapper.getLastUsableList();
        Map<String,Object> map = new HashMap<>(2);
        if(CollectionUtils.isNotEmpty(usableList)){
            map.put("usableVersion",usableList.get(0).getVersion());
        }
        if(CollectionUtils.isNotEmpty(lastUsableList)){
            map.put("lastUsableVersion",lastUsableList.get(0).getVersion());
        }
        return map;
    }

    @Override
    public List<String> getVersionStatusByVersion(Integer version) {
        return warehouseMapper.getVersionStatusByVersion(version);
    }

    @Override
    public Warehouse getByName(String name) {
        return warehouseMapper.getByName(name);
    }


}
//package org.jeecg.modules.base.service.impl;
//
//import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
//import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
//import org.jeecg.modules.base.entity.FactoryModel;
//import org.jeecg.modules.base.entity.Warehouse;
//import org.jeecg.modules.base.mapper.WarehouseClientMapper;
//import org.jeecg.modules.base.mapper.WarehouseMapper;
//import org.jeecg.modules.base.service.IWarehouseService;
//import org.springframework.stereotype.Service;
//import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.transaction.annotation.Transactional;
//import java.io.Serializable;
//import java.util.*;
//
///**
// * @Description: 仓库
// * @Author: jeecg-boot
// * @Date:   2022-11-07
// * @Version: V1.0
// */
//@Service
//public class WarehouseServiceImpl extends ServiceImpl<WarehouseMapper, Warehouse> implements IWarehouseService {
//
//    @Autowired
//    private WarehouseMapper warehouseMapper;
//    @Autowired
//    private WarehouseClientMapper warehouseClientMapper;
//
//    @Override
//    public Page<Map<String, Object>> getWarehouseList(Page<Map<String, Object>> page, Integer version, String enterpriseId) {
//        return page.setRecords(warehouseMapper.getWarehouseList(page,version,enterpriseId));
//    }
//
//    @Override
//    public Integer getInitVersion() {
//        List<Warehouse> usableVersionList = warehouseMapper.getUsableList();
//        Set<Integer> allVersionList = getVersionList();
//        if(CollectionUtils.isNotEmpty(usableVersionList)){
//            return usableVersionList.get(0).getVersion();
//        }else if(CollectionUtils.isNotEmpty(allVersionList)){
//            return allVersionList.stream().findFirst().get();
//        }
//        return null;
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void delMain(String id) {
//        warehouseClientMapper.deleteByMainId(id);
//        warehouseMapper.deleteById(id);
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void delBatchMain(Collection<? extends Serializable> idList) {
//        for(Serializable id:idList) {
//            warehouseClientMapper.deleteByMainId(id.toString());
//            warehouseMapper.deleteById(id);
//        }
//    }
//
//    @Override
//    public Set<Integer> getVersionList() {
//        Set<Integer> set = new TreeSet<Integer>(Comparator.reverseOrder());
//        set.addAll(warehouseMapper.getAllVersion());
//        return set;
//    }
//
//    @Override
//    public List<Warehouse> getLastUsableList() {
//        return warehouseMapper.getLastUsableList();
//    }
//
//    @Override
//    public List<Warehouse> getUsableList() {
//        return warehouseMapper.getUsableList();
//    }
//
//    @Override
//    public Map<String, Object> getNowAndLastUsableVersion() {
//        List<Warehouse> usableList = warehouseMapper.getUsableList();
//        List<Warehouse> lastUsableList = warehouseMapper.getLastUsableList();
//        Map<String,Object> map = new HashMap<>(2);
//        if(CollectionUtils.isNotEmpty(usableList)){
//            map.put("usableVersion",usableList.get(0).getVersion());
//        }
//        if(CollectionUtils.isNotEmpty(lastUsableList)){
//            map.put("lastUsableVersion",lastUsableList.get(0).getVersion());
//        }
//        return map;
//    }
//
//    @Override
//    public List<String> getVersionStatusByVersion(Integer version) {
//        return warehouseMapper.getVersionStatusByVersion(version);
//    }
//
//    @Override
//    public Warehouse getByName(String name) {
//        return warehouseMapper.getByName(name);
//    }
//
//
//}

 lxzn-module-system/lxzn-system-start/pom.xml

@@ -54,6 +54,12 @@
            <artifactId>lxzn-module-eam</artifactId>
            <version>${jeecgboot.version}</version>
        </dependency>
        <!--tms 工具管理模块-->
        <dependency>
            <groupId>org.jeecgframework.boot</groupId>
            <artifactId>lxzn-module-tms</artifactId>
            <version>${jeecgboot.version}</version>
        </dependency>
    </dependencies>

    <build>