private void InsertBatch(IList<ProcessorFile> list, StudyXml studyXml)
{
using (var processor = new ViewerCommandProcessor("Processing WorkItem DICOM file(s)"))
{
try
{
// Create an AggregrateCommand where we batch together all the database updates
// and execute them together as the last command.
var batchDatabaseCommand = new AggregateCommand();
foreach (var file in list)
{
if(!string.IsNullOrEmpty(file.FilePath) && file.File == null)
{
try
{
file.File = new DicomFile(file.FilePath);
// WARNING: If we ever do anything where we update files and save them,
// we may have to change this.
file.File.Load(DicomReadOptions.StorePixelDataReferences | DicomReadOptions.Default);
}
catch (FileNotFoundException)
{
Platform.Log(LogLevel.Warn, "File to be processed is not found, ignoring: {0}",
file.FilePath);
if (file.ItemUid != null)
batchDatabaseCommand.AddSubCommand(new CompleteWorkItemUidCommand(file.ItemUid));
continue;
}
}
else
{
file.FilePath = file.File.Filename;
}
String seriesUid = file.File.DataSet[DicomTags.SeriesInstanceUid].GetString(0, String.Empty);
String sopUid = file.File.DataSet[DicomTags.SopInstanceUid].GetString(0, String.Empty);
String finalDest = StudyLocation.GetSopInstancePath(seriesUid, sopUid);
if (file.FilePath != finalDest)
{
processor.AddCommand(new RenameFileCommand(file.FilePath, finalDest, false));
}
// Update the StudyStream object
var insertStudyXmlCommand = new InsertStudyXmlCommand(file.File, studyXml, StudyLocation, false);
processor.AddCommand(insertStudyXmlCommand);
if (file.ItemUid != null)
batchDatabaseCommand.AddSubCommand(new CompleteWorkItemUidCommand(file.ItemUid));
}
// Now save the batched updates to the StudyXml file.
processor.AddCommand(new SaveStudyXmlCommand(studyXml, StudyLocation));
// Update the Study table, based on the studyXml
var updateReason = IsReprocess ? InsertOrUpdateStudyCommand.UpdateReason.Reprocessing
: InsertOrUpdateStudyCommand.UpdateReason.LiveImport;
batchDatabaseCommand.AddSubCommand(new InsertOrUpdateStudyCommand(StudyLocation, studyXml, updateReason));
// Now, add all the batched database updates
processor.AddCommand(batchDatabaseCommand);
// Do the actual processing
if (!processor.Execute())
{
Platform.Log(LogLevel.Error, "Failure processing {0} for Study: {1}",
processor.Description, StudyLocation.Study.StudyInstanceUid);
throw new ApplicationException(
"Unexpected failure (" + processor.FailureReason + ") executing command for Study: " +
StudyLocation.Study.StudyInstanceUid, processor.FailureException);
}
StudyLocation.Study = processor.ViewerContext.ContextStudy;
Platform.Log(LogLevel.Info, "Processed {0} SOPs for Study {1}", list.Count,StudyLocation.Study.StudyInstanceUid );
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e, "Unexpected exception when {0}. Rolling back operation.",
processor.Description);
processor.Rollback();
throw new ApplicationException("Unexpected exception when processing file.", e);
}
}
}
public bool Process()
{
using (
var processor =
new ViewerCommandProcessor("Deleting series from study: " + _location.Study.StudyInstanceUid))
{
try
{
DicomAttributeCollection instance = null;
foreach (string seriesInstanceUid in SeriesInstanceUids)
{
foreach (SeriesXml seriesXml in StudyXml)
{
if (seriesXml.SeriesInstanceUid.Equals(seriesInstanceUid))
{
foreach (InstanceXml instanceXml in seriesXml)
{
processor.AddCommand(
new FileDeleteCommand(
_location.GetSopInstancePath(seriesInstanceUid, instanceXml.SopInstanceUid),
true));
}
}
else
{
// Save an instance we're keeping so we can update the study
if (instance == null)
instance = CollectionUtils.FirstElement(seriesXml).Collection;
}
}
processor.AddCommand(new RemoveSeriesFromStudyXml(StudyXml, seriesInstanceUid));
}
processor.AddCommand(new SaveStudyXmlCommand(StudyXml, _location));
processor.AddCommand(new InsertOrUpdateStudyCommand(_location, StudyXml, InsertOrUpdateStudyCommand.UpdateReason.SopsDeleted));
// Do the actual processing
if (!processor.Execute())
{
Platform.Log(LogLevel.Error, "Failure deleting {0} series for Study: {1}",
SeriesInstanceUids.Count, _location.Study.StudyInstanceUid);
throw new ApplicationException(
"Unexpected failure (" + processor.FailureReason + ") executing command for Study: " +
_location.Study.StudyInstanceUid, processor.FailureException);
}
Platform.Log(LogLevel.Info, "Deleted {0} Series for Study {1}", SeriesInstanceUids.Count,
_location.Study.StudyInstanceUid);
return true;
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e, "Unexpected exception when {0}. Rolling back operation.",
processor.Description);
processor.Rollback();
throw new ApplicationException("Unexpected exception when processing file.", e);
}
}
}
private void Process(DicomMessageBase message, FileImportBehaviourEnum fileImportBehaviour, WorkItem workItem, DicomProcessingResult result)
{
result.Initialize();
// Use the command processor for rollback capabilities.
using (var commandProcessor = new ViewerCommandProcessor(String.Format("Processing Sop Instance {0}", result.SopInstanceUid)))
{
try
{
var studyLocation = new StudyLocation(result.StudyInstanceUid);
String destinationFile = studyLocation.GetSopInstancePath(result.SeriesInstanceUid, result.SopInstanceUid);
DicomFile file = ConvertToDicomFile(message, destinationFile, _context.SourceAE);
// Create the Study Folder, if need be
commandProcessor.AddCommand(new CreateDirectoryCommand(studyLocation.StudyFolder));
bool duplicateFile = false;
string dupName = null;
if (File.Exists(destinationFile))
{
// TODO (CR Jun 2012): Shouldn't the commands themselves make this decision at the time
// the file is being saved? Otherwise, what happens if the same SOP were being saved 2x simultaneously.
// I know the odds are low, but just pointing it out.
duplicateFile = true;
dupName = Guid.NewGuid().ToString() + ".dcm";
destinationFile = Path.Combine(Path.GetDirectoryName(destinationFile) ?? string.Empty, dupName);
}
if (fileImportBehaviour == FileImportBehaviourEnum.Move)
{
commandProcessor.AddCommand(CommandFactory.CreateRenameFileCommand(file.Filename, destinationFile, true));
}
else if (fileImportBehaviour == FileImportBehaviourEnum.Copy)
{
commandProcessor.AddCommand(CommandFactory.CreateCopyFileCommand(file.Filename, destinationFile, true));
}
else if (fileImportBehaviour == FileImportBehaviourEnum.Save)
{
commandProcessor.AddCommand(CommandFactory.CreateSaveDicomFileCommand(destinationFile, file, true));
}
var insertWorkItemCommand = CreateWorkItemCommand(workItem, result, file, duplicateFile, dupName);
commandProcessor.AddCommand(insertWorkItemCommand);
if (commandProcessor.Execute())
{
result.DicomStatus = DicomStatuses.Success;
IncrementTotalFiles(insertWorkItemCommand, result.StudyInstanceUid);
}
else
{
if (commandProcessor.FailureException is ChangeConflictException
|| commandProcessor.FailureException is SqlCeLockTimeoutException)
result.RetrySuggested = true; // Change conflict or lock timeout may work if we just retry
Platform.Log(LogLevel.Warn, "Failure Importing file: {0}", file.Filename);
string failureMessage = String.Format(
"Failure processing message: {0}. Sending failure status.",
commandProcessor.FailureReason);
result.SetError(DicomStatuses.ProcessingFailure, failureMessage);
// processor already rolled back
}
}
catch (Exception e)
{
Platform.Log(LogLevel.Error, e, "Unexpected exception when {0}. Rolling back operation.", commandProcessor.Description);
commandProcessor.Rollback();
result.SetError(result.DicomStatus ?? DicomStatuses.ProcessingFailure, e.Message);
}
}
}