package org.example.ssmico.demos.web.service.impl;

import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.example.ssmico.demos.web.config.RedisKeys;
import org.example.ssmico.demos.web.entity.*;
import org.example.ssmico.demos.web.mapper.*;
import org.example.ssmico.demos.web.service.SctUserSerivce;
import org.example.ssmico.demos.web.service.UserPayService;
import org.example.ssmico.demos.web.util.*;
import org.example.ssmico.demos.web.vo.UserRegisterVo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.providers.encoding.Md5PasswordEncoder;
import org.springframework.security.providers.encoding.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;
import org.springframework.web.context.WebApplicationContext;
import project.party.model.Party;
import project.user.Token;
import project.wallet.Wallet;

import java.io.Serializable;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

/**
 * @program: ssm-ico
 * @description:
 * @create: 2024-04-12 07:59
 **/
@Service
public class SctUserSerivceImpl extends ServiceImpl<SctUserMapper, SctUser> implements SctUserSerivce {

    @Autowired
    private PartyMapper partyMapper;

    @Autowired
    private SecUserMapper secUserMapper;

    @Autowired
    private RoleMapper roleMapper;

    @Autowired
    private TWalletMapper walletMapper;

    @Autowired
    private UserRecomMapper userRecomMapper;

    @Autowired
    private UserPayService userPayService;

    @Autowired
    private WebApplicationContext applicationContext;

    @Autowired
    private SysparaMapper sysparaMapper;

    @Autowired
    private TUserPayAddressMapper tUserPayAddressMapper;

    @Autowired
    private LogMapper logMapper;

    @Autowired
    private TokenMapper tokenMapper;

    @Autowired
    private SctUserRoleMapper sctUserRoleMapper;

    private Map<String, Map<String, UserData>> cache = new ConcurrentHashMap<String, Map<String, UserData>>();

    @Override
    @Transactional
    public ResultObject saveRegisterNoVerifcode(LocalNormalReg reg) {
        ResultObject resultObject = new ResultObject();
        reg.setUsername(reg.getUsername().trim());
        reg.setPassword(reg.getPassword().trim());

        if (!"null".equals(reg.getSafeword()) && StringUtils.isNotBlank(reg.getSafeword())) {
            reg.setSafeword(reg.getSafeword().trim());
        }

        Party party_reco = findPartyByUsercode(reg.getReco_usercode());

        int ever_user_level_num = find("ever_user_level_num").getInteger();
        int ever_user_level_num_custom = find("ever_user_level_num_custom").getInteger();
        PasswordEncoder passwordEncoder = new Md5PasswordEncoder();
        Party party = new Party();
        party.setUsername(reg.getUsername());
        party.setUuid(ApplicationUtil.getCurrentTimeUUID());
        party.setId(party.getUuid());
        party.setUsercode(this.getUsercode());
        party.setUser_level(ever_user_level_num_custom * 10 + ever_user_level_num);
        party.setSafeword(passwordEncoder.encodePassword(reg.getSafeword(), SaltSigureUtils.saltfigure));
        party.setRolename(Constants.SECURITY_ROLE_MEMBER);
        party.setEmail(reg.getEmail());
        party.setPhone(reg.getPhone());
        party.setEmail_authority(true);
        party.setCreateTime(new Date());

        // 十进制个位表示系统级别：1/新注册；2/邮箱谷歌手机其中有一个已验证；3/用户实名认证；4/用户高级认证；
        // 十进制十位表示自定义级别：对应在前端显示为如VIP1 VIP2等级、黄金 白银等级；
        // 如：级别11表示：新注册的前端显示为VIP1；
        int userLevel = party.getUser_level();
        party.setUser_level(((int) Math.floor(userLevel / 10)) * 10 + 2);
        partyMapper.insert(party);
        String partyString = JSON.toJSONString(party, SerializerFeature.WriteClassName);
        RedisShardedPoolUtils.set(PartyRedisKeys.PARTY_ID + party.getUuid(),partyString);
        RedisShardedPoolUtils.set(PartyRedisKeys.PARTY_USERNAME + party.getUsername(), partyString);


        Role role = findRoleByName(Constants.SECURITY_ROLE_MEMBER);

        SecUser secUser = new SecUser();
        String md5Password = passwordEncoder.encodePassword(reg.getPassword(),reg.getUsername());
        secUser.setPartyId(String.valueOf(party.getUuid()));
        secUser.setUsername(reg.getUsername());
        secUser.setPassword(md5Password);
        secUser.setEmail(reg.getEmail());
        secUser.setUuid(ApplicationUtil.getCurrentTimeUUID());
        secUser.setCreateTime(new Date());
        secUserMapper.insert(secUser);
        cascadeRole(secUser.getUuid(),role);

        // usdt账户
        Wallet wallet = new Wallet();
        wallet.setPartyId(party.getUuid());
        wallet.setUuid(ApplicationUtil.getCurrentTimeUUID());
        walletMapper.insert(wallet);

        if (party_reco != null) {
            UserRecom userRecom = new UserRecom();
            userRecom.setUuid(ApplicationUtil.getCurrentTimeUUID());
            userRecom.setPartyId(party.getUuid());
            // 父类partyId
            userRecom.setReco_id(party_reco.getUuid());
            userRecomMapper.insert(userRecom);
        }

        String uuid = UUIDGenerator.getUUID();
        String partyId = party.getUuid().toString();
        String partyRecoId = party_reco != null ? party_reco.getUuid().toString() : "";
        JdbcTemplate jdbcTemplate=applicationContext.getBean(JdbcTemplate.class);
        jdbcTemplate.execute("INSERT INTO T_USER(UUID,PARTY_ID,PARENT_PARTY_ID) VALUES('"+uuid+"','"+partyId+"','"+partyRecoId+"')");
        saveRegister(party.getUuid());

        //日志
        addLog(secUser.getPartyId(),secUser.getUsername());

        // 注册完直接登录返回token
        String token = savePut(secUser.getPartyId(),secUser.getUsername());
        resultObject.setData(token);
        return resultObject;
    }

