wms / wms_changshushengyi · Files

package com.huaheng.framework.aspectj;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huaheng.common.utils.ServletUtils;
import com.huaheng.common.utils.StringUtils;
import com.huaheng.framework.aspectj.lang.annotation.ProcessTrack;
import com.huaheng.framework.aspectj.lang.constant.ProcessCode;
import com.huaheng.framework.web.domain.AjaxResult;
import com.huaheng.framework.web.domain.RetCode;
import com.huaheng.pc.monitor.process.domain.TaskProcess;
import com.huaheng.pc.monitor.process.domain.TaskProcessRelation;
import com.huaheng.pc.monitor.process.service.TaskProcessRelationService;
import com.huaheng.pc.monitor.process.service.TaskProcessService;
import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.sap.domain.Zarsh;
import com.huaheng.pc.sap.service.ZarshService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.CodeSignature;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.servlet.http.HttpServletResponse;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 任务过程追踪处理
 *
 * @author xcq
 */

@Aspect
@Component
@EnableAsync
@Order(0)
public class TaskProcessAspect {

    private static TaskProcessRelationService taskProcessRelationService;

    private static TaskProcessService taskProcessService;

    private static ReceiptContainerHeaderService receiptContainerHeaderService;

    private static ReceiptHeaderService receiptHeaderService;

    private static ZarshService zarshService;

    @Autowired
    public void setZarshService(ZarshService zarshService) {
        TaskProcessAspect.zarshService = zarshService;
    }

    @Autowired
    public void setReceiptHeaderService(ReceiptHeaderService receiptHeaderService) {
        TaskProcessAspect.receiptHeaderService = receiptHeaderService;
    }

    @Autowired
    public void setTaskProcessRelationService(TaskProcessRelationService processRelationService) {
        TaskProcessAspect.taskProcessRelationService = processRelationService;
    }


    @Autowired
    public void setTaskProcessService(TaskProcessService processService) {
        TaskProcessAspect.taskProcessService = processService;
    }

    @Autowired
    public void setReceiptContainerHeaderService(ReceiptContainerHeaderService receiptContainerHeaderService) {
        TaskProcessAspect.receiptContainerHeaderService = receiptContainerHeaderService;
    }


    /**
     * 配置织入点
     **/
    @Pointcut("@annotation(com.huaheng.framework.aspectj.lang.annotation.ProcessTrack)")
    public void processPointCut() {
    }


    @Around("processPointCut()  && @annotation(processTrack)")
    public Object around(ProceedingJoinPoint point, ProcessTrack processTrack) throws Throwable {
        return this.head(point, processTrack);
    }


    /**
     * 日志追踪调用处理头部
     **/
    private Object head(ProceedingJoinPoint point, ProcessTrack process) throws Throwable {

        TaskProcess taskProcess;
        Object obj = null;
        TaskProcessRelation taskProcessRelation;
        taskProcessRelation = this.getTaskProcessRelation(process, point);
        taskProcess = this.iniTaskProcess(process, point, taskProcessRelation);
        try {
            obj = point.proceed();
        } catch (Exception e) {
            this.errDealWith(taskProcess, e);
            if (obj == null) {
                obj = AjaxResult.error(e.getMessage());
            }
            throw e;
        } finally {
            if (taskProcessRelation != null && StringUtils.isEmpty(taskProcess.getClassValue())) {
                this.getClassValue(taskProcess, taskProcessRelation, obj);
            }
            finishProcess(taskProcess, obj);
        }
        return obj;
    }


