public InconsistentDataSIQEntry(StudyIntegrityQueue studyIntegrityQueueEntry)
{
Platform.CheckTrue(studyIntegrityQueueEntry.StudyIntegrityReasonEnum == StudyIntegrityReasonEnum.InconsistentData,
String.Format("Cannot copy data from StudyIntegrityQueue record of type {0}",
studyIntegrityQueueEntry.StudyIntegrityReasonEnum));
this.SetKey(studyIntegrityQueueEntry.Key);
this.Description = studyIntegrityQueueEntry.Description;
this.InsertTime = studyIntegrityQueueEntry.InsertTime;
this.Details = studyIntegrityQueueEntry.Details;
this.ServerPartitionKey = studyIntegrityQueueEntry.ServerPartitionKey;
this.StudyData = studyIntegrityQueueEntry.StudyData;
this.StudyIntegrityReasonEnum = studyIntegrityQueueEntry.StudyIntegrityReasonEnum;
this.StudyStorageKey = studyIntegrityQueueEntry.StudyStorageKey;
this.GroupID = studyIntegrityQueueEntry.GroupID;
}
public DuplicateSopReceivedQueue(StudyIntegrityQueue studyIntegrityQueueEntry)
{
Platform.CheckTrue(studyIntegrityQueueEntry.StudyIntegrityReasonEnum == StudyIntegrityReasonEnum.Duplicate,
String.Format("Cannot copy data from StudyIntegrityQueue record of type {0}",
studyIntegrityQueueEntry.StudyIntegrityReasonEnum));
this.SetKey(studyIntegrityQueueEntry.GetKey());
this.Description = studyIntegrityQueueEntry.Description;
this.InsertTime = studyIntegrityQueueEntry.InsertTime;
this.Details = studyIntegrityQueueEntry.Details;
this.ServerPartitionKey = studyIntegrityQueueEntry.ServerPartitionKey;
this.StudyData = studyIntegrityQueueEntry.StudyData;
this.StudyIntegrityReasonEnum = studyIntegrityQueueEntry.StudyIntegrityReasonEnum;
this.StudyStorageKey = studyIntegrityQueueEntry.StudyStorageKey;
this.GroupID = studyIntegrityQueueEntry.GroupID;
}
protected override void OnExecute(CommandProcessor theProcessor, IUpdateContext updateContext)
{
string seriesUid = _file.DataSet[DicomTags.SeriesInstanceUid].GetString(0, String.Empty);
string sopUid = _file.DataSet[DicomTags.SopInstanceUid].GetString(0, String.Empty);
ImageSetDescriptor imageSet = new ImageSetDescriptor(_file.DataSet);
ReconcileStudyQueueDescription queueDesc = GetQueueEntryDescription(_storageLocation, _file);
ReconcileStudyWorkQueueData detailsData = new ReconcileStudyWorkQueueData
{
StoragePath = _reconcileImageStorage.GetFolderPath(),
Details = new ImageSetDetails(_file.DataSet)
};
detailsData.Details.InsertFile(_file);
IInsertStudyIntegrityQueue broker = updateContext.GetBroker<IInsertStudyIntegrityQueue>();
InsertStudyIntegrityQueueParameters parameters = new InsertStudyIntegrityQueueParameters
{
Description = queueDesc.ToString(),
StudyInstanceUid = _storageLocation.StudyInstanceUid,
ServerPartitionKey = _storageLocation.ServerPartition.Key,
StudyStorageKey = _storageLocation.Key,
StudyIntegrityReasonEnum = _reason,
SeriesInstanceUid = seriesUid,
SeriesDescription = sopUid,
SopInstanceUid =
_file.DataSet[DicomTags.SopInstanceUid].GetString(0,
String
.
Empty),
StudyData = XmlUtils.SerializeAsXmlDoc(imageSet),
Details = XmlUtils.SerializeAsXmlDoc(detailsData),
GroupID = _uidGroup,
UidRelativePath =
_reconcileImageStorage.GetSopRelativePath(
_file.DataSet[DicomTags.SopInstanceUid].ToString())
};
StudyIntegrityQueue item = broker.FindOne(parameters);
if (item == null)
{
throw new ApplicationException("Unable to update reconcile queue");
}
_siqItem = item;
if (!parameters.Inserted)
{
// Need to re-use the path that's already assigned for this entry
ReconcileStudyWorkQueueData data = XmlUtils.Deserialize<ReconcileStudyWorkQueueData>(item.Details);
data.Details.InsertFile(_file);
XmlDocument updatedQueueDataXml = XmlUtils.SerializeAsXmlDoc(data);
IStudyIntegrityQueueEntityBroker updateBroker = updateContext.GetBroker<IStudyIntegrityQueueEntityBroker>();
StudyIntegrityQueueUpdateColumns columns = new StudyIntegrityQueueUpdateColumns
{Details = updatedQueueDataXml};
updateBroker.Update(item.GetKey(), columns);
}
}
static public StudyIntegrityQueue Insert(IUpdateContext update, StudyIntegrityQueue entity)
{
var broker = update.GetBroker<IStudyIntegrityQueueEntityBroker>();
var updateColumns = new StudyIntegrityQueueUpdateColumns();
updateColumns.ServerPartitionKey = entity.ServerPartitionKey;
updateColumns.StudyStorageKey = entity.StudyStorageKey;
updateColumns.InsertTime = entity.InsertTime;
updateColumns.StudyData = entity.StudyData;
updateColumns.StudyIntegrityReasonEnum = entity.StudyIntegrityReasonEnum;
updateColumns.GroupID = entity.GroupID;
updateColumns.Details = entity.Details;
updateColumns.Description = entity.Description;
StudyIntegrityQueue newEntity = broker.Insert(updateColumns);
return newEntity;
}
static public StudyIntegrityQueue Insert(StudyIntegrityQueue entity)
{
using (var update = PersistentStoreRegistry.GetDefaultStore().OpenUpdateContext(UpdateContextSyncMode.Flush))
{
StudyIntegrityQueue newEntity = Insert(update, entity);
update.Commit();
return newEntity;
}
}
public DuplicateEntryDetails(StudyIntegrityQueue siqEntry):base(siqEntry)
{
_duplicateSIQEntry = new DuplicateSopReceivedQueue(siqEntry);
}
/// <summary>
/// Constructs an instance of <see cref="WorkQueue"/> based on a <see cref="WorkQueueSummary"/> object.
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
/// <remark>
///
/// </remark>
private StudyIntegrityQueueSummary CreateStudyIntegrityQueueSummary(StudyIntegrityQueue item)
{
var summary = new StudyIntegrityQueueSummary();
var ssAdaptor = new StudyStorageAdaptor();
var storages = ssAdaptor.Get(HttpContextData.Current.ReadContext, item.StudyStorageKey);
try
{
summary.Reason = item.StudyIntegrityReasonEnum;
summary.TheStudyIntegrityQueueItem = item;
summary.ThePartition = Partition;
var queueDescription = new ReconcileStudyQueueDescription();
queueDescription.Parse(item.Description);
summary.QueueData = item.StudyIntegrityReasonEnum.Equals(StudyIntegrityReasonEnum.InconsistentData) ? XmlUtils.Deserialize<ReconcileStudyWorkQueueData>(item.Details) : XmlUtils.Deserialize<DuplicateSIQQueueData>(item.Details);
ImageSetDescriptor studyData = ImageSetDescriptor.Parse(item.StudyData.DocumentElement);
// These fields only exists in Enterprise version
if (summary.QueueData.Details != null && summary.QueueData.Details.StudyInfo!=null)
{
summary.ReceivedTime = item.InsertTime;
summary.ConflictingPatientId = summary.QueueData.Details.StudyInfo.PatientInfo.PatientId;
summary.ConflictingPatientName = summary.QueueData.Details.StudyInfo.PatientInfo.Name;
summary.ConflictingAccessionNumber = summary.QueueData.Details.StudyInfo.AccessionNumber;
summary.ConflictingStudyDate = summary.QueueData.Details.StudyInfo.StudyDate;
summary.ConflictingStudyDescription = summary.QueueData.Details.StudyInfo.StudyDescription;
var modalities = new List<string>();
List<SeriesInformation> seriesList = summary.QueueData.Details.StudyInfo.Series;
foreach (SeriesInformation series in seriesList)
{
if (!modalities.Contains(series.Modality))
modalities.Add(series.Modality);
}
summary.ConflictingModalities = modalities.ToArray();
}
else
{
string value;
if (studyData.TryGetValue(DicomTags.PatientId, out value))
summary.ConflictingPatientId = value;
if (studyData.TryGetValue(DicomTags.PatientsName, out value))
summary.ConflictingPatientName = value;
if (studyData.TryGetValue(DicomTags.AccessionNumber, out value))
summary.ConflictingAccessionNumber = value;
if (studyData.TryGetValue(DicomTags.StudyDate, out value))
summary.ConflictingStudyDate = value;
if (studyData.TryGetValue(DicomTags.StudyDescription, out value))
summary.ConflictingStudyDescription = value;
// no modality info
}
// Fetch existing study info. Note: this is done last because the study may not exist.
Study study = storages.LoadStudy(HttpContextData.Current.ReadContext);
summary.StudySummary = StudySummaryAssembler.CreateStudySummary(HttpContextData.Current.ReadContext, study);
if (summary.StudySummary!=null)
{
summary.StudyInstanceUid = summary.StudySummary.StudyInstanceUid;
summary.ExistingPatientName = summary.StudySummary.PatientsName;
summary.ExistingPatientId = summary.StudySummary.PatientId;
summary.ExistingAccessionNumber = summary.StudySummary.AccessionNumber;
}
}
catch(StudyNotFoundException)
{
// Study record may not exist. For eg, duplicate arrives but the existing study hasn't been processed.
}
return summary;
}
public ReconcileDetails(StudyIntegrityQueue queueItem)
{
_item = queueItem;
}
private static void ReconcileStudy(string command,StudyIntegrityQueue item )
{
//Ignore the reconcile command if the item is null.
if (item == null) return;
// Preload the change description so its not done during the DB transaction
XmlDocument changeDescription = new XmlDocument();
changeDescription.LoadXml(command);
// The Xml in the SIQ item was generated when the images were received and put into the SIQ.
// We now add the user info to it so that it will be logged in the history
ReconcileStudyWorkQueueData queueData = XmlUtils.Deserialize<ReconcileStudyWorkQueueData>(item.Details);
queueData.TimeStamp = Platform.Time;
queueData.UserId = ServerHelper.CurrentUserName;
using (IUpdateContext context = PersistentStoreRegistry.GetDefaultStore().OpenUpdateContext(UpdateContextSyncMode.Flush))
{
LockStudyParameters lockParms = new LockStudyParameters
{
QueueStudyStateEnum = QueueStudyStateEnum.ReconcileScheduled,
StudyStorageKey = item.StudyStorageKey
};
ILockStudy broker = context.GetBroker<ILockStudy>();
broker.Execute(lockParms);
if (!lockParms.Successful)
{
throw new ApplicationException(lockParms.FailureReason);
}
//Add to Study History
StudyHistoryeAdaptor historyAdaptor = new StudyHistoryeAdaptor();
StudyHistoryUpdateColumns parameters = new StudyHistoryUpdateColumns
{
StudyData = item.StudyData,
ChangeDescription = changeDescription,
StudyStorageKey = item.StudyStorageKey,
StudyHistoryTypeEnum = StudyHistoryTypeEnum.StudyReconciled
};
StudyHistory history = historyAdaptor.Add(context, parameters);
//Create WorkQueue Entry
WorkQueueAdaptor workQueueAdaptor = new WorkQueueAdaptor();
WorkQueueUpdateColumns row = new WorkQueueUpdateColumns
{
Data = XmlUtils.SerializeAsXmlDoc(queueData),
ServerPartitionKey = item.ServerPartitionKey,
StudyStorageKey = item.StudyStorageKey,
StudyHistoryKey = history.GetKey(),
WorkQueueTypeEnum = WorkQueueTypeEnum.ReconcileStudy,
WorkQueueStatusEnum = WorkQueueStatusEnum.Pending,
ScheduledTime = Platform.Time,
ExpirationTime = Platform.Time.AddHours(1),
GroupID = item.GroupID
};
WorkQueue newWorkQueueItem = workQueueAdaptor.Add(context, row);
StudyIntegrityQueueUidAdaptor studyIntegrityQueueUidAdaptor = new StudyIntegrityQueueUidAdaptor();
StudyIntegrityQueueUidSelectCriteria crit = new StudyIntegrityQueueUidSelectCriteria();
crit.StudyIntegrityQueueKey.EqualTo(item.GetKey());
IList<StudyIntegrityQueueUid> uidList = studyIntegrityQueueUidAdaptor.Get(context, crit);
WorkQueueUidAdaptor workQueueUidAdaptor = new WorkQueueUidAdaptor();
WorkQueueUidUpdateColumns update = new WorkQueueUidUpdateColumns();
foreach (StudyIntegrityQueueUid uid in uidList)
{
update.WorkQueueKey = newWorkQueueItem.GetKey();
update.SeriesInstanceUid = uid.SeriesInstanceUid;
update.SopInstanceUid = uid.SopInstanceUid;
update.RelativePath = uid.RelativePath;
workQueueUidAdaptor.Add(context, update);
}
//DeleteStudyIntegrityQueue Item
StudyIntegrityQueueUidSelectCriteria criteria = new StudyIntegrityQueueUidSelectCriteria();
criteria.StudyIntegrityQueueKey.EqualTo(item.GetKey());
studyIntegrityQueueUidAdaptor.Delete(context, criteria);
StudyIntegrityQueueAdaptor studyIntegrityQueueAdaptor = new StudyIntegrityQueueAdaptor();
studyIntegrityQueueAdaptor.Delete(context, item.GetKey());
context.Commit();
}
}
public bool DeleteStudyIntegrityQueueItem(StudyIntegrityQueue item)
{
return _adaptor.Delete(item.Key);
}
public InconsistentDataSIQRecord(StudyIntegrityQueue queue)
{
_queueItem = queue;
ReconcileStudyWorkQueueData data = XmlUtils.Deserialize<ReconcileStudyWorkQueueData>(queue.Details);
_conflictingImageDetails = data.Details;
_conflictingImageDescriptor = XmlUtils.Deserialize<ImageSetDescriptor>(queue.StudyData);
StudyStorage storage = StudyStorage.Load(HttpContextData.Current.ReadContext, queue.StudyStorageKey);
Study study = storage.LoadStudy(HttpContextData.Current.ReadContext);
_existingStudyInfo = new StudyInformation(new ServerEntityAttributeProvider(study));
}
private string GetSIQItemStorageFolder(StudyIntegrityQueue queue)
{
if (queue.StudyIntegrityReasonEnum.Equals(StudyIntegrityReasonEnum.InconsistentData))
{
ReconcileStudyWorkQueueData data = XmlUtils.Deserialize<ReconcileStudyWorkQueueData>(queue.Details);
DirectoryInfo dir = new DirectoryInfo(data.StoragePath);
return dir.Parent.FullName;
}
if (queue.StudyIntegrityReasonEnum.Equals(StudyIntegrityReasonEnum.Duplicate))
{
DuplicateSIQQueueData data = XmlUtils.Deserialize<DuplicateSIQQueueData>(queue.Details);
DirectoryInfo dir = new DirectoryInfo(data.StoragePath);
return dir.Parent.FullName;
}
return null;
}
public new static DuplicateSopReceivedQueue Load(IPersistenceContext context, ServerEntityKey key)
{
return(new DuplicateSopReceivedQueue(StudyIntegrityQueue.Load(context, key)));
}
