liuc/biz_supplier_manage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

客服-提供项目的负责人信息

Browse Source
This commit is contained in:
yss
2024-09-09 11:23:48 +08:00
parent 80a600ce7b
commit 37c5ca5e6e
5 changed files with 489 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

367
src/main/java/com/chinaunicom/mall/ebtp/project/common/RSAUtil.java Normal file
View File

@ -0,0 +1,367 @@
package com.chinaunicom.mall.ebtp.project.common;
import com.chinaunicom.mall.ebtp.common.exception.common.CommonExceptionEnum;
import lombok.extern.slf4j.Slf4j;
import javax.crypto.Cipher;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
@Slf4j
public class RSAUtil {
public static final String KEY_ALGORITHM = "RSA";
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
private static final String PUBLIC_KEY = "RSAPublicKey";
private static final String PRIVATE_KEY = "RSAPrivateKey";
/**
* 初始化密钥
*
* @return
* @throws Exception
*/
public static Map<String, Object> initKey() throws Exception {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
// 公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
// logger.info("------" + publicKey);
// 私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
// logger.info("------" + publicKey);
Map<String, Object> keyMap = new HashMap <String, Object>(2);
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 取得私钥
*
* @param keyMap
* @return
* @throws Exception
*/
public static String getPrivateKey(Map<String, Object> keyMap)
throws Exception {
Key key = (Key) keyMap.get(PRIVATE_KEY);
return encryptBASE64(key.getEncoded());
}
/**
* 取得公钥
*
* @param keyMap
* @return
* @throws Exception
*/
public static String getPublicKey(Map<String, Object> keyMap)
throws Exception {
Key key = (Key) keyMap.get(PUBLIC_KEY);
return encryptBASE64(key.getEncoded());
}
/**
* 解密<br>
* 用私钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPrivateKey(byte[] data, String key)
throws Exception {
// 对密钥解密
byte[] keyBytes = decryptBASE64(key);
// 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
// 对数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 解密<br>
* 用私钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static String decryptByPrivateKeyString(byte[] data, String key)
throws Exception {
return new String(decryptByPrivateKey(data, key));
}
/**
* 解密<br>
* 用公钥解密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] decryptByPublicKey(byte[] data, String key)
throws Exception {
// 对密钥解密
byte[] keyBytes = decryptBASE64(key);
// 取得公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key publicKey = keyFactory.generatePublic(x509KeySpec);
// 对数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 加密<br>
* 用公钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, String key)
throws Exception {
// 对公钥解密
byte[] keyBytes = decryptBASE64(key);
// 取得公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key publicKey = keyFactory.generatePublic(x509KeySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return cipher.doFinal(data);
}
/**
* 加密<br>
* 用私钥加密
*
* @param data
* @param key
* @return
* @throws Exception
*/
public static byte[] encryptByPrivateKey(byte[] data, String key)
throws Exception {
// 对密钥解密
byte[] keyBytes = decryptBASE64(key);
// 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 用私钥对信息生成数字签名
*
* @param data
* 加密数据
* @param privateKey
* 私钥
*
* @return
* @throws Exception
*/
public static String sign(byte[] data, String privateKey) throws Exception {
// 解密由base64编码的私钥
byte[] keyBytes = decryptBASE64(privateKey);
// 构造PKCS8EncodedKeySpec对象
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
// KEY_ALGORITHM 指定的加密算法
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
// 取私钥匙对象
PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
// 用私钥对信息生成数字签名
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(priKey);
signature.update(data);
return encryptBASE64(signature.sign());
}
/**
* 校验数字签名
*
* @param data
* 加密数据
* @param publicKey
* 公钥
* @param sign
* 数字签名
*
* @return 校验成功返回true 失败返回false
* @throws Exception
*
*/
public static boolean verify(byte[] data, String publicKey, String sign)
throws Exception {
// 解密由base64编码的公钥
byte[] keyBytes = decryptBASE64(publicKey);
// 构造X509EncodedKeySpec对象
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
// KEY_ALGORITHM 指定的加密算法
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
// 取公钥匙对象
PublicKey pubKey = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(pubKey);
signature.update(data);
// 验证签名是否正常
return signature.verify(decryptBASE64(sign));
}
public static byte[] decryptBASE64(String key) throws Exception {
return Base64.getDecoder().decode(key);
}
public static String encryptBASE64(byte[] key) throws Exception {
return Base64.getEncoder().encodeToString(key);
}
public static String encrypt(String value,String publicKey){
try {
String v = encryptBASE64(RSAUtil.encryptByPublicKey(value.getBytes(), publicKey));
return v;
}catch (Exception e){
log.error("加密异常",e);
CommonExceptionEnum.FRAME_EXCEPTION_COMMON_DATA_OTHER_ERROR.customValidName("加密异常", true);
}
return "";
}
public static String decrypt(String value,String privateKey){
try {
byte[] decodedData = decryptByPrivateKey(decryptBASE64(value), privateKey);
String target = new String(decodedData);
return target;
}catch (Exception e){
log.error("解密异常",e);
CommonExceptionEnum.FRAME_EXCEPTION_COMMON_DATA_OTHER_ERROR.customValidName("解密异常", true);
}
return "";
}
public static void main(String[] args) {
Map<String, Object> keyMap;
try {
//Map map = initKey();
//System.out.println(map);
// keyMap = initKey();
// System.out.println(keyMap);
//取得公钥和么私钥
//keyMap = initKey();
// String publicKey = getPublicKey(keyMap);
// String privateKey = getPrivateKey(keyMap);
String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC2Jje0B+QYd5o3njTmc74b4FyatzyrXm+bzuxLcjOwtSBoOtAi3j3NcyEheZuPBe1SDkbY+PMOAotEv+aGMZI79hkyIYjxw/RldR7GpKTU5eO+VWYlSH7g7E7o4IVGR/QltFGQd+8kyNJ40AYbMo6U7MCmlBm9S0WaKlHI9cOJhQIDAQAB";
String privateKey = "MIICeQIBADANBgkqhkiG9w0BAQEFAASCAmMwggJfAgEAAoGBALYmN7QH5Bh3mjeeNOZzvhvgXJq3PKteb5vO7EtyM7C1IGg60CLePc1zISF5m48F7VIORtj48w4Ci0S/5oYxkjv2GTIhiPHD9GV1HsakpNTl475VZiVIfuDsTujghUZH9CW0UZB37yTI0njQBhsyjpTswKaUGb1LRZoqUcj1w4mFAgMBAAECgYEAmG93YoTQEOHXAAC4iLwIN1AWb6w1a70GbkBHZARY2eNbEZ9WnDedRRi6e0dINfNh3q/v/pio3+qlHo3yoA9QLs68YW8yy1xgGqTBsFMhn8Zh1KQ7Alle0+KJdytvpfvf6/YwW6oUk2Y44vm6nVa8EjXKYqloV/PROMa0uTYWUQECQQDvMk/XJ1wjG42IoyLxVSfsMfSCelJvYBYxaFfNPxOYWdOfSSEnAj7QNkDnhuDrLbbsnyy3KvLnUqkILU8fuZLhAkEAwvH5MRwSXpjwZY8xFCLv4YShDB6pG8l4rScjzV5B8SL2DhE/evha5obMO5d+iB73JBP03W6juSCilksy5zovJQJBAI+/Q54ASG3MzCTWLVStIV3fs5qKGmpWa1/r3gA5rPP836G1GBhSUB9ey2iYdSjAg1L2Ya/+PpXn5i9E0200X+ECQQCCQ05QEoHz1B5Ovq/81JuWBhnXD2XQu393tH+n6yQFDWd9XukcMngLMmemKkTSkF50LSGiFRwxyCzcYMNS3v5BAkEA5t2hOtPieYU9SrFENtgQTvtU7WmUumS0mTsDnnGUKsx2hMn8acKPVOskT+VzGg4A2kDoKo+5C9LQp1lc/RkI6A==";
System.out.println("字符类型公钥:" + publicKey);
System.out.println("字符类型私钥:" + privateKey);
//
// System.out.println("公钥加密——私钥解密---------------");
// System.out.println("");
// String source = "220101199902020022";
// System.out.println("\r加密前文字：\r\n" + source);
// byte[] data = source.getBytes();
// byte[] encodedData = encryptByPublicKey(data, publicKey);
// System.out.println("加密后文字：\r\n" + encryptBASE64(encodedData));
// byte[] decodedData = decryptByPrivateKey(encodedData, privateKey);
// String target = new String(decodedData);
// System.out.println("解密后文字: \r\n" + target);
System.out.println("私钥加密——公钥解密--------------");
String source1 = "这是一行测试RSA数字签名的无意义文字";
System.out.println("原文字：\r\n" + source1);
byte[] data1 = source1.getBytes();
byte[] encodedData1 = encryptByPrivateKey(data1, privateKey);
System.out.println("加密后：\r\n" + new String(encodedData1));
byte[] decodedData1 = decryptByPublicKey(encodedData1, publicKey);
String target1 = new String(decodedData1);
System.out.println("解密后: \r\n" + target1);
System.out.println("私钥签名——公钥验证签名------------------");
// String sign = sign(encodedData, privateKey);
// System.out.println("签名:\r" + sign);
// boolean status = verify(encodedData, publicKey, sign);
// System.out.println("验证结果:\r" + status);
// //对内容进行加密和解密
String str = "zqb1231456";
byte[] strByte = str.getBytes();
// //私钥加密
byte[] encode = encryptByPrivateKey(strByte,privateKey);
System.out.println("私钥加密结果:" + encryptBASE64(encode));
//公钥解密
byte[] decode = decryptByPublicKey(encode,publicKey);
System.out.println("公钥解密结果:" + new String(decode));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* String转私钥PrivateKey
*
* @param key
* @return
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = org.apache.commons.codec.binary.Base64.decodeBase64(key);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
}

13
src/main/java/com/chinaunicom/mall/ebtp/project/projectrecord/controller/ProjectRecordController.java
View File

@ -8,6 +8,7 @@ import com.chinaunicom.mall.ebtp.project.checkSpecialCharacters.CheckUtil;
import com.chinaunicom.mall.ebtp.project.projectrecord.entity.ProjectRecord;
import com.chinaunicom.mall.ebtp.project.projectrecord.entity.ProjectRecordVO;
import com.chinaunicom.mall.ebtp.project.projectrecord.service.IProjectRecordService;
import com.chinaunicom.mall.ebtp.project.projectrecord.vo.ProjectInfo;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
@ -325,4 +326,16 @@ public class ProjectRecordController{
return BaseResponse.success(projectRecordService.getRoleVerificationByInquiryId(inquiryId));
}
/**
* 根据项目ids查询项目负责人相关信息
*
* @param projectIds
* @return 返回结果
*/
@ApiOperation("审查人员取消公开")
@PostMapping("/getProjectInfoList")
public BaseResponse<List<ProjectInfo>> getProjectInfoList(@ApiParam(value = "对象数据", required = true) @RequestBody List<String> projectIds) {
return BaseResponse.success(projectRecordService.getProjectInfoList(projectIds));
}
}

3
src/main/java/com/chinaunicom/mall/ebtp/project/projectrecord/service/IProjectRecordService.java
View File

@ -6,6 +6,7 @@ import com.chinaunicom.mall.ebtp.common.base.service.IBaseService;
import com.chinaunicom.mall.ebtp.project.projectentrust.entity.ProjectEntrustVO;
import com.chinaunicom.mall.ebtp.project.projectrecord.entity.ProjectRecord;
import com.chinaunicom.mall.ebtp.project.projectrecord.entity.ProjectRecordVO;
import com.chinaunicom.mall.ebtp.project.projectrecord.vo.ProjectInfo;
import com.chinaunicom.mall.ebtp.project.projectsection.entity.ProjectSectionVO;
import java.math.BigDecimal;
@ -223,4 +224,6 @@ public interface IProjectRecordService extends IBaseService<ProjectRecord>{
* @return 返回结果
*/
Map<String,Object> getRoleVerificationByInquiryId(String inquiryId);
List<ProjectInfo> getProjectInfoList(List<String> projectIds);
}

33
src/main/java/com/chinaunicom/mall/ebtp/project/projectrecord/service/impl/ProjectRecordServiceImpl.java
View File

@ -22,10 +22,7 @@ import com.chinaunicom.mall.ebtp.project.bidqualifyconditionitem.service.IBizQua
import com.chinaunicom.mall.ebtp.project.bidratio.entity.BidRatio;
import com.chinaunicom.mall.ebtp.project.bidratio.service.IBidRatioService;
import com.chinaunicom.mall.ebtp.project.checkSpecialCharacters.CheckUtil;
import com.chinaunicom.mall.ebtp.project.common.EbpProjectCommonUtil;
import com.chinaunicom.mall.ebtp.project.common.InquiryCommonUtil;
import com.chinaunicom.mall.ebtp.project.common.ProjectCommonUtil;
import com.chinaunicom.mall.ebtp.project.common.ProjectExceptionEnum;
import com.chinaunicom.mall.ebtp.project.common.*;
import com.chinaunicom.mall.ebtp.project.dict.entity.DictProvincesCode;
import com.chinaunicom.mall.ebtp.project.dict.service.IDictProvincesCodeService;
import com.chinaunicom.mall.ebtp.project.dictchooseprocess.entity.DictChooseProcess;
@ -45,6 +42,7 @@ import com.chinaunicom.mall.ebtp.project.projectrecord.dao.ProjectRecordMapper;
import com.chinaunicom.mall.ebtp.project.projectrecord.entity.ProjectRecord;
import com.chinaunicom.mall.ebtp.project.projectrecord.entity.ProjectRecordVO;
import com.chinaunicom.mall.ebtp.project.projectrecord.service.IProjectRecordService;
import com.chinaunicom.mall.ebtp.project.projectrecord.vo.ProjectInfo;
import com.chinaunicom.mall.ebtp.project.projectsection.entity.ProjectSection;
import com.chinaunicom.mall.ebtp.project.projectsection.entity.ProjectSectionVO;
import com.chinaunicom.mall.ebtp.project.projectsection.service.IProjectSectionFlowService;
@ -61,6 +59,8 @@ import io.seata.core.context.RootContext;
import io.seata.spring.annotation.GlobalTransactional;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
@ -1440,4 +1440,29 @@ public class ProjectRecordServiceImpl extends BaseServiceImpl<ProjectRecordMappe
resultMap.put("authorityList",authorityList);
return resultMap;
}
@Value("${mconfig.rsa.field.pivate_key}")
private String rsa_field_pivate_key;
@Override
public List<ProjectInfo> getProjectInfoList(List<String> projectIds) {
CommonExceptionEnum.FRAME_EXCEPTION_COMMON_DATA_OTHER_ERROR.customValidName("请提供参数",projectIds==null || projectIds.isEmpty());
List<ProjectRecord> list = this.listByIds(projectIds);
if(list==null || list.isEmpty()){
return new ArrayList<>();
}
List<ProjectInfo> reList =new ArrayList<>();
list.forEach(v->{
ProjectInfo projectInfo =new ProjectInfo();
BeanUtils.copyProperties(v,projectInfo);
try {
projectInfo.setAppManagerId(RSAUtil.encryptByPrivateKey(v.getAppManagerId().getBytes(), rsa_field_pivate_key));
projectInfo.setAppManagerTel(RSAUtil.encryptByPrivateKey(v.getAppManagerTel().getBytes(), rsa_field_pivate_key));
projectInfo.setOwnerContactId(RSAUtil.encryptByPrivateKey(v.getOwnerContactId().getBytes(), rsa_field_pivate_key));
projectInfo.setOwnerContactTel(RSAUtil.encryptByPrivateKey(v.getOwnerContactTel().getBytes(), rsa_field_pivate_key));
} catch (Exception e) {
CommonExceptionEnum.FRAME_EXCEPTION_COMMON_DATA_OTHER_ERROR.customValidName("信息返回失败，请联系招标采购中心",projectIds==null || projectIds.isEmpty());
}
});
return reList;
}
}

77
src/main/java/com/chinaunicom/mall/ebtp/project/projectrecord/vo/ProjectInfo.java Normal file
View File

@ -0,0 +1,77 @@
package com.chinaunicom.mall.ebtp.project.projectrecord.vo;
import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableName;
import com.chinaunicom.mall.ebtp.common.base.entity.BaseEntity;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.experimental.Accessors;
import org.hibernate.validator.constraints.Length;
import org.springframework.format.annotation.DateTimeFormat;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;
/**
* 项目建档实体类 BizProjectRecord
*
* @author daixc
* @date 2020/10/26
*/
@Data
@Accessors(chain = true)
@ApiModel("项目建档信息")
public class ProjectInfo implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 主键
*/
@ApiModelProperty(value = "主键")
@JsonSerialize(using = ToStringSerializer.class)
private String id;
/**
* 招标项目责任人（代理机构项目经理）id
*/
@ApiModelProperty(value = "招标项目责任人（代理机构项目经理）id")
private byte[] appManagerId;
/**
* 招标项目责任人（代理机构项目经理，根据当前账号对应人员联系方式自动填入，可修改）
*/
@ApiModelProperty(value = "招标项目责任人（代理机构项目经理，根据当前账号对应人员联系方式自动填入，可修改）")
private String appManagerName;
/**
* 招标项目责任人联系方式（代理机构项目经理联系方式，根据当前账号对应人员联系方式自动填入，可修改）
*/
@ApiModelProperty(value = "招标项目责任人联系方式（代理机构项目经理联系方式，根据当前账号对应人员联系方式自动填入，可修改）")
private byte[] appManagerTel;
/**
* 采购经理id
*/
@ApiModelProperty(value = "采购经理id")
private byte[] ownerContactId;
/**
* 采购经理名称
*/
@ApiModelProperty(value = "采购经理名称")
private String ownerContactName;
/**
* 采购经理联系方式
*/
@ApiModelProperty(value = "采购经理联系方式")
private byte[] ownerContactTel;
}