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

package com.izouma.nineth.service;

import com.alibaba.excel.util.StringUtils;
import com.google.zxing.WriterException;
import com.izouma.nineth.domain.DomainOrder;
import com.izouma.nineth.domain.FileObject;
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.service.storage.StorageService;
import com.izouma.nineth.utils.ImageUtils;
import com.izouma.nineth.utils.JpaUtils;
import com.izouma.nineth.utils.SecurityUtils;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.RandomStringUtils;
import org.springframework.data.annotation.Transient;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.util.*;
import java.util.List;
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;
    private StorageService      storageService;
    private RockRecordService   rockRecordService;

    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, Long year) {
        List<DomainOrder> notPaidOrders = domainOrderRepo.findAllByUserIdAndOrderStatus(userId, OrderStatus.NOT_PAID);
        Long superUserId = Long.valueOf(sysConfigService.getString("domain_superUserId"));
        if (notPaidOrders.size() > 0) {
            throw new BusinessException("已存在未支付订单，不可继续下单");
        }
        if (domain.contains(".uni")) {
            throw new BusinessException("域名后缀不符合规定.");
        }
        if (!superUserId.equals(SecurityUtils.getAuthenticatedUser().getId())) {
            if (isContainChinese(domain)) {
                throw new BusinessException("禁止注册中文域名");
            }
            if (domain.length() < 9) {
                throw new BusinessException("四位及以下域名只能官方创建。");
            }
        }
        String realName;
        int dotIndex = domain.indexOf(".");
        realName = domain.substring(0, dotIndex);
        Map<String, Object> checkResult = check(realName);
        if (!(Boolean) checkResult.get("result")) {
            throw new BusinessException(checkResult.get("reason").toString());
        }
        BigDecimal singlePrice = sysConfigService.getBigDecimal("domain_price");
        if (singlePrice.multiply(BigDecimal.valueOf(year)).compareTo(price) != 0) {
            throw new BusinessException("价格不符");
        }
//        LocalDateTime startTime = LocalDateTime.of(2023, 2, 10, 17, 0, 0);
//        if (LocalDateTime.now().isBefore(startTime)) {
//            throw new BusinessException("时间不符");
//        }
//        if (price.compareTo(BigDecimal.valueOf(40L)) != 0) {
//            throw new BusinessException("订单价格与配置不符，请重新下单.");
//        }
        User user = userRepo.findById(userId).orElseThrow(new BusinessException("未找到用户"));
        if (domain.contains(".")) {
            int dotIndex1 = domain.indexOf(".");
            domain = domain.substring(0, dotIndex1);
        }

        DomainOrder domainOrder = new DomainOrder();
//        domainOrder.setPic(Collections.singletonList(fileObject));
        domainOrder.setPicName(domain);
        domainOrder.setPrice(price);
        domainOrder.setDomainName((domain + ".nft").toLowerCase());
        domainOrder.setYears(year);
        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) {
        Map<String, Object> result = new HashMap<>();
        Long superUserId = Long.valueOf(sysConfigService.getString("domain_superUserId"));
        String visibleDomain = domain;
        if (domain.contains(".uni")) {
            result.put("result", false);
            result.put("reason", "禁止使用.uni");
            return result;
        }
        if (!domain.contains(".nft")) {
            visibleDomain = domain + ".nft";
        }
        List<String> keywords = Arrays.asList(sysConfigService.getString("domain_keyword").split(","));
        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);
        }
        Pageable pageable = PageRequest.of(0, 10, Sort.by("createdAt").descending());
        List<DomainOrder> used = domainOrderRepo.searchUsedDomain("%" + domain + "%", OrderStatus.CANCELLED, pageable)
                .getContent();

        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").toLowerCase());
                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<>();
            if (!domainOrder.getDomainName().contains(".uni")) {
                sold.put("domain", domainOrder.getDomainName().toLowerCase());
                sold.put("endTime", domainOrder.getEndTime());
                sold.put("sold", true);
                result.add(sold);
            }
            if (result.size() > 9) {

            }
        });
        return result;
    }

    @Transient
    public void notify(Long id, PayMethod payMethod, String transactionId) throws FontFormatException, IOException, WriterException {
        DomainOrder domainOrder = domainOrderRepo.findById(id).orElseThrow(new BusinessException("未找到星图"));
        if (!domainOrder.getOrderStatus().equals(OrderStatus.NOT_PAID)) {
            throw new BusinessException("订单已经处理");
        }
        BufferedImage img = domainImg(domainOrder.getDomainName());
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        ImageIO.write(img, "jpg", os);
        InputStream input = new ByteArrayInputStream(os.toByteArray());
        String path = "image/" + new SimpleDateFormat("yyyy-MM-dd-HH-mm-ss").format(new Date())
                + RandomStringUtils.randomAlphabetic(8) + ".jpg";
        String realUrl = storageService.uploadFromInputStream(input, path);
        FileObject fileObject = new FileObject();
        fileObject.setName(domainOrder.getDomainName());
        fileObject.setType("image/jpeg");
        fileObject.setUrl(realUrl);
        domainOrder.setOrderStatus(OrderStatus.FINISH);
        domainOrder.setPayMethod(payMethod);
        domainOrder.setPic(Collections.singletonList(fileObject));
        domainOrder.setTransactionId(transactionId);
        domainOrder.setStatus(CollectionStatus.SUCCESS);
        domainOrder.setCreateAssetId(createAsset(domainOrder));
        domainOrder.setEndTime(LocalDateTime.now().plusYears(domainOrder.getYears()));
        domainOrderRepo.save(domainOrder);

        rockRecordService.addRock(domainOrder.getUserId(), domainOrder.getPrice(), "购买");
    }

    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();
    }

    public BufferedImage domainImg(String domain) throws IOException, FontFormatException, WriterException {
        String domainName;
        if (domain.contains(".")) {
            int dotIndex = domain.indexOf(".");
            domainName = domain.substring(0, dotIndex).toUpperCase();
        } else {
            domainName = domain.toUpperCase();
        }
        InputStream is1 = this.getClass()
                .getResourceAsStream("/font/VonwaonBitmap_16pxLite.ttf");
        Font font1 = Font.createFont(Font.TRUETYPE_FONT, is1);
        is1.close();
        InputStream is2 = this.getClass()
                .getResourceAsStream("/font/VonwaonBitmap_12pxLite.ttf");
        Font font2 = Font.createFont(Font.TRUETYPE_FONT, is2);
        is2.close();
        int length = domainName.length();
        BufferedImage shareImg;
        if (length <= 2) {
            InputStream is3 = this.getClass().getResourceAsStream("/static/img/png_jing.png");
            shareImg = ImageIO.read(is3);
            is3.close();
        } else if (length <= 4) {
            InputStream is3 = this.getClass().getResourceAsStream("/static/img/png_lv.png");
            shareImg = ImageIO.read(is3);
            is3.close();
        } else {
            InputStream is3 = this.getClass().getResourceAsStream("/static/img/png_zi.png");
            shareImg = ImageIO.read(is3);
            is3.close();
        }


        BufferedImage result = new BufferedImage(shareImg.getWidth(), shareImg.getHeight(), BufferedImage.TYPE_INT_RGB);
        Graphics2D g = result.createGraphics();
        g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
//        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
//        g.setRenderingHint(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        g.setComposite(AlphaComposite.SrcOver);
        g.drawImage(shareImg, 0, 0, null);

//        BufferedImage avatarImg = ImageUtils.makeRoundedCorner(ImageUtils.scale(ImageIO.read(new URL(user.getAvatar())),
//                80, 80,
//                ImageUtils.Fit.COVER), 40);
//        g.drawImage(avatarImg, 334, 136, null);


        int domainLength = domainName.length();
        if (domainLength > 10) {
            g.setColor(new Color(255, 255, 255));
            Font topFont = font1.deriveFont(Font.PLAIN, 130f);
            Font downFont = font2.deriveFont(Font.BOLD, 36f);
            int subIndex = domainLength / 3;
            String str1 = domainName.substring(0, subIndex);
            String str2 = domainName.substring(subIndex, subIndex + subIndex);
            String str3 = domainName.substring(subIndex + subIndex, domainLength);
            ImageUtils.drawCenteredString(g, str1, new Rectangle(0, 180, shareImg
                    .getWidth(), 86), topFont);
            ImageUtils.drawCenteredString(g, str2, new Rectangle(0, 300, shareImg
                    .getWidth(), 86), topFont);
            ImageUtils.drawCenteredString(g, str3, new Rectangle(0, 420, shareImg
                    .getWidth(), 86), topFont);
            ImageUtils.drawCenteredString(g, ".NFT", new Rectangle(0, 540, shareImg
                    .getWidth(), 86), topFont);
            g.setColor(new Color(255, 255, 255));
            ImageUtils.drawCenteredString(g, domain, new Rectangle(0, 650, shareImg
                    .getWidth(), 12), downFont);
        }
        if (domainLength > 5 & domainLength <= 10) {
            g.setColor(new Color(255, 255, 255));
            Font topFont = font1.deriveFont(Font.PLAIN, 190f);
            Font downFont = font2.deriveFont(Font.BOLD, 36f);
            int subIndex = domainLength / 2;
            String str1 = domainName.substring(0, subIndex);
            String str2 = domainName.substring(subIndex, domainLength);
            ImageUtils.drawCenteredString(g, str1, new Rectangle(0, 180, shareImg
                    .getWidth(), 86), topFont);
            ImageUtils.drawCenteredString(g, str2, new Rectangle(0, 350, shareImg
                    .getWidth(), 86), topFont);
            ImageUtils.drawCenteredString(g, ".NFT", new Rectangle(0, 520, shareImg
                    .getWidth(), 86), topFont);
            g.setColor(new Color(255, 255, 255));
            ImageUtils.drawCenteredString(g, domain, new Rectangle(0, 650, shareImg
                    .getWidth(), 12), downFont);
        }
        if (domainLength <= 5) {
            g.setColor(new Color(255, 255, 255));
            Font topFont = font1.deriveFont(Font.PLAIN, 240f);
            Font downFont = font2.deriveFont(Font.BOLD, 36f);
            ImageUtils.drawCenteredString(g, domainName, new Rectangle(17, 220, shareImg
                    .getWidth(), 86), topFont);
            ImageUtils.drawCenteredString(g, ".NFT", new Rectangle(-10, 420, shareImg
                    .getWidth(), 86), topFont);
            g.setColor(new Color(255, 255, 255));
            ImageUtils.drawCenteredString(g, domain, new Rectangle(0, 620, shareImg
                    .getWidth(), 12), downFont);
        }

        //二维码
//        QRCodeWriter qrCodeWriter = new QRCodeWriter();
//        Map<EncodeHintType, Object> hints = new HashMap<>();
//        hints.put(EncodeHintType.MARGIN, 2);
//        BitMatrix bitMatrix = qrCodeWriter
//                .encode(env.getProperty("general.host") + "/wx/share?invitor=" + user.getId(),
//                        BarcodeFormat.QR_CODE, 252, 252, hints);
//        g.drawImage(MatrixToImageWriter.toBufferedImage(bitMatrix), 250, 386, null);

        return result;
    }

}