Skip to content

H
holmes
Commit b43bc524 authored by 黎博's avatar 黎博
Browse files
Options

新增新橙mock

parent a9a25331
Hide whitespace changes
Inline Side-by-side
Showing with 1708 additions and 0 deletions
src/main/java/cn/qg/holmes/config/InterceptorConfig.java
View file @ b43bc524
package cn.qg.holmes.config; package cn.qg.holmes.config;
import cn.qg.holmes.interceptor.RuleEngineInterceptor; import cn.qg.holmes.interceptor.RuleEngineInterceptor;
import cn.qg.holmes.interceptor.XinchengInterceptor;
import cn.qg.holmes.interceptor.YeebaoInterceptor; import cn.qg.holmes.interceptor.YeebaoInterceptor;
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Configuration;
...@@ -23,9 +24,15 @@ public class InterceptorConfig implements WebMvcConfigurer { ...@@ -23,9 +24,15 @@ public class InterceptorConfig implements WebMvcConfigurer {
return new RuleEngineInterceptor(); return new RuleEngineInterceptor();
} }
@Bean
public XinchengInterceptor xinchengInterceptor() {
return new XinchengInterceptor();
}
@Override @Override
public void addInterceptors(InterceptorRegistry registry) { public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(yeebaoInterceptor()).addPathPatterns("/tzt-api/**", "/balance-board/**"); registry.addInterceptor(yeebaoInterceptor()).addPathPatterns("/tzt-api/**", "/balance-board/**");
registry.addInterceptor(ruleEngineInterceptor()).addPathPatterns("/rule_engine/**"); registry.addInterceptor(ruleEngineInterceptor()).addPathPatterns("/rule_engine/**");
registry.addInterceptor(xinchengInterceptor()).addPathPatterns("/webservice/api/lhp/**");
} }
} }
src/main/java/cn/qg/holmes/encrypt/EncryptFactory.java
View file @ b43bc524
...@@ -12,6 +12,8 @@ public class EncryptFactory { ...@@ -12,6 +12,8 @@ public class EncryptFactory {
if ("yeebao".equals(type)) { if ("yeebao".equals(type)) {
// return new YeebaoEncryptConvertor(); // return new YeebaoEncryptConvertor();
return ApplicationContextUtils.getBean("yeebaoEncryptConvertor"); return ApplicationContextUtils.getBean("yeebaoEncryptConvertor");
} else if ("xincheng".equals(type)) {
return ApplicationContextUtils.getBean("xinchengEncryptConvertor");
} else { } else {
log.info("请输入正确的加密类型类型！"); log.info("请输入正确的加密类型类型！");
return null; return null;
......
src/main/java/cn/qg/holmes/encrypt/XinchengEncryptConvertor.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.encrypt;
import cn.qg.holmes.encrypt.xincheng.Base64;
import cn.qg.holmes.encrypt.xincheng.RSA;
import com.alibaba.fastjson.JSON;
import com.google.common.base.Charsets;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Map;
@Slf4j
@Component
public class XinchengEncryptConvertor implements EncryptConvertor {
@Value("${xincheng.fund.public.key}")
private String xinchengPublicKey;
@Value("${xincheng.lhp.private.key}")
private String lhpPrivateKey;
@Override
public String encrypt(String response) {
String encodeData;
try {
encodeData = new String(Base64.encodeBase64(RSA.encryptByPrivateKey(response.getBytes(), lhpPrivateKey)), Charsets.UTF_8);
} catch (Exception e) {
log.error("encrypt,encrypt request is error ", e);
throw new RuntimeException("加密失败！");
}
return encodeData;
}
@Override
public String decrypt(String request) {
String decodeData;
Map<String, Object> requestMap = JSON.parseObject(request, Map.class);
String requestStr = JSON.toJSONString(requestMap.get("content"));
try {
decodeData = new String(RSA.decryptByPublicKey(Base64.decodeBase64(requestStr.getBytes()), xinchengPublicKey), Charsets.UTF_8);
} catch (Exception e) {
log.error("decrypt, decrypt response is error ", e);
throw new RuntimeException("解密新橙响应结果失败！");
}
return decodeData;
}
}
src/main/java/cn/qg/holmes/encrypt/xincheng/Base64.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.encrypt.xincheng;
import java.io.UnsupportedEncodingException;
public class Base64 {
/**
* Chunk size per RFC 2045 section 6.8.
*
* <p>
* The {@value} character limit does not count the trailing CRLF, but counts
* all other characters, including any equal signs.
* </p>
*
* @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section
* 6.8</a>
*/
static final int CHUNK_SIZE = 76;
/**
* Chunk separator per RFC 2045 section 2.1.
*
* @see <a href="http://www.ietf.org/rfc/rfc2045.txt">RFC 2045 section
* 2.1</a>
*/
static final byte[] CHUNK_SEPARATOR = "\r\n".getBytes();
/**
* The base length.
*/
static final int BASELENGTH = 255;
/**
* Lookup length.
*/
static final int LOOKUPLENGTH = 64;
/**
* Used to calculate the number of bits in a byte.
*/
static final int EIGHTBIT = 8;
/**
* Used when encoding something which has fewer than 24 bits.
*/
static final int SIXTEENBIT = 16;
/**
* Used to determine how many bits data contains.
*/
static final int TWENTYFOURBITGROUP = 24;
/**
* Used to get the number of Quadruples.
*/
static final int FOURBYTE = 4;
/**
* Used to test the sign of a byte.
*/
static final int SIGN = -128;
/**
* Byte used to pad output.
*/
static final byte PAD = (byte)'=';
// Create arrays to hold the base64 characters and a
// lookup for base64 chars
private static byte[] base64Alphabet = new byte[BASELENGTH];
private static byte[] lookUpBase64Alphabet = new byte[LOOKUPLENGTH];
// Populating the lookup and character arrays
static {
for (int i = 0; i < BASELENGTH; i++) {
base64Alphabet[i] = (byte)-1;
}
for (int i = 'Z'; i >= 'A'; i--) {
base64Alphabet[i] = (byte)(i - 'A');
}
for (int i = 'z'; i >= 'a'; i--) {
base64Alphabet[i] = (byte)(i - 'a' + 26);
}
for (int i = '9'; i >= '0'; i--) {
base64Alphabet[i] = (byte)(i - '0' + 52);
}
base64Alphabet['+'] = 62;
base64Alphabet['/'] = 63;
for (int i = 0; i <= 25; i++) {
lookUpBase64Alphabet[i] = (byte)('A' + i);
}
for (int i = 26, j = 0; i <= 51; i++, j++) {
lookUpBase64Alphabet[i] = (byte)('a' + j);
}
for (int i = 52, j = 0; i <= 61; i++, j++) {
lookUpBase64Alphabet[i] = (byte)('0' + j);
}
lookUpBase64Alphabet[62] = (byte)'+';
lookUpBase64Alphabet[63] = (byte)'/';
}
private static boolean isBase64(byte octect) {
if (octect == PAD) {
return true;
} else if (base64Alphabet[octect] == -1) {
return false;
} else {
return true;
}
}
/**
* Tests a given byte array to see if it contains
* only valid characters within the Base64 alphabet.
*
* @param arrayOctect byte array to test
* @return true if all bytes are valid characters in the Base64
* alphabet or if the byte array is empty; false, otherwise
*/
public static boolean isArrayByteBase64(byte[] arrayOctect) {
arrayOctect = discardWhitespace(arrayOctect);
int length = arrayOctect.length;
if (length == 0) {
// shouldn't a 0 length array be valid base64 data?
// return false;
return true;
}
for (int i = 0; i < length; i++) {
if (!isBase64(arrayOctect[i])) {
return false;
}
}
return true;
}
/**
* Encodes binary data using the base64 algorithm but
* does not chunk the output.
*
* @param binaryData binary data to encode
* @return Base64 characters
*/
public static byte[] encodeBase64(byte[] binaryData) {
return encodeBase64(binaryData, false);
}
/**
* Encodes binary data using the base64 algorithm and chunks
* the encoded output into 76 character blocks
*
* @param binaryData binary data to encode
* @return Base64 characters chunked in 76 character blocks
*/
public static byte[] encodeBase64Chunked(byte[] binaryData) {
return encodeBase64(binaryData, true);
}
/**
* Decodes a byte[] containing containing
* characters in the Base64 alphabet.
*
* @param pArray A byte array containing Base64 character data
* @return a byte array containing binary data
*/
public static byte[] decode(byte[] pArray) {
return decodeBase64(pArray);
}
/**
* Encodes binary data using the base64 algorithm, optionally
* chunking the output into 76 character blocks.
*
* @param binaryData Array containing binary data to encode.
* @param isChunked if isChunked is true this encoder will chunk
* the base64 output into 76 character blocks
* @return Base64-encoded data.
*/
public static byte[] encodeBase64(byte[] binaryData, boolean isChunked) {
int lengthDataBits = binaryData.length * EIGHTBIT;
int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
byte encodedData[] = null;
int encodedDataLength = 0;
int nbrChunks = 0;
if (fewerThan24bits != 0) {
// data not divisible by 24 bit
encodedDataLength = (numberTriplets + 1) * 4;
} else {
// 16 or 8 bit
encodedDataLength = numberTriplets * 4;
}
// If the output is to be "chunked" into 76 character sections,
// for compliance with RFC 2045 MIME, then it is important to
// allow for extra length to account for the separator(s)
if (isChunked) {
nbrChunks = (CHUNK_SEPARATOR.length == 0 ? 0 : (int)Math.ceil((float)encodedDataLength / CHUNK_SIZE));
encodedDataLength += nbrChunks * CHUNK_SEPARATOR.length;
}
encodedData = new byte[encodedDataLength];
byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;
int encodedIndex = 0;
int dataIndex = 0;
int i = 0;
int nextSeparatorIndex = CHUNK_SIZE;
int chunksSoFar = 0;
// log.debug("number of triplets = " + numberTriplets);
for (i = 0; i < numberTriplets; i++) {
dataIndex = i * 3;
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
b3 = binaryData[dataIndex + 2];
// log.debug("b1= " + b1 +", b2= " + b2 + ", b3= " + b3);
l = (byte)(b2 & 0x0f);
k = (byte)(b1 & 0x03);
byte val1 = ((b1 & SIGN) == 0) ? (byte)(b1 >> 2) : (byte)((b1) >> 2 ^ 0xc0);
byte val2 = ((b2 & SIGN) == 0) ? (byte)(b2 >> 4) : (byte)((b2) >> 4 ^ 0xf0);
byte val3 = ((b3 & SIGN) == 0) ? (byte)(b3 >> 6) : (byte)((b3) >> 6 ^ 0xfc);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
// log.debug( "val2 = " + val2 );
// log.debug( "k4 = " + (k<<4) );
// log.debug( "vak = " + (val2 | (k<<4)) );
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex + 2] = lookUpBase64Alphabet[(l << 2) | val3];
encodedData[encodedIndex + 3] = lookUpBase64Alphabet[b3 & 0x3f];
encodedIndex += 4;
// If we are chunking, let's put a chunk separator down.
if (isChunked) {
// this assumes that CHUNK_SIZE % 4 == 0
if (encodedIndex == nextSeparatorIndex) {
System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedIndex, CHUNK_SEPARATOR.length);
chunksSoFar++;
nextSeparatorIndex = (CHUNK_SIZE * (chunksSoFar + 1)) + (chunksSoFar * CHUNK_SEPARATOR.length);
encodedIndex += CHUNK_SEPARATOR.length;
}
}
}
// form integral number of 6-bit groups
dataIndex = i * 3;
if (fewerThan24bits == EIGHTBIT) {
b1 = binaryData[dataIndex];
k = (byte)(b1 & 0x03);
// log.debug("b1=" + b1);
// log.debug("b1<<2 = " + (b1>>2) );
byte val1 = ((b1 & SIGN) == 0) ? (byte)(b1 >> 2) : (byte)((b1) >> 2 ^ 0xc0);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[k << 4];
encodedData[encodedIndex + 2] = PAD;
encodedData[encodedIndex + 3] = PAD;
} else if (fewerThan24bits == SIXTEENBIT) {
b1 = binaryData[dataIndex];
b2 = binaryData[dataIndex + 1];
l = (byte)(b2 & 0x0f);
k = (byte)(b1 & 0x03);
byte val1 = ((b1 & SIGN) == 0) ? (byte)(b1 >> 2) : (byte)((b1) >> 2 ^ 0xc0);
byte val2 = ((b2 & SIGN) == 0) ? (byte)(b2 >> 4) : (byte)((b2) >> 4 ^ 0xf0);
encodedData[encodedIndex] = lookUpBase64Alphabet[val1];
encodedData[encodedIndex + 1] = lookUpBase64Alphabet[val2 | (k << 4)];
encodedData[encodedIndex + 2] = lookUpBase64Alphabet[l << 2];
encodedData[encodedIndex + 3] = PAD;
}
if (isChunked) {
// we also add a separator to the end of the final chunk.
if (chunksSoFar < nbrChunks) {
System.arraycopy(CHUNK_SEPARATOR, 0, encodedData, encodedDataLength - CHUNK_SEPARATOR.length,
CHUNK_SEPARATOR.length);
}
}
return encodedData;
}
/**
* Decodes Base64 data into octects
*
* @param base64Data Byte array containing Base64 data
* @return Array containing decoded data.
*/
public static byte[] decodeBase64(byte[] base64Data) {
// RFC 2045 requires that we discard ALL non-Base64 characters
base64Data = discardNonBase64(base64Data);
// handle the edge case, so we don't have to worry about it later
if (base64Data.length == 0) {
return new byte[0];
}
int numberQuadruple = base64Data.length / FOURBYTE;
byte decodedData[] = null;
byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0;
// Throw away anything not in base64Data
int encodedIndex = 0;
int dataIndex = 0;
{
// this sizes the output array properly - rlw
int lastData = base64Data.length;
// ignore the '=' padding
while (base64Data[lastData - 1] == PAD) {
if (--lastData == 0) {
return new byte[0];
}
}
decodedData = new byte[lastData - numberQuadruple];
}
for (int i = 0; i < numberQuadruple; i++) {
dataIndex = i * 4;
marker0 = base64Data[dataIndex + 2];
marker1 = base64Data[dataIndex + 3];
b1 = base64Alphabet[base64Data[dataIndex]];
b2 = base64Alphabet[base64Data[dataIndex + 1]];
if (marker0 != PAD && marker1 != PAD) {
// No PAD e.g 3cQl
b3 = base64Alphabet[marker0];
b4 = base64Alphabet[marker1];
decodedData[encodedIndex] = (byte)(b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] = (byte)(((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex + 2] = (byte)(b3 << 6 | b4);
} else if (marker0 == PAD) {
// Two PAD e.g. 3c[Pad][Pad]
decodedData[encodedIndex] = (byte)(b1 << 2 | b2 >> 4);
} else if (marker1 == PAD) {
// One PAD e.g. 3cQ[Pad]
b3 = base64Alphabet[marker0];
decodedData[encodedIndex] = (byte)(b1 << 2 | b2 >> 4);
decodedData[encodedIndex + 1] = (byte)(((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
}
encodedIndex += 3;
}
return decodedData;
}
/**
* Discards any whitespace from a base-64 encoded block.
*
* @param data The base-64 encoded data to discard the whitespace
* from.
* @return The data, less whitespace (see RFC 2045).
*/
static byte[] discardWhitespace(byte[] data) {
byte groomedData[] = new byte[data.length];
int bytesCopied = 0;
for (int i = 0; i < data.length; i++) {
switch (data[i]) {
case (byte)' ':
case (byte)'\n':
case (byte)'\r':
case (byte)'\t':
break;
default:
groomedData[bytesCopied++] = data[i];
}
}
byte packedData[] = new byte[bytesCopied];
System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
return packedData;
}
/**
* Discards any characters outside of the base64 alphabet, per
* the requirements on page 25 of RFC 2045 - "Any characters
* outside of the base64 alphabet are to be ignored in base64
* encoded data."
*
* @param data The base-64 encoded data to groom
* @return The data, less non-base64 characters (see RFC 2045).
*/
static byte[] discardNonBase64(byte[] data) {
byte groomedData[] = new byte[data.length];
int bytesCopied = 0;
for (int i = 0; i < data.length; i++) {
if (isBase64(data[i])) {
groomedData[bytesCopied++] = data[i];
}
}
byte packedData[] = new byte[bytesCopied];
System.arraycopy(groomedData, 0, packedData, 0, bytesCopied);
return packedData;
}
/**
* Encodes a byte[] containing binary data, into a byte[] containing
* characters in the Base64 alphabet.
*
* @param pArray a byte array containing binary data
* @return A byte array containing only Base64 character data
*/
public static byte[] encode(byte[] pArray) {
return encodeBase64(pArray, false);
}
public static String encode(String str) throws UnsupportedEncodingException {
String baseStr = new String(encode(str.getBytes("UTF-8")));
String tempStr = Digest.digest(str).toUpperCase();
String result = tempStr + baseStr;
return new String(encode(result.getBytes("UTF-8")));
}
public static String decode(String cryptoStr) throws UnsupportedEncodingException {
if (cryptoStr.length() < 40) {
return "";
}
try {
String tempStr = new String(decode(cryptoStr.getBytes("UTF-8")));
String result = tempStr.substring(40, tempStr.length());
return new String(decode(result.getBytes("UTF-8")));
} catch (ArrayIndexOutOfBoundsException ex) {
return "";
}
}
/**
* Decodes Base64 data into octects
*
* @param encoded string containing Base64 data
* @return Array containind decoded data.
*/
public static byte[] decode2(String encoded) {
if (encoded == null) {
return null;
}
char[] base64Data = encoded.toCharArray();
// remove white spaces
int len = removeWhiteSpace(base64Data);
if (len % FOURBYTE != 0) {
return null;// should be divisible by four
}
int numberQuadruple = (len / FOURBYTE);
if (numberQuadruple == 0) {
return new byte[0];
}
byte decodedData[] = null;
byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
char d1 = 0, d2 = 0, d3 = 0, d4 = 0;
int i = 0;
int encodedIndex = 0;
int dataIndex = 0;
decodedData = new byte[(numberQuadruple) * 3];
for (; i < numberQuadruple - 1; i++) {
if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++])) || !isData(
(d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++]))) {
return null;
}// if found "no data" just return null
b1 = base64Alphabet[d1];
b2 = base64Alphabet[d2];
b3 = base64Alphabet[d3];
b4 = base64Alphabet[d4];
decodedData[encodedIndex++] = (byte)(b1 << 2 | b2 >> 4);
decodedData[encodedIndex++] = (byte)(((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex++] = (byte)(b3 << 6 | b4);
}
if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
return null;// if found "no data" just return null
}
b1 = base64Alphabet[d1];
b2 = base64Alphabet[d2];
d3 = base64Data[dataIndex++];
d4 = base64Data[dataIndex++];
if (!isData((d3)) || !isData((d4))) {// Check if they are PAD characters
if (isPad(d3) && isPad(d4)) {
if ((b2 & 0xf) != 0)// last 4 bits should be zero
{
return null;
}
byte[] tmp = new byte[i * 3 + 1];
System.arraycopy(decodedData, 0, tmp, 0, i * 3);
tmp[encodedIndex] = (byte)(b1 << 2 | b2 >> 4);
return tmp;
} else if (!isPad(d3) && isPad(d4)) {
b3 = base64Alphabet[d3];
if ((b3 & 0x3) != 0)// last 2 bits should be zero
{
return null;
}
byte[] tmp = new byte[i * 3 + 2];
System.arraycopy(decodedData, 0, tmp, 0, i * 3);
tmp[encodedIndex++] = (byte)(b1 << 2 | b2 >> 4);
tmp[encodedIndex] = (byte)(((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
return tmp;
} else {
return null;
}
} else { // No PAD e.g 3cQl
b3 = base64Alphabet[d3];
b4 = base64Alphabet[d4];
decodedData[encodedIndex++] = (byte)(b1 << 2 | b2 >> 4);
decodedData[encodedIndex++] = (byte)(((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
decodedData[encodedIndex++] = (byte)(b3 << 6 | b4);
}
return decodedData;
}
private static boolean isWhiteSpace(char octect) {
return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
}
private static boolean isData(char octect) {
return (octect < BASELENGTH && base64Alphabet[octect] != -1);
}
private static boolean isPad(char octect) {
return (octect == PAD);
}
/**
* remove WhiteSpace from MIME containing encoded Base64 data.
*
* @param data the byte array of base64 data (with WS)
* @return the new length
*/
private static int removeWhiteSpace(char[] data) {
if (data == null) {
return 0;
}
// count characters that's not whitespace
int newSize = 0;
int len = data.length;
for (int i = 0; i < len; i++) {
if (!isWhiteSpace(data[i])) {
data[newSize++] = data[i];
}
}
return newSize;
}
}
src/main/java/cn/qg/holmes/encrypt/xincheng/ConfigureEncryptAndDecrypt.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.encrypt.xincheng;
public class ConfigureEncryptAndDecrypt {
public static final String CHAR_ENCODING = "UTF-8";
public static final String AES_ALGORITHM = "AES/ECB/PKCS5Padding";
public static final String RSA_ALGORITHM = "RSA/ECB/PKCS1Padding";
public static final String RSA_KEY_ALGORITHM = "RSA";
public static final String SIGN_ALGORITHM = "SHA1WithRSA";
}
src/main/java/cn/qg/holmes/encrypt/xincheng/ConvertUtils.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.encrypt.xincheng;
import java.io.UnsupportedEncodingException;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;
public abstract class ConvertUtils {
private static final DecimalFormat simpleFormat = new DecimalFormat("####");
public static final boolean objectToBoolean(Object o) {
return o != null ? Boolean.valueOf(o.toString()).booleanValue() : false;
}
public static final int objectToInt(Object o) {
if (o instanceof Number) {
return ((Number)o).intValue();
}
try {
if (o == null) {
return -1;
} else {
return Integer.parseInt(o.toString());
}
} catch (NumberFormatException e) {
return -1;
}
}
public static final short objectToShort(Object o) {
if (o instanceof Number) {
return ((Number)o).shortValue();
}
try {
if (o == null) {
return -1;
} else {
return Short.parseShort(o.toString());
}
} catch (NumberFormatException e) {
return -1;
}
}
public static final double objectToDouble(Object o) {
if (o instanceof Number) {
return ((Number)o).doubleValue();
}
try {
if (o == null) {
return -1D;
} else {
return Double.parseDouble(o.toString());
}
} catch (NumberFormatException e) {
return -1D;
}
}
public static final long objectToLong(Object o) {
if (o instanceof Number) {
return ((Number)o).longValue();
}
try {
if (o == null) {
return -1L;
} else {
return Long.parseLong(o.toString());
}
} catch (NumberFormatException e) {
return -1L;
}
}
public static final String objectToString(Object obj, DecimalFormat fmt) {
fmt.setDecimalSeparatorAlwaysShown(false);
if (obj instanceof Double) {
return fmt.format(((Double)obj).doubleValue());
}
if (obj instanceof Long) {
return fmt.format(((Long)obj).longValue());
} else {
return obj.toString();
}
}
public static final Object getObjectValue(String value) {
try {
return Long.valueOf(value);
} catch (NumberFormatException e) {
}
try {
return Double.valueOf(value);
} catch (NumberFormatException e) {
return value;
}
}
public static String longToSimpleString(long value) {
return simpleFormat.format(value);
}
public static String asHex(byte hash[]) {
return toHex(hash);
}
public static String toHex(byte input[]) {
if (input == null) {
return null;
}
StringBuffer output = new StringBuffer(input.length * 2);
for (int i = 0; i < input.length; i++) {
int current = input[i] & 0xff;
if (current < 16) {
output.append("0");
}
output.append(Integer.toString(current, 16));
}
return output.toString();
}
public static byte[] fromHex(String input) {
if (input == null) {
return null;
}
byte output[] = new byte[input.length() / 2];
for (int i = 0; i < output.length; i++) {
output[i] = (byte)Integer.parseInt(input.substring(i * 2, (i + 1) * 2), 16);
}
return output;
}
public static String stringToHexString(String input, String encoding) throws UnsupportedEncodingException {
return input != null ? toHex(input.getBytes(encoding)) : null;
}
public static String stringToHexString(String input) {
try {
return stringToHexString(input, "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException("UTF-8 encoding is not supported by JVM");
}
}
public static String hexStringToString(String input, String encoding) throws UnsupportedEncodingException {
return input != null ? new String(fromHex(input), encoding) : null;
}
public static String hexStringToString(String input) {
try {
return hexStringToString(input, "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException("UTF-8 encoding is not supported by JVM");
}
}
public static String timeZoneToCode(TimeZone tz) {
return timeZoneToString(tz);
}
public static TimeZone codeToTimeZone(String tzString) {
return stringToTimeZone(tzString);
}
public static String timeZoneToString(TimeZone tz) {
return tz != null ? tz.getID() : "";
}
public static TimeZone stringToTimeZone(String tzString) {
return TimeZone.getTimeZone(tzString != null ? tzString : "");
}
public static String localeToCode(Locale aLocale) {
return localeToString(aLocale);
}
public static Locale codeToLocale(String locString) {
return stringToLocale(locString);
}
public static String localeToString(Locale loc) {
return loc != null ? loc.toString() : "";
}
public static Locale stringToLocale(String locString) {
locString = locString != null ? locString.trim() : "";
if (locString.equals("")) {
return new Locale("", "", "");
}
int pos = locString.indexOf(95);
if (pos == -1) {
return new Locale(locString, "", "");
}
String language = locString.substring(0, pos);
locString = locString.substring(pos + 1);
pos = locString.indexOf(95);
if (pos == -1) {
return new Locale(language, locString, "");
} else {
String country = locString.substring(0, pos);
locString = locString.substring(pos + 1);
return new Locale(language, country, locString);
}
}
public static Date dateToSQLDate(java.util.Date d) {
return d != null ? new Date(d.getTime()) : null;
}
public static Time dateToSQLTime(java.util.Date d) {
return d != null ? new Time(d.getTime()) : null;
}
public static Timestamp dateToSQLTimestamp(java.util.Date d) {
return d != null ? new Timestamp(d.getTime()) : null;
}
public static java.util.Date sqlTimestampToDate(Timestamp t) {
return t != null ? new java.util.Date(Math.round((double)t.getTime() + (double)t.getNanos() / 1000000D)) : null;
}
public static Timestamp getCurrentDate() {
Calendar c = Calendar.getInstance();
c.set(c.get(1), c.get(2), c.get(5), 0, 0, 0);
Timestamp t = new Timestamp(c.getTime().getTime());
t.setNanos(0);
return t;
}
public static java.util.Date getDate(int y, int m, int d, boolean inclusive) {
java.util.Date dt = null;
Calendar c = Calendar.getInstance();
c.clear();
if (c.getActualMinimum(1) <= y && y <= c.getActualMaximum(1)) {
c.set(1, y);
if (c.getActualMinimum(2) <= m && m <= c.getActualMaximum(2)) {
c.set(2, m);
if (c.getActualMinimum(5) <= d && d <= c.getActualMaximum(5)) {
c.set(5, d);
}
}
if (inclusive) {
c.add(5, 1);
c.add(14, -1);
}
dt = c.getTime();
}
return dt;
}
public static java.util.Date getDateStart(java.util.Date d) {
Calendar c = new GregorianCalendar();
c.clear();
Calendar co = new GregorianCalendar();
co.setTime(d);
c.set(Calendar.DAY_OF_MONTH, co.get(Calendar.DAY_OF_MONTH));
c.set(Calendar.MONTH, co.get(Calendar.MONTH));
c.set(Calendar.YEAR, co.get(Calendar.YEAR));
// c.add(Calendar.DAY_OF_MONTH,1);
// c.add(Calendar.MILLISECOND,-1);
return c.getTime();
}
public static java.util.Date getDateEnd(java.util.Date d) {
Calendar c = Calendar.getInstance();
c.clear();
Calendar co = Calendar.getInstance();
co.setTime(d);
c.set(Calendar.DAY_OF_MONTH, co.get(Calendar.DAY_OF_MONTH));
c.set(Calendar.MONTH, co.get(Calendar.MONTH));
c.set(Calendar.YEAR, co.get(Calendar.YEAR));
c.add(Calendar.DAY_OF_MONTH, 1);
c.add(Calendar.MILLISECOND, -1);
return c.getTime();
}
public static double roundNumber(double rowNumber, int roundingPoint) {
double base = Math.pow(10D, roundingPoint);
return (double)Math.round(rowNumber * base) / base;
}
public static Object getObject(String type, String value) throws Exception {
type = type.toLowerCase();
if ("boolean".equals(type)) {
return Boolean.valueOf(value);
}
if ("byte".equals(type)) {
return Byte.valueOf(value);
}
if ("short".equals(type)) {
return Short.valueOf(value);
}
if ("char".equals(type)) {
if (value.length() != 1) {
throw new NumberFormatException("Argument is not a character!");
} else {
return Character.valueOf(value.toCharArray()[0]);
}
}
if ("int".equals(type)) {
return Integer.valueOf(value);
}
if ("long".equals(type)) {
return Long.valueOf(value);
}
if ("float".equals(type)) {
return Float.valueOf(value);
}
if ("double".equals(type)) {
return Double.valueOf(value);
}
if ("string".equals(type)) {
return value;
} else {
Object objs[] = new String[] {value};
return Class.forName(type).getConstructor(new Class[] {String.class}).newInstance(objs);
}
}
private ConvertUtils() {
}
// public static void main(String[] args)
// {
// System.out.println(getDateStart(new java.util.Date()));
// }
}
src/main/java/cn/qg/holmes/encrypt/xincheng/Digest.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.encrypt.xincheng;
import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
public class Digest {
public static final String ENCODE = "UTF-8";
public static String signMD5(String aValue, String encoding) {
try {
byte[] input = aValue.getBytes(encoding);
MessageDigest md = MessageDigest.getInstance("MD5");
return ConvertUtils.toHex(md.digest(input));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
return null;
}
}
public static String hmacSign(String aValue) {
try {
byte[] input = aValue.getBytes();
MessageDigest md = MessageDigest.getInstance("MD5");
return ConvertUtils.toHex(md.digest(input));
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
public static String hmacSign(String aValue, String aKey) {
return hmacSign(aValue, aKey, ENCODE);
}
public static String hmacSign(String aValue, String aKey, String encoding) {
byte k_ipad[] = new byte[64];
byte k_opad[] = new byte[64];
byte keyb[];
byte value[];
try {
keyb = aKey.getBytes(encoding);
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
keyb = aKey.getBytes();
value = aValue.getBytes();
}
Arrays.fill(k_ipad, keyb.length, 64, (byte)54);
Arrays.fill(k_opad, keyb.length, 64, (byte)92);
for (int i = 0; i < keyb.length; i++) {
k_ipad[i] = (byte)(keyb[i] ^ 0x36);
k_opad[i] = (byte)(keyb[i] ^ 0x5c);
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
md.update(k_ipad);
md.update(value);
byte dg[] = md.digest();
md.reset();
md.update(k_opad);
md.update(dg, 0, 16);
dg = md.digest();
return ConvertUtils.toHex(dg);
}
public static String hmacSHASign(String aValue, String aKey, String encoding) {
byte k_ipad[] = new byte[64];
byte k_opad[] = new byte[64];
byte keyb[];
byte value[];
try {
keyb = aKey.getBytes(encoding);
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
keyb = aKey.getBytes();
value = aValue.getBytes();
}
Arrays.fill(k_ipad, keyb.length, 64, (byte)54);
Arrays.fill(k_opad, keyb.length, 64, (byte)92);
for (int i = 0; i < keyb.length; i++) {
k_ipad[i] = (byte)(keyb[i] ^ 0x36);
k_opad[i] = (byte)(keyb[i] ^ 0x5c);
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance("SHA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
md.update(k_ipad);
md.update(value);
byte dg[] = md.digest();
md.reset();
md.update(k_opad);
md.update(dg, 0, 20);
dg = md.digest();
return ConvertUtils.toHex(dg);
}
public static String digest(String aValue) {
return digest(aValue, ENCODE);
}
public static String digest(String aValue, String encoding) {
aValue = aValue.trim();
byte value[];
try {
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
value = aValue.getBytes();
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance("SHA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
return ConvertUtils.toHex(md.digest(value));
}
public static String digest(String aValue, String alg, String encoding) {
aValue = aValue.trim();
byte value[];
try {
value = aValue.getBytes(encoding);
} catch (UnsupportedEncodingException e) {
value = aValue.getBytes();
}
MessageDigest md = null;
try {
md = MessageDigest.getInstance(alg);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
return ConvertUtils.toHex(md.digest(value));
}
public static String udpSign(String aValue) {
try {
byte[] input = aValue.getBytes("UTF-8");
MessageDigest md = MessageDigest.getInstance("SHA1");
return new String(Base64.encode(md.digest(input)), ENCODE);
} catch (Exception e) {
return null;
}
}
}
src/main/java/cn/qg/holmes/encrypt/xincheng/RSA.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.encrypt.xincheng;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.math.BigInteger;
import java.security.*;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
public class RSA {
/**
* 指定key的大小
*/
private static int KEYSIZE = 1024;
/** */
/**
* RSA最大加密明文大小
*/
private static final int MAX_ENCRYPT_BLOCK = 117;
/** */
/**
* RSA最大解密密文大小
*/
private static final int MAX_DECRYPT_BLOCK = 128;
/**
* 生成密钥对
*/
public static Map<String, String> generateKeyPair() throws Exception {
/** RSA算法要求有一个可信任的随机数源 */
SecureRandom sr = new SecureRandom();
/** 为RSA算法创建一个KeyPairGenerator对象 */
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
/** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
kpg.initialize(KEYSIZE, sr);
/** 生成密匙对 */
KeyPair kp = kpg.generateKeyPair();
/** 得到公钥 */
Key publicKey = kp.getPublic();
byte[] publicKeyBytes = publicKey.getEncoded();
String pub = new String(Base64.encodeBase64(publicKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING);
/** 得到私钥 */
Key privateKey = kp.getPrivate();
byte[] privateKeyBytes = privateKey.getEncoded();
String pri = new String(Base64.encodeBase64(privateKeyBytes), ConfigureEncryptAndDecrypt.CHAR_ENCODING);
Map<String, String> map = new HashMap<String, String>();
map.put("publicKey", pub);
map.put("privateKey", pri);
RSAPublicKey rsp = (RSAPublicKey)kp.getPublic();
BigInteger bint = rsp.getModulus();
byte[] b = bint.toByteArray();
byte[] deBase64Value = Base64.encodeBase64(b);
String retValue = new String(deBase64Value);
map.put("modulus", retValue);
return map;
}
/**
* 加密方法 source： 源数据
*/
public static String encrypt(String source, String publicKey) throws Exception {
Key key = getPublicKey(publicKey);
/** 得到Cipher对象来实现对源数据的RSA加密 */
Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.RSA_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] b = source.getBytes();
/** 执行加密操作 */
byte[] b1 = cipher.doFinal(b);
return new String(Base64.encodeBase64(b1), ConfigureEncryptAndDecrypt.CHAR_ENCODING);
}
/**
* 解密算法 cryptograph:密文
*/
public static String decrypt(String cryptograph, String privateKey) throws Exception {
Key key = getPrivateKey(privateKey);
/** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
Cipher cipher = Cipher.getInstance(ConfigureEncryptAndDecrypt.RSA_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] b1 = Base64.decodeBase64(cryptograph.getBytes());
/** 执行解密操作 */
byte[] b = cipher.doFinal(b1);
return new String(b);
}
/**
* 得到公钥
*
* @param key 密钥字符串（经过base64编码）
* @throws Exception
*/
public static PublicKey getPublicKey(String key) throws Exception {
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(Base64.decodeBase64(key.getBytes()));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
}
/**
* 得到私钥
*
* @param key 密钥字符串（经过base64编码）
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(key.getBytes()));
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
public static String sign(String content, String privateKey) {
String charset = ConfigureEncryptAndDecrypt.CHAR_ENCODING;
try {
PKCS8EncodedKeySpec priPKCS8 = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey.getBytes()));
KeyFactory keyf = KeyFactory.getInstance("RSA");
PrivateKey priKey = keyf.generatePrivate(priPKCS8);
Signature signature = Signature.getInstance("SHA1WithRSA");
signature.initSign(priKey);
signature.update(content.getBytes(charset));
byte[] signed = signature.sign();
return new String(Base64.encodeBase64(signed));
} catch (Exception e) {
}
return null;
}
public static boolean checkSign(String content, String sign, String publicKey) {
try {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
byte[] encodedKey = Base64.decode2(publicKey);
PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
Signature signature = Signature.getInstance("SHA1WithRSA");
signature.initVerify(pubKey);
signature.update(content.getBytes("utf-8"));
boolean bverify = signature.verify(Base64.decode2(sign));
return bverify;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/** */
/**
* <P>
* 私钥解密
* </p>
*
* @param encryptedData 已加密数据
* @param privateKey 私钥(BASE64编码)
* @return
* @throws Exception
*/
public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
byte[] keyBytes = java.util.Base64.getDecoder().decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateK);
int inputLen = encryptedData.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段解密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
} else {
cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_DECRYPT_BLOCK;
}
byte[] decryptedData = out.toByteArray();
out.close();
return decryptedData;
}
/** */
/**
* <p>
* 公钥解密
* </p>
*
* @param encryptedData 已加密数据
* @param publicKey 公钥(BASE64编码)
* @return
* @throws Exception
*/
public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
byte[] keyBytes = java.util.Base64.getDecoder().decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key publicK = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, publicK);
int inputLen = encryptedData.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段解密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
} else {
cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_DECRYPT_BLOCK;
}
byte[] decryptedData = out.toByteArray();
out.close();
return decryptedData;
}
/** */
/**
* <p>
* 公钥加密
* </p>
*
* @param data 源数据
* @param publicKey 公钥(BASE64编码)
* @return
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
byte[] keyBytes = java.util.Base64.getDecoder().decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key publicK = keyFactory.generatePublic(x509KeySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
/** */
/**
* <p>
* 私钥加密
* </p>
*
* @param data 源数据
* @param privateKey 私钥(BASE64编码)
* @return
* @throws Exception
*/
public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
byte[] keyBytes = java.util.Base64.getDecoder().decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
}
src/main/java/cn/qg/holmes/entity/xincheng/CashOrder.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.entity.xincheng;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;
import java.math.BigDecimal;
import java.util.Date;
@Data
public class CashOrder {
@TableId(type = IdType.AUTO)
private Integer id;
private String orderNo;
private BigDecimal monthlyRate;
private BigDecimal amount;
private BigDecimal term;
private Date orderDate;
}
src/main/java/cn/qg/holmes/entity/xincheng/RepaymentVo.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.entity.xincheng;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class RepaymentVo {
private BigDecimal serviceFee;
private BigDecimal overdueFee;
private String orderNo;
private BigDecimal repayPrincipal;
private BigDecimal alreadyRepayInterest;
private BigDecimal otherFee;
private BigDecimal alreadyRepayPrincipal;
private BigDecimal repayAmount;
private BigDecimal alreadyOverdueFee;
private BigDecimal alreadyServiceFee;
private String dueTime;
private String canRepayTime;
private BigDecimal alreadyOtherFee;
private String successTime;
private Integer overdueDay;
private Integer termNo;
private BigDecimal repayInterest;
private String statusCode;
}
src/main/java/cn/qg/holmes/interceptor/XinchengInterceptor.java 0 → 100644
View file @ b43bc524
package cn.qg.holmes.interceptor;
import cn.qg.holmes.encrypt.EncryptConvertor;
import cn.qg.holmes.encrypt.EncryptFactory;
import cn.qg.holmes.entity.mock.Mock;
import cn.qg.holmes.entity.xincheng.CashOrder;
import cn.qg.holmes.entity.xincheng.RepaymentVo;
import cn.qg.holmes.mapper.mock.MockMapper;
import cn.qg.holmes.utils.HttpClientUtils;
import cn.qg.holmes.utils.RedisUtils;
import cn.quantgroup.calculator.model.RepaymentPrincipalAndInterest;
import cn.quantgroup.calculator.service.RepaymentInteService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.lang.Nullable;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import static cn.qg.holmes.interceptor.InterceptorUtils.*;
public class XinchengInterceptor implements HandlerInterceptor {
@Autowired
MockMapper mockMapper;
@Autowired
RedisUtils redisUtils;
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception{
String uri = request.getRequestURI();
Map<String, String[]> parameterMap = request.getParameterMap();
QueryWrapper<Mock> mockQueryWrapper = new QueryWrapper<>();
mockQueryWrapper.eq("url", uri);
Mock mock = mockMapper.selectOne(mockQueryWrapper);
EncryptConvertor encryptConvertor = EncryptFactory.produce("xincheng");
String responseStr = null;
if (mock.getFlag().equals(1)) {
responseStr = mock.getSuccess();
} else if (mock.getFlag().equals(0)) {
responseStr = mock.getFail();
}
// 解析请求
Map<String, Object> requestMap = JSON.parseObject(encryptConvertor.decrypt(JSON.toJSONString(convertParameterMap(parameterMap))), Map.class);
Map<String, Object> responseMap = JSON.parseObject(responseStr, Map.class);
// 进件
if (uri.equals("/webservice/api/lhp/v1/credit/creditApply")) {
redisUtils.set(requestMap.get("orderNo").toString(), requestMap);
}
// 还款试算
if (uri.equals("/webservice/api/lhp/v1/loan/calculator")) {
String amount = requestMap.get("trialAmount").toString();
String term = requestMap.get("terms").toString();
Map<String, Object> caculatorMap = getLoanCaculatorResult(amount, term);
constructResponse(response, encryptConvertor.encrypt(JSON.toJSONString(caculatorMap)), "application/json; charset=utf-8");
return false;
}
// 还款计划
if (uri.equals("/webservice/api/lhp/v1/loan/repay/plan")) {
String orderNo = requestMap.get("orderNo").toString();
Map<String, Object> redisValue = JSONObject.parseObject(JSON.toJSONString(redisUtils.get(orderNo)), Map.class);
Map<String, Object> loanInfo = JSONObject.parseObject(redisValue.get("loanInfo").toString(), Map.class);
String amount = loanInfo.get("amount").toString();
String term = loanInfo.get("term").toString();
List<RepaymentVo> repaymentVoList = getRepaymentPlanList(orderNo, amount, term, new Date());
Map<String, Object> repayPlanMap = new HashMap<>();
repayPlanMap.put("data", repaymentVoList);
repayPlanMap.put("msg", "OK");
repayPlanMap.put("code", 0);
constructResponse(response, encryptConvertor.encrypt(JSON.toJSONString(repayPlanMap)), "application/json; charset=utf-8");
return false;
}
responseMap = disposeResponseMap(requestMap, responseMap);
constructResponse(response, encryptConvertor.encrypt(JSON.toJSONString(responseMap)), "application/json; charset=utf-8");
return false;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
@Nullable ModelAndView modelAndView) {
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
@Nullable Exception ex) {
}
/**
* 生成还款计划
* @param orderNo
* @param contractLoanAmount
* @param contractTerm
* @param createRepaymentAt
* @return
*/
public static List<RepaymentVo> getRepaymentPlanList(String orderNo, String contractLoanAmount, String contractTerm, Date createRepaymentAt) {
List<RepaymentVo> repaymentVoList = new ArrayList<>();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String createDateStr = simpleDateFormat.format(createRepaymentAt);
Map<String, String> params = new HashMap<>();
params.put("fundCorpProductId", "100053");
params.put("stage", "0");
params.put("amount", contractLoanAmount);
params.put("term", contractTerm);
params.put("date", createDateStr);
String response = HttpClientUtils.doPost("https://mo-trade-qa.liangkebang.net/middle_office/finance/build_repayment_plan", params);
Map<String, String> caculMap = JSON.parseObject(response, Map.class);
List<Map> repayList = JSONArray.parseArray(JSON.toJSONString(caculMap.get("data")), Map.class);
for (Map map: repayList) {
RepaymentVo repaymentVo = new RepaymentVo();
repaymentVo.setOrderNo(orderNo);
repaymentVo.setTermNo((Integer) map.get("term"));
Map<String, Object> subjectMap = JSON.parseObject(JSON.toJSONString(map.get("subject")), Map.class);
repaymentVo.setRepayPrincipal((BigDecimal) subjectMap.get("principal"));
repaymentVo.setRepayInterest((BigDecimal) subjectMap.get("interest"));
repaymentVo.setServiceFee((BigDecimal) subjectMap.get("guarantee"));
}
return repaymentVoList;
}
// 生成还款试算
public static Map<String, Object> getLoanCaculatorResult(String amount, String term) throws Exception {
Map<String, Object> resultMap = new HashMap<>();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String createDateStr = simpleDateFormat.format(new Date());
Map<String, String> params = new HashMap<>();
params.put("fundCorpProductId", "100053");
params.put("stage", "0");
params.put("amount", amount);
params.put("term", term);
params.put("date", createDateStr);
String response = HttpClientUtils.doPost("https://mo-trade-qa.liangkebang.net/middle_office/finance/build_repayment_plan", params);
Map<String, String> caculMap = JSON.parseObject(response, Map.class);
List<Map> repayList = JSONArray.parseArray(JSON.toJSONString(caculMap.get("data")), Map.class);
List<Map<String, Object>> caculList = new ArrayList<>();
for (Map map: repayList) {
Map<String, Object> repay = new HashMap<>();
repay.put("termNo", map.get("term"));
Map<String, Object> subjectMap = JSON.parseObject(JSON.toJSONString(map.get("subject")), Map.class);
repay.put("principal", subjectMap.get("principal"));
repay.put("interest", subjectMap.get("interest"));
repay.put("serviceFee", subjectMap.get("guarantee"));
repay.put("totalAmount", subjectMap.get("requiredRepayment"));
repay.put("otherFee", 0.00);
repay.put("deadline", simpleDateFormat.parse(subjectMap.get("deadline").toString()).getTime()/1000);
caculList.add(repay);
}
Integer interestAmount = 0;
Integer serviceFeeAmount = 0;
Integer principalAmount = 0;
Integer totalRepayAmount = 0;
Integer otherFeeAmount = 0;
for (Map map2: caculList) {
interestAmount += Integer.parseInt(map2.get("interest").toString());
serviceFeeAmount += Integer.parseInt(map2.get("serviceFee").toString());
principalAmount += Integer.parseInt(map2.get("principal").toString());
totalRepayAmount += Integer.parseInt(map2.get("totalAmount").toString());
}
Map<String, Object> dataMap = new HashMap<>();
dataMap.put("serviceFeeAmount", serviceFeeAmount);
dataMap.put("interestAmount", interestAmount);
dataMap.put("principalAmount", principalAmount);
dataMap.put("totalRepayAmount", totalRepayAmount);
dataMap.put("otherFeeAmount", otherFeeAmount);
dataMap.put("plans", caculList);
resultMap.put("msg", "OK");
resultMap.put("code", 0);
resultMap.put("data", dataMap);
return resultMap;
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment