285 lines
12 KiB
Java
285 lines
12 KiB
Java
package net.gepafin.tendermanagement.dao;
|
|
|
|
import java.net.URI;
|
|
import java.time.LocalDateTime;
|
|
import java.time.LocalTime;
|
|
import java.time.format.DateTimeFormatter;
|
|
import java.time.format.DateTimeParseException;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import feign.FeignException;
|
|
import jakarta.servlet.http.HttpServletRequest;
|
|
import net.gepafin.tendermanagement.constants.GepafinConstant;
|
|
import net.gepafin.tendermanagement.entities.*;
|
|
import net.gepafin.tendermanagement.enums.ApplicationSignedDocumentStatusEnum;
|
|
import net.gepafin.tendermanagement.enums.ProtocolTypeEnum;
|
|
import net.gepafin.tendermanagement.enums.VersionActionTypeEnum;
|
|
import net.gepafin.tendermanagement.model.request.VersionHistoryRequest;
|
|
import net.gepafin.tendermanagement.repositories.ApplicationSignedDocumentRepository;
|
|
import net.gepafin.tendermanagement.service.feignClient.ProtocolService;
|
|
import net.gepafin.tendermanagement.util.LoggingUtil;
|
|
import net.gepafin.tendermanagement.util.Utils;
|
|
import org.apache.commons.lang3.StringUtils;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.beans.factory.annotation.Value;
|
|
import org.springframework.http.HttpHeaders;
|
|
import org.springframework.http.ResponseEntity;
|
|
import org.springframework.stereotype.Component;
|
|
|
|
import net.gepafin.tendermanagement.repositories.ProtocolRepository;
|
|
import net.gepafin.tendermanagement.util.DateTimeUtil;
|
|
|
|
@Component
|
|
public class ProtocolDao {
|
|
|
|
@Autowired
|
|
private ProtocolRepository protocolRepository;
|
|
|
|
|
|
@Value("${default.hub.uuid}")
|
|
private String defaultHubUuid;
|
|
|
|
@Autowired
|
|
private LoggingUtil loggingUtil;
|
|
|
|
@Autowired
|
|
private HttpServletRequest request;
|
|
|
|
@Autowired
|
|
private ProtocolService protocolService;
|
|
|
|
@Value("${codAoo}")
|
|
private String codAoo;
|
|
|
|
@Value("${sviluppumbria.username}")
|
|
private String username;
|
|
|
|
@Value("${password}")
|
|
private String password;
|
|
|
|
@Value("${CLASSIFICA}")
|
|
private String classifica;
|
|
|
|
@Value("${TIPO_PROTOCOLLAZIONE}")
|
|
private String TIPO_PROTOCOLLAZIONE;
|
|
|
|
@Value("${tipoCorrispondenteCompany}")
|
|
private String tipoCorrispondenteCompany;
|
|
|
|
@Value("${tipoCorrispondenteWithoutCompany}")
|
|
private String tipoCorrispondenteWithoutCompany;
|
|
|
|
@Value("${mezzo}")
|
|
private String mezzo;
|
|
|
|
@Value("${indirizzoPec}")
|
|
private String indirizzoPec;
|
|
|
|
@Value("${codiceUo}")
|
|
private String codiceUo;
|
|
|
|
@Value("${competente}")
|
|
private Boolean competente;
|
|
|
|
@Value("${tipoCorrispondente}")
|
|
private String tipoCorrispondente;
|
|
|
|
@Value("${isSviluppumbriaProtocolEnabled}")
|
|
private String isSviluppUmbriaProtocolEnabled;
|
|
|
|
@Autowired
|
|
private ApplicationSignedDocumentRepository applicationSignedDocumentRepository;
|
|
|
|
public final Logger log = LoggerFactory.getLogger(ProtocolDao.class);
|
|
|
|
public Long getProtocolNumber(HubEntity hubEntity) {
|
|
Long maxProtocolNumber = protocolRepository.findMaxProtocolNumberAndHubId(hubEntity.getId());
|
|
Long startNumber = 10000001L;
|
|
if(Boolean.FALSE.equals(defaultHubUuid.equals(hubEntity.getUniqueUuid()))) {
|
|
startNumber = 20000001L;
|
|
}
|
|
return (maxProtocolNumber != null) ? maxProtocolNumber + 1 : startNumber;
|
|
}
|
|
|
|
public ProtocolEntity createProtocolEntity(ApplicationEntity applicationEntity,Long protocolNumber, Long hubId,Boolean isForApplication){
|
|
ProtocolEntity protocolEntity=new ProtocolEntity();
|
|
protocolEntity.setCall(applicationEntity.getCall().getId());
|
|
LocalDateTime utcDateTime = DateTimeUtil.DateServerToUTC(LocalDateTime.now());
|
|
protocolEntity.setYear(utcDateTime.getYear());
|
|
protocolEntity.setProtocolNumber(protocolNumber);
|
|
LocalTime time = utcDateTime.toLocalTime().withNano(0);
|
|
protocolEntity.setTime(time);
|
|
protocolEntity.setApplicationId(applicationEntity.getId());
|
|
protocolEntity.setHubId(hubId);
|
|
if(Boolean.TRUE.equals(isForApplication)){
|
|
protocolEntity.setType(ProtocolTypeEnum.INPUT.getValue());
|
|
}else {
|
|
protocolEntity.setType(ProtocolTypeEnum.OUTPUT.getValue());
|
|
}
|
|
|
|
return protocolEntity;
|
|
}
|
|
|
|
public void saveProtocolEntity(ProtocolEntity protocolEntity) {
|
|
protocolRepository.save(protocolEntity);
|
|
|
|
/** This code is responsible for adding a version history log for "create protocol" operation. **/
|
|
loggingUtil.addVersionHistory(VersionHistoryRequest.builder().request(request).actionType(VersionActionTypeEnum.INSERT).oldData(null).newData(protocolEntity).build());
|
|
}
|
|
|
|
public String getBearerToken(String codAoo, String username, String password) {
|
|
log.info("Requesting bearer token for user: {} and codAoo: {}", username, codAoo);
|
|
|
|
HttpHeaders httpHeaders = Utils.getHeaders();
|
|
URI url = URI.create(GepafinConstant.PROTOCOL_SERVICE_BEARER_TOKEN);
|
|
|
|
try {
|
|
ResponseEntity<String> response = protocolService.getBearerToken(httpHeaders, codAoo,username,password);
|
|
|
|
if (response != null && response.getStatusCode().is2xxSuccessful()) {
|
|
log.debug("Bearer token successfully retrieved. HTTP Status: {}", response.getStatusCode());
|
|
return response.getBody().toString(); // Use getBody() instead of toString()
|
|
} else {
|
|
log.warn("Bearer token request failed or returned unexpected status. Response: {}", response);
|
|
}
|
|
} catch (FeignException ex) {
|
|
log.error("FeignException while retrieving bearer token for user {}: {}", username, ex.getMessage(), ex);
|
|
Utils.callException(ex.status(), ex);
|
|
} catch (Exception ex) {
|
|
log.error("Unexpected exception while retrieving bearer token: {}", ex.getMessage(), ex);
|
|
}
|
|
|
|
log.warn("Returning null bearer token for user: {}", username);
|
|
return null;
|
|
}
|
|
|
|
public ProtocolEntity createExternalProtocol(ApplicationEntity application, CompanyEntity company, ProtocolEntity protocol) {
|
|
|
|
if (Boolean.FALSE.equals(Boolean.parseBoolean(isSviluppUmbriaProtocolEnabled))) {
|
|
return protocol;
|
|
}
|
|
|
|
log.info("Starting createExternalProtocol for application ID: {}", application.getId());
|
|
|
|
log.debug("Successfully retrieved bearer token");
|
|
ApplicationSignedDocumentEntity applicationSignedDocumentEntity=applicationSignedDocumentRepository.findByApplicationIdAndStatus(application.getId(), ApplicationSignedDocumentStatusEnum.ACTIVE.getValue());
|
|
|
|
String year = String.valueOf(LocalDateTime.now().getYear());
|
|
String applicationId = String.valueOf(application.getId());
|
|
String mittenteValue="";
|
|
String vatNumber ="";
|
|
if(company!=null) {
|
|
mittenteValue= tipoCorrispondenteCompany;
|
|
vatNumber=company.getVatNumber();
|
|
}else {
|
|
mittenteValue = tipoCorrispondenteWithoutCompany;
|
|
vatNumber = company.getCodiceFiscale();
|
|
}
|
|
String companyName = company.getCompanyName() + " " + vatNumber;
|
|
String callName = application.getCall().getName()+" "+ application.getCall().getId();
|
|
String callId = GepafinConstant.PROTOCOL_CALL_NAME+ String.valueOf(application.getCall().getId());
|
|
String pecEmail=company.getPec();
|
|
String docUrl=applicationSignedDocumentEntity.getFilePath()+GepafinConstant.PROTOCOL_DOC_SUFFIX;
|
|
|
|
|
|
Map<String, Object> requestBody = new HashMap<>();
|
|
requestBody.put(GepafinConstant.PROTOCOL_DOC_URL,docUrl);
|
|
requestBody.put(GepafinConstant.PROTOCOL_DOC_HASH,applicationSignedDocumentEntity.getFileHash());
|
|
requestBody.put(GepafinConstant.PROTOCOL_TIPO_PROTOCOLLAZIONE,TIPO_PROTOCOLLAZIONE);
|
|
requestBody.put(GepafinConstant.PROTOCOL_COMPANY_NAME_VAT_NUMBER,company.getCompanyName());
|
|
Map<String, Object> mittente = new HashMap<>();
|
|
mittente.put(GepafinConstant.PROTOCOL_TIPO_CORRISPONDENTE, mittenteValue);
|
|
mittente.put(GepafinConstant.PROTOCOL_MEZZO,mezzo);
|
|
mittente.put(GepafinConstant.PROTOCOL_INDIRIZZO_PEC,pecEmail);
|
|
mittente.put(GepafinConstant.PROTOCOL_COMPANY_VAT_NUMBER,vatNumber);
|
|
mittente.put(GepafinConstant.PROTOCOL_COMPANY_NAME,company.getCompanyName());
|
|
List<Map<String,Object>> destinatariObject=new ArrayList<>();
|
|
Map<String, Object> destinatari = new HashMap<>();
|
|
destinatari.put(GepafinConstant.PROTOCOL_CODICE_UO,codiceUo);
|
|
destinatari.put(GepafinConstant.PROTOCOL_COMPETENTE,competente);
|
|
destinatari.put(GepafinConstant.PROTOCOL_TIPO_CORRISPONDENTE,tipoCorrispondente);
|
|
requestBody.put(GepafinConstant.PROTOCOL_MITTENTE,mittente);
|
|
destinatariObject.add(destinatari);
|
|
requestBody.put(GepafinConstant.PROTOCOL_DESTINATARI,destinatariObject);
|
|
List<Map<String,Object>> listObject=new ArrayList<>();
|
|
listObject.add(requestBody);
|
|
|
|
log.info("Preparing to create protocol with data: year={}, applicationId={}, companyName={}, callName={}, callId={}",
|
|
year, applicationId, companyName, callName, callId);
|
|
ResponseEntity<Object> response=null;
|
|
try {
|
|
|
|
String bearerToken = getBearerToken(codAoo, username, password);
|
|
if (bearerToken == null) {
|
|
log.error("Bearer token retrieval failed for user: {}", username);
|
|
return protocol;
|
|
}
|
|
HttpHeaders httpHeaders = Utils.getHeaders();
|
|
httpHeaders.set(GepafinConstant.AUTHORIZATION, "Bearer " + bearerToken);
|
|
URI url = URI.create(GepafinConstant.PROTOCOL_SERVICE_CREATE_PROTOCOL);
|
|
|
|
response = protocolService.createProtocol(httpHeaders, classifica, year, applicationId, companyName, callName, callId,listObject
|
|
);
|
|
|
|
log.info("Protocol creation response: status={}, body={}", response.getStatusCode(), response.getBody());
|
|
|
|
} catch (FeignException ex) {
|
|
log.error("FeignException during protocol creation for application ID {}: {}", applicationId, ex.getMessage(), ex);
|
|
// Utils.callException(ex.status(), ex);
|
|
} catch (Exception ex) {
|
|
log.error("Unexpected exception during protocol creation for application ID {}: {}", applicationId, ex.getMessage(), ex);
|
|
}
|
|
|
|
log.info("Finished createExternalProtocol for application ID: {}", application.getId());
|
|
if(response!=null && response.getBody()!=null) {
|
|
protocol = extractDetailForProtocol((List<Map<String, Object>>) response.getBody(), protocol);
|
|
}
|
|
return protocol;
|
|
}
|
|
|
|
public ProtocolEntity extractDetailForProtocol(List<Map<String,Object>> responseObject, ProtocolEntity protocol) {
|
|
Map<String,Object> responseField= responseObject.get(0);
|
|
Object yearObj = responseField.get(GepafinConstant.PROTOCOL_EXTERNAL_YEAR);
|
|
Integer externalProtocolYear = null;
|
|
if (yearObj instanceof Integer) {
|
|
externalProtocolYear = (Integer) yearObj;
|
|
} else if (yearObj instanceof String) {
|
|
try {
|
|
externalProtocolYear = Integer.parseInt((String) yearObj);
|
|
} catch (NumberFormatException e) {
|
|
// handle invalid format gracefully
|
|
externalProtocolYear = null;
|
|
}
|
|
}
|
|
|
|
Object dateObj = responseField.get(GepafinConstant.PROTOCOL_EXTERNAL_DATE);
|
|
LocalDateTime externalProtocolDate = null;
|
|
|
|
if (dateObj instanceof LocalDateTime) {
|
|
externalProtocolDate = (LocalDateTime) dateObj;
|
|
} else if (dateObj instanceof String) {
|
|
externalProtocolDate = DateTimeUtil.parseStringToLocalDateTime((String) dateObj);
|
|
}
|
|
if(externalProtocolDate!=null){
|
|
protocol.setExternalProtocolDate(externalProtocolDate);
|
|
}
|
|
if (externalProtocolYear!=null){
|
|
protocol.setExternalProtocolYear(externalProtocolYear);
|
|
|
|
}
|
|
|
|
String externalProtocolNumber = (String) responseField.get(GepafinConstant.PROTOCOL_EXTERNAL_NUMBER);
|
|
if (Boolean.FALSE.equals(StringUtils.isEmpty(externalProtocolNumber))) {
|
|
protocol.setExternalProtocolNumber(externalProtocolNumber);
|
|
}
|
|
protocolRepository.save(protocol);
|
|
return protocol;
|
|
}
|
|
|
|
}
|