Summary Table
Categories |
Total Count |
PII |
0 |
URL |
0 |
DNS |
1 |
EKL |
0 |
IP |
0 |
PORT |
0 |
VsID |
0 |
CF |
0 |
AI |
0 |
VPD |
0 |
PL |
0 |
Other |
0 |
File Content
package gov.va.med.ars.service.impl;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import gov.va.med.ars.constants.ClaimSubmissionConstants;
import gov.va.med.ars.dao.ars.ClaimContactRepository;
import gov.va.med.ars.dao.ars.ClaimSubmissionNoteRepository;
import gov.va.med.ars.dao.ars.EmailTemplateRepository;
import gov.va.med.ars.dao.ars.IClaimSubmissionRepository;
import gov.va.med.ars.exceptions.EntityNotFoundException;
import gov.va.med.ars.model.request.UpdateRfaiRequest;
import gov.va.med.ars.service.IRfaiUpdateSubmissionService;
import gov.va.med.ars.util.Email;
import gov.va.med.ars.util.EmailInfo;
import gov.va.med.domain.ars.ClaimContact;
import gov.va.med.domain.ars.ClaimSubmission;
import gov.va.med.domain.ars.ClaimSubmissionNote;
import gov.va.med.domain.ars.EmailTemplate;
/**
* @author
DNS
*
*/
@Service
public class RfaiUpdateSubmissionServiceImpl implements IRfaiUpdateSubmissionService {
private static final Logger logger = LogManager.getLogger(RfaiUpdateSubmissionServiceImpl.class);
DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy");
@Autowired
IClaimSubmissionRepository rfaiRepo;
@Autowired
ClaimSubmissionNoteRepository claimSubmissionNoteRepo;
@Autowired
EmailTemplateRepository emailRepo;
@Autowired
ClaimContactRepository claimContactRepo;
@Autowired
EmailInfo info;
public boolean submitSimpleUpdate(UpdateRfaiRequest updateRfaiRequest)
throws ParseException, EntityNotFoundException {
String oldStatus = null;
ClaimSubmissionNote submittedNote = null;
try {
Date operationTime = new Date(System.currentTimeMillis());
ClaimSubmission claimSubmissionBeingUpdated = rfaiRepo.findOne(updateRfaiRequest.getSubmissionId());
if (claimSubmissionBeingUpdated == null) {
throw new EntityNotFoundException(String.valueOf(updateRfaiRequest.getSubmissionId()));
}
String originalClaimStatus = claimSubmissionBeingUpdated.getSubmissionStatus();
if (updateRfaiRequest.getSubmissionStatus().equalsIgnoreCase("SUBMITTED")
&& (originalClaimStatus.equalsIgnoreCase("COMPLETE")
|| originalClaimStatus.equalsIgnoreCase("ERROR")
|| originalClaimStatus.equalsIgnoreCase("ABANDONED")
|| originalClaimStatus.equalsIgnoreCase("MANUALLY CLOSED"))) {
return false;
}
oldStatus = claimSubmissionBeingUpdated.getSubmissionStatus();
if (!checkIfSubmissionBeUpdated(oldStatus, updateRfaiRequest.getSubmissionStatus())) {
return Boolean.FALSE;
}
claimSubmissionBeingUpdated.setDtp203responseduedate(dateFormat.parse(updateRfaiRequest.getResponseDate()));
claimSubmissionBeingUpdated.setSubmissionStatus(updateRfaiRequest.getSubmissionStatus());
claimSubmissionBeingUpdated.setDatemodified(operationTime);
logger.info("Start of rfaiRepo.save()");
Date responseDate = dateFormat.parse(updateRfaiRequest.getResponseDate());
rfaiRepo.updateSubmissionStatus(updateRfaiRequest.getSubmissionId(),
updateRfaiRequest.getSubmissionStatus(), responseDate, new Date());
ClaimSubmissionNote newClaimSubmissionNote = new ClaimSubmissionNote();
newClaimSubmissionNote.setClaimSubmission(claimSubmissionBeingUpdated);
newClaimSubmissionNote.setClaimSubmissionNoteTxt(updateRfaiRequest.getSubmissionNote());
newClaimSubmissionNote.setClaimsSubmissionOldStatus(oldStatus);
newClaimSubmissionNote.setClaimsSubmissionNewStatus(claimSubmissionBeingUpdated.getSubmissionStatus());
newClaimSubmissionNote.setDatecreated(operationTime);
submittedNote = claimSubmissionNoteRepo.save(newClaimSubmissionNote);
List<ClaimContact> claimContacts = claimContactRepo.findAllByclaimSubmissions(claimSubmissionBeingUpdated);
sendStatusChangeEmail(claimSubmissionBeingUpdated, claimContacts);
} catch (ParseException e) {
logger.info("Couldn't parse responseDate into MM/dd/yyyy format");
logger.warn(e.getMessage(), e);
throw e;
} catch (EntityNotFoundException e) {
logger.info(String.format("Error attempting to lookup claim with CLAIM_SUBMISSION.SUBMISSIONID of %s",
updateRfaiRequest.getSubmissionId()));
logger.warn(e.getMessage(), e);
throw e;
}
return submittedNote != null && submittedNote.getClaimSubmissionNoteId() != null;
}
private void sendStatusChangeEmail(ClaimSubmission claimSubmission, List<ClaimContact> claimContacts) {
String templateType = Email.getTemplateName(claimSubmission.getSubmissionStatus());
if (!templateType.equals("Invalid Status")) {
EmailTemplate template = emailRepo.getEmailTemplateByType(templateType);
Email email = new Email();
try {
email.postMail(claimSubmission, template, info, claimContacts);
} catch (Exception e) {
logger.error(e.getMessage());
}
} else {
logger.error("Submission status is invalid");
}
}
// Submission status can only be changed from submitted to manually closed,
// Submission status cannot be changed if it is complete,error,abandoned or
// manually closed already
private Boolean checkIfSubmissionBeUpdated(String oldStatus, String newStatus) {
if (oldStatus.equals(ClaimSubmissionConstants.SUBMISSION_COMPLETE_STATUS)
&& newStatus.equalsIgnoreCase(ClaimSubmissionConstants.SUBMISSION_COMPLETE_STATUS)) {
return Boolean.TRUE;
} else if (oldStatus.equals(ClaimSubmissionConstants.SUBMISSION_ABANDONED_STATUS)
&& newStatus.equalsIgnoreCase(ClaimSubmissionConstants.SUBMISSION_ABANDONED_STATUS)) {
return Boolean.TRUE;
} else if (oldStatus.equals(ClaimSubmissionConstants.SUBMISSION_MANUALLY_CLOSED_STATUS)
&& newStatus.equalsIgnoreCase(ClaimSubmissionConstants.SUBMISSION_MANUALLY_CLOSED_STATUS)) {
return Boolean.TRUE;
} else if (oldStatus.equals(ClaimSubmissionConstants.SUBMISSION_ERROR_STATUS)
&& newStatus.equalsIgnoreCase(ClaimSubmissionConstants.SUBMISSION_ERROR_STATUS)) {
return Boolean.TRUE;
} else if (oldStatus.equalsIgnoreCase(ClaimSubmissionConstants.SUBMISSION_SUBMITTED_STATUS)
&& (newStatus.equalsIgnoreCase(ClaimSubmissionConstants.SUBMISSION_SUBMITTED_STATUS))
|| newStatus.equalsIgnoreCase(ClaimSubmissionConstants.SUBMISSION_MANUALLY_CLOSED_STATUS)) {
return Boolean.TRUE;
} else {
return Boolean.FALSE;
}
}
}