9th/src/test/java/com/izouma/nineth/CommonTest.java

package com.izouma.nineth;

import com.github.kevinsawicki.http.HttpRequest;
import com.izouma.nineth.domain.BaseEntity;
import com.izouma.nineth.domain.BlindBoxItem;
import com.izouma.nineth.domain.User;
import com.izouma.nineth.enums.AuthorityName;
import com.izouma.nineth.security.Authority;
import com.izouma.nineth.utils.UrlUtils;
import com.izouma.nineth.web.BaseController;
import io.ipfs.api.IPFS;
import io.ipfs.api.MerkleNode;
import io.ipfs.api.NamedStreamable;
import io.ipfs.cid.Cid;
import io.ipfs.multihash.Multihash;
import lombok.SneakyThrows;
import net.coobird.thumbnailator.Thumbnails;
import net.coobird.thumbnailator.name.Rename;
import org.apache.commons.codec.EncoderException;
import org.apache.commons.codec.net.URLCodec;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.RandomUtils;
import org.apache.commons.lang3.Range;
import org.apache.commons.text.CaseUtils;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.poi.util.TempFile;
import org.bouncycastle.util.encoders.Base64;
import org.bouncycastle.util.encoders.UrlBase64Encoder;
import org.junit.Assert;
import org.junit.Test;
import org.libjpegturbo.turbojpeg.processor.api.ImageProcessException;
import org.libjpegturbo.turbojpeg.processor.api.ImageProcessInfo;
import org.libjpegturbo.turbojpeg.processor.api.ImageProcessor;
import org.libjpegturbo.turbojpeg.processor.impl.ImageProcessorImpl;
import org.libjpegturbo.turbojpeg.processor.utils.ImageProcessorUtils;
import org.pngquant.PngQuant;
import org.reflections.ReflectionUtils;
import org.reflections.Reflections;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.util.FileCopyUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.imageio.ImageIO;
import java.awt.*;
import java.awt.font.FontRenderContext;
import java.awt.geom.AffineTransform;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;
import java.util.List;
import java.util.regex.Pattern;

import static java.nio.file.StandardOpenOption.CREATE;
import static java.nio.file.StandardOpenOption.TRUNCATE_EXISTING;

public class CommonTest {
    @Test
    public void getGenericsClass() {
        List<User> data = new ArrayList<>();
        data.add(new User());
        System.out.println(data.get(0).getClass().getSimpleName());
        System.out.println(data.getClass());


        Reflections reflections = new Reflections(this.getClass().getPackage().getName() + ".domain");
        Set<Class<? extends BaseEntity>> allClasses = reflections.getSubTypesOf(BaseEntity.class);
        for (Class<? extends BaseEntity> allClass : allClasses) {
            System.out.println(allClass.getName());
        }
    }

    @Test
    public void getapis() {
        List<Map<String, String>> entities = new ArrayList<>();
        Reflections classReflections = new Reflections(this.getClass().getPackage().getName());
        Set<Class<? extends BaseController>> controllers = classReflections.getSubTypesOf(BaseController.class);
        Set<Class<? extends BaseController>> list = ReflectionUtils
                .getAll(controllers, ReflectionUtils.withAnnotation(RestController.class));
        System.out.println(list);

        for (Class<? extends BaseController> aClass : list) {
            RequestMapping requestMapping = aClass.getAnnotation(RequestMapping.class);
            String baseUrl = requestMapping.value()[0];
            for (Method method : ReflectionUtils.getMethods(aClass, ReflectionUtils.withAnnotation(GetMapping.class))) {
                GetMapping getMapping = method.getAnnotation(GetMapping.class);
                System.out.println(getMapping.value()[0]);
            }
            for (Method method : ReflectionUtils
                    .getMethods(aClass, ReflectionUtils.withAnnotation(PostMapping.class))) {
                PostMapping postMapping = method.getAnnotation(PostMapping.class);
                System.out.println(postMapping.value()[0]);
            }
        }
    }

    @Test
    public void testCaseUtils() {
        System.out.println(CaseUtils.toCamelCase("test_Model", true, '_'));
    }

