raex_back/src/main/java/com/izouma/nineth/service/DomainOrderService.java

package com.izouma.nineth.service;

import com.alibaba.excel.util.StringUtils;
import com.izouma.nineth.domain.DomainOrder;
import com.izouma.nineth.domain.FileObject;
import com.izouma.nineth.domain.PhotoAsset;
import com.izouma.nineth.domain.User;
import com.izouma.nineth.dto.PageQuery;
import com.izouma.nineth.enums.CollectionStatus;
import com.izouma.nineth.enums.OrderStatus;
import com.izouma.nineth.enums.PayMethod;
import com.izouma.nineth.exception.BusinessException;
import com.izouma.nineth.repo.DomainOrderRepo;
import com.izouma.nineth.repo.UserRepo;
import com.izouma.nineth.utils.JpaUtils;
import com.izouma.nineth.utils.SecurityUtils;
import lombok.AllArgsConstructor;
import org.springframework.data.annotation.Transient;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;

import javax.print.DocFlavor;
import java.math.BigDecimal;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
@AllArgsConstructor
public class DomainOrderService {

    private DomainOrderRepo     domainOrderRepo;
    private ContentAuditService contentAuditService;
    private UserRepo            userRepo;
    private AssetService        assetService;
    private SysConfigService    sysConfigService;

    public Page<DomainOrder> all(PageQuery pageQuery) {
        return domainOrderRepo
                .findAll(JpaUtils.toSpecification(pageQuery, DomainOrder.class), JpaUtils.toPageRequest(pageQuery));
    }

    public boolean isContainChinese(String str) {

        if (StringUtils.isEmpty(str)) {
            throw new BusinessException("sms context is empty!");
        }
        Pattern p = Pattern.compile("[\u4E00-\u9FA5|\\！|\\，|\\。|\\（|\\）|\\《|\\》|\\“|\\”|\\？|\\：|\\；|\\【|\\】]");
        Matcher m = p.matcher(str);
        if (m.find()) {
            return true;
        }
        return false;
    }

    public DomainOrder create(Long userId, String domain, BigDecimal price) {
        List<DomainOrder> notPaidOrders = domainOrderRepo.findAllByUserIdAndOrderStatus(userId, OrderStatus.NOT_PAID);
        Long superUserId = Long.valueOf(sysConfigService.getString("domain_superUserId"));
        if (!superUserId.equals(SecurityUtils.getAuthenticatedUser().getId())) {
            if (isContainChinese(domain)) {
                throw new BusinessException("禁止注册中文域名");
            }
            if (notPaidOrders.size() > 0) {
                throw new BusinessException("已存在未支付订单，不可继续下单");
            }
            if (domain.length() < 9) {
                throw new BusinessException("四位及以下域名只能官方创建。");
            }
        }
        Map<String, Object> checkResult = check(domain);
        if (!(Boolean) checkResult.get("result")) {
            throw new BusinessException(checkResult.get("reason").toString());
        }
        if (price.compareTo(BigDecimal.valueOf(40L)) != 0) {
            throw new BusinessException("订单价格与配置不符，请重新下单.");
        }
        User user = userRepo.findById(userId).orElseThrow(new BusinessException("未找到用户"));
        if (domain.contains(".")) {
            int dotIndex = domain.indexOf(".");
            domain = domain.substring(0, dotIndex);
        }
        FileObject fileObject = new FileObject();
        fileObject.setName("默认图片");
        fileObject.setType("image/jpeg");
        fileObject.setUrl("https://raex-meta.oss-cn-shenzhen.aliyuncs.com/image/2021-12-17-19-03-38BNAlEhlJ.png");
        DomainOrder domainOrder = new DomainOrder();
        domainOrder.setPic(Collections.singletonList(fileObject));
        domainOrder.setPicName(domain);
        domainOrder.setPrice(price);
        domainOrder.setDomainName(domain + ".nft");
        domainOrder.setStatus(CollectionStatus.PENDING);
        domainOrder.setOrderStatus(OrderStatus.NOT_PAID);
        domainOrder.setUserId(user.getId());
        domainOrder.setUserAvatar(user.getAvatar());
        domainOrder.setUserName(user.getNickname());
        return domainOrderRepo.save(domainOrder);
    }