    private void getClassValue(TaskProcess taskProcess, TaskProcessRelation taskProcessRelation, Object obj) {
        try {
            switch (taskProcessRelation.getCode()) {
                case ProcessCode.RECEIPT_TASK_CODE:
                case ProcessCode.SHIPMENT_TASK_CODE:
                case ProcessCode.AGV_TASK_CODE:
                    this.dataAnalysisReceipt(taskProcess, taskProcessRelation, obj);
                    break;
                case ProcessCode.RECEIPT_BILL_CODE:
                    this.dataAnalysisReceiptBill(taskProcess, taskProcessRelation);
                    break;
                case ProcessCode.AGV_TASK_CREATED:
                    this.dataAnalysisAGVTaskCreated(taskProcess, taskProcessRelation);
                    break;
                case ProcessCode.SHIPMENT_BILL_CODE:
                    this.dataAnalysisShipmentBill(taskProcess, taskProcessRelation, obj);
                    break;
                default:
                    break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 解析出库单据key值
     *
     * @param taskProcess
     * @param taskProcessRelation
     * @param obj
     */
    private void dataAnalysisShipmentBill(TaskProcess taskProcess, TaskProcessRelation taskProcessRelation, Object obj) {
        //  从请求结果取value
        if (ProcessCode.METHOD_RESULT.equals(taskProcessRelation.getMethodCode()) && obj.getClass() == AjaxResult.class) {
            AjaxResult ajaxResult = ((AjaxResult<?>) obj);
            List<ShipmentHeader> shipmentHeaderList = (List<ShipmentHeader>) ajaxResult.getData();
            if (shipmentHeaderList.size() != 0) {
                List<Integer> strings = shipmentHeaderList.stream().map(ShipmentHeader::getId).collect(Collectors.toList());
                taskProcess.setClassValue(String.valueOf(strings));
            }
        }
        if (ProcessCode.METHOD_HEAD.equals(taskProcessRelation.getMethodCode())) {
            String json = taskProcess.getRequestBody();
            if (json != null && ProcessCode.MODIFICATION_EDIT.equals(taskProcessRelation.getClassName())) {
                ShipmentHeader header = JSON.parseObject(json, ShipmentHeader.class);
                if (header != null) {
                    taskProcess.setClassValue(String.valueOf(header.getId()));
                    return;
                }
            }
            if (ProcessCode.REVIEW.equals(taskProcessRelation.getClassName())) {
                taskProcess.setClassValue(json);
            }
            if (ProcessCode.PUSH_SALES_DELIVERY.equals(taskProcessRelation.getClassName())) {
                String value = this.dataAnalysis(taskProcess, taskProcessRelation);
                if (StringUtils.isNotEmpty(value)) {
                    taskProcess.setClassValue(value);
                }
            }

        }
    }

    /**
     * 解析入库单据key值
     *
     * @param taskProcess
     * @param taskProcessRelation
     */
    private void dataAnalysisReceiptBill(TaskProcess taskProcess, TaskProcessRelation taskProcessRelation) {
        //入库或出库组盘头ID
        String referCode;
        if (ProcessCode.SAVE_RECEIPT_HEADER_BY_SAP.equals(taskProcessRelation.getClassName())) {
            referCode = taskProcess.getClassValue();
            Zarsh zarsh = zarshService.getZarshByUnique(referCode);
            if (zarsh == null) {
                return;
            }
            taskProcess.setClassValue(zarsh.getUniqueId());
        }
//        if (ProcessCode.RECEIPT_METHOD.equals(taskProcessRelation.getClassName())){
//            allocationHeadId = this.dataAnalysis(taskProcess, taskProcessRelation);
//            if (StringUtils.isNotEmpty(allocationHeadId)){
//                taskProcess.setClassValue(allocationHeadId);
//            }
//        }

    }

    private void dataAnalysisAGVTaskCreated(TaskProcess taskProcess, TaskProcessRelation taskProcessRelation){
        //入库或出库组盘头ID
        String referCode;
        if (ProcessCode.AGV_TASK_CREATED.equals(taskProcessRelation.getClassName())) {
            referCode = taskProcess.getClassValue();
            Zarsh zarsh = zarshService.getZarshByUnique(referCode);
            if (zarsh == null) {
                return;
            }
            taskProcess.setClassValue(zarsh.getUniqueId());
        }

        if (ProcessCode.AGV_TASK_CREATED.equals(taskProcessRelation.getClassName())) {
            String value = this.dataAnalysis(taskProcess, taskProcessRelation);
            if (StringUtils.isNotEmpty(value)) {
                taskProcess.setClassValue(value);
            }
        }
    }

    /**
     * 解析入库key值
     **/
    private void dataAnalysisReceipt(TaskProcess taskProcess, TaskProcessRelation taskProcessRelation, Object obj) {
        try {
            //  从请求结果取value
            if (ProcessCode.METHOD_RESULT.equals(taskProcessRelation.getMethodCode())) {
                AjaxResult ajaxResult = ((AjaxResult<?>) obj);
                taskProcess.setClassValue(ajaxResult.getData().toString());
            }
            //  从请求头取value
            if (ProcessCode.METHOD_HEAD.equals(taskProcessRelation.getMethodCode())) {
                String value = this.dataAnalysis(taskProcess, taskProcessRelation);
                taskProcess.setClassValue(value);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    private String dataAnalysis(TaskProcess taskProcess, TaskProcessRelation taskProcessRelation) {
        try {
            String body = taskProcess.getRequestBody();
            Map map = JSON.parseObject(body);
            String value = null;
            if (map != null) {
                value = String.valueOf(map.get(taskProcessRelation.getClassKey()));
            }
            return value;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    private void errDealWith(TaskProcess process, Exception exception) {
        try {
            // 错误信息
            process.setResponseBody(exception.getMessage());
            process.setState(String.valueOf(RetCode.FAIL.getValue()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取参数名和参数值
     *
     * @param proceedingJoinPoint
     * @return
     */
    public String getParam(ProceedingJoinPoint proceedingJoinPoint) {
        Map<String, Object> map = new HashMap<>();
        Object[] values = proceedingJoinPoint.getArgs();
        String[] names = ((CodeSignature) proceedingJoinPoint.getSignature()).getParameterNames();
        for (int i = 0; i < names.length; i++) {
            map.put(names[i], values[i]);
        }
        return JSONObject.toJSONString(map);
    }


    private TaskProcess iniTaskProcess(ProcessTrack process, ProceedingJoinPoint point, TaskProcessRelation relation) {
        TaskProcess taskProcess = new TaskProcess();
        try {
            // 请求时间
            taskProcess.setRequestTime(new Date());
            // 获取流程编码
            taskProcess.setProcessRelationCode(process.processCode());
            // 获取任务名称
            taskProcess.setTaskName(process.taskName());
            // 获取执行的方法名
            MethodSignature signature = (MethodSignature) point.getSignature();
            taskProcess.setClassName(signature.getName());
            // 接口调用方
            taskProcess.setRequestFrom(process.from());
            String body = this.getParam(point);
            taskProcess.setRequestBody(body);
            if (ProcessCode.METHOD_HEAD.equals(relation.getMethodCode())) {
                String value = getSpecifiedParameters(point, relation.getClassKey());
                taskProcess.setClassValue(value);
                if (ProcessCode.SAVE_RECEIPT_HEADER_BY_SAP.equals(taskProcess.getClassName())) {
                    this.dataAnalysisReceiptBill(taskProcess, relation);
                }
                if(ProcessCode.AGV_TASK_CREATED.equals(taskProcess.getClassName())){
                    this.dataAnalysisAGVTaskCreated(taskProcess, relation);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return taskProcess;
    }

    private String getSpecifiedParameters(ProceedingJoinPoint point, String key) {
        String value = null;
        Object[] values = point.getArgs();
        String[] names = ((CodeSignature) point.getSignature()).getParameterNames();
        for (int i = 0; i < names.length; i++) {
            if (key.equals(names[i])) {
                value = String.valueOf(values[i]);
                break;
            }
        }
        if (StringUtils.isEmpty(value)) {
            for (int i = 0; i < values.length; i++) {
                String str = JSONObject.toJSONString(values[i]);
                if (StringUtils.isNotEmpty(value)) {
                    return value;
                }
                Map<String, String> map = (Map) JSON.parse(str);
                value = String.valueOf(map.get(key));
            }
        }
        return value;
    }

    private TaskProcessRelation getTaskProcessRelation(ProcessTrack process, ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        // 根据请求编码和方法查询流程关系
        LambdaQueryWrapper<TaskProcessRelation> queryWrapper = Wrappers.lambdaQuery();
        queryWrapper.eq(TaskProcessRelation::getCode, process.processCode())
                .eq(TaskProcessRelation::getClassName, signature.getName());
        TaskProcessRelation taskProcessRelation;
        try {
            taskProcessRelation = taskProcessRelationService.getOne(queryWrapper);
        } catch (Exception e) {
            return null;
        }
        return taskProcessRelation;
    }


    private void finishProcess(TaskProcess process, Object obj) {
        try {
            if (StringUtils.isEmpty(process.getState()) && obj != null) {
                // 获取响应内容
                process.setResponseBody(JSONObject.toJSON(obj).toString());
                // 获取响应状态
                HttpServletResponse resp = ServletUtils.getResponse();
                process.setState(String.valueOf(resp.getStatus()));
            }
            if (obj != null) {
                if (StringUtils.isEmpty(process.getResponseBody())) {
                    // 获取响应内容
                    process.setResponseBody((obj).toString());
                }
                if (obj instanceof AjaxResult) {
                    int retCode = ((AjaxResult) obj).getCode();
                    process.setState(String.valueOf(retCode));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            saveTaskProcess(process);
        }
    }

    @Async
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void saveTaskProcess(TaskProcess process) {
        try {
            String value = process.getClassValue();
            if (StringUtils.isNotEmpty(value)) {
                value = value.replace("\"", "");
                process.setClassValue(value);
                taskProcessService.saveOrUpdate(process);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

}