日志

liujie

2026-05-12 76b3532393aa98c2daaeb67caeefa2ab9556e866

 xp-robotaxi-operation-boot/src/main/java/com/xiaopeng/operation/service/impl/XpWhitelistServiceImpl.java

@@ -2,6 +2,7 @@

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.PhoneUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.dto.account.UcUserInfo;
import com.xiaopeng.api.feignClient.account.UserResourcesClient;
@@ -10,6 +11,7 @@
import com.xiaopeng.api.model.operation.XpWhitelistOperlog;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.utils.SensitiveDataCryptoUtil;
import com.xiaopeng.common.core.utils.ip.IpUtils;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.operation.constant.I18nKeyConstant;
@@ -25,6 +27,7 @@
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.io.Serializable;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
@@ -48,15 +51,19 @@

    @Override
    public PageInfo<XpWhitelist> pageList(WhitelistPageListQuery query) {
        query.setAccountQueryValues(SensitiveDataCryptoUtil.queryValues(query.getAccount()));
        PageInfo<XpWhitelist> pageInfo = new PageInfo<>(query.getPageNum(),query.getPageSize());
        List<XpWhitelist> list = this.baseMapper.pageList(pageInfo,query);
        decryptWhitelistAccounts(list);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<XpWhitelist> exportList(WhitelistPageListQuery query) {
        query.setAccountQueryValues(SensitiveDataCryptoUtil.queryValues(query.getAccount()));
        List<XpWhitelist> list = this.baseMapper.exportList(query);
        decryptWhitelistAccounts(list);
        return list;
    }

@@ -115,13 +122,16 @@

        Set<String> existsAccounts = new HashSet<>();
        if (CollUtil.isNotEmpty(candidates)) {
            existsAccounts = this.lambdaQuery()
            Set<String> existsStoredAccounts = this.lambdaQuery()
                    .select(XpWhitelist::getAccount)
                    .in(XpWhitelist::getAccount, candidates)
                    .in(XpWhitelist::getAccount, buildQueryValues(candidates))
                    .list()
                    .stream()
                    .map(XpWhitelist::getAccount)
                    .filter(StringUtils::hasLength)
                    .collect(Collectors.toSet());
            existsAccounts = existsStoredAccounts.stream()
                    .map(SensitiveDataCryptoUtil::decryptIfPossible)
                    .collect(Collectors.toSet());
        }

@@ -132,7 +142,7 @@
                continue;
            }
            XpWhitelist xpWhitelist = new XpWhitelist();
            xpWhitelist.setAccount(account);
            xpWhitelist.setAccount(SensitiveDataCryptoUtil.encrypt(account));
            xpWhitelist.setNickName(userMap.get(account).getNickName());
            xpWhitelist.setAppUserId(userMap.get(account).getUid());
            xpWhitelist.setStatus(true);
@@ -165,7 +175,7 @@
        StringBuilder operationContent = new StringBuilder("新增账号:");
        StringBuilder accountBuilder = new StringBuilder();
        for (XpWhitelist item : addList) {
            accountBuilder.append("\"").append(item.getAccount()).append("\"").append(",");
            accountBuilder.append("\"").append(SensitiveDataCryptoUtil.decryptIfPossible(item.getAccount())).append("\"").append(",");
        }
        if (accountBuilder.length() > 0) {
            operationContent.append(accountBuilder.substring(0, accountBuilder.length() - 1));
@@ -257,13 +267,14 @@
        }
        UcUserInfo userByAccount = this.getUserByAccount(dto.getAccount());
        XpWhitelist old = this.lambdaQuery()
                .eq(XpWhitelist::getAccount, dto.getAccount())
                .in(XpWhitelist::getAccount, SensitiveDataCryptoUtil.queryValues(dto.getAccount()))
                .ne(XpWhitelist::getId, dto.getId())
                .last("limit 1").one();
        if (old != null) {
            return R.fail("该账号已存在");
        }
        XpWhitelist whitelist = this.getById(dto.getId());
        whitelist.setAccount(SensitiveDataCryptoUtil.decryptIfPossible(whitelist.getAccount()));

        whitelist.setAppUserId(userByAccount.getUid());

@@ -310,7 +321,7 @@
        xpWhitelistOperlogMapper.insert(xpWhitelistOperlog);
        whitelist.setNickName(dto.getNickName());
        whitelist.setIsPriorityDispatch(dto.getIsPriorityDispatch());
        whitelist.setAccount(dto.getAccount());
        whitelist.setAccount(SensitiveDataCryptoUtil.encrypt(dto.getAccount()));
        whitelist.setStatus(dto.getStatus());
        this.updateById(whitelist);
        return R.ok();
