wms / hhwms · Files

package com.huaheng.pc.config.zone.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;

import com.huaheng.common.utils.Wrappers;

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

import com.huaheng.common.constant.QuantityConstant;

import com.huaheng.common.support.Convert;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.common.utils.security.ShiroUtils;
import com.huaheng.framework.aspectj.lang.annotation.Log;
import com.huaheng.framework.aspectj.lang.constant.BusinessType;
import com.huaheng.framework.web.controller.BaseController;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.page.PageDomain;
import com.huaheng.framework.web.page.TableDataInfo;
import com.huaheng.framework.web.page.TableSupport;

import com.huaheng.pc.config.container.domain.Container;

import com.huaheng.pc.config.container.service.ContainerService;

import com.huaheng.pc.config.location.domain.Location;

import com.huaheng.pc.config.location.service.LocationService;

import com.huaheng.pc.config.station.domain.Station;

import com.huaheng.pc.config.warehouse.domain.WarehouseU8;

import com.huaheng.pc.config.zone.domain.Zone;
import com.huaheng.pc.config.zone.service.ZoneService;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

import java.util.ArrayList;
import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;

/**
 * 库区 信息操作处理
 *
 * @author ricard
 * @date 2019-08-12
 */

@Controller
@RequestMapping("/config/zone")
public class ZoneController extends BaseController {

    private String prefix = "config/zone";

    @Autowired
    private ZoneService zoneService;

    @Resource
    private LocationService locationService;

    @Resource
    private ContainerService containerService;

    @RequiresPermissions("config:zone:view")
    @GetMapping()
    public String zone()
    {
        return prefix + "/zone";
    }

    /**
     * 查询库区列表
     */
    @RequiresPermissions("config:zone:list")
    @Log(title = "配置-库区设置", operating = "查看库区列表", action = BusinessType.GRANT)
    @PostMapping("/list")
    @ResponseBody
    public TableDataInfo list(Zone zone,String createdBegin, String createdEnd)
    {
        LambdaQueryWrapper<Zone> lambdaQueryWrapper = Wrappers.lambdaQuery();
        PageDomain pageDomain = TableSupport.buildPageRequest();
        Integer pageNum = pageDomain.getPageNum();

        Integer pageSize = pageDomain.getPageSize();

        lambdaQueryWrapper.ge(StringUtils.isNotEmpty(createdBegin),Zone::getCreated, createdBegin)
                .le(StringUtils.isNotEmpty(createdEnd), Zone::getCreated, createdEnd)

                .eq(Zone::getWarehouseCode,ShiroUtils.getWarehouseCode())

                .eq(StringUtils.isNotEmpty(zone.getCode()), Zone::getCode, zone.getCode())
                .like(StringUtils.isNotEmpty(zone.getName()), Zone::getName, zone.getName())
                .orderByAsc(Zone::getId);

        if (StringUtils.isNotNull(pageNum) && StringUtils.isNotNull(pageSize)){
            /**
             * 使用分页查询
             */
            Page<Zone> page = new Page<>(pageNum, pageSize);
            IPage<Zone> iPage = zoneService.page(page, lambdaQueryWrapper);

            return getMpDataTable(iPage.getRecords(),iPage.getTotal());

        } else {
            List<Zone> list = zoneService.list(lambdaQueryWrapper);
            return getDataTable(list);
        }
    }

    /**
     * 新增库区
     */
    @GetMapping("/add")
    public String add()
    {
        return prefix + "/add";
    }

    /**
     * 新增保存库区
     */
    @RequiresPermissions("config:zone:add")
    @Log(title = "配置-库区设置", operating = "新增库区", action = BusinessType.INSERT)
    @PostMapping("/add")
    @ResponseBody
    public AjaxResult addSave(Zone zone)
    {
        zone.setWarehouseCode(ShiroUtils.getWarehouseCode());
        zone.setCreatedBy(ShiroUtils.getLoginName());
        zone.setLastUpdatedBy(ShiroUtils.getLoginName());

        try {
            zoneService.dataValidation(zone);
        }catch (Exception e){
            return AjaxResult.error(e.getMessage());
        }

        return toAjax(zoneService.save(zone));
    }

    /**
     * 修改库区
     */
    @GetMapping("/edit/{id}")
    public String edit(@PathVariable("id") Integer id, ModelMap mmap)
    {
        Zone zone = zoneService.getById(id);
        mmap.put("zone", zone);
        return prefix + "/edit";
    }

    /**
     * 修改保存库区
     */
    @RequiresPermissions("config:zone:edit")
    @Log(title = "配置-库区设置", operating = "修改库区", action = BusinessType.UPDATE)
    @PostMapping("/edit")
    @ResponseBody
    public AjaxResult editSave(Zone zone)
    {
        zone.setLastUpdatedBy(ShiroUtils.getLoginName());
        return toAjax(zoneService.saveOrUpdate(zone));
    }

