xtywms.git - Gitblit

package com.zy.asrs.controller;
 
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.core.common.DateUtils;
import com.zy.asrs.entity.SaleOrder;
import com.zy.asrs.service.SaleOrderService;
import com.core.annotations.ManagerAuth;
import com.core.common.BaseRes;
import com.core.common.Cools;
import com.core.common.R;
import com.core.controller.AbstractBaseController;
import com.zy.common.web.BaseController;
 
import org.apache.poi.xssf.usermodel.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
 
import java.io.File;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.net.URLEncoder;
import java.util.*;
import javax.servlet.http.HttpServletResponse;
 
@RestController
public class SaleOrderController extends BaseController {
 
    @Autowired
    private SaleOrderService saleOrderService;
 
    @RequestMapping(value = "/saleOrder/{id}/auth")
    @ManagerAuth
    public R get(@PathVariable("id") String id) {
        return R.ok(saleOrderService.selectById(String.valueOf(id)));
    }
 
    @RequestMapping(value = "/saleOrder/list/auth")
    @ManagerAuth
    public R list(@RequestParam(defaultValue = "1") Integer curr,
            @RequestParam(defaultValue = "10") Integer limit,
            @RequestParam(required = false) String orderByField,
            @RequestParam(required = false) String orderByType,
            @RequestParam Map<String, Object> param) {
        EntityWrapper<SaleOrder> wrapper = new EntityWrapper<>();
        excludeTrash(param);
        convert(param, wrapper);
        if (!Cools.isEmpty(orderByField)) {
            wrapper.orderBy(humpToLine(orderByField), "asc".equals(orderByType));
        }
        return R.ok(saleOrderService.selectPage(new Page<>(curr, limit), wrapper));
    }
 
    @RequestMapping(value = "/saleOrder/auditList/auth")
    @ManagerAuth
    public R auditList(@RequestParam(defaultValue = "1") Integer curr,
            @RequestParam(defaultValue = "10") Integer limit,
            @RequestParam(required = false) String order_code) {
        // 查询有待审核附件的订单（temp1Status到temp5Status中任一为0）
        EntityWrapper<SaleOrder> wrapper = new EntityWrapper<>();
        wrapper.andNew()
                .eq("temp1_status", 0)
                .or().eq("temp2_status", 0)
                .or().eq("temp3_status", 0)
                .or().eq("temp4_status", 0)
                .or().eq("temp5_status", 0);
 
        if (!Cools.isEmpty(order_code)) {
            wrapper.like("order_code", order_code);
        }
 
        List<SaleOrder> orders = saleOrderService.selectList(wrapper);
 
        // 展开数据，每个待审核附件单独一行
        List<Map<String, Object>> result = new ArrayList<>();
        String[][] fields = {
                { "temp1Path", "temp1Status", "包材版费" },
                { "temp2Path", "temp2Status", "退税资料" },
                { "temp3Path", "temp3Status", "开票" },
                { "temp4Path", "temp4Status", "内陆费" },
                { "temp5Path", "temp5Status", "收款" }
        };
 
        for (SaleOrder order : orders) {
            for (String[] field : fields) {
                Integer status = null;
                String filePath = null;
 
                switch (field[0]) {
                    case "temp1Path":
                        filePath = order.getTemp1Path();
                        status = order.getTemp1Status();
                        break;
                    case "temp2Path":
                        filePath = order.getTemp2Path();
                        status = order.getTemp2Status();
                        break;
                    case "temp3Path":
                        filePath = order.getTemp3Path();
                        status = order.getTemp3Status();
                        break;
                    case "temp4Path":
                        filePath = order.getTemp4Path();
                        status = order.getTemp4Status();
                        break;
                    case "temp5Path":
                        filePath = order.getTemp5Path();
                        status = order.getTemp5Status();
                        break;
                }
 
                // 只显示待审核的附件（status=0）且有文件
                if (status != null && status == 0 && !Cools.isEmpty(filePath)) {
                    Map<String, Object> item = new HashMap<>();
                    item.put("id", order.getId());
                    item.put("orderCode", order.getOrderCode());
                    item.put("invName", order.getInvName());
                    item.put("field", field[0]);
                    item.put("fieldLabel", field[2]);
                    item.put("statusField", field[1]);
                    item.put("filePath", filePath);
                    item.put("status", status);
                    result.add(item);
                }
            }
        }
 
        // 简单分页处理
        int total = result.size();
        int start = (curr - 1) * limit;
        int end = Math.min(start + limit, total);
        List<Map<String, Object>> pageData = start < total ? result.subList(start, end) : new ArrayList<>();
 
        Map<String, Object> pageResult = new HashMap<>();
        pageResult.put("records", pageData);
        pageResult.put("total", total);
        pageResult.put("current", curr);
        pageResult.put("size", limit);
 
        return R.ok(pageResult);
    }
 
