public bool DoesRuleMatch(RoutedItem rr, DestRule rule)
{
RoutedItemEx routedItem = (RoutedItemEx)rr;
// Connection source, DestRule rule, DicomDataset dataSet
//routedItem.sourceDicomFile?.Dataset
//2017-10-09 sbh I was running into "hard to debug" npe so I broke out the logic for easier debugging
//The idea here is to fail fast on rules and return false
//If a rule field is specified it is "engaged" and must be satisfied
//If a rule field is not specified ie null then it does not have to be satisfied
//near future: We might like to introspect any rule class to make this more dynamic
//all we need is a fieldmatch table between hl7 and DICOM and other sources
//then we can introspect class or JSON and loop the specifiers and compare to match
//otherwise the Rule class itself can grow ridiculously large.
try
{
return(DoesRuleMatchImpl(routedItem, rule));
}
catch (Exception e)
{
_logger.LogFullException(e);
}
return(false);
}
private async Task RunImpl(Rules Item, RoutedItem routedItem)
{
var taskInfo = $"task: {routedItem.TaskID}";
//get destRules that match this connection and
var destRulesToProcess = Item.destRules.FindAll(e => e.fromConnectionName == routedItem.fromConnection);
//loop the rules
foreach (var destRule in destRulesToProcess)
{
//run the scripts for this rule
foreach (var scriptname in destRule.preProcessToConnectionScriptNames)
{
if (scriptname.Equals("ruleTags"))
{
//run the scripts for the rule tags
foreach (var ruleTag in destRule.ruleTags)
{
var tagscript = Item.scripts.Find(e => e.name == ruleTag.scriptName);
routedItem.ruleDicomTag = ruleTag;
_logger.Log(LogLevel.Debug, $"{taskInfo} running tag script {tagscript.name}");
await _scriptService.RunAsync(tagscript, routedItem);
}
}
else
{
var script = Item.scripts.Find(e => e.name == scriptname);
_logger.Log(LogLevel.Debug, $"{taskInfo} running tag script {script.name}");
//await script.RunAsync(routedItem);
await _scriptService.RunAsync(script, routedItem);
}
}
}
}
private void CGetResponse(DicomCGetRequest request, DicomCGetResponse response)
{
RoutedItem ri = (RoutedItem)request.UserState;
var taskInfo = $"id: {ri.id} messageID: {request.MessageID} connection: {Connection.name}";
_logger.Log(LogLevel.Debug, $"{taskInfo} response: {response.Status}");
try
{
//if(response.Status.ToString().Equals("Success") || response.Status.ToString().Equals("Pending")){
if (response.HasDataset)
{
foreach (var data in response.Dataset)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} response.dataset.tag: {data} ");
}
_logger.Log(LogLevel.Debug, $"{taskInfo} StudyID: {response.Dataset.GetValue<string>(DicomTag.StudyID, 0)} ");
_logger.Log(LogLevel.Debug, $"{taskInfo} StudyInstanceUID: {response.Dataset.GetValue<string>(DicomTag.StudyInstanceUID, 0)} ");
_logger.Log(LogLevel.Debug, $"{taskInfo} SOPInstanceUID: {response.Dataset.GetValue<string>(DicomTag.SOPInstanceUID, 0)} ");
_logger.Log(LogLevel.Debug, $"{taskInfo} QueryRetrieveLevel: {response.Dataset.GetValue<string>(DicomTag.QueryRetrieveLevel, 0)} ");
_logger.Log(LogLevel.Debug, $"{taskInfo} PatientName: {response.Dataset.GetValue<string>(DicomTag.PatientName, 0)} ");
_logger.Log(LogLevel.Debug, $"{taskInfo} PatientBirthDate: {response.Dataset.GetValue<string>(DicomTag.PatientBirthDate, 0)} ");
_logger.Log(LogLevel.Debug, $"{taskInfo} StudyDate: {response.Dataset.GetValue<string>(DicomTag.StudyDate, 0)} ");
}
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
}
}
public RoutedItem LoadFromFile(string file)
{
//deserialize
//JsonSerializerSettings settings = new JsonSerializerSettings
//{
// TypeNameHandling = TypeNameHandling.Objects
//};
string json = File.ReadAllText(file);
if (string.IsNullOrEmpty(json))
{
_logger.Log(LogLevel.Error, $"{file} is null or blank.");
return(null);
}
try
{
RoutedItem st = JsonSerializer.Deserialize <RoutedItem>(json);
return(st);
}
catch (System.Text.Json.JsonException)
{
return(null);
}
}
public RoutedItem Dicomize(RoutedItem ri)
{
var routedItem = (RoutedItemEx)ri;
try
{
_logger.Log(LogLevel.Information, $"Attempting to DICOMIZE {routedItem.sourceFileName}");
DicomDataset data = new DicomDataset();
data.AddOrUpdate(DicomTag.PatientID, routedItem.PatientID);
data.AddOrUpdate(DicomTag.StudyInstanceUID, routedItem.Study);
data.AddOrUpdate(DicomTag.AccessionNumber, routedItem.AccessionNumber);
data.AddOrUpdate(DicomTag.SeriesInstanceUID, routedItem.AccessionNumber);
data.AddOrUpdate(DicomTag.SOPInstanceUID, routedItem.Sop);
data.AddOrUpdate(DicomTag.IssuerOfPatientID, routedItem.PatientIDIssuer);
data.Add(DicomTag.SOPClassUID, DicomUID.EncapsulatedPDFStorage);
byte[] fileData = _util.ReadBytesFromFile(routedItem.sourceFileName);
if (fileData.Length > 0)
{
data.Add(DicomTag.EncapsulatedDocument, fileData);
routedItem.sourceDicomFile = new DicomFile(data);
routedItem.sourceDicomFile.Save(routedItem.sourceFileName);
}
}
catch (Exception e)
{
_logger.Log(LogLevel.Critical, $"{routedItem.sourceFileName} cannot be DICOMIZED {e.Message} {e.StackTrace}");
}
return(routedItem);
}
public override RoutedItem Route(RoutedItem routedItem, bool copy = false)
{
try
{
var taskInfo = $"task: {routedItem.TaskID} connection: {Connection.name}:";
//check if dicom, if not dicomize since dicom only does dicom, duh.
if (routedItem.sourceFileName != null)
{
if (!_dicomUtil.IsDICOM(routedItem))
{
routedItem = _dicomUtil.Dicomize(routedItem);
}
}
//enqueue the routedItem
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(Connection, Connection.toDicom, nameof(Connection.toDicom), copy: copy);
}
catch (Exception e)
{
_logger.LogFullException(e);
//throw e;
throw;
}
return(routedItem);
}
private async Task ScanImpl(Profile profile, DcmtkConnection Connection, int taskID)
{
var taskInfo = $"task: {taskID} connection: {Connection.name}";
try
{
var dir = profile.tempPath + Path.DirectorySeparatorChar + Connection.name + Path.DirectorySeparatorChar + "toScanner";
Directory.CreateDirectory(dir);
var fileEntries = _util.DirSearch(dir, "*");
//var dd = new DuplicatesDetection();
if (profile.duplicatesDetectionUpload)
{
_logger.Log(LogLevel.Information,
$"{taskInfo} toCloud: {(fileEntries == null ? 0 : fileEntries.Count)} files to be send to cloud (before duplicates elimination).");
}
else
{
_logger.Log(LogLevel.Information,
$"{taskInfo} toCloud: {(fileEntries == null ? 0 : fileEntries.Count)} files to be send to cloud.");
}
foreach (string file in fileEntries)
{
if (_taskManager.cts.IsCancellationRequested)
{
break;
}
_logger.Log(LogLevel.Debug, $"{taskInfo} Found {file}");
RoutedItem routedItem = new RoutedItem(fromConnection: Connection.name, sourceFileName: file, taskID: taskID)
{
type = RoutedItem.Type.DICOM
};
routedItem = await _dcmDumpService.DcmDump(taskID, routedItem, Connection);
try
{
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(Connection, Connection.toRules, nameof(Connection.toRules));
}
catch (Exception e)
{
_logger.LogFullException(e);
}
}
}
catch (TaskCanceledException)
{
_logger.Log(LogLevel.Information, $"Task was canceled.");
}
catch (Exception e)
{
_logger.LogFullException(e);
}
finally
{
_taskManager.Stop($"{Connection.name}.Scanner");
}
}
public void RemoveCachedItem(RoutedItem routedItem)
{
using var scope = ServiceActivator.GetScope();
var cacheService = scope.ServiceProvider.GetRequiredService <IConnectionCacheResponseService>();
cacheService.RemoveCachedItem(Connection, routedItem, cache);
}
/// <summary>
/// Push a file to DICOM.
/// </summary>
/// <param name="routedItem"></param>
/// <param name="taskID"></param>
/// <param name="connection"></param>
public void CStore(RoutedItem routedItem, long taskID, DICOMConnection connection)
{
Connection = connection;
var taskInfo = $"task: {taskID} connection: {Connection.name}";
try
{
try
{
if (File.Exists(routedItem.sourceFileName))
{
var cStoreRequest = new DicomCStoreRequest(routedItem.sourceFileName);
routedItem.MessageId = cStoreRequest.MessageID;
cStoreRequest.UserState = routedItem;
_logger.Log(LogLevel.Debug, $"{taskInfo} Request id: {routedItem.id} {cStoreRequest.MessageID}, {routedItem.sourceFileName} {routedItem.fileIndex}/{routedItem.fileCount} attempt: {routedItem.attempts}");
cStoreRequest.OnResponseReceived = (DicomCStoreRequest request, DicomCStoreResponse response) =>
{
var ri = (RoutedItem)request.UserState;
_logger.Log(LogLevel.Information, $"{taskInfo} Request id: {ri.id} {response.RequestMessageID} status: {response.Status.Code} description: {response.Status.Description} comment: {response.Status.ErrorComment} state: {response.Status.State}");
_routedItemManager.Init(ri);
//2018-08-01 shb BOUR-559 handle and log failure conditions
if (response.Status == DicomStatus.Success)
{
_routedItemManager.Dequeue(Connection, Connection.toDicom, nameof(Connection.toDicom), error: false);
}
else
{
_routedItemManager.Dequeue(Connection, Connection.toDicom, nameof(Connection.toDicom), error: true);
}
OnCStoreRequestComplete(request, response);
};
dicomClient.AddRequest(cStoreRequest);
}
else
{
_logger.Log(LogLevel.Information, $"{taskInfo} File does not exist: {routedItem.sourceFileName}");
_routedItemManager.Init(routedItem);
_routedItemManager.Dequeue(Connection, Connection.toDicom, nameof(Connection.toDicom), error: true);
}
}
catch (DicomDataException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} {routedItem.sourceFileName} {e.Message} {e.StackTrace} ");
// !e.GetType().IsAssignableFrom(typeof(DicomFileException)))
_routedItemManager.Init(routedItem);
_routedItemManager.Dequeue(Connection, Connection.toDicom, nameof(Connection.toDicom), error: true);
}
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
}
}
public void DisengageWaitConditions(RoutedItem rr)
{
RoutedItemEx routedItem = (RoutedItemEx)rr;
var taskInfo = $"task: {routedItem.TaskID}";
if (routedItem.sourceDicomFile != null)
{
DicomDataset dataSet = routedItem.sourceDicomFile.Dataset;
//Disengage: Waits get engaged when DICOM Priority Tag detected, and get disengaged when done
ushort priority = 3;
string uuid = null;
try
{
if (dataSet.Contains(DicomTag.StudyInstanceUID))
{
uuid = dataSet.GetValue <string>(DicomTag.StudyInstanceUID, 0);
}
}
catch (DicomDataException e)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} {uuid} has no StudyInstanceUID field. {e.Message} {e.StackTrace}");
}
try
{
if (dataSet.Contains(DicomTag.Priority))
{
priority = dataSet.GetValue <ushort>(DicomTag.Priority, 0);
}
else
{
_logger.Log(LogLevel.Debug, $"{taskInfo} {uuid} has no priority field.");
}
}
catch (DicomDataException e)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} {uuid} has no priority field. {e.Message} {e.StackTrace}");
}
if (priority < 3)
{
if (dataSet.Contains(DicomTag.Priority))
{
if (dataSet.GetValue <ushort>(DicomTag.Priority, 0) == 0x01)
{
_logger.Log(LogLevel.Information, $"{taskInfo} {uuid} with high priority completed. Clearing highWait flag.");
_profileStorage.Current.highWait = false;
}
if (dataSet.GetValue <ushort>(DicomTag.Priority, 0) == 0x00)
{
_logger.Log(LogLevel.Information, $"{taskInfo} {uuid} with medium priority completed. Clearing mediumWait flag.");
_profileStorage.Current.mediumWait = false;
}
}
}
}
}
/// <summary>
/// result cache where we consolidate multiple routed items based on the same id.The result is added onto the id: key
/// which usually arrives in chronological order(Pending, Pending, Success) though not required
/// </summary>
/// <param name="routedItem"></param>
/// <returns></returns>
public RoutedItem CacheResponse(RoutedItem routedItem)
{
using (var scope = ServiceActivator.GetScope())
{
var cacheService = scope.ServiceProvider.GetRequiredService <IConnectionCacheResponseService>();
return(cacheService.CacheResponse(Connection, routedItem, cache));
}
}
public override RoutedItem Route(RoutedItem routedItem, bool copy = false)
{
var taskInfo = $"task: {routedItem.TaskID} connection: {Connection.name} type: {routedItem.type} id: {routedItem.id}";
try
{
_logger.Log(LogLevel.Debug, $"{taskInfo}");
if (routedItem.type == RoutedItem.Type.DICOM && routedItem.sourceFileName == null)
{
_logger.Log(LogLevel.Critical,
$"{taskInfo} RoutedItem.Type.DICOM requires routedItem.sourceFileName, will not route this request");
return(null);
}
if (routedItem.type != RoutedItem.Type.COMPLETION)
{
//populate the response cache
routedItem = CacheResponse(routedItem);
}
if (routedItem.type == RoutedItem.Type.RPC || routedItem.type == RoutedItem.Type.COMPLETION)
{
if (routedItem.status == RoutedItem.Status.COMPLETED ||
routedItem.status == RoutedItem.Status.FAILED)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} Enqueuing Completed response");
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(this.Connection, Connection.toCloud, nameof(Connection.toCloud));
}
else if (Connection.sendIntermediateResults)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} Enqueuing Intermediate response");
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(this.Connection, Connection.toCloud, nameof(Connection.toCloud));
}
}
else
{
_logger.Log(LogLevel.Debug, $"{taskInfo} Enqueuing");
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(this.Connection, Connection.toCloud, nameof(Connection.toCloud), copy: copy);
}
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
//throw e;
throw;
}
return(routedItem);
}
private async Task ProcessItem(int taskID, RoutedItem routedItem, LITEConnection connection, IHttpManager httpManager)
{
var taskInfo = $"task: {taskID} connection: {Connection.name}";
if (routedItem.lastAttempt == null || routedItem.lastAttempt >= DateTime.Now.AddMinutes(-connection.retryDelayMinutes)) //not attempted lately
{
await Task.CompletedTask;
return;
}
routedItem.attempts++;
if (routedItem.attempts > 1)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} {routedItem.sourceFileName} second attempt.");
}
routedItem.lastAttempt = DateTime.Now;
if (routedItem.attempts > connection.maxAttempts)
{
_logger.Log(LogLevel.Warning, $"Resource {routedItem.resource} exceeded max attempts. Deleting item.");
if (await _deleteEGSResourceService.DeleteEGSResource(taskID, routedItem, connection, httpManager))
{
_routedItemManager.Init(routedItem);
_routedItemManager.Dequeue(connection, connection.fromEGS, nameof(connection.fromEGS), error: false);
}
else
{
routedItem.Error = "Exceeded maxAttempts";
_routedItemManager.Init(routedItem);
_routedItemManager.Dequeue(connection, connection.fromEGS, nameof(connection.fromEGS), error: true);
}
}
switch (Connection.protocol)
{
case Protocol.Http:
// while (!LITETask.CanStart($"{name}.DownloadViaHttp"))
// {
// await Task.Delay(LITE.profile.taskDelay).ConfigureAwait(false);
// }
var newTaskID = _taskManager.NewTaskID();
Task task = new Task(new Action(async() => await _downloadViaHttpService.DownloadViaHttp(newTaskID, routedItem, connection, httpManager)), _taskManager.cts.Token);
await _taskManager.Start(newTaskID, task, $"{Connection.name}.DownloadViaHttp", routedItem.resource, isLongRunning : false).ConfigureAwait(false);
//await DownloadViaHttp(newTaskID, ri).ConfigureAwait(false);
break;
// case Protocol.UDT:
// await DownloadViaUDTShell(remoteHostname, remotePort, $"{routedItem.box + "/" + routedItem.resource}", LITE.profile.tempPath + Path.DirectorySeparatorChar + "toScanner", taskID);
// break;
}
}
public string GetCachedItemMetaData(LifeImageCloudConnection Connection, RoutedItem routedItem, long taskID)
{
Throw.IfNull(Connection);
var taskInfo = $"conn: {Connection.name} taskID: {taskID}";
RootObject rootObject = new RootObject
{
ImagingStudy = new List <ImagingStudy>()
};
ImagingStudy study = new ImagingStudy
{
accession = new Accession(),
patient = new Patient(),
series = new List <Series>()
};
var cacheItem = LifeImageCloudConnection.cache[routedItem.id].ToList();
var query = cacheItem
.GroupBy(item => new { item.Study, item.Series, item.PatientID, item.AccessionNumber })
.Select(grp => new
{
Study = grp.Key.Study,
Series = grp.Key.Series,
PatientID = grp.Key.PatientID,
Accession = grp.Key.AccessionNumber,
Instances = grp.Count()
});
foreach (var result in query)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} Study:{result.Study} Series:{result.Series} PatientID:{result.PatientID} Accession:{result.Accession} Instances:{result.Instances}");
var series = new Series
{
number = result.Instances,
uid = result.Series
};
study.series.Add(series);
}
study.numberOfInstances = query.Sum(x => x.Instances);
study.numberOfSeries = query.Count();
rootObject.ImagingStudy.Add(study);
var json = JsonSerializer.Serialize(rootObject);
_logger.Log(LogLevel.Debug, $"{taskInfo} Json:{json}");
return(json);
}
/// <summary>
/// Look up translation for specified tag, write translationhistory record and replace tag contents.
/// </summary>
/// <param name="Item"></param>
/// <param name="params"></param>
public void Translate(RoutedItem Item, TranslateServiceParams @params)
{
Throw.IfNull(@params);
Throw.IfNull(@params);
try
{
TranslateImpl(Item, @params);
}
catch (Exception e)
{
_logger.LogFullException(e);
}
}
private async Task ProcessDestRule(Rules Item, RoutedItem routedItem, DestRule destRule, string taskInfo)
{
Throw.IfNull(destRule);
_logger.Log(LogLevel.Debug, $"{taskInfo} rule {destRule.name}");
//run the scripts for this rule
foreach (var scriptname in destRule.preProcessFromConnectionScriptNames)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} script {scriptname}");
await ProcessScripts(scriptname, Item.scripts, routedItem, destRule);
}
}
/// <summary>
/// RunPostProcessToConnectionScripts is intended to be run once for each toConnection after outbound processing.
/// </summary>
/// <param name="Item"></param>
/// <param name="routedItem"></param>
/// <returns></returns>
public async Task RunPostProcessToConnectionScripts(Rules Item, RoutedItem routedItem)
{
Throw.IfNull(Item);
Throw.IfNull(routedItem);
var taskInfo = $"task: {routedItem.TaskID}";
try
{
//get destRules that match this connection and
var destRulesToProcess = Item.destRules.FindAll(e => e.fromConnectionName == routedItem.fromConnection);
//loop the rules
foreach (var destRule in destRulesToProcess)
{
//run the scripts for this rule
foreach (var scriptname in destRule.postProcessToConnectionScriptNames)
{
if (scriptname.Equals("ruleTags"))
{
//run the scripts for the rule tags
foreach (var ruleTag in destRule.ruleTags)
{
var tagscript = Item.scripts.Find(e => e.name == ruleTag.scriptName);
routedItem.ruleDicomTag = ruleTag;
_logger.Log(LogLevel.Debug, $"{taskInfo} running tag script {tagscript.name}");
//await tagscript.RunAsync(routedItem);
await _scriptService.RunAsync(tagscript, routedItem);
}
}
else
{
var script = Item.scripts.Find(e => e.name == scriptname);
_logger.Log(LogLevel.Debug, $"{taskInfo} running script {script.name}");
//await script.RunAsync(routedItem);
await _scriptService.RunAsync(script, routedItem);
}
}
}
}
catch (TaskCanceledException)
{
_logger.Log(LogLevel.Information, $"Task was canceled.");
}
catch (Exception e)
{
_logger.LogFullException(e);
}
}
private async Task RunImpl(Rules Item, RoutedItem routedItem, string taskInfo)
{
//get destRules that match this connection and
var destRulesToProcess = Item.destRules.FindAll(e => e.fromConnectionName == routedItem.fromConnection);
_logger.Log(LogLevel.Debug, $"{taskInfo} found {destRulesToProcess.Count} rules");
//loop the rules
foreach (DestRule destRule in destRulesToProcess)
{
_logger.Log(LogLevel.Debug, $"{taskInfo} rule {destRule.name}");
await ProcessDestRule(Item, routedItem, destRule, taskInfo);
}
}
public async Task <ActionResult <FilesModel> > GetFiles(string box)
{
FilesModel files = new FilesModel();
try
{
var profile = _profileStorage.Current;
var connection = _connectionFinder.GetPrimaryLITEConnection(profile);
var path = connection.resourcePath + Path.DirectorySeparatorChar + connection.name + Path.DirectorySeparatorChar + box;
Directory.CreateDirectory(path);
var temp = Directory.GetFiles(path);
foreach (var file in temp)
{
if (file != ".DS_Store" && !file.EndsWith(".tmp"))
{
try
{
var info = new FileInfo(file);
RoutedItem ri = new RoutedItem
{
type = RoutedItem.Type.FILE,
name = file.Replace(connection.resourcePath + Path.DirectorySeparatorChar + connection.name + Path.DirectorySeparatorChar + box + Path.DirectorySeparatorChar, ""),
resource = file.Replace(connection.resourcePath + Path.DirectorySeparatorChar + connection.name + Path.DirectorySeparatorChar + box + Path.DirectorySeparatorChar, ""),
box = box,
creationTimeUtc = info.CreationTimeUtc,
lastWriteTimeUtc = info.LastWriteTimeUtc,
lastAccessTimeUtc = info.LastAccessTimeUtc,
length = info.Length
};
files.files.Add(ri);
if (files.files.Count >= 1000)
{ //limit rows returned
break;
}
}
catch (FileNotFoundException) { }
}
}
}
catch (DirectoryNotFoundException)
{
}
return(files);
}
// Incoming file, store
public override RoutedItem Route(RoutedItem routedItem, bool copy = false)
{
var taskInfo = $"task: {routedItem.TaskID} connection: {Connection.name}";
//enqueue the routedItem, we don't support Q/R at this stage of dev
if (routedItem.sourceFileName != null)
{
DirectoryInfo mydir;
mydir = Directory.CreateDirectory(PathFormatter(routedItem));
_logger.Log(LogLevel.Debug,
$"{taskInfo} Creating File: {Connection.inpath}/{routedItem.sourceFileName.Replace(":", "-")}");
try
{
routedItem.destFileName = mydir.FullName + Path.DirectorySeparatorChar + routedItem.sourceFileName
.Substring(routedItem.sourceFileName.LastIndexOf(
Path.DirectorySeparatorChar) + 1).Replace(":", "-");
bool result = true;
if (_profileStorage.Current.duplicatesDetectionUpload && routedItem.type == RoutedItem.Type.DICOM)
{
var dd = _duplicatesDetectionService;
dd.DuplicatesPurge();
lock (routedItem)
{
if (!dd.DuplicatesReference(routedItem.fromConnection + "_FileConnection",
routedItem.sourceFileName))
{
result = false;
}
}
}
if (result)
{
File.Copy(routedItem.sourceFileName, routedItem.destFileName, true);
}
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
}
}
return(routedItem);
}
#pragma warning disable 1998
public override RoutedItem Route(RoutedItem routedItem, bool copy = false)
{
//enqueue the routedItem, we don't support Q/R at this stage of dev
if (routedItem.sourceFileName != null)
{
//check if dicom, if not dicomize since dicom only does dicom, duh.
if (!_dicomUtil.IsDICOM(routedItem))
{
routedItem = _dicomUtil.Dicomize(routedItem);
}
}
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(Connection, Connection.toDicom, nameof(Connection.toDicom), copy: copy);
return(routedItem);
}
public void RemoveCachedItem(Connection Connection, RoutedItem routedItem, Dictionary <string, List <RoutedItem> > cache)
{
Throw.IfNull(Connection);
Throw.IfNull(cache);
try
{
_routedItemManager.Init(routedItem);
_routedItemManager.DequeueCache(Connection, cache, nameof(cache), error: false);
_logger.Log(LogLevel.Debug, $"{routedItem.id} removed from cache");
}
catch (Exception e)
{
_logger.LogFullException(e);
}
}
/// <summary>
/// RunPreProcessToConnectionScripts is intended to be run once for the stream before outbound processing
/// </summary>
/// <param name="Item"></param>
/// <param name="routedItem"></param>
/// <returns></returns>
public async Task RunPreProcessToConnectionScripts(Rules Item, RoutedItem routedItem)
{
Throw.IfNull(Item);
Throw.IfNull(routedItem);
try
{
await RunImpl(Item, routedItem);
}
catch (TaskCanceledException)
{
_logger.Log(LogLevel.Information, $"Task was canceled.");
}
catch (Exception e)
{
_logger.LogFullException(e);
}
}
public bool IsDICOM(RoutedItem routedItem)
{
FileStream stream = null;
try
{
if (File.Exists(routedItem.sourceFileName))
{
//check if dicom per spec directly
stream = File.OpenRead(routedItem.sourceFileName);
byte[] bytes = new byte[132];
//stream.Seek(128, SeekOrigin.Begin);
var count = stream.Read(bytes, 0, 132);
string dicomPrefix = Encoding.ASCII.GetString(bytes);
if (dicomPrefix.EndsWith("DICM"))
{
_logger.Log(LogLevel.Debug, $"{routedItem.sourceFileName} is DICOM");
return(true);
}
else
{
_logger.Log(LogLevel.Information, $"{routedItem.sourceFileName} is not DICOM");
return(false);
}
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
finally
{
if (stream != null)
{
stream.Close();
}
}
}
public override RoutedItem Route(RoutedItem routedItem, bool copy = false)
{
var taskInfo = $"task: {routedItem.TaskID} connection: {Connection.name}";
try
{
_logger.Log(LogLevel.Debug, $"{taskInfo} Route item");
if (routedItem.type == RoutedItem.Type.RPC)
{
//populate the response cache and then send the response cache
routedItem = CacheResponse(routedItem);
if (routedItem.status == RoutedItem.Status.COMPLETED || routedItem.status == RoutedItem.Status.FAILED)
{
_logger.Log(LogLevel.Information, "Enqueuing item:", routedItem.name);
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(Connection, Connection.ToHL7, nameof(Connection.ToHL7));
}
else if (Connection.sendIntermediateResults)
{
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(Connection, Connection.ToHL7, nameof(Connection.ToHL7));
}
}
else
{
_routedItemManager.Init(routedItem);
_routedItemManager.Enqueue(Connection, Connection.ToHL7, nameof(Connection.ToHL7), copy: copy);
}
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
//throw e;
throw;
}
return(routedItem);
}
/// <summary>
/// Determines whether all tags specified in the rule are satisfied in the dataSet. If a tagValue can be anything but must be present, use "+." regex
/// </summary>
/// <param name="rule"></param>
/// <param name="rr"></param>
/// <returns></returns>
public RoutedItem DoTagsMatch(DestRule rule, RoutedItem rr)
{
RoutedItemEx ri = (RoutedItemEx)rr;
//dicom tag matching
RoutedItemEx result = DicomMatching(ri, rule);
if (result != null)
{
return(result);
}
result = Hl7Matching(ri, rule);
if (result != null)
{
return(result);
}
ri.RuleMatch = true;
return(ri);
}
public async Task <ScriptState> RunAsync(Core.Models.Script item, RoutedItem routedItem)
{
Throw.IfNull(item);
ScriptState scriptState = null;
try
{
if (item.script == null)
{
Compile(item);
}
scriptState = await item.script.RunAsync(globals : routedItem);
item.errors = $"No Errors. Last executed at {DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.ffff")}";
}
catch (TaskCanceledException)
{
_logger.Log(LogLevel.Information, $"Task was canceled.");
}
catch (Exception e)
{
_logger.LogFullException(e);
item.errors = $"{e.Message} {e.StackTrace}";
int i = 1;
int j = 0;
var lines = item.script.Code.Split("\n");
var formattedCode = "";
foreach (var line in lines)
{
formattedCode += $"[{i++},{j}] " + line.Replace("\n", "").Trim() + (line == "" ? "" : "\n");
j += line.Length + 1;
}
_logger.Log(LogLevel.Critical, $"code: \n{formattedCode}");
}
return(scriptState);
}
private async Task ProcessScriptFromTag(Tag ruleTag, RoutedItem routedItem, List <Script> scripts)
{
Throw.IfNull(ruleTag);
Throw.IfNull(scripts);
Throw.IfNull(routedItem);
var taskInfo = GetTaskInfo(routedItem);
var tagscript = scripts.Find(e => e.name == ruleTag.scriptName);
routedItem.ruleDicomTag = ruleTag;
_logger.Log(LogLevel.Debug, $"{taskInfo} running rule tag: {ruleTag.tagName} tag script: {ruleTag.scriptName}");
if (tagscript != null)
{
await _scriptService.RunAsync(tagscript, routedItem);
//await tagscript.RunAsync(routedItem);
}
else
{
_logger.Log(LogLevel.Debug, $"{taskInfo} script: {ruleTag.scriptName} not found!");
}
}
private async Task ProcessScripts(string scriptname, List <Script> scripts, RoutedItem routedItem, DestRule destRule)
{
Throw.IfNull(destRule);
var taskInfo = GetTaskInfo(routedItem);
_logger.Log(LogLevel.Debug, $"{taskInfo} script {scriptname}");
if (!scriptname.Equals("ruleTags"))
{
var script = scripts.Find(e => e.name == scriptname);
_logger.Log(LogLevel.Debug, $"{taskInfo} running script {script.name}");
await _scriptService.RunAsync(script, routedItem);
return;
}
//run the scripts for the rule tags
foreach (Tag ruleTag in destRule.ruleTags)
{
await ProcessScriptFromTag(ruleTag, routedItem, scripts);
}
}
// Note: cGet is not working at this point
public void CGet(RoutedItem routedItem, int taskID, DICOMConnection connection)
{
Connection = connection;
//process any outstanding moves and return the results
var taskInfo = $"task: {taskID} connection: {Connection.name}";
List <string> movesToRemove = new List <string>();
try
{
_logger.Log(LogLevel.Debug, $"{taskInfo} dicom.AddRequest: {routedItem.id} ");
try
{
var request = new DicomCGetRequest(routedItem.request)
{
UserState = routedItem
};
request.OnResponseReceived += CGetResponse;
// Fix if cGet is ever fixed dicomClient.AddRequest(request);
}
catch (TaskCanceledException)
{
_logger.Log(LogLevel.Information, $"Task was canceled.");
}
catch (DicomDataException e)
{
_logger.Log(LogLevel.Warning, $"{taskInfo} move: {routedItem.id} {e.Message} {e.StackTrace}");
}
}
catch (Exception e)
{
_logger.LogFullException(e, taskInfo);
}
}
