Thank you Dmitry, I unfortunately am also quite busy and have no spare time to invest on this nice to have at the moment.
It is certainly possible to use the TextMate grammar as basis to write a lexer class for Rouge.
I'll let you known if I get started on this !
Hi Ben,
You can use EnsLib.HL7.Schema ResolveSchemaTypeToDocType() class method to resolve DocType dynamically.
For example, if message is an OREF to an instance of EnsLib.HL7.Message :
s message.DocType = ##class(EnsLib.HL7.Schema).ResolveSchemaTypeToDocType("2.5",message.Name)To get an IRIS session integrated in VSCode terminal, you can add it to settings.json :
"terminal.integrated.profiles.windows": {
"IRIS Terminal": {
"path": [
"C:\\InterSystems\\IRISHealth\\bin\\irissession.exe"
],
"args": ["<instance name>"],
"icon": "terminal-cmd"
}
}However, this terminal window will lack the niceties of the ISC Terminal application, such as command history.
Hi,
Assuming your question is about HL7 (or EDI) message serialization.
The DTL is meant for parsing and transforming the message into another one. Serialization occurs when you output the message using the corresponding instance methods.
For an instance of the EnsLib.HL7.Message class, methods that output the message such as OutputToFile() are using instance properties to determine what separators to use : .Separators, .SegmentTerminator.
Also, business operations (extending EnsLib.HL7.Operation.Standard) expose a setting (Separators) that let you configure what separators to use.
Merry Christmas everyone !
My first time with AoC was a lot of fun, thank you for running this Objectscript ladder.
Congratulations to all participants.
My repository: https://github.com/theanor/idc-aoc-2022-theanor
And quality scanner status : https://community.objectscriptquality.com/dashboard?id=intersystems_iris_community%2Fidc-aoc-2022-theanor
If you need to process the entire file and no line filtering, I would go for using pass through file service (EnsLib.File.PassthroughService) to send an instance of stream container (Ens.StreamContainer) to either a message router (EnsLib.MsgRouter.RoutingEngine) or custom (BPL or code) process, and use a transform (class extending Ens.DataTransform) to transform the source stream container into a target stream container and send it to the file pass through operation (EnsLib.File.PassthroughOperation) for output.
I would use a custom process over message router if transform needs data source(s) (e.g. response from another process or operation) other than the input file. The transform can pick a suitable target stream class (Extending %Stream.Object) to hold in the Ens.StreamContainer depending on where you want to store the data (database vs file system,…)
HTH
You can call the Tranform(source,target) class method implemented by classes that extend Ens.DataTransform :
For a simple message transformation flow example, I would go for record map :
So you can focus on DTL and the whole flow can be done from the administration portal, look ma, no code ;-)
The record map file operation append records to the output file. The initial value of the 'Filename' setting is '%Q', hence you get one file per timestamp.
If you set "Filename" to '%f', the output file name will be the same as the input file name and records from one input file will be appended to an output file with the same name.
For simple headers (and footers), you can use the 'batch class' feature of the record map file batch service (EnsLib.RecordMap.Service.BatchFileService) and operation (EnsLib.RecordMap.Operation.BatchFileOperation), and a class such as EnsLib.RecordMap.SimpleBatch to specify a header string.
Hi Evgeny,
If the operation class is using the mechanism in Ens.BusinessOperation to route incoming requests to the OnMessage() method, you can use the XData content to get a list of supported request (just as the Portal testing dialog does). If the operation class implements it’s own custom OnMessage(), there is no simple way to tell what request classes are supported. The XData is described in the documentation.
For responses, there is a RESPONSECLASSNAME parameter defined in classes extending Ens.Request. I believe this used by the BPL editor. This is somewhat limited however, since the operation can as well respond with any %RegisteredObject object and accept any kind of request (via OnMessage), e.g. any class extending %RegisteredObject if it is marked as "in process".
Anyways, as Robert C. points out, documenting what the operation intent is and it's interface, especially if they are not trivial, helps a lot and IMHO is best practice.
Hi,
Using out-of-the-box classes in the EnsLib.HL7 package, you can either completely ignore responses, either process them synchronously. More complex scenarios involving multiple responses (ack/nack) are supported (see Important HL7 Scenarios | Routing HL7 Version 2 Messages in Productions | InterSystems IRIS for Health 2023.1
), but I think they do not match your supplier requirements.
According to the standard, when sending multiple HL7 v2.x messages over MLLP/TCP, the sender (initiating module) must wait for a response before sending the next message. This is described in "Health Level Seven Implementation Support Guide", Appendix C, section C.6.4, item 5. :
It is assumed that an initiating module may connect and perform more than one message transaction before disconnecting, but it may not have more than one outstanding message waiting for a response. In other words, the initiating task must wait for the response to a given message before sending another message.
This vendor requirement to receive multiple messages before sending responses is thus non-standard. It would require the sender to keep track of sent messages with a pending response, handle asynchronous replies and retry errored messages.
While this is possible by writing custom adapter/operation extending the out-of-the-box classes in EnsLib.HL7 package, it would add a lot of complexity and has IMHO, little added value compared to the usual synchronous implementation.
After enabling case-sensitivity in Windows, it is indeed possible to keep the original storage names.
Unfortunately, enabling the flag has no impact on the behaviour of Windows versions of git or vscode, they continue to use case-insensitive comparisons for file names. For example, it is impossible to stage / commit changes to the git repository, as file names differing only case are considered as a single file.
I totally agree.
At the moment I have all routines in a git repo, some files are using suffixes for disambiguation, and will gradually reduce entropy by refactoring and applying clear naming conventions as Evgeny suggest.
my thanks to you both 😀
You can pass the value to the DTL using the transformation auxiliary parameter, as described in the documentation : Working with Rules | Developing Business Rules | InterSystems IRIS for Health 2023.3.
To pass the source configuration name :
To clean pending messages and other suspended production data, you can use Ens.Director.CleanProduction() method, as explained in the documentation. Caution though, this will delete current production state, including removing message headers (Ens.MessageHeader instances) from queues.
EnsLib.HL7.Service.HTTPService may suit your needs : it implements reading HL7 message from incoming HTTP request.
To execute the routine at scheduled intervals, you can use the task scheduler with %SYS.Task.RunLegacyTask , that is intended to do exactly what you describe, run a routine.
If the intent is to wrap the statements in a new variable scope, why not simply extract the block in a private method ?
Hi Joseph,
To unit test interoperability productions and their business hosts, such as business processes, extend the %UnitTest.TestProduction class.
Thank you David, your excellent remarks are now part of the text.
Yes, ^SPOOL is the simplest way to achieve this. If you need a string rather than a global, you can just get all lines from ^SPOOL, for example :
ClassMethod ZWriteToString() As%String
{
#Dim result as%String#Dim i,lineCount as%Integerkill^SPOOL($j)
open2:$juse2zwrites result=""s lineCount=$select($data(var):$za-1,1:$za-2)
close2for i=1:1:lineCount s result=result_^SPOOL($j,i)
return result
}^SPOOL is not buried 😁, it is well documented, along with %IS and %SPOOL utilities.
It is simple and effective when used to it's intended purpose, that is, spooling text written to the currently in use device.
Hi,
To summarize the documentation :
:?R=RF,:?E=S,:~=S,:?A=C,:*=S,:I?=W,:T?=C
To match the application reject code in the HL7 ACK^O01 message in the example, and suspend all matching messages, use the following specifier, that matches all ACKs with MSA:1 = "AR" and suspend message, while retaining default behavior for other error conditions :
:?R=S,:?E=S,:~=S,:?A=C,:*=S,:I?=W,:T?=C
Size 201 181 181, all unit tests passed (including undefined argument, and additional .Type("abc,de","de,abc") --> Unsorted)
Thanks Eduard, I missed the extraneous quotes (my mind is still not entirely purged of strongly typed languages habits 😅)
ClassMethod Type(a...) As%String
{
f i=$i(r):1:$g(a){f j=1:1:$l(a(i),","){sl=$l($tr($p(a(i),",",j)," ")),c=$g(c,l),r=$s(l=c:r,r<3*l>c:2,r#2*c>l:3,1:4),c=l} k c} q$p("Constant1Increasing1Decreasing1Unsorted",1,r)
}Indeed f j=$i(r)... would get a !! mark if it was a chess move 😉
Congratulations !
When dealing with stream input, it’s good to keep in mind that strings are limited in length, as explained in the documentaton.
You can use $classmethod to invoke any class method, including %New, e.g.
set cls = "MyPackage.MyClass"set obj = $classmethod(cls,"%New")The curly brace syntax "source.{PID:12}" is not supported in code action as the block is included as is in the class code generated at compile time. Use GetValueAt() to achieve the same effect :
Set country = source.GetValueAt("PID:12")