    @Test
    public void testMeasureText() throws IOException, FontFormatException {
        AffineTransform affinetransform = new AffineTransform();
        FontRenderContext frc = new FontRenderContext(affinetransform, true, true);
        Font font = Font.createFont(Font.TRUETYPE_FONT, this.getClass()
                .getResourceAsStream("/font/SourceHanSansCN-Normal.ttf"));
        System.out.println((int) (font.deriveFont(14f).getStringBounds("aaa", frc).getWidth()));
    }

    @Test
    public void testIdNoRegexp() {
        boolean b = Pattern
                .matches("^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0-2]\\d)|3[0-1])\\d{3}$|^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0-2]\\d)|3[0-1])\\d{3}[0-9xX]$", "32100219950830461X");
        System.out.println(b);
    }

    @Test
    public void tesSms() throws IOException {
        Reflections reflections = new Reflections(this.getClass().getPackage().getName() + ".enums");
        Set<Class<? extends Enum>> entitySet = reflections.getSubTypesOf(Enum.class);
        StringBuilder idxJs = new StringBuilder();
        for (Class<? extends Enum> entity : entitySet) {
            idxJs.append("import ").append(entity.getSimpleName()).append(" from \"./").append(entity.getSimpleName())
                    .append("\";\n");
            StringBuilder str = new StringBuilder("export default {\n");
            for (Enum enumConstant : entity.getEnumConstants()) {
                str.append("    ").append(enumConstant.name()).append(": \"").append(enumConstant.name())
                        .append("\",\n");
            }
            str.append("}");
            Files.write(Paths.get(System.getProperty("user.dir"), "src", "main", "vue", "src", "constants", entity
                    .getSimpleName() + ".js"), str.toString()
                    .getBytes(StandardCharsets.UTF_8), CREATE, TRUNCATE_EXISTING);
            Files.write(Paths.get(System.getProperty("user.dir"), "src", "main", "zmj_mp", "src", "constants", entity
                    .getSimpleName() + ".js"), str.toString()
                    .getBytes(StandardCharsets.UTF_8), CREATE, TRUNCATE_EXISTING);
        }
        idxJs.append("export default {\n");
        for (Class<? extends Enum> entity : entitySet) {
            idxJs.append("    ").append(entity.getSimpleName()).append(": ").append(entity.getSimpleName())
                    .append(",\n");
        }
        idxJs.append("}");
        System.out.println(idxJs.toString());
        Files.write(Paths
                .get(System.getProperty("user.dir"), "src", "main", "vue", "src", "constants", "index.js"), idxJs
                .toString().getBytes(StandardCharsets.UTF_8), CREATE, TRUNCATE_EXISTING);
        Files.write(Paths
                .get(System.getProperty("user.dir"), "src", "main", "zmj_mp", "src", "constants", "index.js"), idxJs
                .toString().getBytes(StandardCharsets.UTF_8), CREATE, TRUNCATE_EXISTING);
    }

    @Test
    public void gen() {
        System.out.println(RandomStringUtils.randomAlphabetic(32));
    }

    @Test
    public void password() {
        String password = new BCryptPasswordEncoder().encode("123456");

        System.out.println(password);
    }

    @SneakyThrows
    @Test
    public void pngquant() {
        PngQuant pngQuant = new PngQuant();
        ImageIO.write(pngQuant
                        .getRemapped(ImageIO.read(new File("/Users/drew/Downloads/2021-11-01-18-07-04JCDfFxKb.HEIC"))),
                "jpg", new File("/Users/drew/Downloads/111.jpg"));
    }

    @SneakyThrows
    @Test
    public void mozjpeg() {
        File out = TempFile.createTempFile("kljasdlkhfasldg", ".jpg");
        ImageProcessor processor = new ImageProcessorImpl();
        ImageProcessInfo processInfo = ImageProcessInfo.fromMap(ImageProcessorUtils.compressImage(processor,
                new File("/Users/drew/Downloads/2020-09-08-17-07-21zwBhaHeQ.jpg"),
                out, 75));
        FileCopyUtils.copy(out, new File("/Users/drew/Desktop/111.jpg"));
        System.out.println(out);
    }

