Example 6 with PersonalName
use of com.itrus.portal.db.PersonalName in project portal by ixinportal.
the class EvidenceSaveContractService method saveFactor.
// 核验要素
private Map<String, Object> saveFactor(Map<String, Object> result, EvidenceSaveService evidenceSaveService, String evidenceSn, JSONObject jsonEvidenceContent, EvidenceBasicInformation basicInformation, RealNameAuthentication realNameAuthentication, RealNameAuthentication realNameAuthenticationOss, EvidenceServiceConfiguration serviceConfiguration, Boolean bl, Long sbtTime) throws Exception {
List<Object> objs = new ArrayList<Object>();
// 定义证据要素字段
String saveFactor = null;
// 证据存证的业务类型
String type = null;
// 得到业务基本信息要素配置
String factorBusinessInfo = evidenceSaveService.getFactorBusinessInfo();
JSONArray jsonBiArray = JSONArray.parseArray(factorBusinessInfo);
try {
// TODO : 核验身份认证
if (jsonEvidenceContent.get("authId") != null && bl) {
basicInformation.setEvidenceType(1);
// 得到数据包身份认证数据
JSONObject jsonAuthId = jsonEvidenceContent.getJSONObject("authId");
for (int i = 0; i < jsonBiArray.size(); i++) {
JSONObject object = jsonBiArray.getJSONObject(i);
JSONObject jsonContent;
// 事件发生平台
if (i == 0) {
jsonContent = jsonAuthId.getJSONObject("eventHapPlatform");
// 判断是否接收
if (object.getBooleanValue("b_isReception")) {
// 判断是否必填
if (object.getBooleanValue("b_isRequired") && StringUtils.isEmpty(jsonContent.getString("hapPlatformDomain"))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少事件发生平台必要参数值");
return result;
}
basicInformation.setEventPlatformName(jsonContent.getString("hapPlatformName"));
basicInformation.setDomainName(jsonContent.getString("hapPlatformDomain"));
if (StringUtils.isEmpty(saveFactor) || !saveFactor.contains("基本信息"))
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, "基本信息");
}
}
}
EvidenceMainInformation mainInformation = null;
// 得到身份认证要素配置
String factorIdVerify = evidenceSaveService.getFactorIdVerify();
JSONArray jsonIdArray = JSONArray.parseArray(factorIdVerify);
// 得到证据包中的身份认证数据
for (int i = 0; i < jsonIdArray.size(); i++) {
// 得到对应认证配置
JSONObject object = jsonIdArray.getJSONObject(i);
JSONObject jsonContent = null;
switch(i) {
// 主体身份
case 0:
jsonContent = jsonAuthId.getJSONObject("principalId");
// 判断是否接收
if (object.getBooleanValue("i_isReception")) {
// 判断是否必填
if (object.getBooleanValue("i_isRequired") && (StringUtils.isEmpty(jsonContent.getString("name")) || StringUtils.isEmpty(jsonContent.getString("dataId")) || StringUtils.isEmpty(jsonContent.getString("type")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少主体身份参数值");
return result;
}
// 判断主体是否存在
String idCacheKey = jsonContent.getString("name") + jsonContent.getString("dataId");
if (cacheMainMap.get(idCacheKey) != null) {
mainInformation = cacheMainMap.get(idCacheKey);
} else {
EvidenceMainInformationExample mainInformationExample = new EvidenceMainInformationExample();
EvidenceMainInformationExample.Criteria mainExampleCriteria = mainInformationExample.createCriteria();
mainExampleCriteria.andSubjectNameEqualTo(jsonContent.getString("name").trim());
mainExampleCriteria.andIdentificationEqualTo(jsonContent.getString("dataId").trim());
mainExampleCriteria.andMainTypeEqualTo(jsonContent.getString("type"));
mainInformationExample.setOrderByClause("create_time DESC");
List<EvidenceMainInformation> mainInformationList = sqlSession.selectList("com.itrus.portal.db.EvidenceMainInformationMapper.selectByExample", mainInformationExample);
if (!mainInformationList.isEmpty()) {
mainInformation = mainInformationList.get(0);
}
// 当主体为空时 添加主体信息
if (mainInformation == null) {
mainInformation = new EvidenceMainInformation();
mainInformation.setSubjectName(jsonContent.getString("name").trim());
mainInformation.setIdentification(jsonContent.getString("dataId").trim());
mainInformation.setMainType(jsonContent.getString("type"));
mainInformation.setCreateTime(new Date());
objs.add(mainInformation);
}
cacheMainMap.put(mainInformation.getSubjectName() + mainInformation.getIdentification(), mainInformation);
}
// 添加证据和主体关系表
EvidenceSubjectIdentity subjectIdentity1 = new EvidenceSubjectIdentity();
subjectIdentity1.setBasicInformation(evidenceSn);
subjectIdentity1.setMainInformation(jsonContent.getString("dataId").trim());
subjectIdentity1.setMainName(jsonContent.getString("name").trim());
subjectIdentity1.setMainType(jsonContent.getShort("type"));
subjectIdentity1.setCreateTime(new Date());
objs.add(subjectIdentity1);
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("i_factor"));
}
break;
// 身份意愿鉴别
case 1:
jsonContent = jsonAuthId.getJSONObject("authIdWillSms");
// 判断是否接收
if (object.getBooleanValue("i_isReception")) {
// 判断是否必填
if (object.getBooleanValue("i_isRequired") && (StringUtils.isEmpty(jsonContent.getString("phone")) || StringUtils.isEmpty(jsonContent.getString("sendTime")) || StringUtils.isEmpty(jsonContent.getString("content")) || StringUtils.isEmpty(jsonContent.getString("verifyCode")) || StringUtils.isEmpty(jsonContent.getString("verifySmsTime")) || StringUtils.isEmpty(jsonContent.getString("verifierType")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少身份意愿鉴别参数值");
return result;
}
// 获取验证方
String eventVerifier = getAuthenticator(Integer.parseInt(jsonContent.getString("verifierType")), basicInformation.getEventPlatformName());
// 存储身份意愿鉴别信息
EvidenceDesireIdentify desireIdentify = new EvidenceDesireIdentify();
desireIdentify.setVerifier(eventVerifier);
desireIdentify.setVerifierType(jsonContent.getString("verifierType"));
desireIdentify.setPhone(jsonContent.getString("phone"));
desireIdentify.setSendOutTime(jsonContent.getDate("sendTime"));
desireIdentify.setSmsContent(jsonContent.getString("content"));
desireIdentify.setVerificationCode(jsonContent.getString("verifyCode"));
desireIdentify.setVerificationTime(jsonContent.getDate("verifySmsTime"));
desireIdentify.setMainInformation(mainInformation.getSubjectName() + ";" + mainInformation.getIdentification());
desireIdentify.setCreateTime(new Date());
desireIdentify.setEvidenceSn(evidenceSn);
objs.add(desireIdentify);
// 整合提交要素
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("i_factor"));
}
break;
// 身份实名认证
case 2:
JSONObject jsonContentPerson = jsonAuthId.getJSONObject("authIdInfoPerson");
JSONObject jsonContentBusiness = jsonAuthId.getJSONObject("authIdInfoBusiness");
// 判断是否接收
if (object.getBooleanValue("i_isReception")) {
// 核验个人身份认证和企业身份认证是否提交其一
if ((jsonContentPerson == null && jsonContentBusiness == null) || (jsonContentPerson != null && jsonContentBusiness != null)) {
result.put("status", 0);
result.put("message", "提交的参数信息错误，个人身份认证和企业身份认证只能提交其一");
return result;
}
// true 代表个人身份认证 false 代表企业身份认证
if (jsonContentPerson != null) {
// 判断是否必填
if (object.getBooleanValue("i_isRequired") && (StringUtils.isEmpty(jsonContentPerson.getString("authenticatorType")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少身份实名认证参数值");
return result;
}
String eventVerifier = getAuthenticator(Integer.parseInt(jsonContentPerson.getString("authenticatorType")), basicInformation.getEventPlatformName());
// 身份实名认证表
EvidenceRealName realName = new EvidenceRealName();
realName.setEventVerifierType(jsonContentPerson.getString("authenticatorType"));
realName.setEventVerifier(eventVerifier);
realName.setCertificationTime(jsonContentPerson.getDate("time"));
realName.setType(mainInformation.getMainType());
realName.setMainInformation(mainInformation.getSubjectName() + ";" + mainInformation.getIdentification());
realName.setEvidenceSn(evidenceSn);
String orderNumber = jsonContentPerson.getString("orderNumber");
if (jsonContentPerson.getInteger("authenticatorType") == 1) {
// 认证方 为 1 时，orderNumber 为必填项
if (StringUtils.isEmpty(orderNumber)) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少身份实名认证参数值");
return result;
}
realName.setSerialnumber(orderNumber);
// 判断企业实名认证信息是否为可靠信息
for (String o : orderNumber.split(",")) {
PersonalNameExample personalNameExample = new PersonalNameExample();
PersonalNameExample.Criteria pec = personalNameExample.createCriteria();
pec.andSerialnumberEqualTo(o);
PersonalName personalName = sqlSession.selectOne("com.itrus.portal.db.PersonalNameMapper.selectByExample", personalNameExample);
if (personalName == null || personalName.getAuthenticationstatus() != 0) {
result.put("status", 0);
result.put("message", "流水号为：" + o + "的个人信息验证未通过");
return result;
}
}
} else if (jsonContentPerson.getInteger("authenticatorType") == 2) {
EvidenceIndividual individual = new EvidenceIndividual();
individual.setName(mainInformation.getSubjectName());
individual.setCreateTime(new Date());
individual.setIdCode(UniqueIDUtils.getUID());
// 必填判断
if (object.getBooleanValue("i_isRequired") && (StringUtils.isEmpty(jsonContentPerson.getString("idType")) || StringUtils.isEmpty(jsonContentPerson.getString("idCode")) || StringUtils.isEmpty(jsonContentPerson.getString("idImg1")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少身份实名认证参数值");
return result;
}
individual.setType(jsonContentPerson.getString("idType"));
individual.setCertificateid(jsonContentPerson.getString("idCode"));
// 1.身份证 2.其他
if (jsonContentPerson.getIntValue("idType") == 1) {
if (StringUtils.isNotEmpty(jsonContentPerson.getString("idImg1")) && StringUtils.isNotEmpty(jsonContentPerson.getString("idImg2"))) {
// 存储图片
File frontImg = saveImg(evidenceSn, jsonContentPerson.getString("idImg1"), IMG_ID_IMG_FRONT);
individual.setPhotoCodeImg(frontImg.getName());
individual.setPhotoCodeImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
File frontImg2 = saveImg(evidenceSn, jsonContentPerson.getString("idImg2"), IMG_ID_IMG_BACK);
individual.setInformationImg(frontImg2.getName());
individual.setInformationImgHash(HMACSHA1.genSha1HashOfFile(frontImg2));
} else {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，个人身份认证证据为身份证时 idImg2 为必选参数。");
return result;
}
} else {
// 存储图片
File frontImg = saveImg(evidenceSn, jsonContentPerson.getString("idImg1"), IMG_ID_IMG_BACK);
individual.setPhotoCodeImg(frontImg.getName());
individual.setPhotoCodeImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
}
objs.add(individual);
realName.setIndividual(individual.getIdCode());
}
objs.add(realName);
} else {
// 判断是否必填
if (object.getBooleanValue("i_isRequired") && (StringUtils.isEmpty(jsonContentBusiness.getString("authenticatorType")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少身份实名认证参数值");
return result;
}
String eventVerifier = getAuthenticator(Integer.parseInt(jsonContentBusiness.getString("authenticatorType")), basicInformation.getEventPlatformName());
// 身份实名认证表
EvidenceRealName realName = new EvidenceRealName();
realName.setEventVerifierType(jsonContentBusiness.getString("authenticatorType"));
realName.setEventVerifier(eventVerifier);
realName.setCertificationTime(jsonContentBusiness.getDate("time"));
realName.setType(mainInformation.getMainType());
realName.setMainInformation(mainInformation.getSubjectName() + ":" + mainInformation.getIdentification());
realName.setEvidenceSn(evidenceSn);
String orderNumber = jsonContentBusiness.getString("orderNumber");
if (jsonContentBusiness.getInteger("authenticatorType") == 1) {
// 认证方 为 1 时，orderNumber 为必填项
if (StringUtils.isEmpty(orderNumber)) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少身份实名认证参数值");
return result;
}
realName.setSerialnumber(orderNumber);
// 判断企业实名认证信息是否为可靠信息
for (String o : orderNumber.split(",")) {
RealNameRecordExample recordExample = new RealNameRecordExample();
RealNameRecordExample.Criteria rec = recordExample.createCriteria();
rec.andSerialnumberEqualTo(o);
RealNameRecord realNameRecord = sqlSession.selectOne("com.itrus.portal.db.RealNameRecordMapper.selectByExample", recordExample);
if (realNameRecord == null || realNameRecord.getAuthenticationstatus() != 0) {
result.put("status", 0);
result.put("message", "流水号为：" + o + "的企业信息验证未通过");
return result;
}
}
} else if (jsonContentBusiness.getInteger("authenticatorType") == 2) {
if (object.getBooleanValue("i_isRequired") && ((StringUtils.isEmpty(jsonContentBusiness.getString("blCode")) && StringUtils.isEmpty(jsonContentBusiness.getString("blImg"))) && (StringUtils.isEmpty(jsonContentBusiness.getString("orgCode")) && StringUtils.isEmpty(jsonContentBusiness.getString("orgImg"))))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少身份实名认证参数值");
return result;
}
// 法人
EvidenceRepresentative representative = null;
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("legalIdName")) && StringUtils.isNotEmpty(jsonContentBusiness.getString("legalIdType")) && StringUtils.isNotEmpty(jsonContentBusiness.getString("legalIdCode"))) {
representative = new EvidenceRepresentative();
representative.setName(jsonContentBusiness.getString("legalIdName"));
representative.setType(jsonContentBusiness.getString("legalIdType"));
representative.setCertificateid(jsonContentBusiness.getString("legalIdCode"));
representative.setCreateTime(new Date());
representative.setIdCode(UniqueIDUtils.getUID());
// 存储图片
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("idImg1"))) {
File frontImg = saveImg(evidenceSn, jsonContentBusiness.getString("idImg1"), IMG_ID_IMG_FRONT);
representative.setPhotoCodeImg(frontImg.getName());
representative.setPhotoCodeImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
}
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("idImg2"))) {
File frontImg = saveImg(evidenceSn, jsonContentBusiness.getString("idImg2"), IMG_ID_IMG_BACK);
representative.setInformationImg(frontImg.getName());
representative.setInformationImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
}
// 存储法人信息
objs.add(representative);
}
// 代理人
EvidenceTheAgent theAgent = null;
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("agentIdName")) && StringUtils.isNotEmpty(jsonContentBusiness.getString("agentIdType")) && StringUtils.isNotEmpty(jsonContentBusiness.getString("agentIdCode"))) {
theAgent = new EvidenceTheAgent();
theAgent.setName(jsonContentBusiness.getString("agentIdName"));
theAgent.setType(jsonContentBusiness.getString("agentIdType"));
theAgent.setCertificateid(jsonContentBusiness.getString("agentIdCode"));
theAgent.setCreateTime(new Date());
theAgent.setIdCode(UniqueIDUtils.getUID());
// 存储图片
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("agentIdImg1"))) {
File frontImg = saveImg(evidenceSn, jsonContentBusiness.getString("agentIdImg1"), IMG_ID_IMG_FRONT);
theAgent.setPhotoCodeImg(frontImg.getName());
theAgent.setPhotoCodeImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
}
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("agentIdImg2"))) {
File frontImg = saveImg(evidenceSn, jsonContentBusiness.getString("agentIdImg2"), IMG_ID_IMG_BACK);
theAgent.setInformationImg(frontImg.getName());
theAgent.setInformationImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
}
// // 存储代理人信息
objs.add(theAgent);
// 营业执照
EvidenceCompaniesSubmit companiesSubmit = new EvidenceCompaniesSubmit();
companiesSubmit.setBusCertificateid(jsonContentBusiness.getString("blCode"));
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("blImg"))) {
// 存储图片
File frontImg = saveImg(evidenceSn, jsonContentBusiness.getString("blImg"), IMG_BL);
companiesSubmit.setPhotoCodeImg(frontImg.getName());
companiesSubmit.setPhotoCodeImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
}
// 组织机构代码
companiesSubmit.setOrgCertificateid(jsonContentBusiness.getString("orgCode"));
if (StringUtils.isNotEmpty(jsonContentBusiness.getString("orgImg"))) {
// 存储图片
File frontImg = saveImg(evidenceSn, jsonContentBusiness.getString("orgImg"), IMG_ORG);
companiesSubmit.setInformationImg(frontImg.getName());
companiesSubmit.setInformationImgHash(HMACSHA1.genSha1HashOfFile(frontImg));
}
if (theAgent != null)
companiesSubmit.setTheAgent(theAgent.getIdCode());
if (representative != null)
companiesSubmit.setRepresentative(representative.getIdCode());
companiesSubmit.setBusinessName(mainInformation.getSubjectName());
companiesSubmit.setCreateTime(new Date());
companiesSubmit.setIdCode(UniqueIDUtils.getUID());
objs.add(companiesSubmit);
realName.setCompaniesSubmit(companiesSubmit.getIdCode());
}
}
objs.add(realName);
}
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("i_factor"));
}
break;
default:
break;
}
}
}
// TODO : 核验事件认证
if (jsonEvidenceContent.get("authEvent") != null) {
basicInformation.setEvidenceType(2);
JSONObject jsonAuthEvent = jsonEvidenceContent.getJSONObject("authEvent");
// 可信身份缓存信息
List<EvidenceTrustedIdentity> tiCacheList = new ArrayList<>();
// 核验基础信息
for (int i = 0; i < jsonBiArray.size(); i++) {
JSONObject object = jsonBiArray.getJSONObject(i);
JSONObject jsonContent;
switch(i) {
// 事件发生平台
case 0:
jsonContent = jsonAuthEvent.getJSONObject("eventHapPlatform");
// 判断是否接收
if (object.getBooleanValue("b_isReception")) {
// 判断是否必填
if (object.getBooleanValue("b_isRequired") && StringUtils.isEmpty(jsonContent.getString("hapPlatformDomain"))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少事件发生平台必要参数值");
return result;
}
basicInformation.setEventPlatformName(jsonContent.getString("hapPlatformName"));
basicInformation.setDomainName(jsonContent.getString("hapPlatformDomain"));
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, "基本信息");
}
break;
// 业务类型
case 1:
String eventType = jsonAuthEvent.getString("eventType");
// 判断是否接收
if (object.getBooleanValue("b_isReception")) {
// 判断是否必填
if (object.getBooleanValue("b_isRequired") && StringUtils.isEmpty(eventType)) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少业务类型参数值");
return result;
}
basicInformation.setType(eventType);
type = object.getString("b_category");
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, "基本信息");
}
break;
// 业务单号
case 3:
String eventSn = jsonAuthEvent.getString("eventSn");
// 判断是否接收
if (object.getBooleanValue("b_isReception")) {
basicInformation.setServiceNumber(eventSn);
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, "基本信息");
}
break;
default:
break;
}
}
// 得到身份认证要素配置
JSONArray jsonIdArray = JSONArray.parseArray(evidenceSaveService.getFactorIdVerify());
for (int i = 0; i < jsonIdArray.size(); i++) {
JSONObject object = jsonIdArray.getJSONObject(i);
if (i == 3 && object.getBooleanValue("i_isReception")) {
// 得到事件包信息数据
JSONArray jsonContentArray = jsonAuthEvent.getJSONArray("event");
for (int j = 0; j < jsonContentArray.size(); j++) {
JSONObject jsonContent = jsonContentArray.getJSONObject(j).getJSONObject("principalId");
// 判断是否必填
if (object.getBooleanValue("e_isRequired") && (StringUtils.isEmpty(jsonContent.getString("type")) || StringUtils.isEmpty(jsonContent.getString("certSn")) || StringUtils.isEmpty(jsonContent.getString("name")) || StringUtils.isEmpty(jsonContent.getString("dataId")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少可信身份标识参数值");
return result;
}
// 判断主体是否存在
String idCacheKey = jsonContent.getString("name").trim() + jsonContent.getString("dataId").trim();
EvidenceMainInformation mainInformation = cacheMainMap.get(idCacheKey);
EvidenceBasicInformation basicInformation2 = null;
if (mainInformation == null) {
EvidenceMainInformationExample mainInformationExample = new EvidenceMainInformationExample();
EvidenceMainInformationExample.Criteria mainExampleCriteria = mainInformationExample.createCriteria();
mainExampleCriteria.andSubjectNameEqualTo(jsonContent.getString("name").trim());
mainExampleCriteria.andIdentificationEqualTo(jsonContent.getString("dataId").trim());
mainExampleCriteria.andMainTypeEqualTo(jsonContent.getString("type"));
mainInformationExample.setOrderByClause("create_time DESC");
List<EvidenceMainInformation> mainInformationList = sqlSession.selectList("com.itrus.portal.db.EvidenceMainInformationMapper.selectByExample", mainInformationExample);
if (!mainInformationList.isEmpty()) {
mainInformation = mainInformationList.get(0);
}
}
// 当主体为空时 添加主体信息
if (mainInformation == null) {
mainInformation = new EvidenceMainInformation();
mainInformation.setSubjectName(jsonContent.getString("name").trim());
mainInformation.setIdentification(jsonContent.getString("dataId").trim());
mainInformation.setMainType(jsonContent.getString("type"));
mainInformation.setCreateTime(new Date());
objs.add(mainInformation);
}
// 遍历 mapIdCache 的key值 判断是否存在 不存在则添加
// for(String key:mapIdCache.keySet()) {
// if(!idCacheKey.equals(key)) {
cacheMainMap.put(mainInformation.getSubjectName() + mainInformation.getIdentification(), mainInformation);
// }
// }
// 判断基础信息表 和 主体表是否存在关联
// EvidenceSubjectIdentityExample subjectIdentityExampleExist = new EvidenceSubjectIdentityExample();
// EvidenceSubjectIdentityExample.Criteria iece = subjectIdentityExampleExist.createCriteria();
// iece.andBasicInformationEqualTo(evidenceSn);
// iece.andMainInformationEqualTo(mainInformation.getIdentification());
// EvidenceSubjectIdentity subjectIdentityExist = sqlSession
// .selectOne("com.itrus.portal.db.EvidenceSubjectIdentityMapper.selectByExample", subjectIdentityExampleExist);
// if(subjectIdentityExist == null) {
//
// }
// 基础信息表 和 主体表添加关联
EvidenceSubjectIdentity subjectIdentity1 = new EvidenceSubjectIdentity();
subjectIdentity1.setBasicInformation(evidenceSn);
subjectIdentity1.setMainInformation(mainInformation.getIdentification());
subjectIdentity1.setCreateTime(new Date());
subjectIdentity1.setMainName(mainInformation.getSubjectName());
subjectIdentity1.setMainType(Short.parseShort(mainInformation.getMainType()));
objs.add(subjectIdentity1);
// 判断是否需要关联身份证据
if (StringUtils.isNotEmpty(jsonContent.getString("evidenceSn"))) {
basicInformation2 = basicInformationService.getInformationBySn(jsonContent.getString("evidenceSn"), 1);
if (basicInformation2 != null) {
EvidenceSubjectIdentityExample subjectIdentityExample = new EvidenceSubjectIdentityExample();
EvidenceSubjectIdentityExample.Criteria iec = subjectIdentityExample.createCriteria();
iec.andBasicInformationEqualTo(jsonContent.getString("evidenceSn"));
iec.andMainInformationEqualTo(mainInformation.getIdentification());
EvidenceSubjectIdentity subjectIdentity = sqlSession.selectOne("com.itrus.portal.db.EvidenceSubjectIdentityMapper.selectByExample", subjectIdentityExample);
if (subjectIdentity == null) {
result.put("status", 0);
result.put("message", "证据编码：" + jsonContent.getString("evidenceSn") + "与主体：" + jsonContent.getString("name") + "," + jsonContent.getString("dataId") + "不存在关联");
return result;
}
} else {
result.put("status", 0);
result.put("message", "证据编码：" + jsonContent.getString("evidenceSn") + "与主体：" + jsonContent.getString("name") + "," + jsonContent.getString("dataId") + "不存在关联");
return result;
}
}
EvidenceTrustedIdentity trustedIdentity = new EvidenceTrustedIdentity();
trustedIdentity.setCertSerialnumber(jsonContent.getString("certSn"));
trustedIdentity.setIdentiType(jsonContent.getString("type"));
trustedIdentity.setBasicInformation(basicInformation.getEvidenceSn());
// trustedIdentity.setEvidenceEnclosure(enclosure.getId());
if (StringUtils.isNotEmpty(jsonContent.getString("evidenceSn")))
trustedIdentity.setEvidenceSn(jsonContent.getString("evidenceSn"));
trustedIdentity.setCreateTime(new Date());
if (mainInformation != null && !"".equals(mainInformation))
trustedIdentity.setMainInformation(mainInformation.getSubjectName() + ";" + mainInformation.getIdentification());
// sqlSession.insert("com.itrus.portal.db.EvidenceTrustedIdentityMapper.insert", trustedIdentity);
// sqlSession.flushStatements();
tiCacheList.add(trustedIdentity);
}
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("i_factor"));
}
}
// 得到事件认证要素配置
JSONArray jsonEvArray = JSONArray.parseArray(evidenceSaveService.getFactorEventVerify());
EvidenceEventContent eventContent = new EvidenceEventContent();
// 得到证据包中的事件数据
for (int i = 0; i < jsonEvArray.size(); i++) {
JSONObject object = jsonEvArray.getJSONObject(i);
switch(i) {
// 事件认证
case 0:
log.equals("type is " + "电子合同PDF".equals(type));
// 判断合同类型
if ("电子合同PDF".equals(type)) {
// 电子合同
log.error("e_isReception is " + object.getBooleanValue("e_isReception"));
// 判断是否接收
if (object.getBooleanValue("e_isReception")) {
// 得到事件内容中的信息
JSONObject jsonEventContent = jsonAuthEvent.getJSONObject("eventContent");
// 判断必填
if (object.getBooleanValue("e_isRequired") && (StringUtils.isEmpty(jsonEventContent.getString("contCode")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少事件内容认证参数值");
return result;
}
String urlPdfVerify = realNameAuthentication.getRealNameddress() + PDF_VERIFY;
Map<String, Object> mapPdfVerify = new HashMap<String, Object>();
mapPdfVerify.put("pdfContent", jsonEventContent.get("contCode"));
eventContent.setIsPdf(true);
eventContent.setContractTitle(jsonEventContent.getString("title"));
eventContent.setValidStartTime(jsonEventContent.getDate("validStartTime"));
eventContent.setValidEndTime(jsonEventContent.getDate("validEndTime"));
eventContent.setCreateTime(new Date());
eventContent.setEvidenceSn(evidenceSn);
eventContent.setIdCode(UniqueIDUtils.getUID());
log.error("e_isVerify is " + object.getBooleanValue("e_isVerify"));
if (object.getBooleanValue("e_isVerify")) {
Long pdfVerifyTimeAsync = System.currentTimeMillis();
// 异步处理pdf验章
// HttpAsyncClientUtil.getInstance().execute(
// urlPdfVerify,
// AuthService.getHeader(),
// mapPdfVerify,
// new EvidencePdfVerifyService(
// urlPdfVerify,
// jsonEventContent.getString("contCode"),
// eventContent,
// tiCacheList));
OkHttpClientManagerPdfVerify.postAsyn(urlPdfVerify, AuthService.getHeader().get("Authorization").toString(), mapPdfVerify, new EvidencePdfVerifyService(urlPdfVerify, jsonEventContent.getString("contCode"), eventContent, tiCacheList));
log.error("pdfVerifyTimeAsync time is [" + (System.currentTimeMillis() - pdfVerifyTimeAsync) + "]");
// 调用pdf验章接口
// Long pdfVerifyTime = System.currentTimeMillis();
// String rep_pdf_verify = OkHttpClientManagerPdfVerify.post(urlPdfVerify, AuthService.getHeader().get("Authorization").toString(), mapPdfVerify);
// log.error("pdfVerifyTime time is [" + (System.currentTimeMillis() - pdfVerifyTime) + "]");
//
// JSONObject jsonPdfVerify = JSONObject.parseObject(rep_pdf_verify);
// if(jsonPdfVerify.getInteger("code") == 0){
// eventContent.setEventStatus(1);
// } else {
// eventContent.setEventStatus(0);
// eventContent.setFailureReason(jsonPdfVerify.getString("message"));
// basicInformation.setEvidenceStatus(0);
// if(StringUtils.isEmpty(basicInformation.getFailureReason())) {
// basicInformation.setFailureReason(jsonPdfVerify.getString("message"));
// } else {
// basicInformation.setFailureReason(basicInformation.getFailureReason() + "," + jsonPdfVerify.getString("message"));
// }
// }
// String retVerifyTi = null;
// String retVerifyBehavior = null;
// String retVerifyTime = null;
// if(StringUtils.isNotEmpty(rep_pdf_verify)
// && StringUtils.isNotEmpty(jsonPdfVerify.getString("signInfos"))) {
// // 解析pdf验章返回信息
// JSONArray jsonArraySignInfos = jsonPdfVerify.getJSONArray("signInfos");
// List<String> listStr = new ArrayList<>();
// int noId = 0;
// for(int k=0;k<jsonArraySignInfos.size();k++) {
// // 循环得到pdf验章返回数据
// JSONObject json = jsonArraySignInfos.getJSONObject(k);
// // 对应可信身份
// EvidenceTrustedIdentity trustedIdentity1 = null;
//
// // 判断验章是否包含证书
// if(StringUtils.isNotEmpty(json.getString("signerCert"))) {
// // 解析签名者证书base64编码
// UserCert userCert1 = CertUtil.getCertFromBase64(json.getString("signerCert"));
// EvidenceCertUser certUser = certUserService.getCertBySn(userCert1.getCertSn());
// if(certUser == null) {
// certUser = new EvidenceCertUser();
// certUser.setCertBase64(json.getString("signerCert"));
// certUser.setCertSerialnumber(userCert1.getCertSn());
// certUser.setSubjectdn(userCert1.getCertDn());
// certUser.setIssuerdn(userCert1.getIssuerDn());
// certUser.setIssuer(EvidenceSaveServiceApi.getCertCn(userCert1.getIssuerDn()));
// if(userCert1.getCertBuf() != null){
// certUser.setEvidenceBuf(userCert1.getCertBuf().toString());
// }
// certUser.setStartTime(userCert1.getCertStartTime());
// certUser.setEndTime(userCert1.getCertEndTime());
// certUser.setCreateTime(new Date());
// certUser.setIdCode(UniqueIDUtils.getUID());
// objs.add(certUser);
// }
//
// boolean blt = true;
// // 循环已经存在的证书序列号 判断证书序列号是否存在
// for(String strCertSn:listStr){
// if(userCert1 != null && strCertSn.equals(userCert1.getCertSn())){
// blt = false;
// }
// }
// // 循环可信身份list缓存 判断证书序列号是否相同
// if(!tiCacheList.isEmpty() && tiCacheList != null){
// for(EvidenceTrustedIdentity identity:tiCacheList) {
// if(identity.getCertSerialnumber().equals(userCert1.getCertSn())){
// trustedIdentity1 = identity;
// }
// }
// }
// if(trustedIdentity1 == null) {
// noId--;
// }
// if(blt) {
// // 事件对象定义
// EvidenceTrustedIdentity trustedIdentity = new EvidenceTrustedIdentity();
// trustedIdentity.setBasicInformation(basicInformation.getEvidenceSn());
// trustedIdentity.setEventContent(eventContent.getIdCode());
// if(trustedIdentity1 != null){
// trustedIdentity.setMainInformation(trustedIdentity1.getMainInformation());
// // 整合证书信息存储到对应可信身份表
// trustedIdentity1.setCertBase64(certUser.getIdCode());
// // sqlSession.update("com.itrus.portal.db.EvidenceTrustedIdentityMapper.updateByPrimaryKey",
// // trustedIdentity1);
// objs.add(trustedIdentity1);
// } else {
// trustedIdentity.setMainInformation(noId+"");
// }
// trustedIdentity.setCertBase64(certUser.getIdCode());
// trustedIdentity.setCreateTime(new Date());
// trustedIdentity.setIdentiType("1");
// if(userCert1.getCertBuf() != null){
// trustedIdentity.setEvidenceBuf(userCert1.getCertBuf().toString());
// }
// trustedIdentity.setStartTime(userCert1.getCertStartTime());
// trustedIdentity.setEndTime(userCert1.getCertEndTime());
//
// // 事件对象核验结果
// trustedIdentity.setCheckTime(new Date());
// if(json.getIntValue("vcResult") == 0) {
// trustedIdentity.setCheckStatus("1");
// trustedIdentity.setCheckSuccessTime(new Date());
// } else {
// if(StringUtils.isEmpty(retVerifyTi))
// retVerifyTi = "事件对象核验失败";
// trustedIdentity.setCheckStatus("0");
// if(json.getIntValue("vcResult") == 30006)
// trustedIdentity.setUnreason("未找到对应的受信任CA证书");
// else if(json.getIntValue("vcResult") == 30007)
// trustedIdentity.setUnreason("证书已吊销");
// else if(json.getIntValue("vcResult") == 30008)
// trustedIdentity.setUnreason("证书不在有效期内");
// else if(json.getIntValue("vcResult") == 30009)
// trustedIdentity.setUnreason("无效的证书签名");
// else if(json.getIntValue("vcResult") == 300010)
// trustedIdentity.setUnreason("其他证书验证错误");
// else
// trustedIdentity.setUnreason("非正常其他证书验证错误");
// }
// trustedIdentity.setVewestCheckTime(new Date());
// // trustedIdentity.setCheckContent("1.验证证书有效期/n2.验证证书颁发者签名/n3.验证证书是否吊销");
// // sqlSession.insert("com.itrus.portal.db.EvidenceTrustedIdentityMapper.insert", trustedIdentity);
// objs.add(trustedIdentity);
// }
// listStr.add(userCert1.getCertSn());
// } else {
// retVerifyTi = "事件对象核验失败";
// }
// // 事件行为定义
// EvidenceEventBehavior eventBehavior = new EvidenceEventBehavior();
// // 判断时间戳是否存在
// if(StringUtils.isNotEmpty(json.getString("timeStamp"))
// && !json.getString("timeStamp").equals("{}")) {
// // 验证时间戳
// EvidenceEventTime eventTime = new EvidenceEventTime();
// if(trustedIdentity1 != null){
// eventTime.setMainInformation(trustedIdentity1.getMainInformation());
// } else {
// eventTime.setMainInformation(noId+"");
// }
// eventTime.setIdentiType("1");
// eventTime.setEventContent(eventContent.getIdCode());
// eventTime.setCertificate(json.getJSONObject("timeStamp").getString("signature"));
// eventTime.setHashAlgorithm(json.getJSONObject("timeStamp").getString("hashAlg"));
// eventTime.setHashvalue(json.getJSONObject("timeStamp").getString("hashData"));
// eventTime.setCertBase64(json.getJSONObject("timeStamp").getString("tsCert"));
// if(StringUtils.isNotEmpty(json.getJSONObject("timeStamp").getString("time"))) {
// eventTime.setSignatureTime(json.getJSONObject("timeStamp").getDate("time"));
// } else {
// eventTime.setSignatureTime(json.getDate("stampTime"));
// }
// eventTime.setCreateTime(new Date());
// // 解析时间戳证书 Base64
// if(json.getJSONObject("timeStamp").getString("tsCert") != null) {
// UserCert userCert = CertUtil.getCertFromBase64(json.getJSONObject("timeStamp").getString("tsCert"));
// eventTime.setCertificateDn(userCert.getCertDn());
// eventTime.setIssuerdn(userCert.getIssuerDn());
// }
// // 时间核验结果
// eventTime.setCheckTime(new Date());
// if(json.getIntValue("vtsResult") == 0) {
// eventTime.setCheckStatus("1");
// eventTime.setCheckSuccessTime(new Date());
// } else {
// if(StringUtils.isEmpty(retVerifyTime)) {
// retVerifyTime = "事件时间核验失败";
// }
// eventTime.setCheckStatus("0");
// if(json.getIntValue("vtsResult") == 60002) {
// eventTime.setUnreason("验证时戳失败");
// } else {
// eventTime.setUnreason("其他验证时戳错误");
// }
// }
// eventTime.setVewestCheckTime(new Date());
// // eventTime.setCheckContent("签名原文完整、真实、是否被篡改");
// objs.add(eventTime);
// } else {
// eventBehavior.setVerificationTime(json.getDate("stampTime"));
// }
// // 判断事件行为是否返回为空
// if(StringUtils.isNotEmpty(json.getString("signature"))) {
// eventBehavior.setHashAlgorithm(json.getString("hashAlg"));
// eventBehavior.setSignaturevalue(json.getString("signature"));
// eventBehavior.setHashBackSigning(json.getString("msgDigest"));
// eventBehavior.setEventContent(eventContent.getIdCode());
// eventBehavior.setIdentiType("1");
// eventBehavior.setCreateTime(new Date());
// if(trustedIdentity1 != null){
// eventBehavior.setMainInformation(trustedIdentity1.getMainInformation());
// } else {
// eventBehavior.setMainInformation(noId+"");
// }
// // 事件行为核验结果
// eventBehavior.setCheckTime(new Date());
// if(json.getIntValue("vdsResult") == 0) {
// eventBehavior.setCheckStatus("1");
// eventBehavior.setCheckSuccessTime(new Date());
// } else {
// if(StringUtils.isEmpty(retVerifyBehavior)) {
// retVerifyBehavior = "事件行为核验失败";
// }
// eventBehavior.setCheckStatus("0");
// if(json.getIntValue("vdsResult") == 40002) {
// eventBehavior.setUnreason("验证签名失败");
// } else {
// eventBehavior.setUnreason("其他验证签名错误");
// }
// }
// eventBehavior.setVewestCheckTime(new Date());
// // eventBehavior.setCheckContent("签名原文完整、真实、是否被篡改");
// objs.add(eventBehavior);
// } else {
// retVerifyBehavior = "事件行为核验失败";
// }
// }
// if(jsonArraySignInfos.size() == 0) {
// // eventContent.setEventStatus(0);
// // if(StringUtils.isNotEmpty(eventContent.getFailureReason())) {
// // eventContent.setFailureReason(eventContent.getFailureReason() + ",pdf签章失败:返回集合为空。");
// // } else {
// // eventContent.setFailureReason("pdf签章失败:返回集合为空。");
// // }
//
// result.put("status", 0);
// result.put("message", "pdf签章失败:返回集合为空。");
// return result;
// }
// // 整合错误信息
// // if(StringUtils.isNotEmpty(eventContent.getFailureReason())) {
// // eventContent.setFailureReason(eventContent.getFailureReason());
// // }
// if(StringUtils.isNotEmpty(retVerifyTi)) {
// if(StringUtils.isNotEmpty(eventContent.getFailureReason()))
// eventContent.setFailureReason(eventContent.getFailureReason() + "," + retVerifyTi);
// else
// eventContent.setFailureReason(retVerifyTi);
// }
// if(StringUtils.isNotEmpty(retVerifyBehavior)) {
// if(StringUtils.isNotEmpty(eventContent.getFailureReason()))
// eventContent.setFailureReason(retVerifyBehavior);
// else
// eventContent.setFailureReason(eventContent.getFailureReason() + "," + retVerifyBehavior);
// }
// if(StringUtils.isNotEmpty(retVerifyTime)) {
// if(StringUtils.isNotEmpty(eventContent.getFailureReason()))
// eventContent.setFailureReason(retVerifyTime);
// else
// eventContent.setFailureReason(eventContent.getFailureReason() + "," + retVerifyTime);
// }
// if(eventContent.getEventStatus() == 0) {
// if(StringUtils.isNotEmpty(basicInformation.getFailureReason())) {
// basicInformation.setFailureReason(basicInformation.getFailureReason() + "," + eventContent.getFailureReason());
// } else {
// basicInformation.setEvidenceStatus(0);
// basicInformation.setFailureReason(eventContent.getFailureReason());
// }
// result.put("status", 0);
// result.put("message", eventContent.getFailureReason());
// return result;
// }
// }
} else {
objs.add(eventContent);
for (EvidenceTrustedIdentity identity : tiCacheList) {
objs.add(identity);
}
}
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("e_factor"));
}
/**
*********************************************** 《电子合同PDF》 获取事件内容 end *******************************************
*/
}
break;
default:
break;
}
}
JSONArray jsonContentArray = jsonAuthEvent.getJSONArray("event");
for (int i = 0; i < jsonContentArray.size(); i++) {
// 得到对应的主体信息
JSONObject jsonContent = jsonContentArray.getJSONObject(i);
JSONObject jsonIdIdentify = jsonContent.getJSONObject("principalId");
// 判断主体是否存在
String idCacheKey = jsonIdIdentify.getString("name") + jsonIdIdentify.getString("dataId");
EvidenceMainInformation mainInformation = null;
if (cacheMainMap.get(idCacheKey) == null || "".equals(cacheMainMap.get(idCacheKey))) {
EvidenceMainInformationExample mainInformationExample = new EvidenceMainInformationExample();
EvidenceMainInformationExample.Criteria mainExampleCriteria = mainInformationExample.createCriteria();
mainExampleCriteria.andSubjectNameEqualTo(jsonIdIdentify.getString("name"));
mainExampleCriteria.andIdentificationEqualTo(jsonIdIdentify.getString("dataId"));
List<EvidenceMainInformation> mainInformationList = sqlSession.selectList("com.itrus.portal.db.EvidenceMainInformationMapper.selectByExample", mainInformationExample);
if (!mainInformationList.isEmpty()) {
mainInformation = mainInformationList.get(0);
cacheMainMap.put(mainInformation.getSubjectName() + mainInformation.getIdentification(), mainInformation);
}
} else {
mainInformation = cacheMainMap.get(idCacheKey);
}
if (mainInformation == null || "".equals(mainInformation)) {
result.put("status", 0);
result.put("message", "判断主体为空");
return result;
}
// 得到证据包中的事件数据
for (int j = 0; j < jsonEvArray.size(); j++) {
JSONObject object = jsonEvArray.getJSONObject(j);
switch(j) {
// 事件意愿认证
case 2:
// <--------------------- 提交证书授权 start ------------------------->
JSONObject jsonWillCert = jsonContent.getJSONObject("authEventWillCert");
JSONObject jsonWillSms = jsonContent.getJSONObject("authEventWillSms");
if (jsonWillSms != null && jsonWillCert != null) {
result.put("status", 0);
result.put("message", "提交的参数信息错误，证据及短信授权信息只能填写其一");
return result;
}
if (jsonWillCert != null) {
// 判断是否接收
if (object.getJSONObject("e_isReception").getBooleanValue("e_isReception_1")) {
EvidenceEventDesire eventDesire = new EvidenceEventDesire();
if (object.getBooleanValue("e_isRequired") && (StringUtils.isEmpty(jsonWillCert.getString("certBase64")) || StringUtils.isEmpty(jsonWillCert.getString("challengeCode")) || StringUtils.isEmpty(jsonWillCert.getString("answerCode")) || StringUtils.isEmpty(jsonWillCert.getString("verifyTime")) || StringUtils.isEmpty(jsonWillCert.getString("authenticatorThenType")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少事件意愿认证参数值");
return result;
}
// 验证证书
String urlCertVerify = realNameAuthentication.getRealNameddress() + CERT_VERIFY;
Map<String, Object> mapCertVerify = new HashMap<String, Object>();
mapCertVerify.put("cert", jsonWillCert.getString("certBase64"));
mapCertVerify.put("verifyFlag", "7");
String rep_cert_verify = HttpClientUtil.postForm(urlCertVerify, AuthService.getHeader(), mapCertVerify);
JSONObject jsonCertVerify = JSONObject.parseObject(rep_cert_verify);
if (StringUtils.isNotEmpty(rep_cert_verify) && jsonCertVerify.getIntValue("code") == 0) {
// 解析证书Base64
UserCert userCert = CertUtil.getCertFromBase64(jsonWillCert.getString("certBase64"));
eventDesire.setCertSerialnumber(userCert.getCertSn());
eventDesire.setSubjectdn(userCert.getCertDn());
eventDesire.setIssuerdn(userCert.getIssuerDn());
if (userCert.getCertBuf() != null) {
eventDesire.setEvidenceBuf(userCert.getCertBuf().toString());
}
eventDesire.setStartTime(userCert.getCertStartTime());
eventDesire.setEndTime(userCert.getCertEndTime());
} else {
result.put("status", 0);
result.put("message", "验证证书失败");
return result;
}
eventDesire.setChallengeCode(jsonWillCert.getString("challengeCode"));
eventDesire.setAnswerCode(jsonWillCert.getString("answerCode"));
eventDesire.setClientDevice(jsonWillCert.getString("clientFacility"));
eventDesire.setVerificationTime(jsonWillCert.getDate("verifyTime"));
eventDesire.setWaysExpression("1");
String eventVerifier = getAuthenticator(Integer.parseInt(jsonWillCert.getString("authenticatorThenType")), basicInformation.getEventPlatformName());
eventDesire.setMainInformation(mainInformation.getSubjectName() + ";" + mainInformation.getIdentification());
eventDesire.setEventContente(eventContent.getIdCode());
eventDesire.setCreateTime(new Date());
eventDesire.setEventVerifierType(jsonWillCert.getString("authenticatorThenType"));
eventDesire.setEventVerifier(eventVerifier);
objs.add(eventDesire);
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("e_factor"));
}
}
// <--------------------- 提交短信授权 start ------------------------->
if (jsonWillSms != null) {
// 判断是否接收
if (object.getJSONObject("e_isReception").getBooleanValue("e_isReception_2")) {
EvidenceEventDesire eventDesire = new EvidenceEventDesire();
if (object.getBooleanValue("e_isRequired") && (StringUtils.isEmpty(jsonWillSms.getString("phone")) || StringUtils.isEmpty(jsonWillSms.getString("sendTime")) || StringUtils.isEmpty(jsonWillSms.getString("smsContent")) || StringUtils.isEmpty(jsonWillSms.getString("verifyCode")) || StringUtils.isEmpty(jsonWillSms.getString("verifyTime")) || StringUtils.isEmpty(jsonWillSms.getString("authenticatorThenType")))) {
result.put("status", 0);
result.put("message", "提交的参数信息不完整，缺少事件意愿认证参数值");
return result;
}
eventDesire.setPhone(jsonWillSms.getString("phone"));
eventDesire.setSmsContent(jsonWillSms.getString("smsContent"));
eventDesire.setVerificationCode(jsonWillSms.getString("verifyCode"));
eventDesire.setSendOutTime(jsonWillSms.getDate("sendTime"));
eventDesire.setVerificationTime(jsonWillSms.getDate("verifyTime"));
eventDesire.setWaysExpression("2");
String eventVerifier = getAuthenticator(Integer.parseInt(jsonWillSms.getString("authenticatorThenType")), basicInformation.getEventPlatformName());
eventDesire.setMainInformation(mainInformation.getSubjectName() + ";" + mainInformation.getIdentification());
eventDesire.setEventContente(eventContent.getIdCode());
eventDesire.setCreateTime(new Date());
eventDesire.setEventVerifierType(jsonWillSms.getString("authenticatorThenType"));
eventDesire.setEventVerifier(eventVerifier);
objs.add(eventDesire);
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("e_factor"));
}
}
break;
// 事件地点认证
case 4:
// 判断是否接收
if (object.getBooleanValue("e_isReception")) {
JSONObject jsonAddress = jsonContent.getJSONObject("netAddress");
if (jsonAddress != null && !(jsonAddress.getString("appUid") == null && jsonAddress.getString("timeReg") == null && jsonAddress.getString("ipAddressReg") == null && jsonAddress.getString("ipAddressSign") == null)) {
// 定义事件网络地址对象
EvidenceEventNetworkAddress eventNetworkAddress = new EvidenceEventNetworkAddress();
// 整合数据 存储
eventNetworkAddress.setEventContent(eventContent.getIdCode());
eventNetworkAddress.setMainInformation(mainInformation.getSubjectName() + ";" + mainInformation.getIdentification());
eventNetworkAddress.setCreateTime(new Date());
eventNetworkAddress.setAccountNumber(jsonAddress.getString("appUid"));
eventNetworkAddress.setIpAddress(jsonAddress.getString("ipAddressReg"));
eventNetworkAddress.setSigninTime(jsonAddress.getDate("timeReg"));
eventNetworkAddress.setSigninNumber(jsonAddress.getString("appUid"));
eventNetworkAddress.setSigninipAddress(jsonAddress.getString("ipAddressReg"));
eventNetworkAddress.setSendOutTime(jsonAddress.getDate("timeReg"));
objs.add(eventNetworkAddress);
}
saveFactor = EvidenceSaveServiceApi.mergeFactor(saveFactor, object.getString("e_factor"));
}
break;
}
}
}
}
log.error("saveFactor content is [" + saveFactor + "]");
result.put("saveFactor", saveFactor);
result.put("basicInformation", basicInformation);
result.put("objs", objs);
return result;
} catch (Exception e) {
e.printStackTrace();
StackTraceElement stackTraceElement = e.getStackTrace()[e.getStackTrace().length - 5];
String info = stackTraceElement.getClassName() + stackTraceElement.getLineNumber() + e.toString();
LogUtil.evidencelog(sqlSession, evidenceSn, "存证接口", "存证失败，证据编号：" + evidenceSn + ", 失败原因:" + info);
result.put("status", -5);
result.put("message", "系统服务错误，请联系管理员");
return result;
}
}
Also used :
EvidenceIndividual(com.itrus.portal.db.EvidenceIndividual)
EvidenceSubjectIdentityExample(com.itrus.portal.db.EvidenceSubjectIdentityExample)
EvidenceBasicInformation(com.itrus.portal.db.EvidenceBasicInformation)
ConcurrentHashMap(java.util.concurrent.ConcurrentHashMap)
HashMap(java.util.HashMap)
PersonalNameExample(com.itrus.portal.db.PersonalNameExample)
ArrayList(java.util.ArrayList)
EvidenceMainInformation(com.itrus.portal.db.EvidenceMainInformation)
EvidenceRealName(com.itrus.portal.db.EvidenceRealName)
EvidenceTheAgent(com.itrus.portal.db.EvidenceTheAgent)
PersonalName(com.itrus.portal.db.PersonalName)
EvidenceEventDesire(com.itrus.portal.db.EvidenceEventDesire)
EvidenceCompaniesSubmit(com.itrus.portal.db.EvidenceCompaniesSubmit)
EvidenceEventContent(com.itrus.portal.db.EvidenceEventContent)
UserCert(com.itrus.portal.db.UserCert)
EvidenceDesireIdentify(com.itrus.portal.db.EvidenceDesireIdentify)
JSONArray(com.alibaba.fastjson.JSONArray)
EvidenceSubjectIdentity(com.itrus.portal.db.EvidenceSubjectIdentity)
RealNameRecord(com.itrus.portal.db.RealNameRecord)
Date(java.util.Date)
JSONObject(com.alibaba.fastjson.JSONObject)
EvidenceTrustedIdentity(com.itrus.portal.db.EvidenceTrustedIdentity)
JSONObject(com.alibaba.fastjson.JSONObject)
EvidenceMainInformationExample(com.itrus.portal.db.EvidenceMainInformationExample)
RealNameRecordExample(com.itrus.portal.db.RealNameRecordExample)
EvidenceRepresentative(com.itrus.portal.db.EvidenceRepresentative)
File(java.io.File)
EvidenceEventNetworkAddress(com.itrus.portal.db.EvidenceEventNetworkAddress)
Example 7 with PersonalName
use of com.itrus.portal.db.PersonalName in project portal by ixinportal.
the class QueueService method run.
@Override
public void run() {
boolean isException = false;
while (true) {
log.debug("execute run,the queue size is [" + OBJECT_QUEUE.size() + "]");
if (OBJECT_QUEUE.isEmpty()) {
try {
// 若队列中没有信息则等待十秒
sleep(10 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
continue;
}
log.debug("execute run,the queue size is [" + OBJECT_QUEUE.size() + "]");
Map<String, RealNameRecord> realMap = new HashMap<String, RealNameRecord>();
Map<String, PersonalName> perMap = new HashMap<String, PersonalName>();
// for (int i = 0; !OBJECT_QUEUE.isEmpty() && i < 500; i++) {
Object obj = OBJECT_QUEUE.poll();
if (obj instanceof Map) {
if ((RealNameRecord) ((Map) obj).get("realNameRecord") != null) {
realMap.put("realNameRecord", (RealNameRecord) ((Map) obj).get("realNameRecord"));
}
if ((PersonalName) ((Map) obj).get("personalName") != null) {
perMap.put("personalName", (PersonalName) ((Map) obj).get("personalName"));
}
}
// 存储企业路径
if (!realMap.isEmpty()) {
try {
RealNameRecord realNameRecord = (RealNameRecord) ((Map) obj).get("realNameRecord");
log.error("【认证信息入库】 企业名称 ：" + realNameRecord.getCompanyname() + "，入库时间 ：" + new Date());
sqlSession.insert("com.itrus.portal.db.RealNameRecordMapper.insert", realNameRecord);
Agentinformation agentinformation = (Agentinformation) ((Map) obj).get("agentinformation");
if (agentinformation != null) {
agentinformation.setRealNameRecord(realNameRecord.getId());
sqlSession.insert("com.itrus.portal.db.AgentinformationMapper.insert", agentinformation);
realNameRecord.setAgentinformation(agentinformation.getId());
}
ApplicationInfo applicationInfo = (ApplicationInfo) ((Map) obj).get("applicationInfo");
AppService appService = (AppService) ((Map) obj).get("appService");
// 计费 appId serviceCode 服务类别,二选一(企业为1,个人为2) 调用前还是调用后
Map<String, Object> cert = certificationChargingService.charging(applicationInfo.getAppId(), appService.getAppServiceId(), appService.getServiceConfigName(), appService.getServiceConfigId(), applicationInfo, appService, realNameRecord.getId(), "RealNameRecord");
if ((int) cert.get("retCode") != 1) {
// 错误
realNameRecord.setServicestate(1L);
}
realNameRecord.setReturntime(new Date());
sqlSession.update("com.itrus.portal.db.RealNameRecordMapper.updateByPrimaryKeySelective", realNameRecord);
} catch (Exception e) {
isException = true;
// 将错误信息显示，不进行操作
log.error(e);
}
}
// 存储个人记录
if (!perMap.isEmpty()) {
try {
PersonalName personalName = (PersonalName) ((Map) obj).get("personalName");
log.error("【认证信息入库】 名称 ：" + personalName.getName() + "，入库时间 ：" + new Date());
sqlSession.insert("com.itrus.portal.db.PersonalNameMapper.insert", personalName);
ApplicationInfo applicationInfo = (ApplicationInfo) ((Map) obj).get("applicationInfo");
AppService appService = (AppService) ((Map) obj).get("appService");
// 计费 appId code 服务类别,二选一(企业为1,个人为2) 调用前还是调用后
Map<String, Object> cert = certificationChargingService.charging(applicationInfo.getAppId(), appService.getAppServiceId(), appService.getServiceConfigName(), appService.getServiceConfigId(), applicationInfo, appService, personalName.getId(), "PersonalName");
if ((int) cert.get("retCode") != 1) {
// 错误
personalName.setServicestate(1);
}
personalName.setReturntime(new Date());
sqlSession.update("com.itrus.portal.db.PersonalNameMapper.updateByPrimaryKeySelective", personalName);
} catch (Exception e) {
isException = true;
// 将错误信息显示，不进行操作
log.error(e);
}
}
log.debug("the exception is [" + isException + "]");
// 若出现异常则暂停10秒钟
if (isException) {
try {
// 若队列中没有信息则等待十秒
sleep(10 * 1000);
} catch (InterruptedException e) {
log.error(e);
} finally {
isException = false;
}
}
}
}
Also used :
AppService(com.itrus.portal.db.AppService)
HashMap(java.util.HashMap)
ApplicationInfo(com.itrus.portal.db.ApplicationInfo)
RealNameRecord(com.itrus.portal.db.RealNameRecord)
Date(java.util.Date)
Agentinformation(com.itrus.portal.db.Agentinformation)
PersonalName(com.itrus.portal.db.PersonalName)
HashMap(java.util.HashMap)
Map(java.util.Map)
Example 8 with PersonalName
use of com.itrus.portal.db.PersonalName in project portal by ixinportal.
the class HisCertificateController method preview.
/**
* 预览出证信息
*
* @param serialnumber
* @param type
* @param uiModel
* @return
*/
@RequestMapping(value = "/outhis/{serialnumber}", produces = "text/html")
public String preview(@PathVariable("serialnumber") String serialnumber, Model uiModel) {
// 得到证据基本信息表
List<EvidenceBasicInformation> blist = new ArrayList<EvidenceBasicInformation>();
// 得到企业平台信息
Map<Long, EvidenceCompaniesSubmit> companiesSubmit = new HashMap<Long, EvidenceCompaniesSubmit>();
// 得到天威企业信息
Map<Long, List<RealNameRecord>> realnameRecor = new HashMap<Long, List<RealNameRecord>>();
// 得到天威个人信息
Map<Long, PersonalName> personalName = new HashMap<Long, PersonalName>();
// 得到个人平台信息
Map<Long, EvidenceIndividual> denceid = new HashMap<Long, EvidenceIndividual>();
// 得到得到身份意愿信息
Map<Long, EvidenceDesireIdentify> mdesire = new HashMap<Long, EvidenceDesireIdentify>();
// 得到事件内容信息
Map<Long, EvidenceEventContent> eventcontent = new HashMap<Long, EvidenceEventContent>();
// 得到时间对象
Map<Long, List<EvidenceTrustedIdentity>> trusid = new HashMap<Long, List<EvidenceTrustedIdentity>>();
// 得到身份标识信息
Map<Long, List<EvidenceTrustedIdentity>> trusted = new HashMap<Long, List<EvidenceTrustedIdentity>>();
// 得到事件时间信息
Map<Long, List<EvidenceEventTime>> enenttime = new HashMap<Long, List<EvidenceEventTime>>();
// 得到事件行为认证信息
Map<Long, List<EvidenceEventBehavior>> enenbehavior = new HashMap<Long, List<EvidenceEventBehavior>>();
// 得到事件意愿认证信息
Map<Long, List<EvidenceEventDesire>> evendesire = new HashMap<Long, List<EvidenceEventDesire>>();
// 得到平台提交信息代表人
Map<Long, EvidenceRepresentative> erepresetative = new HashMap<Long, EvidenceRepresentative>();
// 得到平台提交信息代理人
Map<Long, EvidenceTheAgent> etheagent = new HashMap<Long, EvidenceTheAgent>();
// 得到营业执照
Map<Long, Licenseinformation> licensein = new HashMap<Long, Licenseinformation>();
// 得到企业银行信息
Map<Long, Enterprisebank> enterpris = new HashMap<Long, Enterprisebank>();
// 得到组织机构代码
Map<Long, Organization> organiza = new HashMap<Long, Organization>();
// 得到法定代表人信息
Map<Long, Corporateinformation> corporat = new HashMap<Long, Corporateinformation>();
// 得到代理人信息
Map<Long, Agentinformation> agemtom = new HashMap<Long, Agentinformation>();
// 得到银行三四要素信息
Map<Long, Bankcardelements> bankcardele = new HashMap<Long, Bankcardelements>();
// 证据基本信息，放入多个基本信息
List<EvidenceBasicInformation> basicinfos = new ArrayList<EvidenceBasicInformation>();
// 得到出证信息
EvidenceHisCertificateExample hiscer = new EvidenceHisCertificateExample();
EvidenceHisCertificateExample.Criteria tificate = hiscer.createCriteria();
tificate.andSerialnumberEqualTo(serialnumber);
EvidenceHisCertificate hisCertificate = sqlSession.selectOne("com.itrus.portal.db.EvidenceHisCertificateMapper.selectByExample", hiscer);
// 出征流水号
contractNumber = hisCertificate.getSerialnumber();
// 得到出证存证中间表
EvidenceHisRelationshipExample hisrelation = new EvidenceHisRelationshipExample();
EvidenceHisRelationshipExample.Criteria shipEx = hisrelation.createCriteria();
shipEx.andHisCertificateEqualTo(hisCertificate.getId());
List<EvidenceHisRelationship> hisrelationship = sqlSession.selectList("com.itrus.portal.db.EvidenceHisRelationshipMapper.selectByExample", hisrelation);
for (EvidenceHisRelationship h : hisrelationship) {
// 得到基本信息表
EvidenceBasicInformation basic = sqlSession.selectOne("com.itrus.portal.db.EvidenceBasicInformationMapper.selectByPrimaryKey", h.getBasicInformation());
basicinfos.add(basic);
// 得到身份意愿信息
EvidenceDesireIdentifyExample desireIdentify = new EvidenceDesireIdentifyExample();
EvidenceDesireIdentifyExample.Criteria desireExample = desireIdentify.createCriteria();
desireExample.andEvidenceSnEqualTo(basic.getEvidenceSn());
EvidenceDesireIdentify desire = sqlSession.selectOne("com.itrus.portal.db.EvidenceDesireIdentifyMapper.selectByExample", desireIdentify);
mdesire.put(basic.getId(), desire);
// 得到身份信息表
EvidenceRealNameExample realnameE = new EvidenceRealNameExample();
EvidenceRealNameExample.Criteria realnameEx = realnameE.createCriteria();
realnameEx.andBasicInformationEqualTo(basic.getId());
EvidenceRealName erealname = sqlSession.selectOne("com.itrus.portal.db.EvidenceRealNameMapper.selectByExample", realnameE);
if (erealname != null) {
// 判断身份信息是否为空
if (!"1".equals(erealname.getEventVerifierType())) {
// 判断平台认证
if ("1".equals(erealname.getType())) {
// 判断平台企业认证
EvidenceCompaniesSubmit companiesSubmit1 = sqlSession.selectOne("com.itrus.portal.db.EvidenceCompaniesSubmitMapper.selectByPrimaryKey", erealname.getCompaniesSubmit());
companiesSubmit.put(basic.getId(), companiesSubmit1);
// 得到法定代表人
EvidenceRepresentative representative = sqlSession.selectOne("com.itrus.portal.db.EvidenceRepresentativeMapper.selectByPrimaryKey", companiesSubmit1.getRepresentative());
erepresetative.put(basic.getId(), representative);
// 得到代理人
EvidenceTheAgent theAgen = sqlSession.selectOne("com.itrus.portal.db.EvidenceTheAgentMapper.selectByPrimaryKey", companiesSubmit1.getTheAgent());
etheagent.put(basic.getId(), theAgen);
uiModel.addAttribute("companiesSubmit", companiesSubmit);
uiModel.addAttribute("realname", companiesSubmit);
} else {
// 平台个人认证
EvidenceIndividual dic = sqlSession.selectOne("com.itrus.portal.db.EvidenceIndividualMapper.selectByPrimaryKey", erealname.getIndividual());
denceid.put(basic.getId(), dic);
uiModel.addAttribute("denceid", denceid);
uiModel.addAttribute("realname", denceid);
}
} else {
// 天威认证
if ("1".equals(erealname.getType())) {
// 天威企业认证
String serialnamber = erealname.getSerialnumber();
String[] namber = serialnamber.split(",");
// List<RealNameRecord> listReal = new
// ArrayList<RealNameRecord>();
List<String> listString = new ArrayList<String>();
for (int i = 0; i < namber.length; i++) {
listString.add(namber[i]);
}
RealNameRecordExample realname = new RealNameRecordExample();
RealNameRecordExample.Criteria recor = realname.createCriteria();
// recor.andSerialnumberEqualTo(erealname.getSerialnumber());
recor.andSerialnumberIn(listString);
List<RealNameRecord> realnameRecor1 = sqlSession.selectList("com.itrus.portal.db.RealNameRecordMapper.selectByExample", realname);
realnameRecor.put(basic.getId(), realnameRecor1);
for (RealNameRecord real : realnameRecor1) {
// 得到营业执照
if (real.getLicenseinformation() != null) {
Licenseinformation information = sqlSession.selectOne("com.itrus.portal.db.LicenseinformationMapper.selectByPrimaryKey", real.getLicenseinformation());
licensein.put(basic.getId(), information);
}
// 得到企业银行信息
if (real.getEnterprisebank() != null) {
Enterprisebank enterprise = sqlSession.selectOne("com.itrus.portal.db.EnterprisebankMapper.selectByPrimaryKey", real.getEnterprisebank());
enterpris.put(basic.getId(), enterprise);
}
// 得到组织机构代码信息
if (real.getOrganization() != null) {
Organization organization = sqlSession.selectOne("com.itrus.portal.db.OrganizationMapper.selectByPrimaryKey", real.getOrganization());
organiza.put(basic.getId(), organization);
}
// 得到法定代表人信息
if (real.getCorporateinformation() != null) {
Corporateinformation enterprise = sqlSession.selectOne("com.itrus.portal.db.CorporateinformationMapper.selectByPrimaryKey", real.getCorporateinformation());
corporat.put(basic.getId(), enterprise);
}
// 得到代理人信息
if (real.getAgentinformation() != null) {
Agentinformation enterprise = sqlSession.selectOne("com.itrus.portal.db.AgentinformationMapper.selectByPrimaryKey", real.getAgentinformation());
agemtom.put(basic.getId(), enterprise);
}
}
uiModel.addAttribute("realname", realnameRecor);
} else {
// 天威个人认证
PersonalNameExample personal = new PersonalNameExample();
PersonalNameExample.Criteria personalname = personal.createCriteria();
personalname.andSerialnumberEqualTo(erealname.getSerialnumber());
PersonalName personalName1 = sqlSession.selectOne("com.itrus.portal.db.PersonalNameMapper.selectByExample", personal);
personalName.put(basic.getId(), personalName1);
// 得到银行三四要素信息
Bankcardelements bank = sqlSession.selectOne("com.itrus.portal.db.BankcardelementsMapper.selectByPrimaryKey", personalName1.getBankcardelements());
bankcardele.put(basic.getId(), bank);
uiModel.addAttribute("personalName", personalName);
uiModel.addAttribute("realname", personalName);
}
}
}
// 事件内容
EvidenceEventContentExample evencontent = new EvidenceEventContentExample();
EvidenceEventContentExample.Criteria countent = evencontent.createCriteria();
// countent.andBasicInformationEqualTo(basic.getEvidenceSn());
countent.andEvidenceSnEqualTo(basic.getEvidenceSn());
List<EvidenceEventContent> mevencontent = sqlSession.selectList("com.itrus.portal.db.EvidenceEventContentMapper.selectByExample", evencontent);
eventcontent.put(basic.getId(), mevencontent.get(0));
// 得到身份可信标识
EvidenceTrustedIdentityExample trusten = new EvidenceTrustedIdentityExample();
EvidenceTrustedIdentityExample.Criteria identityex = trusten.createCriteria();
identityex.andBasicInformationEqualTo(basic.getEvidenceSn());
identityex.andEventContentIsNull();
List<EvidenceTrustedIdentity> trustedidentity = sqlSession.selectList("com.itrus.portal.db.EvidenceTrustedIdentityMapper.selectByExample", trusten);
trusted.put(basic.getId(), trustedidentity);
// 事件对象认证
EvidenceTrustedIdentityExample trustenid = new EvidenceTrustedIdentityExample();
EvidenceTrustedIdentityExample.Criteria identitye = trustenid.createCriteria();
identitye.andEventContentEqualTo(mevencontent.get(0).getIdCode());
List<EvidenceTrustedIdentity> trustedidentit = sqlSession.selectList("com.itrus.portal.db.EvidenceTrustedIdentityMapper.selectByExample", trustenid);
trusid.put(basic.getId(), trustedidentit);
// 事件时间认证
EvidenceEventTimeExample eventime = new EvidenceEventTimeExample();
EvidenceEventTimeExample.Criteria eventimeEx = eventime.createCriteria();
eventimeEx.andEventContentEqualTo(mevencontent.get(0).getIdCode());
List<EvidenceEventTime> meventime = sqlSession.selectList("com.itrus.portal.db.EvidenceEventTimeMapper.selectByExample", eventime);
enenttime.put(basic.getId(), meventime);
// 事件行为认证
EvidenceEventBehaviorExample eventbehaciorEx = new EvidenceEventBehaviorExample();
EvidenceEventBehaviorExample.Criteria eventbe = eventbehaciorEx.createCriteria();
eventbe.andEventContentEqualTo(mevencontent.get(0).getIdCode());
List<EvidenceEventBehavior> eventbehacior = sqlSession.selectList("com.itrus.portal.db.EvidenceEventBehaviorMapper.selectByExample", eventbehaciorEx);
enenbehavior.put(basic.getId(), eventbehacior);
// 事件意愿认证
EvidenceEventDesireExample desireEx = new EvidenceEventDesireExample();
EvidenceEventDesireExample.Criteria eventdesire = desireEx.createCriteria();
// eventdesire.andMainInformationEqualTo(basic.getId());
eventdesire.andEventContenteEqualTo(mevencontent.get(0).getIdCode());
List<EvidenceEventDesire> meventdesire = sqlSession.selectList("com.itrus.portal.db.EvidenceEventDesireMapper.selectByExample", desireEx);
evendesire.put(basic.getId(), meventdesire);
blist.add(basic);
// 判断图片是否存在
if (mevencontent.get(0).getIsimg() == null) {
// 得到证据附件表，用于获取信息
EvidenceEnclosureExample envlosureE = new EvidenceEnclosureExample();
EvidenceEnclosureExample.Criteria envlosureEx = envlosureE.createCriteria();
envlosureEx.andEvidenceSnEqualTo(basic.getEvidenceSn());
envlosureEx.andPdfTypeEqualTo("2");
EvidenceEnclosure envlosure = sqlSession.selectOne("com.itrus.portal.db.EvidenceEnclosureMapper.selectByExample", envlosureE);
// 判断是否为用户上传pdf
if (envlosure != null) {
String urlFile = systemConfigService.getpdfurl() + File.separator + envlosure.getBucketName() + File.separator + envlosure.getEvidenceSn();
File filePathStr = new File(urlFile, envlosure.getObjectName());
int pdfToPng = 0;
if (filePathStr != null && filePathStr.getPath() != null) {
try {
// 调用生成图片方法生成图片
pdfToPng = Pdf.pdf2png(filePathStr.getPath());
} catch (Exception e) {
e.printStackTrace();
}
}
// 判断生成图片是否成功
if (pdfToPng > 0) {
// 修改内容表信息，表示生成图片
log.error("pdfToPng=" + pdfToPng);
mevencontent.get(0).setIsimg(1);
mevencontent.get(0).setImgCount(pdfToPng);
sqlSession.update("com.itrus.portal.db.EvidenceEventContentMapper.updateByPrimaryKey", mevencontent);
String oper = "原文图片生成成功";
String info = "图片地址：" + urlFile;
LogUtil.evidencelog(sqlSession, null, oper, info);
} else {
String oper = "原文图片生成失败";
String info = "失败原因：" + systemConfigService.getpdfurl() + File.separator + envlosure.getBucketName();
LogUtil.evidencelog(sqlSession, null, oper, info);
}
}
}
}
uiModel.addAttribute("basicinfos", basicinfos);
// 平台代表人
uiModel.addAttribute("erepresetative", erepresetative);
// 平台代理人
uiModel.addAttribute("etheagent", etheagent);
// 营业执照信息
uiModel.addAttribute("licensein", licensein);
// 企业银行信息
uiModel.addAttribute("enterpris", enterpris);
// 住址机构代码
uiModel.addAttribute("organiza", organiza);
// 法定代表人
uiModel.addAttribute("corporat", corporat);
// 法定代理人
uiModel.addAttribute("agemtom", agemtom);
// 银行卡三四要素
uiModel.addAttribute("bankcardele", bankcardele);
// 得到得到身份意愿信息
uiModel.addAttribute("mdesire", mdesire);
// 得到事件时间信息
uiModel.addAttribute("enenttime", enenttime);
// 得到事件行为认证信息
uiModel.addAttribute("enenbehavior", enenbehavior);
// 得到时间对象
uiModel.addAttribute("trusid", trusid);
// 得到身份标识信息
uiModel.addAttribute("trusted", trusted);
// 得到证据基本信息表
uiModel.addAttribute("blist", blist);
// 得到事件内容信息
uiModel.addAttribute("eventcontent", eventcontent);
// 得到出证信息
uiModel.addAttribute("hisCertificate", hisCertificate);
// 出证时间
uiModel.addAttribute("datetime", new Date());
return "reporttemplate/certificationReport";
}
Also used :
EvidenceIndividual(com.itrus.portal.db.EvidenceIndividual)
HashMap(java.util.HashMap)
PersonalNameExample(com.itrus.portal.db.PersonalNameExample)
ArrayList(java.util.ArrayList)
Corporateinformation(com.itrus.portal.db.Corporateinformation)
EvidenceRealName(com.itrus.portal.db.EvidenceRealName)
ArrayList(java.util.ArrayList)
List(java.util.List)
EvidenceEventDesire(com.itrus.portal.db.EvidenceEventDesire)
Enterprisebank(com.itrus.portal.db.Enterprisebank)
EvidenceDesireIdentify(com.itrus.portal.db.EvidenceDesireIdentify)
EvidenceEventBehaviorExample(com.itrus.portal.db.EvidenceEventBehaviorExample)
EvidenceHisRelationship(com.itrus.portal.db.EvidenceHisRelationship)
EvidenceEnclosureExample(com.itrus.portal.db.EvidenceEnclosureExample)
RealNameRecord(com.itrus.portal.db.RealNameRecord)
EvidenceEventContentExample(com.itrus.portal.db.EvidenceEventContentExample)
EvidenceEventTime(com.itrus.portal.db.EvidenceEventTime)
EvidenceRepresentative(com.itrus.portal.db.EvidenceRepresentative)
File(java.io.File)
MultipartFile(org.springframework.web.multipart.MultipartFile)
EvidenceRealNameExample(com.itrus.portal.db.EvidenceRealNameExample)
Organization(com.itrus.portal.db.Organization)
EvidenceBasicInformation(com.itrus.portal.db.EvidenceBasicInformation)
EvidenceHisCertificate(com.itrus.portal.db.EvidenceHisCertificate)
EvidenceEnclosure(com.itrus.portal.db.EvidenceEnclosure)
EvidenceTheAgent(com.itrus.portal.db.EvidenceTheAgent)
Agentinformation(com.itrus.portal.db.Agentinformation)
EvidenceDesireIdentifyExample(com.itrus.portal.db.EvidenceDesireIdentifyExample)
PersonalName(com.itrus.portal.db.PersonalName)
EvidenceEventDesireExample(com.itrus.portal.db.EvidenceEventDesireExample)
EvidenceEventTimeExample(com.itrus.portal.db.EvidenceEventTimeExample)
EvidenceCompaniesSubmit(com.itrus.portal.db.EvidenceCompaniesSubmit)
EvidenceEventContent(com.itrus.portal.db.EvidenceEventContent)
Licenseinformation(com.itrus.portal.db.Licenseinformation)
EvidenceHisRelationshipExample(com.itrus.portal.db.EvidenceHisRelationshipExample)
IOException(java.io.IOException)
FileNotFoundException(java.io.FileNotFoundException)
Date(java.util.Date)
EvidenceEventBehavior(com.itrus.portal.db.EvidenceEventBehavior)
EvidenceHisCertificateExample(com.itrus.portal.db.EvidenceHisCertificateExample)
EvidenceTrustedIdentity(com.itrus.portal.db.EvidenceTrustedIdentity)
Bankcardelements(com.itrus.portal.db.Bankcardelements)
RealNameRecordExample(com.itrus.portal.db.RealNameRecordExample)
EvidenceTrustedIdentityExample(com.itrus.portal.db.EvidenceTrustedIdentityExample)
RequestMapping(org.springframework.web.bind.annotation.RequestMapping)
Aggregations
PersonalName (com.itrus.portal.db.PersonalName)8
RealNameRecord (com.itrus.portal.db.RealNameRecord)7
HashMap (java.util.HashMap)6
EvidenceBasicInformation (com.itrus.portal.db.EvidenceBasicInformation)5
EvidenceCompaniesSubmit (com.itrus.portal.db.EvidenceCompaniesSubmit)5
EvidenceDesireIdentify (com.itrus.portal.db.EvidenceDesireIdentify)5
EvidenceEventContent (com.itrus.portal.db.EvidenceEventContent)5
EvidenceEventDesire (com.itrus.portal.db.EvidenceEventDesire)5
EvidenceIndividual (com.itrus.portal.db.EvidenceIndividual)5
EvidenceRealName (com.itrus.portal.db.EvidenceRealName)5
EvidenceTrustedIdentity (com.itrus.portal.db.EvidenceTrustedIdentity)5
PersonalNameExample (com.itrus.portal.db.PersonalNameExample)5
RealNameRecordExample (com.itrus.portal.db.RealNameRecordExample)5
Date (java.util.Date)5
RequestMapping (org.springframework.web.bind.annotation.RequestMapping)5
Agentinformation (com.itrus.portal.db.Agentinformation)4
EvidenceDesireIdentifyExample (com.itrus.portal.db.EvidenceDesireIdentifyExample)4
EvidenceEnclosure (com.itrus.portal.db.EvidenceEnclosure)4
EvidenceEnclosureExample (com.itrus.portal.db.EvidenceEnclosureExample)4
EvidenceEventBehavior (com.itrus.portal.db.EvidenceEventBehavior)4