    /**
     * 删除库区
     */
    @RequiresPermissions("config:zone:remove")
    @Log(title = "配置-库区设置", operating = "删除库区", action = BusinessType.DELETE)
    @PostMapping( "/remove")
    @ResponseBody
    public AjaxResult remove(String ids)
    {

        if (StringUtils.isEmpty(ids)) {

            return AjaxResult.error("id不能为空");

        }

        for (Integer id : Convert.toIntArray(ids))
        {
            Zone record = new Zone();
            zoneService.removeById(id);
        }
        return AjaxResult.success("删除成功！");
    }

    @PostMapping("/getData")
    @ResponseBody
    public Map<String, Object> getData() {
        LambdaQueryWrapper<Zone> lambdaQueryWrapper = Wrappers.lambdaQuery();
        lambdaQueryWrapper.ne(Zone::getArea, "");
        List<Zone> zoneList = zoneService.list(lambdaQueryWrapper);
        Map<String, Object> map = new HashMap<>();

        List<Map<String, Object>> list = new ArrayList<>();
        for (Zone zone : zoneList) {
            Map<String, Object> resultMap = new HashMap<>();
            resultMap.put("id", zone.getArea());
            resultMap.put("text", zone.getName());
            list.add(resultMap);
        }
        map.put("results", list);
        return map;
    }

    @GetMapping("/getStatus")
    @ResponseBody

    public AjaxResult getStatus(String warehouseCode,String zoneCode) {
        if(warehouseCode==null){
            warehouseCode=ShiroUtils.getWarehouseCode();
        }

        HashMap<String, Integer> map = new HashMap<>();

        LambdaQueryWrapper<Location> queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.eq(Location::getZoneCode,zoneCode);

        queryWrapper.eq(Location::getWarehouseCode,warehouseCode);

        List<Location> locationList = locationService.list(queryWrapper);

        map.put("location", locationList.size());

        queryWrapper = new LambdaQueryWrapper<>();

        queryWrapper.and(wrapper->wrapper.isNull(Location::getContainerCode).or().eq(Location::getContainerCode,""))

                .eq(Location::getZoneCode,zoneCode).eq(Location::getWarehouseCode,warehouseCode);

        List<Location> emptyLocationList = locationService.list(queryWrapper);

        map.put("emptyLocation", emptyLocationList.size());

        LambdaQueryWrapper<Container> containerLambdaQueryWrapper2 = new LambdaQueryWrapper<>();

        containerLambdaQueryWrapper2.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_EMPTY);

        containerLambdaQueryWrapper2.eq(Container::getWarehouseCode, warehouseCode);

        List<Container> containerList2 = containerService.list(containerLambdaQueryWrapper2);
        List<String> containerCodeList2 = containerList2.stream().map(Container::getCode).collect(Collectors.toList());

        LambdaQueryWrapper<Location> locationLambdaQueryWrapper2 = new LambdaQueryWrapper<>();

        locationLambdaQueryWrapper2.in(Location::getContainerCode, containerCodeList2);
        locationLambdaQueryWrapper2.eq(Location::getZoneCode, zoneCode);

        locationLambdaQueryWrapper2.eq(Location::getWarehouseCode, warehouseCode);

        List<Location> haveEmptyContainLocation = locationService.list(locationLambdaQueryWrapper2);
        map.put("haveContainLocation", haveEmptyContainLocation.size());

        LambdaQueryWrapper<Container> containerLambdaQueryWrapper = new LambdaQueryWrapper<>();

        containerLambdaQueryWrapper.eq(Container::getStatus, QuantityConstant.STATUS_CONTAINER_SOME);

        containerLambdaQueryWrapper.eq(Container::getWarehouseCode, warehouseCode);

        List<Container> containerList = containerService.list(containerLambdaQueryWrapper);

        int containerListSize = containerList.size();

        List<String> containerCodeList = containerList.stream().map(Container::getCode).collect(Collectors.toList());

        LambdaQueryWrapper<Location> locationLambdaQueryWrapper = new LambdaQueryWrapper<>();

        locationLambdaQueryWrapper.in(containerListSize !=0, Location::getContainerCode, containerCodeList);

        locationLambdaQueryWrapper.eq(Location::getZoneCode, zoneCode);

        locationLambdaQueryWrapper.eq(Location::getWarehouseCode, warehouseCode);

        List<Location> haveInventoryLocation = locationService.list(locationLambdaQueryWrapper);
        map.put("haveInventoryLocation", haveInventoryLocation.size());

        return AjaxResult.success().setData(map);
    }

    @PostMapping( "/findByWare")
    @ResponseBody
    @Transactional
    public TableDataInfo findByWare(String warehouseCode) {
        List<Zone> zone = zoneService.findByWare(warehouseCode);
        return getDataTable(zone);
    }

}