    private void convert(Map<String, Object> map, EntityWrapper wrapper) {
        for (Map.Entry<String, Object> entry : map.entrySet()) {
            String val = String.valueOf(entry.getValue());
            if (val.contains(RANGE_TIME_LINK)) {
                String[] dates = val.split(RANGE_TIME_LINK);
                wrapper.ge(entry.getKey(), DateUtils.convert(dates[0]));
                wrapper.le(entry.getKey(), DateUtils.convert(dates[1]));
            } else {
                wrapper.like(entry.getKey(), val);
            }
        }
    }
    
    /**
     * 安全地将对象转换为BigDecimal，确保null值不会被错误转换
     * 使用BigDecimal可以避免浮点数精度问题，特别适合金额和数量字段
     * @param obj 待转换的对象
     * @return BigDecimal值，如果对象为null或无法转换则返回null
     */
    private BigDecimal parseBigDecimalSafely(Object obj) {
        if (obj == null) {
            return null;
        }
        // 如果是字符串"null"，返回null
        String str = String.valueOf(obj);
        if ("null".equalsIgnoreCase(str) || str.trim().isEmpty()) {
            return null;
        }
        try {
            // 如果已经是BigDecimal，直接返回
            if (obj instanceof BigDecimal) {
                return (BigDecimal) obj;
            }
            // 如果是Number类型，转换为BigDecimal
            if (obj instanceof Number) {
                // 使用字符串转换避免精度损失
                return new BigDecimal(obj.toString());
            }
            // 字符串转换为BigDecimal
            return new BigDecimal(str.trim());
        } catch (NumberFormatException e) {
            // 转换失败，返回null
            return null;
        }
    }
    
    /**
     * 安全地将对象转换为Double，确保null值不会被错误转换
     * @deprecated 建议使用 parseBigDecimalSafely 替代，以避免精度问题
     * @param obj 待转换的对象
     * @return Double值，如果对象为null或无法转换则返回null
     */
    @Deprecated
    private Double parseDoubleSafely(Object obj) {
        if (obj == null) {
            return null;
        }
        // 如果是字符串"null"，返回null
        String str = String.valueOf(obj);
        if ("null".equalsIgnoreCase(str) || str.trim().isEmpty()) {
            return null;
        }
        try {
            // 尝试转换为Double
            if (obj instanceof Number) {
                return ((Number) obj).doubleValue();
            }
            return Double.valueOf(str);
        } catch (NumberFormatException e) {
            // 转换失败，返回null
            return null;
        }
    }
 
    @RequestMapping(value = "/saleOrder/add/auth")
    @ManagerAuth
    public R add(SaleOrder saleOrder) {
        saleOrderService.insert(saleOrder);
        return R.ok();
    }
 
