its-op-server/src/test/java/com/its/op/ItsOpServerApplicationTests.java

package com.its.op;

import com.its.op.entity.its.atrd.TbAtrd;
import com.its.utils.AES256Util;
import com.its.utils.SHA256Util;
import lombok.extern.slf4j.Slf4j;
import net.jodah.expiringmap.ExpiringMap;
import org.jasypt.encryption.pbe.PooledPBEStringEncryptor;
import org.jasypt.encryption.pbe.config.SimpleStringPBEConfig;
import org.jasypt.salt.StringFixedSaltGenerator;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ActiveProfiles;

import javax.persistence.EntityManager;
import java.sql.Connection;
import java.sql.DriverManager;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
//@SpringBootTest
@ActiveProfiles(profiles = "dev")
public class ItsOpServerApplicationTests {
//    @Autowired
//    DefaultListableBeanFactory bf;

    @Autowired
    private EntityManager em;

    @Test
    void res() {
        //Result result = new Result(1, null);
    }
    @Test
    void qry() {
        List<TbAtrd> result = em.createQuery("select m from TbAtrd m", TbAtrd.class)
                .getResultList();
        log.error("{} EA.", result.size());
        result.forEach(obj -> {
            log.error("{}", obj.getAtrdId());
        });

        log.error("======================================================================================");
        List<TbAtrd> result_ = em.createQuery("select m from TbAtrd m where m.atrdId = :paramId", TbAtrd.class)
                .setParameter("paramId", "ATRD010")
                .getResultList();
        log.error("{} EA.", result_.size());
        result_.forEach(obj -> {
            log.error("{}", obj.getAtrdId());
        });
    }

    @Test
    void ttl() {
        ExpiringMap<String, String> tokenEventMap;
        tokenEventMap = ExpiringMap.builder()
                .variableExpiration()
                .maxSize(1000)
                .build();
        Date date = new Date();
        long secondAtExpiry = date.toInstant().getEpochSecond();
        long secondAtLogout = Instant.now().getEpochSecond();
        long ttl = Math.max(0, secondAtExpiry - secondAtLogout);
        log.error("{}, {}, {}", secondAtExpiry, secondAtLogout, ttl);
        tokenEventMap.put("TEST", "data", ttl, TimeUnit.SECONDS);
        log.error("{}", tokenEventMap);
    }
    @Test
    void encrypt() {
//        for(String n : bf.getBeanDefinitionNames()){
//            log.error("{}", n);
//        }
        log.error("{}", SHA256Util.encrypt("1"));               // 6b86b273ff34fce19d6b804eff5a3f5747ada4eaa22f1d49c01e52ddb7875b4b
        log.error("{}", SHA256Util.encrypt2("admin12#$!")); // 3de9f98e4b5b4e52ff7d78cfa3140cf23e2b33c5a3143d1b2d1048237c31593c
    }
    @Test
    public void testConnection() {
        try (
            Connection conn = DriverManager.getConnection("jdbc:oracle:thin:@115.91.94.42:1522:HANTE19C", "ptatms","ptatms");
        ) {
            log.info("XXXX: {}", conn);
        } catch (Exception e) {
            log.error("{}", e.getMessage());
        }
    }

    void reference1() {
        String name = "test";
        LocalDateTime ldt = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-dd-MM HH:mm:ss.SSS");
        System.out.println(ldt.format(formatter) + " Started thread " + name);
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            log.error("InterruptedException");
        }
        ldt = LocalDateTime.now();
        System.out.println(ldt.format(formatter) + "  Ended thread " + name);
    }

    @Test
    void test1() {
        for (int ii = 0; ii < 24; ii++) {
            for (int jj = 0; jj < 12; jj++) {
                log.error("{}:{}", ii, jj*5);
            }
        }

        String prcsDt = "20220120173526";
        log.error("{}", prcsDt.substring(0, 2));
        log.error("{}", prcsDt.substring(8, 10));
        log.error("{}", prcsDt.substring(10, 12));

        String svcDt = "20210120173526";

        log.error("compareTo: {}", svcDt.compareTo(prcsDt));
    }


    @Test
    void jasypt() {
        String encKey = "asdkjfaslkjflkajslfjkajlkf";
        PooledPBEStringEncryptor encryptor = new PooledPBEStringEncryptor();
        SimpleStringPBEConfig config = new SimpleStringPBEConfig();

        // ==> SimpleStringPBEConfig 사용시 아래 3개 반드시 설정해야함
        config.setPassword(encKey);                                         // 암호화에 사용할 키
        config.setPoolSize(1);                                              // Pool Size
        config.setSaltGenerator(new StringFixedSaltGenerator("fixedSalt")); // 고정으로 암호화(Default: Random)
        //config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        //config.setAlgorithm("PBEWithMD5AndTripleDES");
        config.setAlgorithm("PBEWithMD5AndDES"); // Jasypt 를 이용한 암호화 알고리즘
        config.setProviderName("SunJCE");
        config.setKeyObtentionIterations("10000");
        config.setStringOutputType("base64");
        /*private Boolean proxyPropertySources = false;
        private String bean = "jasyptStringEncryptor";
        private String password;
        private String algorithm = "PBEWithMD5AndDES";
        private String keyObtentionIterations = "1000";
        private String poolSize = "1";
        private String providerName = null;
        //config.setSaltGeneratorClassName("org.jasypt.salt.RandomSaltGenerator");
        private String saltGeneratorClassname = "org.jasypt.salt.RandomSaltGenerator";
        private String stringOutputType = "base64";*/
        encryptor.setConfig(config);

        String yiits = encryptor.encrypt("yiits");
        String rutis = encryptor.encrypt("rutis");
        log.info("{}", yiits);
        log.info("{}", rutis);
    }

    @Test
    void sha256() {
        String data = AES256Util.encryptSHA256("yonginits");
        log.info("{}", data);
        log.info("{}", data.toUpperCase());
        log.info("{}", AES256Util.encryptSHA256("yiits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
        log.info("{}", AES256Util.encryptSHA256("yonginits"));
    }

    @Test
    void test9() {
        int ltc1 = 2933;
        int TOTAL = 4361;
        double tLtc1 = Double.parseDouble(String.format("%.1f", ltc1 / TOTAL * 100.0));
        log.error("{}, {}, {}, {}", ltc1, TOTAL, tLtc1, (ltc1 / (float)TOTAL * 100.0));
    }
}