internal IHL7Message DoParse(IMessage message) { if (message == null) { throw new HL7apiException("Cannot parse an invalid message"); } IHL7Message ret = null; Terser t = new Terser(message); string messageID = t.Get("/MSH-21(0)-1-1"); if (string.IsNullOrEmpty(messageID)) { messageID = GetMessageIDFromMessageType(message.GetMessageType(), message.Version); if (string.IsNullOrEmpty(messageID)) { throw new HL7apiException("Invalid Message type"); } } ret = (IHL7Message)InstantiateMessage(messageID, message.Version, message); return(ret); }
internal IHL7Message InstantiateMessage(string messageID, string version) { string assemblyName = $"HL7api.V{version.Replace(".", "")}";//.HL7api.V251 string className = $"{assemblyName}.Message.{messageID}"; IHL7Message message = null; Type messageType = null; String classToTry = $"{className},{assemblyName}"; messageType = Type.GetType(classToTry); //GetType from the specified assembly if (messageType == null) { messageType = Type.GetType(className); //try in the current assembly } if (messageType == null) { throw new Exception(); } try { message = Activator.CreateInstance(messageType) as IHL7Message; } catch (Exception e) { throw new HL7apiException("Unable to instantiate the class" + messageID, e); } return(message); }
/// <summary> /// /// </summary> /// <param name="ack"></param> /// <returns></returns> private void ProcessIncomingAck(IHL7Message ack) { HL7Request req = null; var v = m_OutgoingRequests.Where((request, b) => { if (ack.IsAckForRequest(request.Request) && request.Acknowledgment == null) { request.Acknowledgment = ack as IHL7Message; return(true); } else { return(false); } }).ToList(); if (v.Count() == 0) { string log = "Unexpected ack received or ack received to late"; m_HL7Server.Logger.Error(log); } else if (v.Count() > 1) { string log = "each ack should be bount to a single request"; throw new HL7InterfaceException(log); } else { req = v.FirstOrDefault(); req.AckReceivedEvent.Set(); } }
internal ParserResult Validate(String messageString) { IMessage messageObject = null; try { messageObject = contextParser.Parse(messageString); } catch (System.Exception se) { return(SystemExceptionHandler(se, messageString)); } parsedMessage = hl7Parser.DoParse(messageObject); if (parsedMessage.IsAcknowledge) { return(new ParserResult(parsedMessage, null, true, true, "")); } hl7Ack = hl7Parser.GetAckForMessage(parsedMessage); SetACK(AckTypes.AA, messageString, parsedMessage.Message); return(new ParserResult(parsedMessage, hl7Ack, true, false, "")); }
public IHL7Message GetAckForMessage(IHL7Message hl7Message) { string ackName = hl7Message.ExpectedAckID; string version = hl7Message.HL7Version; return(InstantiateMessage(ackName, version)); }
public HL7Request(IHL7Message message) { Request = message; ResponseReceivedEvent = new AutoResetEvent(false); AckReceivedEvent = new AutoResetEvent(false); RequestCompletedEvent = new AutoResetEvent(false); RequestCancellationToken = new CancellationTokenSource(); }
public virtual bool IsAckForRequest(IHL7Message request) { if (!this.IsAcknowledge) { return(false); } return(HL7Parser.IsAckForRequest(request, this)); }
public string Encode(IHL7Message hl7Message, HL7Encoding encoding, bool validate) { if (HL7Encoding.XML == encoding) { return(xmlParser.Encode(hl7Message.Message)); } return(pipeParser.Encode(hl7Message.Message)); }
public static bool IsAckForRequest(IHL7Message request, IHL7Message ack) { if (request == null) { throw new ArgumentNullException("Please provide a non-null value for the request"); } if (ack == null) { return(false); } if (string.IsNullOrEmpty(request.ExpectedAckID)) { throw new HL7apiException("The request should not be an acknowledgment"); } if (!string.IsNullOrEmpty(ack.ExpectedAckID)) { throw new HL7apiException("The ack should be an acknowledgment"); } string msa2 = ack.GetValue("/MSA-2"); string msh10 = request.ControlID; if (string.IsNullOrEmpty(msa2) || string.IsNullOrEmpty(msh10)) { throw new HL7apiException("The MSH-10 and MSA-2 are mandatory in the messages:" + request.MessageID + "and" + ack.MessageID); } if (String.Compare(msa2, msh10) != 0) { return(false); } //if the trigger event is provided then check aigain if (!string.IsNullOrEmpty(ack.TriggerEvent)) { if (!request.ExpectedAckType.Equals($"{ack.MessageCode}_{ack.TriggerEvent}")) { return(false); } } else { if (!ack.MessageCode.Equals("ACK")) { return(false); } } return(true); }
public override bool IsResponseForRequest(IHL7Message request) { if (request == null) { throw new ArgumentNullException("the request and the response should be both non-null"); } if (string.IsNullOrEmpty(request.ExpectedResponseType)) { throw new ArgumentException("the request cannot be a type of response message or acknowledgment"); } if (string.IsNullOrEmpty(this.TriggerEvent) || string.IsNullOrEmpty(this.MessageCode)) { throw new HL7apiException($"The message code and trigger event of the message: " + $" {this.MessageID} are mandatory fields"); } // to avoid situation in which response is actually a request if (!string.IsNullOrEmpty(this.ExpectedResponseType)) { return(false); } if (request.ExpectedResponseType != $"{this.MessageCode}_{this.TriggerEvent}") { return(false); } if ((request.ExpectedResponseID != this.MessageID)) { return(false); } if (request is EquipmentCommandRequest) { //if (!(this is EquipmentCommandResponse)) // return false; //if (request.GetValue("COMMAND(0)/ECD-2-1") // != this.GetValue("COMMAND_RESPONSE(0)/ECD-2-1")) // return false; //if (request.GetValue("COMMAND(0)/SPECIMEN_CONTAINER/SAC-3-1") // != this.GetValue("COMMAND_RESPONSE(0)/SPECIMEN_CONTAINER/SAC-3-1")) // return false; } return(true); }
public async Task <HL7Request> SendHL7MessageAsync(IHL7Message message) { HL7Request hl7Request = new HL7Request(message); if (!m_OutgoingRequests1.TryAdd(message.ControlID, hl7Request)) { throw new HL7InterfaceException("m_OutgoingRequests"); } m_OutgoingRequests.Add(hl7Request); TaskCompletionSource <HL7Request> senderTaskCompletionSource = new TaskCompletionSource <HL7Request>(); hl7Request.SenderTask = Task.Run(() => { bool success = false; int responseRetries = m_HL7Protocol.Config.MaxResponseRetriesNumber; try { do { success = SendMessageOne(hl7Request, ref responseRetries); }while (!success); } catch (Exception ex) { if (ex is HL7InterfaceException) { throw ex; } } finally { hl7Request.RequestCompletedEvent.Set(); } return(hl7Request); }, hl7Request.RequestCancellationToken.Token); return(await hl7Request.SenderTask); //.ConfigureAwait(false); }
internal IHL7Message InstantiateMessage(string messageID, string version, IMessage message) { string assemblyName = $"HL7api.V{version.Replace(".", "")}"; //.HL7api.V251 string className = $"{assemblyName}.Message.{messageID}"; IHL7Message hl7Message = null; Type messageType = null; String classToTry = $"{className},{assemblyName}"; messageType = Type.GetType(classToTry); //GetType from the specified assembly if (messageType == null) { messageType = Type.GetType(className); //try in the current assembly } if (messageType == null) { throw new HL7apiException(); } try { ConstructorInfo[] cis = messageType.GetConstructors(BindingFlags.NonPublic | BindingFlags.Instance); hl7Message = (IHL7Message)Activator.CreateInstance( messageType, BindingFlags.NonPublic | BindingFlags.Instance, null, new object[] { message }, null); } catch (Exception ex) { throw new HL7apiException("Unable to instantiate the class " + messageID, ex); } return(hl7Message); }
public override bool IsResponseForRequest(IHL7Message request) { throw new NotImplementedException(); }
//public static IHL7Protocol GetMessageProtocol() //{ // //IHL7Protocol p = null; // //string messageProtocolTypeName = ConfigurationManager.AppSettings["MessageProtocol"]; // //if (messageProtocolTypeName == null) // // p = new DefaultProtocol(); // //else // //{ // // try // // { // // Type t = Type.GetType(messageProtocolTypeName); // // p = Activator.CreateInstance(t) as IHL7Protocol; // // } // // catch (Exception e) // // { // // throw new HL7InterfaceException // // ("Unable to instantiate the Message Protocol class from the assembly name provided", e); // // } // //} // //return p; //} #region IProtocol Interface public virtual byte[] Encode(IHL7Message hl7Message) { string mllpMessage = HL7api.Util.MLLP.CreateMLLPMessage(hl7Message.Encode()); return(Encoding.ASCII.GetBytes(mllpMessage)); }
public override bool IsResponseForRequest(IHL7Message request) { return(false); }
public abstract bool IsResponseForRequest(IHL7Message request);
private ParserResult SystemExceptionHandler(Exception se, string messageString) { if (string.IsNullOrEmpty(messageString)) { return(new ParserResult(null, null, false, null, se.Message)); } //Do not handle configuration Exceptions if (se is ConfigurationException) { throw (ConfigurationException)se; } if (typeof(System.Configuration.ConfigurationException).IsAssignableFrom(se.GetType())) { throw (ConfigurationException)se; } _errorMessage.AppendLine(se.Message); if (se.InnerException != null) { _errorMessage.AppendLine(se.InnerException.Message); } string messageType = null; string version = null; ISegment criticalSegment = null; try { criticalSegment = TryToRecoverCriticalDataFromMessage(messageString); if (criticalSegment == null) { version = TryToRecoverTheVersion(messageString); messageType = TryTorecoverTheMessageType(messageString); } else { version = Terser.Get(criticalSegment, 12, 0, 1, 1); messageType = $"{Terser.Get(criticalSegment, 9, 0, 1, 1)}" + $"_{Terser.Get(criticalSegment, 9, 0, 2, 1)}"; } if (messageType == null) { return(new ParserResult(null, null, false, null, _errorMessage.ToString())); } //the messageType is not null! if (version == null) { version = "2.5.1"; } string responseType = HL7Parser.GetMessageIDFromMessageType(messageType, version); if (responseType == null) { //the incoming message is an ack, the acknowledgment should not be aknoledged return(new ParserResult(null, null, false, true, _errorMessage.ToString())); } hl7Ack = hl7Parser.InstantiateMessage(responseType, version); ISegment err = (ISegment)hl7Ack.Message.GetStructure("ERR", 0); if ((se.InnerException != null) && typeof(HL7Exception).IsAssignableFrom(se.InnerException.GetType())) { HL7Exception he = (HL7Exception)se.InnerException; he.populate(err); } //if (typeof(HL7Exception).IsAssignableFrom(se.GetType())) //{ // HL7Exception he = (HL7Exception)se; // he.populate(err); // Debug.Print((new PipeParser()).Encode(ack)); //} SetACK(AckTypes.AR, messageString); } catch (Exception e) { _errorMessage.AppendLine(e.Message); return(new ParserResult(parsedMessage, hl7Ack, false, null, _errorMessage.ToString())); } return(new ParserResult(parsedMessage, hl7Ack, false, parsedMessage.IsAcknowledge, _errorMessage.ToString())); }
public string Encode(IHL7Message message) { return(Encode(message, HL7Encoding.ER7, true)); }