wms / wms_guangxijianyi · 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.support.Convert;
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.domain.ReceiptContainerHeader;
import com.huaheng.pc.receipt.receiptContainerHeader.service.ReceiptContainerHeaderService;
import com.huaheng.pc.receipt.receiptHeader.domain.ReceiptHeader;
import com.huaheng.pc.receipt.receiptHeader.service.ReceiptHeaderService;
import com.huaheng.pc.shipment.shipmentHeader.domain.ShipmentHeader;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
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.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;
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;
    

    @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:
                    this.dataAnalysisReceipt(taskProcess, taskProcessRelation, obj);
                    break;
                case ProcessCode.RECEIPT_BILL_CODE:
                    this.dataAnalysisReceiptBill(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 allocationHeadId;
        if (ProcessCode.CREATE_RECEIPT_TASK.equals(taskProcessRelation.getClassName())){
            allocationHeadId = taskProcess.getClassValue();
            ReceiptContainerHeader receiptContainerHeader = receiptContainerHeaderService.getById(allocationHeadId);
            if (receiptContainerHeader == null){
                return;
            }
            LambdaQueryWrapper<ReceiptHeader> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ReceiptHeader::getOrderCode, receiptContainerHeader.getOrderCode());
            ReceiptHeader header = receiptHeaderService.getOne(queryWrapper);
            if (header == null){
                return;
            }
            taskProcess.setClassValue(String.valueOf(header.getId()));
        }
//        if (ProcessCode.RECEIPT_METHOD.equals(taskProcessRelation.getClassName())){
//            allocationHeadId = this.dataAnalysis(taskProcess, taskProcessRelation);
//            if (StringUtils.isNotEmpty(allocationHeadId)){
//                taskProcess.setClassValue(allocationHeadId);
//            }
//        }

    }

    /**解析入库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.CREATE_RECEIPT_TASK.equals(taskProcess.getClassName())){
                   this.dataAnalysisReceiptBill(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())){
                // 获取响应内容
                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("\"", "");
                List idList = Arrays.asList(Convert.toIntArray(value));
                if (idList != null && idList.size() > 0){
                    idList.forEach(item->{
                        String classValue = String.valueOf(item);
                        process.setClassValue(classValue);
                        taskProcessService.saveOrUpdate(process);
                    });
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }

}