    @RequestMapping(value = "/saleOrder/batchSave/auth", method = RequestMethod.POST)
    @ManagerAuth
    public R batchSave(@RequestBody List<Map<String, Object>> dataList) {
        if (Cools.isEmpty(dataList)) {
            return R.error("数据不能为空");
        }
        int successCount = 0;
        int updateCount = 0;
        for (Map<String, Object> data : dataList) {
            try {
                // 检查是否已存在（根据订单号和物料编码）
                SaleOrder existOrder = saleOrderService.selectOne(new EntityWrapper<SaleOrder>()
                        .eq("order_code", data.get("orderCode")).eq("inv_code", data.get("invCode")));
                
                SaleOrder saleOrder;
                boolean isUpdate = false;
                if (existOrder != null) {
                    // 已存在，更新数据
                    saleOrder = existOrder;
                    isUpdate = true;
                    updateCount++;
                } else {
                    // 不存在，创建新记录
                    saleOrder = new SaleOrder();
                    successCount++;
                }
                
                saleOrder.setOrderCode(data.get("orderCode") != null ? String.valueOf(data.get("orderCode")) : null);
                saleOrder.setPersonName(data.get("personName") != null ? String.valueOf(data.get("personName")) : null);
                saleOrder.setInvCode(data.get("invCode") != null ? String.valueOf(data.get("invCode")) : null);
                saleOrder.setInvName(data.get("invName") != null ? String.valueOf(data.get("invName")) : null);
                saleOrder.setInvStd(data.get("invStd") != null ? String.valueOf(data.get("invStd")) : null);
                
                saleOrder.setOrderQty(parseDoubleSafely(data.get("orderQty")));
                saleOrder.setProductQty(parseDoubleSafely(data.get("productQty")));
                saleOrder.setInQty(parseDoubleSafely(data.get("inQty")));
                saleOrder.setOutQty(parseDoubleSafely(data.get("outQty")));
                saleOrder.setOutAmount(parseDoubleSafely(data.get("outAmount")));
                saleOrder.setOutPrice(parseDoubleSafely(data.get("outPrice")));
                saleOrder.setIcsbeqty(parseDoubleSafely(data.get("icsbeqty")));
                saleOrder.setSeoseqty(parseDoubleSafely(data.get("seoseqty")));
                
                // 日期字段处理
                if (data.get("deliveryDate") != null && !Cools.isEmpty(String.valueOf(data.get("deliveryDate")))) {
                    try {
                        String dateStr = String.valueOf(data.get("deliveryDate"));
                        java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd");
                        saleOrder.setDeliveryDate(sdf.parse(dateStr));
                    } catch (Exception ex) {
                        // 尝试使用 DateUtils 解析其他格式
                        saleOrder.setDeliveryDate(DateUtils.convert(String.valueOf(data.get("deliveryDate"))));
                    }
                } else {
                    saleOrder.setDeliveryDate(null);
                }
                
                // 保存或更新
                if (isUpdate) {
                    saleOrderService.updateById(saleOrder);
                } else {
                    saleOrderService.insert(saleOrder);
                }
            } catch (Exception e) {
                // 记录失败的记录，继续处理下一条
                e.printStackTrace();
            }
        }
        return R.ok("成功保存 " + successCount + " 条新数据，更新 " + updateCount + " 条已存在数据");
    }
 
    @RequestMapping(value = "/saleOrder/update/auth")
    @ManagerAuth
    public R update(SaleOrder saleOrder) {
        if (Cools.isEmpty(saleOrder) || null == saleOrder.getId()) {
            return R.error();
        }
        saleOrderService.updateById(saleOrder);
        return R.ok();
    }
 
    @RequestMapping(value = "/saleOrder/delete/auth")
    @ManagerAuth
    public R delete(@RequestParam String param) {
        List<SaleOrder> list = JSONArray.parseArray(param, SaleOrder.class);
        if (Cools.isEmpty(list)) {
            return R.error();
        }
        for (SaleOrder entity : list) {
            saleOrderService.delete(new EntityWrapper<>(entity));
        }
        return R.ok();
    }
 
