微信强授权/后台管理

admin

2024-06-30 b6fdf185c7e8fb1f06da0e609e39aecaef6b66f5

 src/main/java/com/taoke/autopay/service/impl/KeyOrderServiceImpl.java

@@ -1,18 +1,23 @@
package com.taoke.autopay.service.impl;

import com.taoke.autopay.dao.KeyOrderMapper;
import com.taoke.autopay.dao.WxUserSettingsMapper;
import com.taoke.autopay.entity.KeyOrder;
import com.taoke.autopay.entity.OrderCountTypeEnum;
import com.taoke.autopay.entity.OrderDistributeCountInfo;
import com.taoke.autopay.entity.WxUserSettings;
import com.taoke.autopay.exception.KeyOrderException;
import com.taoke.autopay.exception.WxOrderCountException;
import com.taoke.autopay.factory.OrderFactory;
import com.taoke.autopay.service.KeyOrderService;
import com.taoke.autopay.service.WxUserOrderCountService;
import com.taoke.autopay.service.WxUserSettingService;
import com.taoke.autopay.utils.TimeUtil;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.*;

/**
 * @author hxh
@@ -26,26 +31,41 @@
    @Resource
    private KeyOrderMapper keyOrderMapper;

    @Resource
    private WxUserSettingService wxUserSettingService;

    @Resource
    private WxUserOrderCountService wxUserOrderCountService;


    @Override
    public KeyOrder selectById(String id) {
        return keyOrderMapper.selectById(id);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public KeyOrder addKeyOrder(String key) throws KeyOrderException {
        String id =   OrderFactory.createId(key);
        KeyOrder order =   keyOrderMapper.selectById(id);
        if(order!=null){
           throw  new KeyOrderException("请勿重复提交口令");
    public KeyOrder addKeyOrder(String key, Long uid, String day) throws KeyOrderException, WxOrderCountException {
        // 判断提交次数是否过量
        if (uid != null) {
            WxUserSettings settings = wxUserSettingService.selectByUid(uid);
            wxUserOrderCountService.addOrderCount(uid, OrderCountTypeEnum.SUBMIT_TOKEN_COUNT, day, 1, settings.getTotalOrderCountPerDay());
        }
        order =new KeyOrder();
        String id = OrderFactory.createId(key);
        KeyOrder order = keyOrderMapper.selectById(id);
        if (order != null) {
            throw new KeyOrderException("请勿重复提交口令");
        }
        order = new KeyOrder();
        order.setId(id);
        order.setKey(key);
        order.setUid(uid);
        order.setState(KeyOrder.STATE_NOT_PROCESS);
        order.setStateDesc("尚未处理");
        order.setCreateTime(new Date());
        keyOrderMapper.insertSelective(order);


        return order;
    }

@@ -67,12 +87,32 @@

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void setOrderInfo(String id,String orderNo, int orderState)  throws  KeyOrderException{
    public void paySuccess(String id, String stateDesc,String day) throws WxOrderCountException {
        KeyOrder old = keyOrderMapper.selectByPrimaryKeyForUpdate(id);
        if(old==null){
           return;
        }
        if(old.getState() == KeyOrder.STATE_PAY){
            return;
        }
        if(old.getUid()!=null) {
            wxUserOrderCountService.addOrderCount(old.getUid(),OrderCountTypeEnum.DY_ORDER_PAY,day,1,null);
        }
        KeyOrder orderUpdate = new KeyOrder();
        orderUpdate.setId(id);
        orderUpdate.setState(KeyOrder.STATE_PAY);
        orderUpdate.setStateDesc(stateDesc);
        update(orderUpdate);
    }

    @Transactional(rollbackFor = Exception.class)
    @Override
    public void setOrderInfo(String id, String orderNo, int orderState) throws KeyOrderException {
        KeyOrder old = keyOrderMapper.selectByPrimaryKeyForUpdate(id);
        if (old == null) {
           throw new  KeyOrderException("口令不存在");
            throw new KeyOrderException("口令不存在");
        }
        KeyOrder keyOrder=new KeyOrder();
        KeyOrder keyOrder = new KeyOrder();
        keyOrder.setId(id);
        // 默认1抖音
        keyOrder.setOrderType(1);
@@ -96,17 +136,53 @@

    @Override
    public Long getCanDistributeUid() {
        List<OrderDistributeCountInfo>  list =   keyOrderMapper.listDistributeUids();
        if(list==null||list.size()==0){
        // 最近1小时有活跃
        List<OrderDistributeCountInfo> list = keyOrderMapper.listDistributeUids(new Date(System.currentTimeMillis() - 1000 * 60 * 60L));
        if (list == null || list.size() == 0) {
            return null;
        }
        Comparator<OrderDistributeCountInfo> cm = (OrderDistributeCountInfo o1, OrderDistributeCountInfo o2)-> o1.getCount()-o2.getCount();
        // count小于2直接视为0
        for (OrderDistributeCountInfo info : list) {
            if (info.getCount() < 2) {
                info.setCount(0);
            }
        }

        Comparator<OrderDistributeCountInfo> cm = new Comparator<OrderDistributeCountInfo>() {
            @Override
            public int compare(OrderDistributeCountInfo o1, OrderDistributeCountInfo o2) {
                return o1.getCount() - o2.getCount();
            }
        };
        list.sort(cm);
        if (list.get(0).getCount() == 0) {
            // 处理大多数设备都没有分配的情况
            // 将为0的数据随机分配
            List<OrderDistributeCountInfo> tempList = new ArrayList<>();
            for (OrderDistributeCountInfo info : list) {
                if (info.getCount() == 0) {
                    tempList.add(info);
                }
            }
            int index = new Random().nextInt(tempList.size());
            if (index < 0) {
                index = 0;
            }
            if (index >= tempList.size()) {
                index = tempList.size() - 1;
            }
            return tempList.get(index).getUid();
        }
        return list.get(0).getUid();
    }

    @Override
    public List<KeyOrder> listNotDistributed(int page, int pageSize) {
        return keyOrderMapper.listNotDistributed((page-1)*pageSize,pageSize);
        return keyOrderMapper.listNotDistributed((page - 1) * pageSize, pageSize);
    }

    @Override
    public void deleteAll(Date maxCreateTime) {
        keyOrderMapper.deleteAll(maxCreateTime);
    }
}