    @Test
    public void thumbnailator() throws IOException, ImageProcessException {
        Thumbnails.of(new File("/Users/drew/Downloads/2021-11-01-17-47-55zMwbSlgJ.jpeg"))
                .size(3000, 3000)
                .outputFormat("jpg")
                .toFile("/Users/drew/Desktop/1.jpg");

        PngQuant pngQuant = new PngQuant();
        ImageIO.write(pngQuant
                        .getRemapped(ImageIO.read(new File("/Users/drew/Desktop/1.jpg"))),
                "jpg", new File("/Users/drew/Desktop/2.jpg"));

        ImageProcessor processor = new ImageProcessorImpl();
        ImageProcessInfo processInfo = ImageProcessInfo.fromMap(ImageProcessorUtils.compressImage(processor,
                new File("/Users/drew/Desktop/1.jpg"),
                new File("/Users/drew/Desktop/3.jpg"), 75));
    }

    @Test
    public void base64() {
        System.out.println(Base64.decode("e6e6vQJYhGmIkcA1pfnsipTovp10wJ"));
    }

    @Test
    public void resolveUrl() {
        try {
            System.out.println(new URLCodec().encode("http://www.baidu.com"));
        } catch (EncoderException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testIPFS() throws IOException {
        IPFS ipfs = new IPFS("121.40.132.44", 5001);
        HttpRequest request = HttpRequest.get("https://awesomeadmin.oss-cn-hangzhou.aliyuncs.com/image/2021-10-21-16-44-52kZqxuwhH.gif");
        File file = File.createTempFile("ipfs", ".tmp");
        request.receive(file);
        NamedStreamable.FileWrapper file1 = new NamedStreamable.FileWrapper(file);
        MerkleNode put = ipfs.add(file1).get(0);
        Multihash multihash = ipfs.pin.add(put.hash).get(0);
        System.out.println(put.hash.toBase58());
        System.out.println(multihash.toBase58());
    }

    @Test
    public void testWin() {
        List<BlindBoxItem> items = new ArrayList<>();
        items.add(BlindBoxItem.builder()
                .name("普通1")
                .total(100)
                .stock(100)
                .build());
        items.add(BlindBoxItem.builder()
                .name("普通2")
                .total(100)
                .stock(100)
                .build());
        items.add(BlindBoxItem.builder()
                .name("稀有1")
                .total(5)
                .stock(5)
                .rare(true)
                .build());
        items.add(BlindBoxItem.builder()
                .name("稀有2")
                .total(5)
                .stock(5)
                .rare(true)
                .build());
        for (int k = 0; k < items.stream().mapToInt(BlindBoxItem::getTotal).sum(); k++) {
            Map<BlindBoxItem, Range<Integer>> randomRange = new HashMap<>();
            int c = 0, sum = 0;
            for (BlindBoxItem item : items) {
                randomRange.put(item, Range.between(c, c + item.getStock()));
                c += item.getStock();
                sum += item.getStock();
            }

            boolean win = false;
            int retry = 0;
            BlindBoxItem winItem = null;
            while (winItem == null) {
                int rand = RandomUtils.nextInt(0, sum + 1);
                for (Map.Entry<BlindBoxItem, Range<Integer>> entry : randomRange.entrySet()) {
                    BlindBoxItem item = entry.getKey();
                    Range<Integer> range = entry.getValue();
                    if (rand >= range.getMinimum() && rand < range.getMaximum()) {
                        int total = items.stream().filter(i -> !i.isRare())
                                .mapToInt(BlindBoxItem::getTotal).sum();
                        int stock = items.stream().filter(i -> !i.isRare())
                                .mapToInt(BlindBoxItem::getStock).sum();
                        if (item.isRare()) {
                            double nRate = stock / (double) total;
                            double rRate = (item.getStock() - 1) / (double) item.getTotal();

                            if (Math.abs(nRate - rRate) < (1 / (double) item.getTotal()) || retry > 1 || rRate == 0) {
                                if (!(nRate > 0.1 && item.getStock() == 1)) {
                                    winItem = item;
                                }
                            } else {
                                retry++;
                            }
                        } else {
                            double nRate = (stock - 1) / (double) total;
                            double rRate = item.getStock() / (double) item.getTotal();

                            if (Math.abs(nRate - rRate) < 0.2 || retry > 1 || nRate == 0) {
                                winItem = item;
                            } else {
                                retry++;
                            }
                        }
                    }
                }
            }
            winItem.setStock(winItem.getStock() - 1);
            System.out.println(winItem.getName() + (winItem.isRare() ? "\t+++" : ""));
        }
    }

}