    public Map<String, Object> check(String domain) {
        Long superUserId = Long.valueOf(sysConfigService.getString("domain_superUserId"));
        String visibleDomain = domain + ".nft";
        List<String> keywords = Arrays.asList(sysConfigService.getString("domain_keyword").split(","));

        Map<String, Object> result = new HashMap<>();
        if (!superUserId.equals(SecurityUtils.getAuthenticatedUser().getId())) {
            if (keywords.stream().anyMatch(keyword -> org.apache.commons.lang.StringUtils.equals(keyword, domain))) {
                result.put("result", false);
                result.put("reason", "包含敏感关键字");
                return result;
            }
            if (visibleDomain.length() < 9 || visibleDomain.length() > 20) {
                result.put("result", false);
                result.put("reason", "域名长度不合规");
                return result;
            }
            if (!contentAuditService.auditText(domain)) {
                result.put("result", false);
                result.put("reason", "该域名内容不合规");
                return result;
            }
        }
        Integer count = domainOrderRepo
                .countAllByDomainNameEqualsAndOrderStatusNot(visibleDomain, OrderStatus.CANCELLED);
        if (count > 0) {
            result.put("result", false);
            result.put("reason", "该域名已被注册");
            return result;
        }
        result.put("result", true);
        result.put("reason", "可以注册");
        return result;
    }

    public List<Map<String, Object>> search(String domain) {
        if (domain.contains(".")) {
            int dotIndex = domain.indexOf(".");
            domain = domain.substring(0, dotIndex);
        }
        List<DomainOrder> used = domainOrderRepo.searchUsedDomain("%" + domain + "%", OrderStatus.CANCELLED);

        String n = domain.substring(domain.length() - 1);
        List<Map<String, Object>> recommend = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            if (i != 0) {
                domain = domain + n;
            }

            Map<String, Object> checkResult = check(domain);
            if ((Boolean) checkResult.get("result")) {
                Map<String, Object> sold = new HashMap<>();
                sold.put("domain", domain + ".nft");
                sold.put("sold", false);
                recommend.add(sold);
            }
            if (recommend.size() > 2) {
                break;
            }
        }
        List<Map<String, Object>> result = new ArrayList<>(recommend);

        used.forEach(domainOrder -> {
            Map<String, Object> sold = new HashMap<>();
            sold.put("domain", domainOrder.getDomainName());
            sold.put("sold", true);
            result.add(sold);
        });
        return result;
    }

    @Transient
    public void notify(Long id, PayMethod payMethod, String transactionId) {
        DomainOrder domainOrder = domainOrderRepo.findById(id).orElseThrow(new BusinessException("未找到星图"));
        if (!domainOrder.getOrderStatus().equals(OrderStatus.NOT_PAID)) {
            throw new BusinessException("订单已经处理");
        }
        domainOrder.setOrderStatus(OrderStatus.FINISH);
        domainOrder.setPayMethod(payMethod);
        domainOrder.setTransactionId(transactionId);
        domainOrder.setStatus(CollectionStatus.SUCCESS);
        domainOrder.setCreateAssetId(createAsset(domainOrder));
        domainOrderRepo.save(domainOrder);
    }

    public void cancel(DomainOrder domainOrder) {
        domainOrder.setOrderStatus(OrderStatus.CANCELLED);
        domainOrder.setStatus(CollectionStatus.FAIL);
        domainOrderRepo.save(domainOrder);
    }

    public Long createAsset(DomainOrder domainOrder) {
        return assetService.createAsset(domainOrder, userRepo.findById(domainOrder.getUserId())
                .orElseThrow(new BusinessException("无用户记录")), null, BigDecimal.ZERO, "域名", null, false).getId();
    }

}