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;
}
}
}