blame | history | patch | commit | commitdiff | show whitespace
zyy3
2025-12-02 b967bac24b2fd662ac3b8826700fb76c26690aec 
 trading-order-admin/src/main/java/com/yami/trading/api/controller/exchange/ApiChannelBlockchainController.java


@@ -4,30 +4,36 @@


import cn.hutool.extra.qrcode.QrConfig;


import com.alibaba.fastjson.JSON;


import com.alibaba.fastjson.JSONObject;


import com.fasterxml.jackson.databind.ObjectMapper;


import com.yami.trading.UD.*;


import com.yami.trading.UD.Address;


import com.yami.trading.bean.exchange.PartyBlockchain;


import com.yami.trading.bean.model.ChannelBlockchain;


import com.yami.trading.bean.model.RechargeBlockchainOrder;


import com.yami.trading.bean.model.User;


import com.yami.trading.common.constants.Constants;


import com.yami.trading.common.constants.RedisKeys;


import com.yami.trading.common.domain.Result;


import com.yami.trading.common.exception.YamiShopBindException;


import com.yami.trading.common.util.MD5;


import com.yami.trading.common.util.StringUtils;


import com.yami.trading.security.common.util.SecurityUtils;


import com.yami.trading.service.ChannelBlockchainService;


import com.yami.trading.service.RechargeBlockchainOrderService;


import com.yami.trading.service.exchange.PartyBlockchainService;


import com.yami.trading.service.syspara.SysparaService;


import com.yami.trading.service.user.UserService;


import io.swagger.annotations.Api;


import lombok.extern.slf4j.Slf4j;


import okhttp3.*;


import okhttp3.RequestBody;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.web.bind.annotation.CrossOrigin;


import org.springframework.web.bind.annotation.GetMapping;


import org.springframework.web.bind.annotation.RequestMapping;


import org.springframework.web.bind.annotation.RestController;


import org.springframework.data.redis.core.RedisTemplate;


import org.springframework.web.bind.annotation.*;




import javax.servlet.http.HttpServletRequest;


import java.io.IOException;


import java.math.BigDecimal;


import java.util.*;


import java.util.stream.Collectors;




