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

cuilei

2025-05-06 4a42e8745fe27cf8edf500eaa5b2d65e080c09b0

 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);
//    }
//
//}