/*
* Created on 10-May-2004
*/
package ca.uhn.hl7v2.protocol.impl;
import java.io.IOException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ca.uhn.hl7v2.AcknowledgmentCode;
import ca.uhn.hl7v2.ErrorCode;
import ca.uhn.hl7v2.HL7Exception;
import ca.uhn.hl7v2.model.Message;
import ca.uhn.hl7v2.model.Segment;
import ca.uhn.hl7v2.parser.GenericParser;
import ca.uhn.hl7v2.parser.Parser;
import ca.uhn.hl7v2.protocol.AcceptValidator;
import ca.uhn.hl7v2.protocol.Processor;
import ca.uhn.hl7v2.protocol.ProcessorContext;
import ca.uhn.hl7v2.protocol.Transportable;
import ca.uhn.hl7v2.util.DeepCopy;
/**
* Checks whether messages can be accepted and creates appropriate
* ACK messages.
*
* @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp</a>
* @version $Revision: 1.1 $ updated on $Date: 2007-02-19 02:24:26 $ by $Author: jamesagnew $
*/
public class AcceptAcknowledger {
private static final Logger log = LoggerFactory.getLogger(AcceptAcknowledger.class);
private static Parser ourParser = new GenericParser();
/**
* Validates the given message against our accept validators, attempts to commit
* the message to safe storage, and returns an ACK message indicating acceptance
* or rejection at the accept level (see enhanced mode processing rules in HL7
* chapter 2, v2.5).
*/
public static AcceptACK validate(ProcessorContext theContext, Transportable theMessage) throws HL7Exception {
AcceptACK ruling = null;
AcceptValidator[] validators = theContext.getValidators();
for (int i = 0; i < validators.length && ruling == null; i++) {
AcceptValidator.AcceptRuling vr = validators[i].check(theMessage);
if (!vr.isAcceptable()) {
String description = (vr.getReasons().length > 0) ? vr.getReasons()[0] : null;
Transportable ack = makeAcceptAck(theMessage, vr.getAckCode(), ErrorCode.errorCodeFor(vr.getErrorCode()), description);
ruling = new AcceptACK(false, ack);
}
}
if (ruling == null) {
try {
theContext.getSafeStorage().store(theMessage);
Transportable ack = makeAcceptAck(theMessage, Processor.CA, ErrorCode.MESSAGE_ACCEPTED, "");
ruling = new AcceptACK(true, ack);
} catch (HL7Exception e) {
log.error(e.getMessage(), e);
Transportable ack = makeAcceptAck(theMessage, Processor.CR, ErrorCode.APPLICATION_INTERNAL_ERROR, e.getMessage());
ruling = new AcceptACK(false, ack);
}
}
return ruling;
}
private static Transportable makeAcceptAck(Transportable theMessage, String theAckCode, ErrorCode theErrorCode, String theDescription) throws HL7Exception {
Segment header = ourParser.getCriticalResponseData(theMessage.getMessage());
Message dummy = header.getMessage();
// MSH header refers to dummy, but not the other way round!
DeepCopy.copy(header, (Segment)dummy.get("MSH"));
try {
HL7Exception hl7e = new HL7Exception(theDescription, theErrorCode);
AcknowledgmentCode code = theAckCode == null ?
AcknowledgmentCode.CR :
AcknowledgmentCode.valueOf(theAckCode);
Message out = dummy.generateACK(code, hl7e);
String originalEncoding = ourParser.getEncoding(theMessage.getMessage());
String ackText = ourParser.encode(out, originalEncoding);
return new TransportableImpl(ackText);
} catch (IOException e) {
throw new HL7Exception(e);
}
}
/**
* A structure for decisions as to whether a message can be accepted,
* along with a corresponding accept or reject acknowlegement message.
*
* @author <a href="mailto:bryan.tripp@uhn.on.ca">Bryan Tripp</a>
* @version $Revision: 1.1 $ updated on $Date: 2007-02-19 02:24:26 $ by $Author: jamesagnew $
*/
public static class AcceptACK {
private Transportable myAck;
private boolean myIsAcceptable;
public AcceptACK(boolean isAcceptable, Transportable theAck) {
myIsAcceptable = isAcceptable;
myAck = theAck;
}
public boolean isAcceptable() {
return myIsAcceptable;
}
public Transportable getMessage() {
return myAck;
}
}
}