    @RequestMapping(value = "/saleOrder/export/auth")
    @ManagerAuth
    public R export(@RequestBody JSONObject param) {
        EntityWrapper<SaleOrder> wrapper = new EntityWrapper<>();
        List<String> fields = JSONObject.parseArray(param.getJSONArray("fields").toJSONString(), String.class);
        Map<String, Object> map = excludeTrash(param.getJSONObject("saleOrder"));
        convert(map, wrapper);
        List<SaleOrder> list = saleOrderService.selectList(wrapper);
        return R.ok(exportSupport(list, fields));
    }
 
    @RequestMapping(value = "/saleOrderQuery/auth")
    @ManagerAuth
    public R query(String condition) {
        EntityWrapper<SaleOrder> wrapper = new EntityWrapper<>();
        wrapper.like("id", condition);
        Page<SaleOrder> page = saleOrderService.selectPage(new Page<>(0, 10), wrapper);
        List<Map<String, Object>> result = new ArrayList<>();
        for (SaleOrder saleOrder : page.getRecords()) {
            Map<String, Object> map = new HashMap<>();
            map.put("id", saleOrder.getId());
            map.put("value", saleOrder.getId());
            result.add(map);
        }
        return R.ok(result);
    }
 
    @RequestMapping(value = "/saleOrder/check/column/auth")
    @ManagerAuth
    public R query(@RequestBody JSONObject param) {
        Wrapper<SaleOrder> wrapper = new EntityWrapper<SaleOrder>().eq(humpToLine(String.valueOf(param.get("key"))),
                param.get("val"));
        if (null != saleOrderService.selectOne(wrapper)) {
            return R.parse(BaseRes.REPEAT).add(getComment(SaleOrder.class, String.valueOf(param.get("key"))));
        }
        return R.ok();
    }
 
    @RequestMapping(value = "/saleOrder/uploadFile/auth", method = RequestMethod.POST)
    @ManagerAuth
    public R uploadFile(@RequestParam("file") MultipartFile file,
            @RequestParam("id") Long id,
            @RequestParam("field") String field) {
        if (file.isEmpty()) {
            return R.error("文件不能为空");
        }
        try {
            // 获取文件名
            String originalFilename = file.getOriginalFilename();
            String suffix = originalFilename.substring(originalFilename.lastIndexOf("."));
            String newFileName = System.currentTimeMillis() + "_" + id + suffix;
 
            // 保存文件到D盘
            String uploadDir = "D:/upload/saleOrder/";
            File dir = new File(uploadDir);
            if (!dir.exists()) {
                dir.mkdirs();
            }
            String filePath = uploadDir + newFileName;
            file.transferTo(new File(filePath));
 
            // 返回相对路径供前端访问
            String relativePath = "/upload/saleOrder/" + newFileName;
 
            // 更新对应字段
            SaleOrder saleOrder = saleOrderService.selectById(id);
            if (saleOrder != null) {
                switch (field) {
                    case "temp1Path":
                        saleOrder.setTemp1Path(relativePath);
                        saleOrder.setTemp1Status(0); // 设为待审核
                        break;
                    case "temp2Path":
                        saleOrder.setTemp2Path(relativePath);
                        saleOrder.setTemp2Status(0); // 设为待审核
                        break;
                    case "temp3Path":
                        saleOrder.setTemp3Path(relativePath);
                        saleOrder.setTemp3Status(0); // 设为待审核
                        break;
                    case "temp4Path":
                        saleOrder.setTemp4Path(relativePath);
                        saleOrder.setTemp4Status(0); // 设为待审核
                        break;
                    case "temp5Path":
                        saleOrder.setTemp5Path(relativePath);
                        saleOrder.setTemp5Status(0); // 设为待审核
                        break;
                }
                saleOrderService.updateById(saleOrder);
            }
 
            return R.ok().add(relativePath);
        } catch (Exception e) {
            e.printStackTrace();
            return R.error("文件上传失败: " + e.getMessage());
        }
    }
 
