java-insagent-pc/src/main/java/com/ydtech/aop/StringBufferContentAspect.java

package com.ydtech.aop;

import com.ydtech.modules.admin.constants.DataPermissionsEnum;
import com.ydtech.modules.admin.dao.DataPermissionsMapper;
import com.ydtech.modules.admin.model.DataPermissions;
import com.ydtech.modules.admin.model.InsRoleMenuPermissions;
import com.ydtech.modules.admin.model.InsRolePermissions;
import com.ydtech.modules.admin.model.SysUser;
import com.ydtech.modules.admin.model.dto.InsRoleMenuPermissionsDto;
import com.ydtech.modules.admin.model.dto.InsRolePermissionsDto;
import com.ydtech.modules.admin.model.vo.DataPermissionsVo;
import com.ydtech.modules.admin.service.DataPermissionsService;
import com.ydtech.modules.admin.service.InsRoleMenuPermissionsService;
import com.ydtech.modules.admin.service.InsRolePermissionsService;
import com.ydtech.modules.admin.utils.DataParams;
import com.ydtech.modules.base.controller.BaseController;
import com.ydtech.modules.inv.model.vo.InvAccountQueryVo;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Aspect
@Component
public class StringBufferContentAspect {
    @Autowired
    private HttpServletRequest request;


    @Autowired
    private DataPermissionsMapper dataPermissionsMapper;

    @Autowired
    private InsRoleMenuPermissionsService insRoleMenuPermissionsService;

    @Autowired
    private InsRolePermissionsService insRolePermissionsService;

    @Autowired
    private DataPermissionsService  dataPermissionsService;

    @Pointcut("@annotation(GetStringBufferContent)")
    public void getStringBufferContentPointcut() {
    }

    @Around("getStringBufferContentPointcut()")
    public Object aroundGetStringBufferContent(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取HttpServletRequest并添加空指针检查（这里假设已经在Spring配置中正确注入了HttpServletRequest，实际可能需要进一步处理注入问题）
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        if (attributes == null) {
            throw new IllegalStateException("无法获取ServletRequestAttributes");
        }
        HttpServletRequest request = attributes.getRequest();
        if (request == null) {
            throw new IllegalStateException("无法获取HttpServletRequest");
        }
        String string = request.getRequestURL().toString();
        URI uri = new URI(string);
        String path = uri.getPath();

        DataParams invAccountQueryVo = (DataParams) joinPoint.getArgs()[0];
        // 假设这里通过某种业务逻辑生成了stringBufferContent的值
        this.buildStringBufferBasedOnDataPermissions(path, invAccountQueryVo);

        // 继续执行被注解标注的方法或类的原有逻辑e
        return joinPoint.proceed();
    }

    private void buildStringBufferBasedOnDataPermissions(String path, DataParams invAccountQueryVo) {
        StringBuilder stringBuffer = new StringBuilder();
        List<DataPermissions> operatorList = dataPermissionsMapper.getByPath(path);

        List<DataPermissions> cheList = this.checkData(operatorList);
        if(!cheList.isEmpty()){
            Map<String, List<DataPermissions>> groupedMap = cheList.stream()
                    .collect(Collectors.groupingBy(DataPermissions::getRuleField));
            if (operatorList.size() == 1) {

                handleSingleDataPermission(cheList.get(0), stringBuffer, invAccountQueryVo);
            } else {
                handleMultipleDataPermissions(groupedMap, stringBuffer, invAccountQueryVo);
            }
        }
    }