@@ -319,6 +330,7 @@
    @Override
    public R freezeUnfreeze(Long id, SysUser sysUser) {
        XpWhitelist whitelist = this.getById(id);
        whitelist.setAccount(SensitiveDataCryptoUtil.decryptIfPossible(whitelist.getAccount()));
        StringBuilder operationContent = new StringBuilder("编辑账号:"+"\""+whitelist.getAccount()+"\"");
        StringBuilder accountBuilder = new StringBuilder();
        accountBuilder.append("状态" + "\"" + (whitelist.getIsPriorityDispatch() ? "正常" : "冻结") + "\"" + "为" + "\"" + (!whitelist.getIsPriorityDispatch() ? "正常" : "冻结") + "\"");
@@ -339,7 +351,9 @@
    @Override
    public R deleteByIds(List<Long> ids, SysUser sysUser) {
        List<String> accounts = this.lambdaQuery().in(XpWhitelist::getId, ids).list()
                .stream().map(XpWhitelist::getAccount).collect(Collectors.toList());
                .stream().map(XpWhitelist::getAccount)
                .map(SensitiveDataCryptoUtil::decryptIfPossible)
                .collect(Collectors.toList());
        this.removeBatchByIds(ids);
        StringBuilder operationContent = new StringBuilder("删除账号:");
        StringBuilder accountBuilder = new StringBuilder();
@@ -384,6 +398,116 @@
    @Override
    public List<String> getAllWhiteList() {
        return lambdaQuery().select(XpWhitelist::getAccount).list()
                .stream().map(XpWhitelist::getAccount).collect(Collectors.toList());
                .stream().map(XpWhitelist::getAccount)
                .map(SensitiveDataCryptoUtil::decryptIfPossible)
                .collect(Collectors.toList());
    }

    private static List<String> buildQueryValues(Collection<String> plainValues) {
        Set<String> values = new LinkedHashSet<>();
        if (plainValues == null) {
            return new ArrayList<>();
        }
        for (String plainValue : plainValues) {
            if (StringUtils.hasLength(plainValue)) {
                values.addAll(SensitiveDataCryptoUtil.queryValues(plainValue));
            }
        }
        return new ArrayList<>(values);
    }

    private static void decryptWhitelistAccounts(List<XpWhitelist> list) {
        if (CollUtil.isEmpty(list)) {
            return;
        }
        for (XpWhitelist item : list) {
            item.setAccount(SensitiveDataCryptoUtil.decryptIfPossible(item.getAccount()));
        }
    }

    @Override
    public XpWhitelist getById(Serializable id) {
        XpWhitelist whitelist = super.getById(id);
        decryptWhitelistAccount(whitelist);
        return whitelist;
    }

    @Override
    public boolean save(XpWhitelist entity) {
        encryptWhitelistAccount(entity);
        try {
            return super.save(entity);
        } finally {
            decryptWhitelistAccount(entity);
        }
    }

    @Override
    public boolean saveBatch(Collection<XpWhitelist> entityList) {
        if (entityList != null) {
            entityList.forEach(this::encryptWhitelistAccount);
        }
        try {
            return super.saveBatch(entityList);
        } finally {
            decryptWhitelistAccounts(entityList);
        }
    }

    @Override
    public boolean updateById(XpWhitelist entity) {
        encryptWhitelistAccount(entity);
        try {
            return super.updateById(entity);
        } finally {
            decryptWhitelistAccount(entity);
        }
    }

    @Override
    public boolean updateBatchById(Collection<XpWhitelist> entityList) {
        if (entityList != null) {
            entityList.forEach(this::encryptWhitelistAccount);
        }
        try {
            return super.updateBatchById(entityList);
        } finally {
            decryptWhitelistAccounts(entityList);
        }
    }

    @Override
    public List<XpWhitelist> list(Wrapper<XpWhitelist> queryWrapper) {
        List<XpWhitelist> list = super.list(queryWrapper);
        decryptWhitelistAccounts(list);
        return list;
    }

    @Override
    public List<XpWhitelist> list() {
        List<XpWhitelist> list = super.list();
        decryptWhitelistAccounts(list);
        return list;
    }

    private void encryptWhitelistAccount(XpWhitelist whitelist) {
        if (whitelist != null) {
            whitelist.setAccount(SensitiveDataCryptoUtil.encrypt(whitelist.getAccount()));
        }
    }

    private static void decryptWhitelistAccount(XpWhitelist whitelist) {
        if (whitelist != null) {
            whitelist.setAccount(SensitiveDataCryptoUtil.decryptIfPossible(whitelist.getAccount()));
        }
    }

    private void decryptWhitelistAccounts(Collection<XpWhitelist> list) {
        if (CollUtil.isEmpty(list)) {
            return;
        }
        for (XpWhitelist item : list) {
            decryptWhitelistAccount(item);
        }
    }
}