    @RequestMapping(value = "/saleOrder/downloadFile/auth", method = RequestMethod.GET)
    // @ManagerAuth
    public void downloadFile(@RequestParam("filePath") String filePath,
            HttpServletResponse response) {
        try {
            // 获取完整文件路径 - 从D盘读取
            String fullPath = "D:" + filePath;
            File file = new File(fullPath);
 
            if (!file.exists()) {
                response.setStatus(HttpServletResponse.SC_NOT_FOUND);
                return;
            }
 
            // 获取文件名
            String fileName = file.getName();
 
            // 设置响应头
            response.setContentType("application/octet-stream");
            response.setHeader("Content-Disposition", "attachment; filename=" +
                    URLEncoder.encode(fileName, "UTF-8"));
            response.setContentLengthLong(file.length());
 
            // 输出文件流
            try (FileInputStream fis = new FileInputStream(file);
                    OutputStream os = response.getOutputStream()) {
                byte[] buffer = new byte[4096];
                int bytesRead;
                while ((bytesRead = fis.read(buffer)) != -1) {
                    os.write(buffer, 0, bytesRead);
                }
                os.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
            response.setStatus(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        }
    }
 
    @RequestMapping(value = "/saleOrder/exportExcel/auth", method = RequestMethod.GET)
    // @ManagerAuth
    public void exportExcel(HttpServletResponse response,
            @RequestParam(required = false) String order_code,
            @RequestParam(required = false) String inv_name) {
        try {
            // 查询数据
            EntityWrapper<SaleOrder> wrapper = new EntityWrapper<>();
            if (!Cools.isEmpty(order_code)) {
                wrapper.like("order_code", order_code);
            }
            if (!Cools.isEmpty(inv_name)) {
                wrapper.like("inv_name", inv_name);
            }
            List<SaleOrder> list = saleOrderService.selectList(wrapper);
 
            // 创建工作簿
            XSSFWorkbook workbook = new XSSFWorkbook();
            XSSFSheet sheet = workbook.createSheet("销售订单");
 
            // 创建样式 - 表头（只有边框）
            XSSFCellStyle headerStyle = workbook.createCellStyle();
            headerStyle.setBorderBottom(org.apache.poi.ss.usermodel.BorderStyle.THIN);
            headerStyle.setBorderTop(org.apache.poi.ss.usermodel.BorderStyle.THIN);
            headerStyle.setBorderLeft(org.apache.poi.ss.usermodel.BorderStyle.THIN);
            headerStyle.setBorderRight(org.apache.poi.ss.usermodel.BorderStyle.THIN);
 
            // 创建样式 - 普通单元格（只有边框）
            XSSFCellStyle dataStyle = workbook.createCellStyle();
            dataStyle.setBorderBottom(org.apache.poi.ss.usermodel.BorderStyle.THIN);
            dataStyle.setBorderTop(org.apache.poi.ss.usermodel.BorderStyle.THIN);
            dataStyle.setBorderLeft(org.apache.poi.ss.usermodel.BorderStyle.THIN);
            dataStyle.setBorderRight(org.apache.poi.ss.usermodel.BorderStyle.THIN);
 
            // 计算列使用相同样式
            XSSFCellStyle calcDataStyle = dataStyle;
 
            // 表头
            String[] headers = { "生产单号", "业务员", "图号", "物料名称", "规格", "订单数量", "交货日期",
                    "任务单数量", "成品数量", "出货通知数", "实出数量", "对账数量", "对账单价", "对账金额",
                    "包材版费", "退税资料", "开票", "内陆费", "收款", "应收款余额",
                    "对账数量残余", "对账金额残余", "任务单残余", "实出数量残余", "收款残余" };
            boolean[] isCalc = { false, false, false, false, false, false, false,
                    false, false, false, false, false, false, false,
                    false, false, false, false, false, false,
                    true, true, true, true, true };
 
            XSSFRow headerRow = sheet.createRow(0);
            for (int i = 0; i < headers.length; i++) {
                XSSFCell cell = headerRow.createCell(i);
                cell.setCellValue(headers[i]);
                cell.setCellStyle(headerStyle);
            }
 
            // 数据行
            int rowNum = 1;
            for (SaleOrder order : list) {
                XSSFRow row = sheet.createRow(rowNum++);
                int col = 0;
 
                // 基础字段
                createCell(row, col++, order.getOrderCode(), dataStyle);
                createCell(row, col++, order.getPersonName(), dataStyle);
                createCell(row, col++, order.getInvCode(), dataStyle);
                createCell(row, col++, order.getInvName(), dataStyle);
                createCell(row, col++, order.getInvStd(), dataStyle);
                createNumCell(row, col++, order.getOrderQty(), dataStyle);
                createCell(row, col++, order.getDeliveryDate$(), dataStyle);
                createNumCell(row, col++, order.getProductQty(), dataStyle);
                createNumCell(row, col++, order.getInQty(), dataStyle);
                createNumCell(row, col++, order.getIcsbeqty(), dataStyle);
                createNumCell(row, col++, order.getSeoseqty(), dataStyle);
                createNumCell(row, col++, order.getOutQty(), dataStyle);
                createNumCell(row, col++, order.getOutPrice(), dataStyle);
                createNumCell(row, col++, order.getOutAmount(), dataStyle);
                createCell(row, col++, order.getTemp1(), dataStyle);
                createCell(row, col++, order.getTemp2(), dataStyle);
                createCell(row, col++, order.getTemp3(), dataStyle);
                createCell(row, col++, order.getTemp4(), dataStyle);
                createCell(row, col++, order.getTemp5(), dataStyle);
                createCell(row, col++, order.getTemp8(), dataStyle);
 
                // 计算字段
                Double outQty = order.getOutQty() != null ? order.getOutQty() : 0;
                Double seoseqty = order.getSeoseqty() != null ? order.getSeoseqty() : 0;
                Double outPrice = order.getOutPrice() != null ? order.getOutPrice() : 0;
                Double productQty = order.getProductQty() != null ? order.getProductQty() : 0;
                Double inQty = order.getInQty() != null ? order.getInQty() : 0;
                Double icsbeqty = order.getIcsbeqty() != null ? order.getIcsbeqty() : 0;
                Double outAmount = order.getOutAmount() != null ? order.getOutAmount() : 0;
                Double temp5Val = 0.0;
                try {
                    temp5Val = order.getTemp5() != null ? Double.parseDouble(order.getTemp5()) : 0;
                } catch (Exception e) {
                }
 
                Double dzQtyCanYu = outQty - seoseqty; // 对账数量残余 = 对账数量-实出数量
                createNumCell(row, col++, dzQtyCanYu, calcDataStyle);
                createNumCell(row, col++, dzQtyCanYu * outPrice, calcDataStyle); // 对账金额残余 = 对账数量残余*对账单价
                createNumCell(row, col++, productQty - inQty, calcDataStyle); // 任务单残余 = 任务单数量-成品数量
                createNumCell(row, col++, seoseqty - icsbeqty, calcDataStyle); // 实出数量残余 = 实出数量-出货通知数
                createNumCell(row, col++, temp5Val - outAmount, calcDataStyle); // 收款残余 = 收款-对账金额
            }
 
            // 自动调整列宽
            for (int i = 0; i < headers.length; i++) {
                sheet.autoSizeColumn(i);
            }
 
            // 输出
            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
            response.setHeader("Content-Disposition",
                    "attachment; filename=" + URLEncoder.encode("销售订单导出.xlsx", "UTF-8"));
            workbook.write(response.getOutputStream());
            workbook.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    private void createCell(XSSFRow row, int col, String value,
            XSSFCellStyle style) {
        XSSFCell cell = row.createCell(col);
        cell.setCellValue(value != null ? value : "");
        cell.setCellStyle(style);
    }
 
    private void createNumCell(XSSFRow row, int col, Double value,
            XSSFCellStyle style) {
        XSSFCell cell = row.createCell(col);
        if (value != null) {
            cell.setCellValue(value);
        }
        cell.setCellStyle(style);
    }
 
}