    public void addLog(String partyId,String username){
        Log log = new Log();
        log.setUuid(ApplicationUtil.getCurrentTimeUUID());
        log.setCategory(Constants.LOG_CATEGORY_SECURITY);
        log.setLog("用户注册");
        log.setPartyId(partyId);
        log.setUsername(username);
        logMapper.insert(log);
    }

    public String savePut(String partyId,String username) {
        String s = RedisShardedPoolUtils.get(UserRedisKeys.TOKEN_PARTY_ID + partyId);
        Token token = JSONUtil.toBean(s,Token.class);
        if (token == null) {
            token = new Token();
        }
        String uuid = UUIDGenerator.getUUID();
        token.setToken(uuid);
        if(StringUtils.isBlank(token.getUuid())){
            token.setPartyId(partyId);
            token.setUuid(ApplicationUtil.getCurrentTimeUUID());
            tokenMapper.insert(token);
        }else{
            tokenMapper.update(token,new LambdaUpdateWrapper<Token>().eq(Token::getUuid,token.getUuid()));
        }
        RedisShardedPoolUtils.set(UserRedisKeys.TOKEN + uuid, partyId);
        RedisShardedPoolUtils.set(UserRedisKeys.USER_NAME + uuid, username);
        String jsonString = JSON.toJSONString(token, SerializerFeature.WriteClassName);
        RedisShardedPoolUtils.set(UserRedisKeys.TOKEN_PARTY_ID + partyId, jsonString);
        return uuid;
    }

    @Override
    public ResultObject updateUser(UserRegisterVo vo, String lang) throws Exception {
        GoogleTranslateUtil googleTranslateUtil = new GoogleTranslateUtil();
        ResultObject resultObject = new ResultObject();
//        String userId = RedisShardedPoolUtils.get("TOKEN_" + vo.getTokne());
//        userId = userId.replace("\"","");
////        String userId = "232a10b2485531e99713c66bd9ddb4e0";
//
//        Long emailCount = partyMapper.selectCount(new LambdaQueryWrapper<Party>().eq(Party::getEmail, vo.getEmail()).ne(Party::getUuid,userId));
//        if(emailCount > 0){
//            resultObject.setCode("1");
//            resultObject.setMsg(googleTranslateUtil.translate("邮箱已存在",lang));
//            return resultObject;
//        }
//
//        Long phoneCount = partyMapper.selectCount(new LambdaQueryWrapper<Party>().eq(Party::getPhone, vo.getPhone()).ne(Party::getUuid,userId));
//        if(phoneCount > 0){
//            resultObject.setCode("1");
//            resultObject.setMsg(googleTranslateUtil.translate("手机号已存在",lang));
//            return resultObject;
//        }
//
//        Party party = partyMapper.selectOne(new LambdaQueryWrapper<Party>().eq(Party::getUuid, userId));
//        if(null == party){
//            resultObject.setCode("1");
//            resultObject.setMsg(googleTranslateUtil.translate("注册失败，未找到用户",lang));
//            return resultObject;
//        }
//        party.setUsername(vo.getUsername());
//        party.setPhone(vo.getPhone());
//        party.setEmail(vo.getEmail());
//        partyMapper.update(party,new LambdaUpdateWrapper<Party>().eq(Party::getUuid,userId));
        return resultObject;
    }