@@ -47,6 +53,15 @@


    UserService userService;


    @Autowired


    PartyBlockchainService partyBlockchainService;




    @Autowired


    UdunClient udunClient;




    @Autowired


    RedisTemplate redisTemplate;




    @Autowired


    RechargeBlockchainOrderService rechargeBlockchainOrderService;




    /**


     * 获取所有链地址


@@ -96,10 +111,13 @@


     * 根据币种获取链地址


     */


    @GetMapping(action + "getBlockchainName.action")


    public Object getBlockchainName(HttpServletRequest request) throws IOException {


    public Object getBlockchainName(HttpServletRequest request) {


        try {


        String coin = request.getParameter("coin");


        List<ChannelBlockchain> data = new ArrayList<ChannelBlockchain>();




        String partyId = SecurityUtils.getUser().getUserId();


            if (coin.equalsIgnoreCase("usdc")) {


                List<ChannelBlockchain> data = new ArrayList<>();


        User party = userService.getById(partyId);


        if (0 == this.sysparaService.find("can_recharge").getInteger()) {


            return Result.failed("请联系客服充值");


@@ -141,6 +159,116 @@


            }


        }


        return Result.succeed(data);


            } else {


                coin = coin.toLowerCase();


                List<ChannelBlockchain> data = new ArrayList<>();




                Map<String, List<CryptoCurrencyEnum>> allGroupedByCoin = CryptoCurrencyEnum.getAllGroupedByCoin();


                List<CryptoCurrencyEnum> currencyEnums = allGroupedByCoin.get(coin);


                List<Coin> coinList = udunClient.listSupportCoin(false);




                currencyEnums.forEach((currencyEnum) -> {


                    String coinName = currencyEnum.getName();


                    Coin c = coinList.stream().filter(x -> x.getName().equals(coinName)).findFirst().orElse(null);


                    if (c != null) {


                        ChannelBlockchain rechargeAddressVo = new ChannelBlockchain();


                        //创建地址


                        Address address;


                        String ress = (String)redisTemplate.opsForValue().get(RedisKeys.BLOCKCHAIN_ADDRESS + partyId + coinName);


                        if(StringUtils.isNotEmpty(ress)){


                            rechargeAddressVo.setAddress(ress);


                        }else{


                            address = udunClient.createAddress(c.getMainCoinType());


                            rechargeAddressVo.setAddress(address.getAddress());


                            redisTemplate.opsForValue().set(RedisKeys.BLOCKCHAIN_ADDRESS + partyId + coinName, address.getAddress());


                        }


                        //rechargeAddressVo.setAddress("test" + coinName);


                        rechargeAddressVo.setCoin(currencyEnum.getCoin());


                        rechargeAddressVo.setBlockchain_name(currencyEnum.getChain());


                        rechargeAddressVo.setAuto(false);


                        rechargeAddressVo.setImg(null);




                        //缓存订单


                        RechargeBlockchainOrder recharge = new RechargeBlockchainOrder();


                        recharge.setBlockchainName(currencyEnum.getChain());


                        recharge.setSymbol(currencyEnum.getSymbol());


                        recharge.setPartyId(partyId);


                        redisTemplate.opsForValue().set(rechargeAddressVo.getAddress(), recharge);




                        data.add(rechargeAddressVo);


                    }


                });


                return Result.succeed(data);


            }


        }catch (Exception e){


            log.error("获取充值地址错误：",e);


            return Result.failed("失败");


        }


    }




    @PostMapping(action +"rechargeCallback.action")


    public ResultMsg rechargeCallback(HttpServletRequest request){


        String timestamp = request.getParameter("timestamp");


        String nonce = request.getParameter("nonce");


        String sign = request.getParameter("sign");


        String body = request.getParameter("body");




        ResultMsg resultMsg = new ResultMsg();


        try{


            log.info("===rechargeCallback===：{}", body);


            boolean flag = udunClient.checkSign(timestamp, nonce, body, sign);


            log.info("===rechargeCallback===sign：{}", flag);




            if (!flag){


                resultMsg.setCode(406);


                resultMsg.setMessage("充值回调验签失败");


                return resultMsg;


            }


            ObjectMapper objectMapper = new ObjectMapper();


            Map<String, Object> map = objectMapper.readValue(body, HashMap.class);


            double amounts = Double.parseDouble(map.get("amount").toString());  // 假设 amount 的值为 1000


            double decimals = Double.parseDouble(map.get("decimals").toString());


            double success_amount  = amounts / Math.pow(10, decimals);


            String address = map.get("address").toString();


            Integer status = Integer.valueOf(map.get("status").toString());


            /*RechargeBlockchainOrder blockchainOrder = rechargeBlockchainOrderService.getOne(new LambdaQueryWrapper<>(RechargeBlockchainOrder.class)


                    .eq(RechargeBlockchainOrder::getSucceeded, 0)


                    .eq(RechargeBlockchainOrder::getChannelAddress, address).last(" limit 1 "));


            if(ObjectUtil.isEmpty(blockchainOrder)) {


                resultMsg.setCode(200);


                return resultMsg;


            }*/




            //查询地址订单


            RechargeBlockchainOrder blockchainOrder = (RechargeBlockchainOrder)redisTemplate.opsForValue().get(address);


            if (blockchainOrder == null){


                resultMsg.setCode(200);


                return resultMsg;


            }


            blockchainOrder.setAddress(null);


            blockchainOrder.setVolume(success_amount);


            blockchainOrder.setImg(null);


            blockchainOrder.setSucceeded(0);


            blockchainOrder.setChannelAddress(address);


            blockchainOrder.setTx("");


            rechargeBlockchainOrderService.saveOrder(blockchainOrder);


            User user = userService.getById(blockchainOrder.getPartyId());




            log.info("===rechargeCallback==d=blockchainOrder：{}", blockchainOrder);


            if (status == 3) { //交易成功


                log.info("===rechargeCallback==manualReceipt{}", blockchainOrder.getOrderNo());


                rechargeBlockchainOrderService.manualReceipt(blockchainOrder.getOrderNo(), BigDecimal.valueOf(success_amount), user.getUserName());


            } else if(status == 2) {   //驳回


                rechargeBlockchainOrderService.refusalApply(blockchainOrder.getUuid(), "订单失败：" + status, user.getUserName());


            }


            resultMsg.setCode(200);


            return resultMsg;


        }catch (Exception e){


            e.printStackTrace();


            resultMsg.setCode(500);


            resultMsg.setMessage("回调处理失败");


            return resultMsg;


        }


    }




    /**