612 lines
34 KiB
Java
612 lines
34 KiB
Java
package net.gepafin.tendermanagement.dao;
|
|
|
|
import net.gepafin.tendermanagement.config.Translator;
|
|
import net.gepafin.tendermanagement.constants.GepafinConstant;
|
|
import net.gepafin.tendermanagement.entities.*;
|
|
import net.gepafin.tendermanagement.enums.ApplicationStatusTypeEnum;
|
|
import net.gepafin.tendermanagement.enums.DocumentSourceTypeEnum;
|
|
import net.gepafin.tendermanagement.enums.RoleStatusEnum;
|
|
import net.gepafin.tendermanagement.model.request.ApplicationFormFieldRequestBean;
|
|
import net.gepafin.tendermanagement.model.request.ApplicationRequest;
|
|
import net.gepafin.tendermanagement.model.request.ApplicationRequestBean;
|
|
import net.gepafin.tendermanagement.model.response.*;
|
|
import net.gepafin.tendermanagement.repositories.*;
|
|
import net.gepafin.tendermanagement.service.CallService;
|
|
import net.gepafin.tendermanagement.service.DocumentService;
|
|
import net.gepafin.tendermanagement.service.FormService;
|
|
import net.gepafin.tendermanagement.util.DateTimeUtil;
|
|
import net.gepafin.tendermanagement.util.FieldValidator;
|
|
import net.gepafin.tendermanagement.util.Utils;
|
|
import net.gepafin.tendermanagement.util.Validator;
|
|
import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
|
|
import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
|
|
import net.gepafin.tendermanagement.web.rest.api.errors.Status;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.data.jpa.domain.Specification;
|
|
import org.springframework.stereotype.Component;
|
|
|
|
import jakarta.persistence.criteria.Predicate;
|
|
|
|
import java.text.MessageFormat;
|
|
import java.time.LocalDateTime;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
@Component
|
|
public class ApplicationDao {
|
|
|
|
private final Logger log = LoggerFactory.getLogger(ApplicationDao.class);
|
|
|
|
@Autowired
|
|
private CallService callService;
|
|
|
|
@Autowired
|
|
private ApplicationRepository applicationRepository;
|
|
|
|
@Autowired
|
|
private ApplicationFormRepository applicationFormRepository;
|
|
|
|
@Autowired
|
|
private ApplicationFormFieldRepository applicationFormFieldRepository;
|
|
|
|
@Autowired
|
|
private FormService formService;
|
|
|
|
@Autowired
|
|
private DocumentService documentService;
|
|
|
|
@Autowired
|
|
private CallDao callDao;
|
|
|
|
@Autowired
|
|
private FlowFormDao flowFormDao;
|
|
|
|
@Autowired
|
|
private FlowEdgesRepository flowEdgesRepository;
|
|
|
|
@Autowired
|
|
private FlowDataRepository flowDataRepository;
|
|
|
|
@Autowired
|
|
private Validator validator;
|
|
|
|
|
|
public ApplicationResponseBean createApplication(ApplicationRequestBean applicationRequestBean, UserEntity userEntity, Long formId, Long applicationId) {
|
|
FormEntity formEntity = formService.validateForm(formId);
|
|
// callService.validatePublishedCall(formEntity.getCall().getId());
|
|
validateFormFields(applicationRequestBean,formEntity);
|
|
ApplicationEntity applicationEntity = validateApplication(applicationId);
|
|
if(Boolean.TRUE.equals(applicationEntity.getStatus().equals(ApplicationStatusTypeEnum.SUBMIT.getValue()))) {
|
|
throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.APPLICATION_ALREADY_SUBMITTED));
|
|
}
|
|
formService.validateFormField(applicationRequestBean.getFormFields(),applicationEntity,formEntity);
|
|
ApplicationFormEntity applicationFormEntity = getApplicationFormOrCreate(formEntity, applicationEntity);
|
|
createOrUpdateMultipleFormFields(applicationRequestBean.getFormFields(), applicationFormEntity,formEntity);
|
|
return getApplicationById(applicationEntity.getId(),formEntity.getId());
|
|
}
|
|
|
|
public ApplicationFormEntity saveApplicationFormEntity(ApplicationFormEntity applicationFormEntity) {
|
|
ApplicationFormEntity applicationFormEntity1 = applicationFormRepository.save(applicationFormEntity);
|
|
return applicationFormEntity1;
|
|
}
|
|
|
|
public ApplicationFormEntity createApplicationFormEntity(ApplicationEntity application, FormEntity formEntity) {
|
|
ApplicationFormEntity applicationFormEntity = new ApplicationFormEntity();
|
|
applicationFormEntity.setApplication(application);
|
|
applicationFormEntity.setForm(formEntity);
|
|
applicationFormEntity = saveApplicationFormEntity(applicationFormEntity);
|
|
return applicationFormEntity;
|
|
}
|
|
|
|
public ApplicationEntity createApplicationEntity(UserEntity user, CallEntity call, CompanyEntity companyEntity) {
|
|
ApplicationEntity entity = new ApplicationEntity();
|
|
entity.setUserId(user.getId());
|
|
entity.setCompany(companyEntity);
|
|
entity.setCall(call);
|
|
entity.setIsDeleted(false);
|
|
entity.setStatus(ApplicationStatusTypeEnum.DRAFT.getValue());
|
|
return entity;
|
|
}
|
|
|
|
public ApplicationResponseBean getApplicationById(Long id,Long formId) {
|
|
log.info("Fetching application with ID: {}", id);
|
|
|
|
ApplicationEntity applicationEntity = validateApplication(id);
|
|
ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(),formId);
|
|
List<ApplicationFormFieldResponseBean> applicationFormFieldResponseBeans=new ArrayList<>();
|
|
List<ApplicationFormFieldEntity> applicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId());
|
|
applicationFormFieldResponseBeans=createApplicationFormFieldResponse(applicationFormFieldEntities, applicationFormEntity, applicationFormFieldResponseBeans);
|
|
ApplicationResponseBean applicationResponseBean= convertApplicationEntityToApplicationResponseBean(applicationEntity);
|
|
applicationResponseBean.setFormFields(applicationFormFieldResponseBeans);
|
|
return applicationResponseBean;
|
|
}
|
|
|
|
private List<ApplicationFormFieldResponseBean> createApplicationFormFieldResponse(
|
|
List<ApplicationFormFieldEntity> applicationFormFieldEntities,
|
|
ApplicationFormEntity applicationFormEntity,
|
|
List<ApplicationFormFieldResponseBean> applicationFormFieldResponseBeans) {
|
|
|
|
List<ContentResponseBean> contentResponseBeans = Utils.convertJsonStringToList(
|
|
applicationFormEntity.getForm().getContent(), ContentResponseBean.class);
|
|
|
|
for (ApplicationFormFieldEntity applicationFormFieldEntity : applicationFormFieldEntities) {
|
|
|
|
Optional<ContentResponseBean> fileUploadContent = contentResponseBeans.stream()
|
|
.filter(contentResponseBean -> "fileupload".equals(contentResponseBean.getName()) &&
|
|
contentResponseBean.getId().equals(applicationFormFieldEntity.getFieldId()))
|
|
.findFirst();
|
|
|
|
List<DocumentResponseBean> documentResponseBeans = new ArrayList<>();
|
|
if (fileUploadContent.isPresent()) {
|
|
String documentId = applicationFormFieldEntity.getFieldValue();
|
|
if (documentId != null && !documentId.isEmpty()) {
|
|
documentResponseBeans = Arrays.stream(documentId.split(","))
|
|
.map(String::trim)
|
|
.map(Long::parseLong)
|
|
.map(docId -> {
|
|
DocumentEntity documentEntity = documentService.validateDocument(docId);
|
|
if (Boolean.FALSE.equals(DocumentSourceTypeEnum.APPLICATION.getValue().equals(documentEntity.getSource()))) {
|
|
throw new CustomValidationException(Status.NOT_FOUND,Translator.toLocale(GepafinConstant.DOCUMENT_NOT_FOUND));
|
|
}
|
|
return documentEntity;
|
|
})
|
|
.map(callDao::convertToDocumentResponseBean)
|
|
.collect(Collectors.toList());
|
|
}
|
|
}
|
|
ApplicationFormFieldResponseBean responseBean = convertApplicationFormFieldEntityToApplicationFormFieldResponseBean(
|
|
applicationFormFieldEntity, applicationFormEntity.getId());
|
|
if (!documentResponseBeans.isEmpty()) {
|
|
responseBean.setFieldValue(documentResponseBeans);
|
|
}
|
|
applicationFormFieldResponseBeans.add(responseBean);
|
|
}
|
|
|
|
return applicationFormFieldResponseBeans;
|
|
}
|
|
|
|
public void deleteById(Long id) {
|
|
log.info("Deleting application with ID: {}", id);
|
|
|
|
ApplicationEntity applicationEntity= validateApplication(id);
|
|
applicationEntity.setIsDeleted(true);
|
|
applicationEntity=saveApplicationEntity(applicationEntity);
|
|
log.info("Application deleted with ID: {}", id);
|
|
}
|
|
|
|
// public List<ApplicationResponse> getAllApplications(UserEntity userEntity, Long callId, CompanyEntity companyEntity) {
|
|
// boolean isBeneficiary = validator.checkIsBeneficiary();
|
|
//
|
|
// log.info("Fetching applications for RoleType: {}", userEntity.getRoleEntity().getRoleType());
|
|
// List<ApplicationResponse> applicationResponses = new ArrayList<>();
|
|
//
|
|
// if (callId != null) {
|
|
// // Fetch based on callId and user if role is BENEFICIARY, otherwise fetch all for the call
|
|
// log.info("Fetching applications for callId: {}", callId);
|
|
// CallEntity call = callService.validateCall(callId);
|
|
//
|
|
// // Use a single method to handle both conditions for consistency
|
|
// List<ApplicationEntity> applicationEntities = isBeneficiary
|
|
// ? applicationRepository.findByUserIdAndCallIdAndIsDeletedFalse(userEntity.getId(), call.getId())
|
|
// .map(List::of) // Convert Optional<ApplicationEntity> to a List of one element
|
|
// .orElse(List.of()) // If not present, return an empty list
|
|
// : applicationRepository.findByCallIdAndIsDeletedFalse(call.getId());
|
|
//
|
|
// applicationResponses = applicationEntities.stream()
|
|
// .map(this::getApplicationResponse)
|
|
// .collect(Collectors.toList());
|
|
//
|
|
// } else {
|
|
// // Fetch all applications for the user if BENEFICIARY, or fetch all applications in general
|
|
// List<ApplicationEntity> applicationEntities = isBeneficiary
|
|
// ? applicationRepository.findByUserIdAndIsDeletedFalse(companyEntity.getId())
|
|
// : applicationRepository.findByIsDeletedFalse();
|
|
//
|
|
// applicationResponses = applicationEntities.stream()
|
|
// .map(this::getApplicationResponse)
|
|
// .collect(Collectors.toList());
|
|
// }
|
|
//
|
|
// return applicationResponses;
|
|
// }
|
|
|
|
public List<ApplicationResponse> getAllApplications(UserEntity userEntity, Long callId, Long companyId) {
|
|
|
|
log.info("Fetching applications for RoleType: {}", userEntity.getRoleEntity().getRoleType());
|
|
|
|
Specification<ApplicationEntity> spec = search(userEntity.getId(), callId, companyId);
|
|
|
|
List<ApplicationEntity> applicationEntities = applicationRepository.findAll(spec);
|
|
|
|
return applicationEntities.stream()
|
|
.map(this::getApplicationResponse)
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
|
|
private Specification<ApplicationEntity> search(Long userId, Long callId, Long companyId) {
|
|
return (root, query, builder) -> {
|
|
Boolean isBeneficiary = validator.checkIsBeneficiary();
|
|
Predicate predicate = builder.isFalse(root.get("isDeleted"));
|
|
if (isBeneficiary) {
|
|
predicate = builder.and(predicate, builder.equal(root.get("userId"), userId));
|
|
}
|
|
if (callId != null) {
|
|
predicate = builder.and(predicate, builder.equal(root.get("call").get("id"), callId));
|
|
}
|
|
if (companyId != null) {
|
|
predicate = builder.and(predicate, builder.equal(root.get("company").get("id"), companyId));
|
|
}
|
|
return predicate;
|
|
};
|
|
}
|
|
|
|
private ApplicationResponse getApplicationResponse(ApplicationEntity applicationEntity) {
|
|
ApplicationResponse responseBean = new ApplicationResponse();
|
|
List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByCallId(applicationEntity.getCall().getId());
|
|
Long totalFormSteps = flowFormDao.calculateTotalSteps(flowEdgesList);
|
|
Long completedSteps= Long.valueOf(flowFormDao.getCompletedSteps(applicationEntity));
|
|
Integer progress=calculateProgress(totalFormSteps,completedSteps);
|
|
responseBean.setId(applicationEntity.getId());
|
|
responseBean.setProgress(progress);
|
|
responseBean.setCallTitle(applicationEntity.getCall().getName());
|
|
responseBean.setCallEndDate(applicationEntity.getCall().getEndDate());
|
|
responseBean.setModifiedDate(applicationEntity.getCall().getUpdatedDate());
|
|
responseBean.setCallId(applicationEntity.getCall().getId());
|
|
responseBean.setSubmissionDate(applicationEntity.getSubmissionDate());
|
|
responseBean.setStatus(applicationEntity.getStatus());
|
|
responseBean.setComments(applicationEntity.getComments());
|
|
responseBean.setCompanyId(applicationEntity.getCompany().getId());
|
|
responseBean.setCompanyName(applicationEntity.getCompany().getCompanyName());
|
|
return responseBean;
|
|
}
|
|
|
|
public ApplicationEntity validateApplication(Long id) {
|
|
ApplicationEntity applicationEntity = applicationRepository.findById(id)
|
|
.orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
|
|
Translator.toLocale(GepafinConstant.APPLICATION_NOT_FOUND_MSG)));
|
|
return applicationEntity;
|
|
}
|
|
|
|
private ApplicationResponseBean convertApplicationEntityToApplicationResponseBean(ApplicationEntity entity) {
|
|
ApplicationResponseBean response = new ApplicationResponseBean();
|
|
response.setId(entity.getId());
|
|
response.setSubmissionDate(entity.getSubmissionDate());
|
|
response.setStatus(entity.getStatus());
|
|
response.setComments(entity.getComments());
|
|
response.setCallId(entity.getCall().getId());
|
|
response.setCreatedDate(entity.getCreatedDate());
|
|
response.setUpdatedDate(entity.getUpdatedDate());
|
|
return response;
|
|
}
|
|
|
|
private ApplicationFormEntity getApplicationFormOrCreate(FormEntity formEntity, ApplicationEntity applicationEntity) {
|
|
ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), formEntity.getId());
|
|
if(applicationFormEntity == null){
|
|
applicationFormEntity = createApplicationFormEntity(applicationEntity, formEntity);
|
|
}
|
|
return applicationFormEntity;
|
|
}
|
|
|
|
public List<ApplicationFormFieldEntity> createOrUpdateMultipleFormFields(List<ApplicationFormFieldRequestBean> formFieldResponseBeans, ApplicationFormEntity applicationFormEntity,FormEntity formEntity) {
|
|
List<ApplicationFormFieldEntity> existingFields = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId());
|
|
|
|
List<ApplicationFormFieldEntity> applicationFormFieldEntity = formFieldResponseBeans.stream()
|
|
.map(requestBean -> createOrUpdateApplicationFormField(requestBean, applicationFormEntity,existingFields,formEntity))
|
|
.collect(Collectors.toList());
|
|
return applicationFormFieldEntity;
|
|
}
|
|
|
|
public ApplicationFormFieldEntity createOrUpdateApplicationFormField(ApplicationFormFieldRequestBean applicationFormFieldRequestBean, ApplicationFormEntity applicationFormEntity,List<ApplicationFormFieldEntity> applicationFormFieldEntities ,FormEntity formEntity) {
|
|
|
|
ApplicationFormFieldEntity applicationFormFieldEntity=null;
|
|
|
|
validateFileUploadDocuments(applicationFormFieldRequestBean, formEntity);
|
|
|
|
if(applicationFormFieldEntities==null || applicationFormFieldEntities.isEmpty()){
|
|
applicationFormFieldEntity = new ApplicationFormFieldEntity();
|
|
applicationFormFieldEntity.setApplicationForm(applicationFormEntity);
|
|
}else {
|
|
for (ApplicationFormFieldEntity applicationFormFieldEntity1 : applicationFormFieldEntities) {
|
|
if (applicationFormFieldEntity1.getFieldId().equals(applicationFormFieldRequestBean.getFieldId())) {
|
|
applicationFormFieldEntity = applicationFormFieldEntity1;
|
|
if(applicationFormEntity.getForm().getId().equals(applicationFormEntity.getApplication().getCall().getInitialForm())){
|
|
validateRequiredFields(applicationFormEntity.getForm(),applicationFormEntity.getApplication(), applicationFormFieldRequestBean.getFieldId());
|
|
}
|
|
break;
|
|
} else {
|
|
applicationFormFieldEntity = new ApplicationFormFieldEntity();
|
|
applicationFormFieldEntity.setApplicationForm(applicationFormEntity);
|
|
}
|
|
}
|
|
}
|
|
Utils.setIfUpdated(applicationFormFieldEntity::getFieldId, applicationFormFieldEntity::setFieldId, applicationFormFieldRequestBean.getFieldId());
|
|
|
|
if(applicationFormFieldRequestBean.getFieldValue() !=null ) {
|
|
applicationFormFieldEntity.setFieldValue(Utils.convertObjectToJsonString(applicationFormFieldRequestBean.getFieldValue()));
|
|
}
|
|
if(applicationFormFieldRequestBean.getFieldValue() ==null ) {
|
|
applicationFormFieldEntity.setFieldValue(null);
|
|
}
|
|
return applicationFormFieldRepository.save(applicationFormFieldEntity);
|
|
}
|
|
|
|
private List<Long> validateFileUploadDocuments(ApplicationFormFieldRequestBean applicationFormFieldRequestBean, FormEntity formEntity) {
|
|
List<Long> documentIds=null;
|
|
List<ContentResponseBean> contentResponseBeans=Utils.convertJsonStringToList(formEntity.getContent(),ContentResponseBean.class);
|
|
for (ContentResponseBean contentResponseBean:contentResponseBeans){
|
|
if(Boolean.TRUE.equals(contentResponseBean.getName().equals("fileupload"))) {
|
|
if (contentResponseBean.getId().equals(applicationFormFieldRequestBean.getFieldId())) {
|
|
Object fieldValueObject = applicationFormFieldRequestBean.getFieldValue();
|
|
if (fieldValueObject instanceof String) {
|
|
// Safely cast the object to a string
|
|
String documentId = (String) fieldValueObject;
|
|
// Now you can use documentId as needed
|
|
documentIds = validateDocumentIds(documentId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return documentIds;
|
|
}
|
|
|
|
private List<Long> validateDocumentIds(String documentId) {
|
|
if (documentId != null && !documentId.isEmpty()) {
|
|
return Arrays.stream(documentId.split(","))
|
|
.map(Long::parseLong)
|
|
.peek(docId -> documentService.validateDocument(docId))
|
|
.collect(Collectors.toList());
|
|
}
|
|
return Collections.emptyList();
|
|
}
|
|
|
|
|
|
public ApplicationFormFieldEntity validateApplicationFormField(Long applicationFormFieldId) {
|
|
Optional<ApplicationFormFieldEntity> applicationFormFieldEntity = applicationFormFieldRepository.findById(applicationFormFieldId);
|
|
if (applicationFormFieldEntity.isEmpty()) {
|
|
throw new ResourceNotFoundException(Status.NOT_FOUND, Translator.toLocale(GepafinConstant.APPLICATION_FORM_FIELD_NOT_FOUND));
|
|
}
|
|
return applicationFormFieldEntity.get();
|
|
}
|
|
|
|
public List<ApplicationFormFieldEntity> saveApplicationFormFieldEntities(List<ApplicationFormFieldEntity> applicationFormFieldEntities) {
|
|
List<ApplicationFormFieldEntity> applicationFormFieldEntities1 = applicationFormFieldRepository.saveAll(applicationFormFieldEntities);
|
|
return applicationFormFieldEntities1;
|
|
}
|
|
|
|
public List<ApplicationFormFieldResponseBean> convertApplicationFormFieldEntitiesToApplicationFormFieldResponseBeans(List<ApplicationFormFieldEntity> applicationFormFieldEntities, Long applicationFormId) {
|
|
return applicationFormFieldEntities.stream()
|
|
.map(requestBean -> convertApplicationFormFieldEntityToApplicationFormFieldResponseBean(requestBean, applicationFormId))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
public ApplicationFormFieldResponseBean convertApplicationFormFieldEntityToApplicationFormFieldResponseBean(ApplicationFormFieldEntity applicationFormFieldEntity, Long applicationFormId) {
|
|
ApplicationFormFieldResponseBean applicationFormFieldResponseBean = new ApplicationFormFieldResponseBean();
|
|
applicationFormFieldResponseBean.setApplicationFormId(applicationFormId);
|
|
applicationFormFieldResponseBean.setFieldId(applicationFormFieldEntity.getFieldId());
|
|
if(applicationFormFieldEntity.getFieldValue() != null) {
|
|
applicationFormFieldResponseBean.setFieldValue(Utils.getFieldValueAsObject(applicationFormFieldEntity.getFieldValue()));
|
|
}
|
|
applicationFormFieldResponseBean.setId(applicationFormFieldEntity.getId());
|
|
applicationFormFieldResponseBean.setCreatedDate(applicationFormFieldEntity.getCreatedDate());
|
|
applicationFormFieldResponseBean.setUpdatedDate(applicationFormFieldEntity.getUpdatedDate());
|
|
return applicationFormFieldResponseBean;
|
|
}
|
|
public ApplicationEntity saveApplicationEntity(ApplicationEntity application){
|
|
ApplicationEntity applicationEntity=applicationRepository.save(application);
|
|
return applicationEntity;
|
|
}
|
|
|
|
public ApplicationGetResponseBean getApplicationByFormId( Long applicationId, Long formId, UserEntity userEntity) {
|
|
List<FormApplicationResponse> formApplicationResponses = new ArrayList<>();
|
|
List<FormEntity> formEntities = new ArrayList<>();
|
|
boolean isBeneficiary = isBeneficiary(userEntity);
|
|
ApplicationEntity applicationEntity = isBeneficiary
|
|
? applicationRepository.findByIdAndUserIdAndIsDeletedFalse(applicationId, userEntity.getId())
|
|
.orElseThrow(() -> new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_NOT_FOUND_MSG)))
|
|
: applicationRepository.findById(applicationId)
|
|
.stream().findFirst()
|
|
.orElseThrow(() -> new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_NOT_FOUND_MSG)));
|
|
if (formId != null) {
|
|
FormEntity formEntity = formService.validateForm(formId);
|
|
Optional<ApplicationEntity> application = applicationRepository.findByIdAndUserIdAndCallIdAndIsDeletedFalse(applicationId, userEntity.getId(),
|
|
formEntity.getCall().getId());
|
|
applicationEntity=application.get();
|
|
formEntities.add(formEntity);
|
|
addFormApplication(formEntity, applicationEntity, formApplicationResponses);
|
|
}
|
|
else {
|
|
List<ApplicationFormEntity> applicationFormEntities = applicationFormRepository.findByApplicationId(applicationEntity.getId());
|
|
for (ApplicationFormEntity applicationFormEntity : applicationFormEntities) {
|
|
FormEntity form = formService.validateForm(applicationFormEntity.getForm().getId());
|
|
formEntities.add(form);
|
|
addFormApplication(form, applicationEntity, formApplicationResponses);
|
|
}
|
|
}
|
|
|
|
return createApplicationGetResponseBean(applicationEntity, formEntities, formApplicationResponses);
|
|
}
|
|
|
|
private boolean isBeneficiary(UserEntity userEntity) {
|
|
RoleStatusEnum roleStatus = RoleStatusEnum.valueOf(userEntity.getRoleEntity().getRoleType());
|
|
boolean isBeneficiary = RoleStatusEnum.ROLE_BENEFICIARY.equals(roleStatus);
|
|
return isBeneficiary;
|
|
}
|
|
|
|
private void addFormApplication(FormEntity formEntity, ApplicationEntity applicationEntity,
|
|
List<FormApplicationResponse> formApplicationResponses) {
|
|
FormApplicationResponse formApplicationResponse = processForm(formEntity, applicationEntity);
|
|
if(formApplicationResponse.getContent() != null && formApplicationResponse.getFormFields() != null) {
|
|
formApplicationResponses.add(formApplicationResponse);
|
|
}
|
|
|
|
}
|
|
|
|
public FormApplicationResponse processForm(FormEntity formEntity, ApplicationEntity applicationEntity) {
|
|
FormApplicationResponse formApplicationResponse = createFormApplicationResponse(formEntity);
|
|
List<ApplicationFormFieldResponseBean> applicationFormFieldResponseBeans =new ArrayList<>();
|
|
ApplicationFormEntity applicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), formEntity.getId());
|
|
if(applicationFormEntity!=null) {
|
|
List<ApplicationFormFieldEntity> applicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(applicationFormEntity.getId());
|
|
// formApplicationResponse = createFormApplicationResponse(formEntity);
|
|
applicationFormFieldResponseBeans = createApplicationFormFieldResponse(applicationFormFieldEntities, applicationFormEntity,applicationFormFieldResponseBeans);
|
|
formApplicationResponse.setFormFields(applicationFormFieldResponseBeans);
|
|
}
|
|
return formApplicationResponse;
|
|
}
|
|
|
|
private ApplicationGetResponseBean createApplicationGetResponseBean(ApplicationEntity applicationEntity, List<FormEntity> formEntities, List<FormApplicationResponse> formApplicationResponses) {
|
|
ApplicationGetResponseBean applicationGetResponseBean = createApplicationGetResponseBean(applicationEntity);
|
|
applicationGetResponseBean.setForm(formApplicationResponses);
|
|
return applicationGetResponseBean;
|
|
}
|
|
|
|
private ApplicationGetResponseBean createApplicationGetResponseBean(ApplicationEntity applicationEntity) {
|
|
ApplicationGetResponseBean applicationGetResponseBean = new ApplicationGetResponseBean();
|
|
applicationGetResponseBean.setId(applicationEntity.getId());
|
|
applicationGetResponseBean.setStatus(applicationEntity.getStatus());
|
|
applicationGetResponseBean.setComments(applicationEntity.getComments());
|
|
applicationGetResponseBean.setSubmissionDate(applicationEntity.getSubmissionDate());
|
|
applicationGetResponseBean.setCallId(applicationEntity.getCall().getId());
|
|
applicationGetResponseBean.setCallTitle(applicationEntity.getCall().getName());
|
|
applicationGetResponseBean.setCompanyId(applicationEntity.getCompany().getId());
|
|
applicationGetResponseBean.setCompanyName(applicationEntity.getCompany().getCompanyName());
|
|
return applicationGetResponseBean;
|
|
}
|
|
|
|
private FormApplicationResponse createFormApplicationResponse(FormEntity formEntity) {
|
|
FormApplicationResponse formApplicationResponse=new FormApplicationResponse();
|
|
formApplicationResponse.setId(formEntity.getId());
|
|
formApplicationResponse.setLabel(formEntity.getLabel());
|
|
formApplicationResponse.setCallId(formEntity.getCall().getId());
|
|
formApplicationResponse.setContent(Utils.convertJsonStringToList(formEntity.getContent(), ContentResponseBean.class));
|
|
return formApplicationResponse;
|
|
}
|
|
|
|
public ApplicationResponse createApplicationByCallId(CompanyEntity companyEntity,
|
|
ApplicationRequest applicationRequest, Long callId, UserEntity userEntity) {
|
|
CallEntity call = callService.validateCall(callId);
|
|
// call = callService.validatePublishedCall(call.getId());
|
|
checkIfApplicationExists(call, companyEntity);
|
|
ApplicationEntity applicationEntity = createApplicationEntity(userEntity, call, companyEntity);
|
|
applicationEntity.setComments(applicationRequest.getComments());
|
|
applicationEntity = saveApplicationEntity(applicationEntity);
|
|
ApplicationResponse applicationResponse = getApplicationResponse(applicationEntity);
|
|
return applicationResponse;
|
|
}
|
|
public void checkIfApplicationExists(CallEntity call, CompanyEntity companyEntity){
|
|
Optional<ApplicationEntity> applicationEntity=applicationRepository.findByCompanyIdAndCallIdAndIsDeletedFalse(companyEntity.getId(),call.getId());
|
|
if(applicationEntity.isPresent()){
|
|
throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.APPLICATION_ALREADY_EXISTS));
|
|
}
|
|
}
|
|
|
|
public ApplicationResponse updateApplicationStatus(Long applicationId, ApplicationStatusTypeEnum status) {
|
|
ApplicationEntity applicationEntity = validateApplication(applicationId);
|
|
|
|
if (status.equals(ApplicationStatusTypeEnum.SUBMIT)) {
|
|
callService.validatePublishedCall(applicationEntity.getCall().getId());
|
|
// CallEntity callEntity = applicationEntity.getCall();
|
|
// Long initialFormId = callEntity.getInitialForm();
|
|
// Long finalFormId = callEntity.getFinalForm();
|
|
//// if (initialFormId == null || finalFormId == null) {
|
|
//// throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_IS_INCOMPLETE_MSG));
|
|
//// }
|
|
// ApplicationFormEntity initialApplicationForm = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), initialFormId);
|
|
// ApplicationFormEntity finalApplicationForm = applicationFormRepository.findByApplicationIdAndFormId(applicationEntity.getId(), finalFormId);
|
|
// if (initialApplicationForm == null || finalApplicationForm == null) {
|
|
// throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_IS_INCOMPLETE_MSG));
|
|
// }
|
|
List<FlowEdgesEntity> flowEdgesList = flowEdgesRepository.findByCallId(applicationEntity.getCall().getId());
|
|
Long totalSteps=flowFormDao.calculateTotalSteps(flowEdgesList);
|
|
Integer completedSteps=flowFormDao.getCompletedSteps(applicationEntity);
|
|
if (totalSteps.intValue() != completedSteps) {
|
|
throw new CustomValidationException(Status.BAD_REQUEST, Translator.toLocale(GepafinConstant.APPLICATION_IS_INCOMPLETE_MSG));
|
|
}
|
|
applicationEntity.setStatus(ApplicationStatusTypeEnum.SUBMIT.getValue());
|
|
applicationEntity.setSubmissionDate(DateTimeUtil.DateServerToUTC(LocalDateTime.now()));
|
|
} else {
|
|
applicationEntity.setStatus(status.getValue());
|
|
}
|
|
applicationEntity = saveApplicationEntity(applicationEntity);
|
|
|
|
return getApplicationResponse(applicationEntity);
|
|
}
|
|
|
|
public Integer calculateProgress(Long totalSteps, Long completedSteps) {
|
|
if (FieldValidator.isNullOrZero(totalSteps)) {
|
|
throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.TOTAL_STEPS_NOT_BE_ZERO));
|
|
}
|
|
|
|
if (completedSteps < 0 || completedSteps > totalSteps) {
|
|
throw new CustomValidationException(Status.BAD_REQUEST,Translator.toLocale(GepafinConstant.COMPLETED_STEPS_NOT_VALID));
|
|
}
|
|
|
|
double progress = ((double) completedSteps / totalSteps) * 100;
|
|
return (int) Math.round(progress);
|
|
}
|
|
public void validateFormFields(ApplicationRequestBean request, FormEntity formEntity) {
|
|
|
|
List<ContentResponseBean> contentResponseBeans=Utils.convertJsonStringToList(formEntity.getContent(),ContentResponseBean.class);
|
|
|
|
List<ApplicationFormFieldRequestBean> requestFields = request.getFormFields();
|
|
|
|
Map<String, String> contentMap = contentResponseBeans.stream()
|
|
.collect(Collectors.toMap(ContentResponseBean::getId, ContentResponseBean::getLabel)); // Change getLabel() if needed
|
|
FieldValidator validator = FieldValidator.create();
|
|
for (ApplicationFormFieldRequestBean requestField : requestFields) {
|
|
String fieldId = requestField.getFieldId();
|
|
|
|
if (!contentMap.containsKey(fieldId)) {
|
|
validator.addError(MessageFormat.format(Translator.toLocale(GepafinConstant.FIELD_ID_NOT_FOUND), fieldId));
|
|
}
|
|
|
|
}
|
|
validator.validate();
|
|
}
|
|
|
|
public void validateRequiredFields(FormEntity formEntity, ApplicationEntity applicationEntity, String fieldId) {
|
|
FlowDataEntity flowDataEntity = flowDataRepository.findByFormIdAndCallId(
|
|
formEntity.getId(), applicationEntity.getCall().getId());
|
|
|
|
if (flowDataEntity == null) {
|
|
return;
|
|
}
|
|
|
|
ApplicationFormFieldEntity applicationFormFieldEntity = applicationFormFieldRepository
|
|
.findByFieldIdAndApplicationFormFormIdAndApplicationFormApplicationId(
|
|
flowDataEntity.getChoosenField(), formEntity.getId(), applicationEntity.getId())
|
|
.orElse(null);
|
|
|
|
if (applicationFormFieldEntity == null || !fieldId.equals(applicationFormFieldEntity.getFieldId())) {
|
|
return;
|
|
}
|
|
List<Long> nextFormIds = flowEdgesRepository.findBySourceIdAndCallId(
|
|
formEntity.getId(), applicationEntity.getCall().getId())
|
|
.stream()
|
|
.map(FlowEdgesEntity::getTargetId)
|
|
.collect(Collectors.toList());
|
|
|
|
Optional<Long> nextFormIdOptional = flowDataRepository.findByChoosenValueAndFormIdIn(
|
|
applicationFormFieldEntity.getFieldValue(), nextFormIds)
|
|
.map(FlowDataEntity::getFormId);
|
|
|
|
if (nextFormIdOptional.isPresent()) {
|
|
Long nextFormId = nextFormIdOptional.get();
|
|
|
|
FormEntity nextForm = formService.validateForm(nextFormId);
|
|
ApplicationFormEntity nextApplicationFormEntity = applicationFormRepository.findByApplicationIdAndFormId(
|
|
applicationEntity.getId(), nextForm.getId());
|
|
|
|
if (nextApplicationFormEntity != null) {
|
|
List<ApplicationFormFieldEntity> nextApplicationFormFieldEntities = applicationFormFieldRepository.findByApplicationFormId(nextApplicationFormEntity.getId());
|
|
applicationFormFieldRepository.deleteAll(nextApplicationFormFieldEntities);
|
|
applicationFormRepository.delete(nextApplicationFormEntity);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|