    public ResultObject addUserPayAddress(String coin, String partyId,String lang) throws Exception {
        ResultObject resultObject = new ResultObject();
        Object addressData = new Object();
        ResultObject addressResult = new ResultObject();
        addressResult = userPayService.getUserRechargeAddress(coin, partyId,lang);
        if (addressResult.getCode().equals("1")) {
            log.error("获取地址错误：" + addressResult.getMsg());
            return addressResult;
        }
        addressData = addressResult.getData().toString();

        TUserPayAddress address = new TUserPayAddress();
        if (addressData != null) {
            address.setAddress(addressData.toString());
            address.setType(coin);
            address.setPartyUuid(partyId);
            address.setCreatedAt(new Date());
            address.setUpdatedAt(new Date());

            TUserPayAddress payAddress = tUserPayAddressMapper.selectOne(new LambdaQueryWrapper<TUserPayAddress>()
                    .eq(TUserPayAddress::getPartyUuid, partyId)
                    .eq(TUserPayAddress::getType, coin));

            if (payAddress == null) {
                tUserPayAddressMapper.insert(address);
                resultObject.setData(address);
            } else {
                payAddress.setAddress(addressData.toString());
                tUserPayAddressMapper.update(payAddress, new LambdaUpdateWrapper<TUserPayAddress>()
                        .eq(TUserPayAddress::getPartyUuid, partyId).eq(TUserPayAddress::getType, coin));
                resultObject.setData(payAddress);
            }
        } else {
            resultObject.setData(null);
        }

        return resultObject;
    }


    private void cascadeRole(String uuid,Role role) {
        if(null==role) return;
        sctUserRoleMapper.delete(new LambdaQueryWrapper<SctUserRole>().eq(SctUserRole::getUserUuid,uuid));
        if(ObjectUtils.isEmpty(role)) return;
        SctUserRole sctUserRole = new SctUserRole();
        sctUserRole.setUserUuid(uuid);
        sctUserRole.setROLEUUID(role.getUuid());
        sctUserRoleMapper.insert(sctUserRole);
    }

    public void saveRegister(Serializable partyId) {
        UserRecom userRecom = findByPartyId(partyId);
        if (userRecom == null) return;

        List<UserRecom> parents = getParents(userRecom.getPartyId());
        int loop = 4;
        for (int i = 0; i < parents.size(); i++) {
            Party party_parent = cachePartyBy(parents.get(i).getReco_id(), true);
            if (Constants.SECURITY_ROLE_MEMBER.equals(party_parent.getRolename()) && loop > 0) {
                UserData userData_reco = new UserData();
                userData_reco.setRolename(party_parent.getRolename());
                userData_reco.setCreateTime(new Date());
                userData_reco.setPartyId(parents.get(i).getReco_id());
                userData_reco.setReco_num(1);
                save(userData_reco);

                UserDataSum userDataSum = this.saveBySum(parents.get(i).getReco_id().toString());
                userDataSum.setReco_num(userDataSum.getReco_num() + 1);
                this.updateSum(userDataSum);
                loop--;
            }
        }
    }

    public void updateSum(UserDataSum entity) {
        ApplicationUtil.executeUpdate(entity);
    }


    /**
     * 根据partyId获取UserDataSum
     */
    public UserDataSum saveBySum(String partyId) {
        List<UserDataSum> list = ApplicationUtil.executeSelect(UserDataSum.class,"WHERE PARTY_ID=?",new Object[] {partyId});
        if (list.size()>0) return list.get(0);

        UserDataSum userDataSum = new UserDataSum();
        userDataSum.setPartyId(partyId);
        ApplicationUtil.executeInsert(userDataSum);

        return userDataSum;
    }