    /**
     * @param operatorList
     * @return 校验数据
     */
    private List<DataPermissions> checkData(List<DataPermissions> operatorList) {
        SysUser user = BaseController.getUser();
        String roleId = user.getRoleId();  // 角色id

        // 提取该接口配置的菜单id列表，去重
        List<String> menuIdList = operatorList.stream()
                .map(DataPermissions::getMenuId)
                .distinct()
                .collect(Collectors.toList());

        if (menuIdList.isEmpty()) {
            // 如果没有配置菜单，直接返回空的DataPermissions列表
            return new ArrayList<DataPermissions>();
        }

        // 创建用于查询角色菜单权限的对象，在循环中只需设置具体属性即可
        InsRoleMenuPermissionsDto insRoleMenuPermissionsDto = new InsRoleMenuPermissionsDto();
        insRoleMenuPermissionsDto.setRoleId(roleId);

        // 创建用于查询角色权限的对象，同样在循环中设置具体属性
        InsRolePermissionsDto insRolePermissionsDto = new InsRolePermissionsDto();
        insRolePermissionsDto.setRoleId(roleId);

        for (String menuId : menuIdList) {
            // 设置当前循环中菜单id到相应查询对象中
            insRoleMenuPermissionsDto.setMenuId(menuId);
            insRolePermissionsDto.setMenuId(menuId);

            // 通过角色id和菜单id查询是否配置了该菜单权限
            List<InsRoleMenuPermissionsDto> roleMenuPermissionsList = insRoleMenuPermissionsService.getRoleMenuPermissionsList(insRoleMenuPermissionsDto);
            if (!roleMenuPermissionsList.isEmpty()) {
                // 如果存在该菜单权限，则查询该角色下的权限规则有哪些
                List<InsRolePermissions> InsRolePermissionsServiceList = insRolePermissionsService.getInsRolePermissionsServiceList(insRolePermissionsDto);
                if (!InsRolePermissionsServiceList.isEmpty()) {
                    List<String> permissionsList = InsRolePermissionsServiceList.stream()
                            .map(InsRolePermissions::getPermissionsId)
                            .collect(Collectors.toList());

                    DataPermissionsVo dataPermissionsVo = new DataPermissionsVo();
                    dataPermissionsVo.setPermissionsList(permissionsList);
                    // 执行查询并返回结果，一旦找到符合条件的权限并查询到对应数据权限，直接返回
                    return dataPermissionsService.queryList(dataPermissionsVo);
                }
            }
        }
        // 如果遍历完所有菜单都没有符合条件的权限，返回空的DataPermissions列表
        return new ArrayList<DataPermissions>();
    }
    private void handleSingleDataPermission(DataPermissions dataPermissions, StringBuilder stringBuffer,
                                            DataParams invAccountQueryVo) {
        HashMap<String, String> sqlMap = new HashMap<>();
        String ruleCondition = dataPermissions.getRuleCondition();
        String descByCode = DataPermissionsEnum.getDescByCode(ruleCondition);
        String ruleField = dataPermissions.getRuleField();
        String ruleValue = dataPermissions.getRuleValue();

        sqlMap.put(ruleField, ruleValue);
        buildStringBuffer(stringBuffer, ruleField, descByCode, ruleValue);

        invAccountQueryVo.setStringBufferContent(stringBuffer.toString());
        invAccountQueryVo.setStringBufferContentMap(sqlMap);
    }

    private void handleMultipleDataPermissions(Map<String, List<DataPermissions>> groupedMap, StringBuilder stringBuffer, DataParams invAccountQueryVo) {
        HashMap<String, String> sqlMap = new HashMap<>();
        for (Map.Entry<String, List<DataPermissions>> entry : groupedMap.entrySet()) {
            List<DataPermissions> dataPermissionsList = entry.getValue();
            int index = 0;
            for (DataPermissions dataPermissions : dataPermissionsList) {
                String ruleCondition = dataPermissions.getRuleCondition();
                String descByCode = DataPermissionsEnum.getDescByCode(ruleCondition);
                String ruleField = dataPermissions.getRuleField();
                String ruleValue = dataPermissions.getRuleValue();
                StringBuilder stringBuilder = new StringBuilder();
                if(ruleValue.contains(",")){
                    String[] split = ruleValue.split(",");
                    int  indexNumber  =0;
                    for (String s : split) {
                        stringBuilder.append("'").append(s).append("'").append(",");
                        indexNumber++;
                    }
                    stringBuilder.deleteCharAt(stringBuilder.length() - 1);
                    ruleValue =stringBuilder.toString();

                }
                if (index >= 1) {
                    sqlMap.put(ruleField + index, ruleValue);
                } else {
                    sqlMap.put(ruleField, ruleValue);
                }
                buildStringBuffer(stringBuffer, ruleField, descByCode, ruleValue, index);
                index++;
            }
        }
        invAccountQueryVo.setStringBufferContent(stringBuffer.toString());
    }

    private void buildStringBuffer(StringBuilder stringBuffer, String ruleField, String descByCode, String ruleValue) {
        buildStringBuffer(stringBuffer, ruleField, descByCode, ruleValue, 0);
    }

    private void buildStringBuffer(StringBuilder stringBuffer, String ruleField, String descByCode, String ruleValue, int index) {
        // 根据索引构建用于从map取值的键
        String mapValueKey = index >= 1 ? ruleField + index : ruleField;
        // 构建公共的SQL语句前缀部分
        String commonSqlPrefix = String.format(" and %s %s", ruleField, descByCode);
        String sqlFragment;
        if (descByCode.contains("in")) {
            if(!ruleValue.contains(",")){
                sqlFragment = commonSqlPrefix + " ('"+ruleValue+"') ";

            }else {
                // 如果是in的情况，添加括号包裹map取值部分
                sqlFragment = commonSqlPrefix + " ("+ruleValue+") ";
            }
        } else {
            // 其他情况直接拼接map取值部分
            sqlFragment = commonSqlPrefix +  " '"+ruleValue+"' ";
        }
        stringBuffer.append(sqlFragment);
    }
}