BFLOWS/bflows-bandi-be
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Created call api's in 2 steps and for update call

Browse Source
This commit is contained in:
rajesh
2024-08-28 01:52:25 +05:30
parent e7fa11f35e
commit 22e72f6cd4
20 changed files with 287 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

266
src/main/java/net/gepafin/tendermanagement/dao/CallDao.java
View File

@@ -4,8 +4,8 @@ import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
@@ -44,7 +44,7 @@ import net.gepafin.tendermanagement.repositories.EvaluationCriteriaRepository;
import net.gepafin.tendermanagement.repositories.FaqRepository;
import net.gepafin.tendermanagement.repositories.LookUpDataRepository;
import net.gepafin.tendermanagement.repositories.RegionRepository;
import net.gepafin.tendermanagement.repositories.UserRepository;
import net.gepafin.tendermanagement.service.UserService;
import net.gepafin.tendermanagement.util.DateTimeUtil;
import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
@@ -77,17 +77,18 @@ public class CallDao {
private CallTargetAudienceChecklistRepository callTargetAudienceChecklistRepository;
@Autowired
private UserRepository userRepository;
private UserService userService;
public CreateCallResponseBean createCallStep1(CreateCallRequestStep1 createCallRequest, Long userId) {
CreateCallResponseBean createCallResponseBean = null;
CallEntity callEntity = convertToCallEntity(createCallRequest);
List<FaqEntity> faqEntities = convertToFaqEntities(createCallRequest.getFaq(), callEntity, userId);
List<LookUpDataResponse> amiedTo = convertLookUpDataEntities(createCallRequest.getAimedTo(), callEntity,
convertToFaqEntities(createCallRequest.getFaq(), callEntity, userId);
convertLookUpDataEntities(createCallRequest.getAimedTo(), callEntity,
LookUpDataTypeEnum.AIMED_TO);
createCallResponseBean = assembleCreateCallResponseBean(callEntity, Collections.emptyList(),
Collections.emptyList(), faqEntities, Collections.emptyList());
createCallResponseBean.setAimedTo(amiedTo);
// createCallResponseBean = assembleCreateCallResponseBean(callEntity, Collections.emptyList(),
// Collections.emptyList(), faqEntities, Collections.emptyList());
// createCallResponseBean.setAimedTo(amiedTo);
// createCallResponseBean.setCurrentStep(GepafinConstant.STEP_1);
CreateCallResponseBean createCallResponseBean = getCallResponseBean(callEntity);
createCallResponseBean.setCurrentStep(GepafinConstant.STEP_1);
return createCallResponseBean;
@@ -118,62 +119,87 @@ public class CallDao {
}
public List<EvaluationCriteriaEntity> convertToEvaluationCriteriaEntities(
List<EvaluationCriteriaReq> criteriaReqList, CallEntity callEntity) {
List<EvaluationCriteriaReq> criteriaReqList, CallEntity callEntity, LookUpDataTypeEnum type) {
if (criteriaReqList == null) {
return null;
}
List<EvaluationCriteriaEntity> existingCriteria = evaluationCriteriaRepository.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), type.getValue());
List<Long> incomingIds = criteriaReqList.stream().map(EvaluationCriteriaReq::getId)
.filter(id -> id != null && id > 0).collect(Collectors.toList());
existingCriteria.stream().filter(criteria -> !incomingIds.contains(criteria.getId())).forEach(this::softDeleteEvaluationCriteria);
List<EvaluationCriteriaEntity> evaluationCriteriaEntities = criteriaReqList.stream()
.map(req -> convertToEvaluationCriteriaEntity(req, callEntity)).collect(Collectors.toList());
.map(req -> convertToEvaluationCriteriaEntity(req, callEntity, type)).collect(Collectors.toList());
evaluationCriteriaRepository.saveAll(evaluationCriteriaEntities);
return evaluationCriteriaEntities;
}
private void softDeleteEvaluationCriteria(EvaluationCriteriaEntity evaluationCriteriaEntity) {
evaluationCriteriaEntity.setIsDeleted(true);
evaluationCriteriaRepository.save(evaluationCriteriaEntity);
}
private EvaluationCriteriaEntity convertToEvaluationCriteriaEntity(EvaluationCriteriaReq criteriaReq,
CallEntity callEntity) {
EvaluationCriteriaEntity criteriaEntity = new EvaluationCriteriaEntity();
LookUpDataEntity lookUpDataEntity = getOrCreateLookUpData(criteriaReq, LookUpDataTypeEnum.EVALUATION_CRITERIA);
criteriaEntity.setLookupData(lookUpDataEntity);
criteriaEntity.setScore(criteriaReq.getScore());
criteriaEntity.setCall(callEntity);
CallEntity callEntity, LookUpDataTypeEnum type) {
EvaluationCriteriaEntity criteriaEntity = null;
LookUpDataEntity lookupDataEntity = convertLookUpDataRequestIntoLookUpDataEntity(criteriaReq, type);
if (criteriaReq.getId() == null && criteriaReq.getId().equals(0l)) {
criteriaEntity = evaluationCriteriaRepository.findById(criteriaReq.getId())
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.CALL_NOT_FOUND)));
} else {
criteriaEntity = new EvaluationCriteriaEntity();
criteriaEntity.setCall(callEntity);
criteriaEntity.setLookupData(lookupDataEntity);
criteriaEntity.setIsDeleted(false);
}
setIfUpdated(criteriaEntity::getScore, criteriaEntity::setScore, criteriaReq.getScore());
if (Boolean.FALSE.equals(criteriaEntity.getLookupData().getId().equals(lookupDataEntity.getId()))) {
criteriaEntity.setLookupData(lookupDataEntity);
}
return criteriaEntity;
}
private LookUpDataEntity getOrCreateLookUpData(EvaluationCriteriaReq criteriaReq, LookUpDataTypeEnum typeEnum) {
LookUpDataEntity lookUpDataEntity = null;
if (criteriaReq.getLookUpDataId() == null || criteriaReq.getLookUpDataId().equals(0l)) {
validateEvolutionCrieteriaEntity(criteriaReq.getValue());
lookUpDataEntity = new LookUpDataEntity();
lookUpDataEntity.setValue(criteriaReq.getValue());
lookUpDataEntity.setType(typeEnum.getValue());
lookUpDataRepository.save(lookUpDataEntity);
} else {
lookUpDataEntity = lookUpDataRepository.findById(null)
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.LOOK_UP_DATA_NOT_VALID_MSG)));
public List<DocumentEntity> convertToDocumentEntities(List<DocumentReq> documentReqList, CallEntity callEntity,
DocumentTypeEnum documentType) {
if (documentReqList == null) {
return null;
}
List<DocumentEntity> existingDocuments = documentRepository
.findByCallIdAndTypeAndIsDeletedFalse(callEntity.getId(), documentType.getValue());
return lookUpDataEntity;
}
List<Long> incomingIds = documentReqList.stream().map(DocumentReq::getId).filter(id -> id != null && id > 0)
.collect(Collectors.toList());
public List<DocumentEntity> convertToDocumentEntities(List<DocumentReq> documentReqList, CallEntity callEntity) {
existingDocuments.stream().filter(document -> !incomingIds.contains(document.getId()))
.forEach(this::softDeleteDocument);
List<DocumentEntity> documentEntities = documentReqList.stream()
.map(req -> convertToDocumentEntity(req, callEntity)).collect(Collectors.toList());
documentRepository.saveAll(documentEntities);
return documentEntities;
}
private void softDeleteDocument(DocumentEntity documentEntity) {
documentEntity.setIsDeleted(true);
documentRepository.save(documentEntity);
}
private DocumentEntity convertToDocumentEntity(DocumentReq documentReq, CallEntity callEntity) {
validateDocumentEntity(documentReq.getId(), documentReq.getFileName());
DocumentEntity documentEntity = documentRepository.findById(documentReq.getId())
validateDocumentEntity(documentReq.getId());
DocumentEntity documentEntity = documentRepository.findByIdAndCallIdAndIsDeletedFalse(documentReq.getId(), callEntity.getId())
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.DOCUMENT_NOT_FOUND)));
// if(documentEntity==null){
// throw ;
// }
// documentEntity.setFileName(documentReq.getFileName());
// documentEntity.setFilePath(documentReq.getUrl());
// documentEntity.setCall(callEntity);
return documentEntity;
}
public List<FaqEntity> convertToFaqEntities(List<FaqReq> faqReqList, CallEntity callEntity, Long userId) {
if (faqReqList == null) {
return null;
}
List<FaqEntity> faqEntities = faqReqList.stream().map(req -> convertToFaqEntity(req, callEntity, userId))
.collect(Collectors.toList());
faqRepository.saveAll(faqEntities);
@@ -183,9 +209,8 @@ public class CallDao {
private FaqEntity convertToFaqEntity(FaqReq faqReq, CallEntity callEntity, Long userId) {
FaqEntity faqEntity = new FaqEntity();
validateFaqEntity(faqReq.getQuestion());
UserEntity userEntity = userRepository.findById(userId)
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.LOOK_UP_DATA_NOT_VALID_MSG)));
UserEntity userEntity = userService.validateUser(userId);
faqEntity.setUser(userEntity);
faqEntity.setIsVisible(true);
if (faqReq.getIsVisible() != null) {
@@ -199,6 +224,7 @@ public class CallDao {
faqEntity.setResponseShort(faqReq.getResponseShort());
faqEntity.setResponse(faqReq.getResponse());
faqEntity.setCall(callEntity);
faqEntity.setIsDeleted(false);
return faqEntity;
}
@@ -209,18 +235,14 @@ public class CallDao {
}
}
public void validateDocumentEntity(Long documentId, String name) {
public void validateDocumentEntity(Long documentId) {
if (documentId == null) {
throw new CustomValidationException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.DOCUMENT_ID_NOT_FOUND));
}
// if (!StringUtils.hasText(name)) {
// throw new CustomValidationException(Status.VALIDATION_ERROR, Translator.toLocale(GepafinConstant.NAME_NOT_EMPTY_MSG));
// }
}
public void validateEvolutionCrieteriaEntity(String name) {
public void validateEvaluationCriteriaEntity(String name) {
if (!StringUtils.hasText(name)) {
throw new CustomValidationException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.NAME_NOT_EMPTY_MSG));
@@ -335,8 +357,6 @@ public class CallDao {
List<LookUpDataEntity> lookUpDataEntities = lookUpData.stream()
.map(req -> convertLookUpDataRequestIntoLookUpDataEntity(req, type)).collect(Collectors.toList());
lookUpDataRepository.saveAll(lookUpDataEntities);
return createCallTargetAudienceCheckList(callEntity, lookUpDataEntities);
}
@@ -348,6 +368,7 @@ public class CallDao {
callTargetAudienceChecklistEntity.setIsValidated(false);
callTargetAudienceChecklistEntity.setLookupData(lookUpDataEntity);
callTargetAudienceChecklistEntity.setCall(callEntity);
callTargetAudienceChecklistEntity.setIsDeleted(false);
callTargetAudienceChecklistEntity = callTargetAudienceChecklistRepository
.save(callTargetAudienceChecklistEntity);
lookUpDataResponses.add(convertToLookUpDataResponseBean(callTargetAudienceChecklistEntity));
@@ -361,7 +382,7 @@ public class CallDao {
LookUpDataEntity newEntity = new LookUpDataEntity();
newEntity.setValue(req.getValue());
newEntity.setType(type.getValue());
return newEntity;
return lookUpDataRepository.save(newEntity);
}
return lookUpDataRepository.findById(req.getLookUpDataId())
@@ -388,28 +409,29 @@ public class CallDao {
}
public CreateCallResponseBean createCallStep2(CreateCallRequestStep2 createCallRequest, Long userId) {
CreateCallResponseBean createCallResponseBean = null;
CallEntity callEntity = callRepository.findById(createCallRequest.getCallId())
.orElseThrow(() -> new CustomValidationException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.CALL_NOT_FOUND)));
callEntity.setThreshold(createCallRequest.getThreshold());
callEntity.setStatus(createCallRequest.getStatus().getValue());
setIfUpdated(callEntity::getThreshold, callEntity::setThreshold, createCallRequest.getThreshold());
callRepository.save(callEntity);
List<EvaluationCriteriaEntity> evaluationCriteriaEntities = convertToEvaluationCriteriaEntities(
createCallRequest.getCriteria(), callEntity);
List<DocumentEntity> documentEntities = convertToDocumentEntities(createCallRequest.getDocs(), callEntity);
List<DocumentEntity> imageEntities = convertToDocumentEntities(createCallRequest.getImages(), callEntity);
List<LookUpDataResponse> checkList = convertLookUpDataEntities(createCallRequest.getCheckList(), callEntity,
LookUpDataTypeEnum.CHECKLIST);
List<FaqEntity> faqEntities = faqRepository.findByCallId(callEntity.getId());
List<LookUpDataResponse> amiedTo = callTargetAudienceChecklistRepository
.findByCallIdAndLookupDataType(callEntity.getId(), LookUpDataTypeEnum.AIMED_TO.getValue()).stream()
.map(this::convertToLookUpDataResponseBean).toList();
createCallResponseBean = assembleCreateCallResponseBean(callEntity, evaluationCriteriaEntities,
documentEntities, faqEntities, imageEntities);
createCallResponseBean.setAimedTo(amiedTo);
createCallResponseBean.setCheckList(checkList);
convertToEvaluationCriteriaEntities(createCallRequest.getCriteria(), callEntity, LookUpDataTypeEnum.EVALUATION_CRITERIA);
convertToDocumentEntities(createCallRequest.getDocs(), callEntity, DocumentTypeEnum.DOCUMENT);
convertToDocumentEntities(createCallRequest.getImages(), callEntity, DocumentTypeEnum.IMAGES);
updateLookUpData(callEntity, createCallRequest.getCheckList(), LookUpDataTypeEnum.CHECKLIST);
// List<FaqEntity> faqEntities = faqRepository.findByCallIdAndIsDeletedFalse(callEntity.getId());
// List<LookUpDataResponse> amiedTo = callTargetAudienceChecklistRepository
// .findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.AIMED_TO.getValue()).stream()
// .map(this::convertToLookUpDataResponseBean).toList();
// createCallResponseBean = assembleCreateCallResponseBean(callEntity, evaluationCriteriaEntities,
// documentEntities, faqEntities, imageEntities);
// createCallResponseBean.setAimedTo(amiedTo);
// createCallResponseBean.setCheckList(checkList);
CreateCallResponseBean createCallResponseBean = getCallResponseBean(callEntity);
createCallResponseBean.setCurrentStep(GepafinConstant.STEP_2);
return createCallResponseBean;
}
@@ -422,10 +444,10 @@ public class CallDao {
Boolean isValid = true;
if (startDate != null && endDate != null && startDate.isAfter(endDate)) {
isValid = false;
} else if (startDate != null && callEntity.getEndDate() != null
} else if (startDate != null && endDate == null && callEntity.getEndDate() != null
&& startDate.isAfter(callEntity.getEndDate().toLocalDate())) {
isValid = false;
} else if (endDate != null && callEntity.getStartDate() != null
} else if (startDate == null && endDate != null && callEntity.getStartDate() != null
&& callEntity.getStartDate().toLocalDate().isAfter(endDate)) {
isValid = false;
}
@@ -438,6 +460,7 @@ public class CallDao {
public CreateCallResponseBean updateCallStep1(Long callId, UpdateCallRequestStep1 updateCallRequest, Long userId) {
CallEntity callEntity = getCallById(callId);
UserEntity userEntity = userService.validateUser(userId);
isValidDateRange(updateCallRequest, callEntity);
setIfUpdated(callEntity::getName, callEntity::setName, updateCallRequest.getName());
setIfUpdated(callEntity::getDescriptionShort, callEntity::setDescriptionShort,
@@ -451,27 +474,114 @@ public class CallDao {
setIfUpdated(callEntity::getDocumentationRequested, callEntity::setDocumentationRequested,
updateCallRequest.getDocumentationRequested());
setIfUpdated(callEntity::getConfidi, callEntity::setConfidi, updateCallRequest.getConfidi());
updateLookUpData(callEntity, updateCallRequest.getAimedTo(), LookUpDataTypeEnum.AIMED_TO);
updateFaq(callEntity, updateCallRequest.getFaq(), userEntity);
CreateCallResponseBean createCallResponseBean = getCallResponseBean(callEntity);
createCallResponseBean.setCurrentStep(GepafinConstant.STEP_1);
return createCallResponseBean;
}
private void updateFaq(CallEntity callEntity, List<FaqReq> faqReqList, UserEntity userEntity) {
if(faqReqList==null) {
return;
}
List<FaqEntity> existingFaqs = faqRepository.findByCallIdAndIsDeletedFalse(callEntity.getId());
List<Long> incomingIds = faqReqList.stream().map(FaqReq::getId).filter(Objects::nonNull).filter(id -> id > 0)
.collect(Collectors.toList());
existingFaqs.stream().filter(faq -> !incomingIds.contains(faq.getId())).forEach(this::softDeleteFaq);
faqReqList.forEach(faqReq -> createOrUpdateFaq(faqReq, callEntity, userEntity));
}
private void softDeleteFaq(FaqEntity faqEntity) {
faqEntity.setIsDeleted(true);
faqRepository.save(faqEntity);
}
private void createOrUpdateFaq(FaqReq faqReq, CallEntity callEntity, UserEntity userEntity) {
FaqEntity faqEntity = null;
if (isExistingFaq(faqReq)) {
faqEntity = faqRepository.findById(faqReq.getId())
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.CALL_NOT_FOUND)));
} else {
faqEntity = new FaqEntity();
faqEntity.setCall(callEntity);
faqEntity.setUser(userEntity);
faqEntity.setIsDeleted(false);
}
setIfUpdated(faqEntity::getQuestionShort, faqEntity::setQuestionShort, faqReq.getQuestionShort());
setIfUpdated(faqEntity::getQuestion, faqEntity::setQuestion, faqReq.getQuestion());
setIfUpdated(faqEntity::getResponseShort, faqEntity::setResponseShort, faqReq.getResponseShort());
setIfUpdated(faqEntity::getResponse, faqEntity::setResponse, faqReq.getResponse());
setIfUpdated(faqEntity::getIsVisible, faqEntity::setIsVisible, faqReq.getIsVisible());
faqRepository.save(faqEntity);
}
private boolean isExistingFaq(FaqReq faqReq) {
return faqReq.getId() != null && faqReq.getId() > 0;
}
private void updateLookUpData(CallEntity callEntity, List<LookUpDataReq> lookupDataReqList, LookUpDataTypeEnum type) {
if (lookupDataReqList == null) {
return;
}
List<CallTargetAudienceChecklistEntity> existingChecklist = callTargetAudienceChecklistRepository
.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), type.getValue());
List<Long> incomingIds = lookupDataReqList.stream().map(LookUpDataReq::getLookUpDataId)
.filter(id -> id != null && id > 0).collect(Collectors.toList());
existingChecklist.stream().filter(checklist -> !incomingIds.contains(checklist.getLookupData().getId()))
.forEach(this::softDeleteCallTargetAudienceChecklist);
lookupDataReqList
.forEach(lookUpDataReq -> createOrUpdateCallTargetAudienceChecklist(lookUpDataReq, callEntity, type));
}
private void createOrUpdateCallTargetAudienceChecklist(LookUpDataReq lookUpDataReq, CallEntity callEntity,
LookUpDataTypeEnum type) {
CallTargetAudienceChecklistEntity checklistEntity = null;
LookUpDataEntity lookupDataEntity = convertLookUpDataRequestIntoLookUpDataEntity(lookUpDataReq, type);
if (lookUpDataReq.getId() != null && lookUpDataReq.getId() > 0) {
checklistEntity = callTargetAudienceChecklistRepository.findById(lookUpDataReq.getId())
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.CALL_NOT_FOUND)));
if (Boolean.FALSE.equals(checklistEntity.getLookupData().getId().equals(lookupDataEntity.getId()))) {
checklistEntity.setLookupData(lookupDataEntity);
}
} else {
checklistEntity = new CallTargetAudienceChecklistEntity();
checklistEntity.setCall(callEntity);
checklistEntity.setLookupData(lookupDataEntity);
checklistEntity.setIsValidated(false);
checklistEntity.setIsDeleted(false);
}
callTargetAudienceChecklistRepository.save(checklistEntity);
}
private void softDeleteCallTargetAudienceChecklist(
CallTargetAudienceChecklistEntity callTargetAudienceChecklistEntity) {
callTargetAudienceChecklistEntity.setIsDeleted(true);
callTargetAudienceChecklistRepository.save(callTargetAudienceChecklistEntity);
}
private CreateCallResponseBean getCallResponseBean(CallEntity callEntity) {
List<DocumentEntity> documentEntities = documentRepository.findByCallIdAndType(callEntity.getId(),
List<DocumentEntity> documentEntities = documentRepository.findByCallIdAndTypeAndIsDeletedFalse(callEntity.getId(),
DocumentTypeEnum.DOCUMENT.getValue());
List<DocumentEntity> imageEntities = documentRepository.findByCallIdAndType(callEntity.getId(),
List<DocumentEntity> imageEntities = documentRepository.findByCallIdAndTypeAndIsDeletedFalse(callEntity.getId(),
DocumentTypeEnum.DOCUMENT.getValue());
List<FaqEntity> faqEntities = faqRepository.findByCallId(callEntity.getId());
List<FaqEntity> faqEntities = faqRepository.findByCallIdAndIsDeletedFalse(callEntity.getId());
List<LookUpDataResponse> amiedTo = callTargetAudienceChecklistRepository
.findByCallIdAndLookupDataType(callEntity.getId(), LookUpDataTypeEnum.AIMED_TO.getValue()).stream()
.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.AIMED_TO.getValue()).stream()
.map(this::convertToLookUpDataResponseBean).toList();
List<LookUpDataResponse> checkList = callTargetAudienceChecklistRepository
.findByCallIdAndLookupDataType(callEntity.getId(), LookUpDataTypeEnum.CHECKLIST.getValue()).stream()
.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.CHECKLIST.getValue()).stream()
.map(this::convertToLookUpDataResponseBean).toList();
List<EvaluationCriteriaEntity> evaluationCriteriaEntities = evaluationCriteriaRepository
.findByCallIdAndLookupDataType(callEntity.getId(), LookUpDataTypeEnum.EVALUATION_CRITERIA.getValue());
.findByCallIdAndLookupDataTypeAndIsDeletedFalse(callEntity.getId(), LookUpDataTypeEnum.EVALUATION_CRITERIA.getValue());
CreateCallResponseBean createCallResponseBean = assembleCreateCallResponseBean(callEntity, evaluationCriteriaEntities,
documentEntities, faqEntities, imageEntities);

7
src/main/java/net/gepafin/tendermanagement/dao/DocumentDao.java
View File

@@ -18,7 +18,6 @@ import net.gepafin.tendermanagement.enums.DocumentTypeEnum;
import net.gepafin.tendermanagement.model.response.DocumentResponseBean;
import net.gepafin.tendermanagement.repositories.DocumentRepository;
import net.gepafin.tendermanagement.service.AmazonS3Service;
import net.gepafin.tendermanagement.util.Utils;
import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
import net.gepafin.tendermanagement.web.rest.api.errors.Status;
@@ -48,6 +47,7 @@ public class DocumentDao {
documentEntity.setFileName(fileName);
documentEntity.setType(fileType.getValue());
documentEntity.setFilePath(filepath);
documentEntity.setIsDeleted(false);
documentEntities.add(documentEntity);
} catch (IOException e) {}
}
@@ -62,9 +62,8 @@ public class DocumentDao {
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.DOCUMENT_NOT_FOUND)));
String fileName = Utils.extractFileName(documentEntity.getFilePath());
amazonS3Service.delete(fileName);
documentRepository.delete(documentEntity);
documentEntity.setIsDeleted(true);
documentRepository.save(documentEntity);
}
}

6
src/main/java/net/gepafin/tendermanagement/dao/UserDao.java
View File

@@ -149,4 +149,10 @@ public class UserDao {
log.info("Login successful for email: {}", loginReq.getEmail());
return jwtToken;
}
public UserEntity validateUser(Long userId) {
return userRepository.findById(userId)
.orElseThrow(() -> new ResourceNotFoundException(Status.VALIDATION_ERROR,
Translator.toLocale(GepafinConstant.USER_NOT_FOUND_MSG)));
}
}