    public void save(UserData entity) {
        UserData db = findBydate(entity.getPartyId().toString(), entity.getCreateTime());
        if (db != null) {
            db.setRecharge_dapp(Arith.add(db.getRecharge_dapp(), entity.getRecharge_dapp()));
            db.setWithdraw_dapp(Arith.add(db.getWithdraw_dapp(), entity.getWithdraw_dapp()));

            db.setRecharge(Arith.add(db.getRecharge(), entity.getRecharge()));
            db.setRecharge_eth(Arith.add(db.getRecharge_eth(), entity.getRecharge_eth()));
            db.setRecharge_usdt(Arith.add(db.getRecharge_usdt(), entity.getRecharge_usdt()));
            db.setRecharge_usdc(Arith.add(db.getRecharge_usdc(), entity.getRecharge_usdc()));
            db.setRecharge_btc(Arith.add(db.getRecharge_btc(), entity.getRecharge_btc()));
            db.setRecharge_ht(Arith.add(db.getRecharge_ht(), entity.getRecharge_ht()));
            db.setRecharge_ltc(Arith.add(db.getRecharge_ltc(), entity.getRecharge_ltc()));
            // 充值返佣
            db.setRechargeRecom(Arith.add(db.getRechargeRecom(), entity.getRechargeRecom()));

            db.setWithdraw_all(Arith.add(db.getWithdraw_all(), entity.getWithdraw_all()));
            db.setWithdraw(Arith.add(db.getWithdraw(), entity.getWithdraw()));
            db.setWithdraw_eth(Arith.add(db.getWithdraw_eth(), entity.getWithdraw_eth()));
            db.setWithdraw_btc(Arith.add(db.getWithdraw_btc(), entity.getWithdraw_btc()));

            db.setAmount(Arith.add(db.getAmount(), entity.getAmount()));
            db.setFee(Arith.add(db.getFee(), entity.getFee()));
            db.setOrder_income(Arith.add(db.getOrder_income(), entity.getOrder_income()));
            db.setFinance_amount(Arith.add(db.getFinance_amount(), entity.getFinance_amount()));
            db.setFinance_income(Arith.add(db.getFinance_income(), entity.getFinance_income()));
            db.setExchange_amount(Arith.add(db.getExchange_amount(), entity.getExchange_amount()));
            db.setExchange_fee(Arith.add(db.getExchange_fee(), entity.getExchange_fee()));
            db.setExchange_income(Arith.add(db.getExchange_income(), entity.getExchange_income()));
            db.setCoin_income(Arith.add(db.getCoin_income(), entity.getCoin_income()));
            db.setFurtures_amount(Arith.add(db.getFurtures_amount(), entity.getFurtures_amount()));
            db.setFurtures_fee(Arith.add(db.getFurtures_fee(), entity.getFurtures_fee()));
            db.setFurtures_income(Arith.add(db.getFurtures_income(), entity.getFurtures_income()));

            db.setReco_num(db.getReco_num() + entity.getReco_num());
            db.setRecharge_withdrawal_fee(
                    Arith.add(db.getRecharge_withdrawal_fee(), entity.getRecharge_withdrawal_fee()));
            db.setGift_money(Arith.add(db.getGift_money(), entity.getGift_money()));

            db.setMiner_amount(Arith.add(db.getMiner_amount(), entity.getMiner_amount()));
            db.setMiner_income(Arith.add(db.getMiner_income(), entity.getMiner_income()));

            // 质押2.0
            db.setGalaxy_amount(Arith.add(db.getGalaxy_amount(), entity.getGalaxy_amount()));
            db.setGalaxy_income(Arith.add(db.getGalaxy_income(), entity.getGalaxy_income()));

            db.setThird_recharge_amount(Arith.add(db.getThird_recharge_amount(), entity.getThird_recharge_amount()));
            db.setHolding_money(Arith.add(db.getHolding_money(), entity.getHolding_money()));
            db.setTransfer_in_money(Arith.add(db.getTransfer_in_money(), entity.getTransfer_in_money()));
            db.setTransfer_out_money(Arith.add(db.getTransfer_out_money(), entity.getTransfer_out_money()));

            db.setExchange_lever_amount(Arith.add(db.getExchange_lever_amount(), entity.getExchange_lever_amount()));
            db.setExchange_lever_fee(Arith.add(db.getExchange_lever_fee(), entity.getExchange_lever_fee()));
            db.setExchange_lever_order_income(Arith.add(db.getExchange_lever_order_income(), entity.getExchange_lever_order_income()));

            ApplicationUtil.executeUpdate(db);
            setCache(db);
        } else {
            ApplicationUtil.executeInsert(entity);
            setCache(entity);
        }
    }
    public void setCache(UserData entity) {
        Map<String, UserData> map_party = cache.get(entity.getPartyId().toString());
        if (map_party == null) cache.put(entity.getPartyId().toString(),map_party=new ConcurrentHashMap<String,UserData>());
        map_party.put(DateUtils.format(entity.getCreateTime(), DateUtils.DEFAULT_DATE_FORMAT), entity);
    }

    private UserData findBydate(String partyId, Date date) {
        Date createTime_begin = null;
        Date createTime_end = null;
        if (date != null) {
            createTime_begin = DateUtils.toDate(DateUtils.format(date, "yyyy-MM-dd"));
            createTime_end = addDate(createTime_begin, 1);
        }

        List<UserData> list = ApplicationUtil.executeSelect(UserData.class,"WHERE PARTY_ID=? AND CREATE_TIME>=? AND CREATE_TIME<?",new Object[] {partyId,createTime_begin,createTime_end});
        return list.size()<=0?null:list.get(0);
    }
    public static Date addDate(Date date, int day) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.DAY_OF_YEAR, day);
        return calendar.getTime();
    }

    /**
     * @param partyId 用户ID
     * @param localcache 是否需要先读取本地缓存'
     * @return 用户对象
     */
    public Party cachePartyBy(Serializable partyId, boolean localcache) {
        Party party = null;
        String s = null;
        if (localcache) { //先读本地缓存，再读Redis缓存
            s = RedisShardedPoolUtils.get(PartyRedisKeys.PARTY_ID + partyId);
        } else { //仅读取Redis缓存
            s = RedisShardedPoolUtils.get(PartyRedisKeys.PARTY_ID + partyId);
        }
        party = JSONUtil.toBean(s, Party.class);
        return party;
    }

    public List<UserRecom> getParents(Serializable partyId) {
        LinkedList<UserRecom> list = new LinkedList<UserRecom>();
        if (partyId == null) return list;
        list = findParents(partyId, list);
        return list;
    }

    /**
     * 向上查找用户的祖先节点推荐树(含用户自己)
     * @param partyId 用户ID
     * @param list 推荐树节点列表
     * @return 推荐树节点列表(含用户自己)
     */
    private LinkedList<UserRecom> findParents(Serializable partyId, LinkedList<UserRecom> list) {
        if(null==partyId) return list;
        String s = RedisShardedPoolUtils.get(PartyRedisKeys.USER_RECOM_PARTYID + partyId);
        UserRecom userRecom = JSONUtil.toBean(s, UserRecom.class);
        if(null==userRecom) return list;

        list.add(userRecom);
        findParents(userRecom.getReco_id(), list);

        return list;
    }


    public UserRecom findByPartyId(Serializable partyId) {
        String s = RedisShardedPoolUtils.get(PartyRedisKeys.USER_RECOM_PARTYID + partyId);
        UserRecom bean = JSONUtil.toBean(s, UserRecom.class);
        return null==partyId?null:bean;
    }

    public SecUser findUserByPartyId(Serializable partyId) {
        if(null==partyId) return null;

        JdbcTemplate jdbcTemplate=applicationContext.getBean(JdbcTemplate.class);
        List<SecUser> users=jdbcTemplate.query("SELECT * FROM SCT_USER WHERE PARTY_UUID=?",RecordObjectMapper.newInstance(SecUser.class),partyId);

        SecUser user=null;
        if(null==users || users.isEmpty() || null==(user=users.get(0))) return null;

        return bindRoleResource(user);
    }

    public Role findRoleByName(String roleName) {
        List<Role> list = roleMapper.selectList(new LambdaQueryWrapper<Role>().eq(Role::getRoleName,roleName));
        if(null==list || list.isEmpty()) return null;
        if(list.size()>1) throw new RuntimeException("Found Duplicate Name In Role Table!");

        return list.get(0);
    }

    /**
     * 绑定资源到角色
     * @param role 角色对象
     * @return 角色对象
     */
    private static final Role bindResource(Role role) {
        if(null==role) return null;
        String whereSubStatement="WHERE UUID IN(SELECT RESOURCE_UUID FROM SCT_ROLE_RESOURCE WHERE ROLE_UUID=?)";
        List<Resource> resourceList=ApplicationUtil.executeSelect(Resource.class,whereSubStatement,new Object[] {role.getUuid()});

        if(null!=resourceList && !resourceList.isEmpty()) role.setResources(resourceList.stream().filter(res->null!=res).collect(Collectors.toSet()));
        return role;
    }

    /**
     * @param entity 用户对象
     * @return 用户对象
     */
    public Party save(Party entity) {
        if(null==entity) return null;
        JdbcTemplate jdbcTemplate=applicationContext.getBean(JdbcTemplate.class);

        entity.setCreateTime(new Date());
        if(null==entity.getUuid()) entity.setUuid(ApplicationUtil.getCurrentTimeUUID());

        Object[] jdbcParams=ApplicationUtil.getInsertStatement(entity);
        jdbcTemplate.update((String)jdbcParams[0],(Object[])jdbcParams[1]);
        return entity;
    }
    private String getUsercode() {
        Syspara syspara = find("user_uid_sequence");
        int random = (int) (Math.random() * 3 + 1);
        int user_uid_sequence = syspara.getInteger() + random;
        syspara.setValue(user_uid_sequence);
        update(syspara);
        String usercode = String.valueOf(user_uid_sequence);
        return usercode;
    }
    public void update(Syspara entity) {
        if (0==entity.getType()) return;
        sysparaMapper.update(entity,new LambdaUpdateWrapper<Syspara>().eq(Syspara::getUuid,entity.getUuid()));
    }

    /**
     * 绑定角色资源
     * @param secuser 用户对象
     */
    public final SecUser bindRoleResource(SecUser secuser) {
        if(null==secuser) return secuser;
        JdbcTemplate jdbcTemplate = applicationContext.getBean(JdbcTemplate.class);

        String roleSql="SELECT * FROM SCT_ROLE SR WHERE EXISTS (SELECT ROLE_UUID FROM SCT_USER_ROLE WHERE USER_UUID=? AND ROLE_UUID=SR.UUID)";
        List<Role> roleList=jdbcTemplate.query(roleSql, RecordObjectMapper.newInstance(Role.class), secuser.getUuid());

        if(null==roleList || roleList.isEmpty()) return secuser;
        Set<Role> roleSet=roleList.stream().filter(role->null!=role).collect(Collectors.toSet());

        String resoSql="SELECT * FROM SCT_RESOURCE SR WHERE EXISTS (SELECT RESOURCE_UUID FROM SCT_ROLE_RESOURCE WHERE ROLE_UUID=? AND RESOURCE_UUID=SR.UUID)";
        for(Role role:roleSet) {
            List<Resource> resoList=jdbcTemplate.query(resoSql, RecordObjectMapper.newInstance(Resource.class), role.getUuid());
            if(null==resoList || resoList.isEmpty()) continue;
            role.setResources(resoList.stream().filter(reso->null!=reso).collect(Collectors.toSet()));
        }

        return secuser;
    }
    public Syspara find(String code) {
        String s = RedisShardedPoolUtils.get(RedisKeys.SYSPARA_CODE + code);
        log.error("------->"+s);
        Syspara syspara = JSONUtil.toBean(s,Syspara.class);
        return null==syspara?null:syspara;
    }

    /**
     * 根据用户码获取用户
     * @param usercode 用户码
     * @return 用户对象
     */
    public Party findPartyByUsercode(String usercode) {

        LambdaQueryWrapper<Party> queryWrapper  =  Wrappers.lambdaQuery(Party.class)
                .eq(StringUtils.isNotBlank(usercode),Party::getUsercode, usercode);
        List<Party> list = partyMapper.selectList(queryWrapper);
        return list.size() > 0?list.get(0):null;
    }
}