/// <summary>
/// Creates an instance of <see cref="StudyDetails"/> base on a <see cref="Study"/> object.
/// </summary>
/// <param name="study"></param>
/// <returns></returns>
public StudyDetails CreateStudyDetail(Study study)
{
var details = new StudyDetails();
details.StudyInstanceUID = study.StudyInstanceUid;
details.PatientName = study.PatientsName;
details.AccessionNumber = study.AccessionNumber;
details.PatientID = study.PatientId;
details.StudyDescription = study.StudyDescription;
details.StudyDate = study.StudyDate;
details.StudyTime = study.StudyTime;
var controller = new StudyController();
using (IReadContext ctx = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
{
details.Modalities = controller.GetModalitiesInStudy(ctx, study);
}
if (study.StudyInstanceUid != null)
{
StudyStorage storages = StudyStorage.Load(study.StudyStorageKey);
if (storages != null)
{
details.WriteLock = storages.WriteLock;
details.ReadLock = storages.ReadLock;
details.Status = storages.StudyStatusEnum.ToString();
}
}
return details;
}
public IList<Series> GetSeries(Study study)
{
SeriesSelectCriteria criteria = new SeriesSelectCriteria();
criteria.StudyKey.EqualTo(study.Key);
return _seriesAdaptor.Get(criteria);
}
public ValidationStudyInfo(Study theStudy, ServerPartition partition)
{
ServerAE = partition.AeTitle;
PatientsName = theStudy.PatientsName;
PatientsId = theStudy.PatientId;
StudyInstaneUid = theStudy.StudyInstanceUid;
AccessionNumber = theStudy.AccessionNumber;
StudyDate = theStudy.StudyDate;
}
/// <summary>
/// Loads the related <see cref="Study"/> entity.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private Study LoadStudy(IPersistenceContext context)
{
if (_study == null)
{
lock (SyncRoot)
{
_study = Study.Find(context, StudyStorageKey);
}
}
return _study;
}
private void DoSeriesLevelValidation(StudyStorageLocation storageLocation, StudyXml studyXml, Study study)
{
IDictionary<string, Series> seriesList = study.Series;
foreach (var entry in seriesList)
{
Series series = entry.Value;
SeriesXml seriesXml = studyXml[series.SeriesInstanceUid];
ValidateSeries(storageLocation, series, seriesXml);
}
}
/// <summary>
/// Loads the related <see cref="Study"/> entity.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public Study LoadStudy(IPersistenceContext context)
{
StudyStorage storage = LoadStudyStorage(context);
if (_study == null)
{
lock (_syncLock)
{
_study = storage.LoadStudy(context);
}
}
return _study;
}
private void LoadAdditionalEntities()
{
Debug.Assert(ServerPartition != null);
Debug.Assert(StorageLocation != null);
using (ServerExecutionContext context = new ServerExecutionContext())
{
if (_filesystem != null)
_filesystem = FilesystemMonitor.Instance.GetFilesystemInfo(StorageLocation.FilesystemKey);
_study = StorageLocation.LoadStudy(context.ReadContext);
_patient = Patient.Load(context.ReadContext, _study.PatientKey);
}
}
/// <summary>
/// Returns an instance of <see cref="PatientSummary"/> for a <see cref="Study"/>.
/// </summary>
/// <param name="study"></param>
/// <returns></returns>
/// <remark>
///
/// </remark>
static public PatientSummary CreatePatientSummary(Study study)
{
PatientSummary patient = new PatientSummary();
patient.PatientId = study.PatientId;
patient.Birthdate = study.PatientsBirthDate;
patient.PatientName = study.PatientsName;
patient.Sex = study.PatientsSex;
PatientAdaptor adaptor = new PatientAdaptor();
Patient pat = adaptor.Get(study.PatientKey);
patient.IssuerOfPatientId = pat.IssuerOfPatientId;
return patient;
}
public Study GetStudy()
{
if (_study == null)
{
lock (SyncRoot)
{
using (var context = new ServerExecutionContext())
{
_study = LoadStudy(context.ReadContext);
}
}
}
return _study;
}
private void LoadRelatedEntities()
{
if (_study==null || _studyStorage==null)
{
using (var context = new ServerExecutionContext())
{
lock (SyncRoot)
{
if (_study == null)
_study = LoadStudy(context.ReadContext);
if (_studyStorage == null)
_studyStorage = LoadStudyStorage(context.ReadContext);
}
}
}
}
public Study GetStudy()
{
if (_study == null)
{
lock (SyncRoot)
{
// TODO: Use ExecutionContext to re-use db connection if possible
// This however requires breaking the Common --> Model dependency.
using (IReadContext readContext = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
{
_study = LoadStudy(readContext);
}
}
}
return _study;
}
private void LoadRelatedEntities()
{
if (_study==null || _studyStorage==null)
{
using (IReadContext context = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
{
lock (SyncRoot)
{
if (_study == null)
_study = LoadStudy(context);
if (_studyStorage == null)
_studyStorage = LoadStudyStorage(context);
}
}
}
}
private void LoadRelatedEntities()
{
if (_study == null || _studyStorage == null)
{
using (var context = new ServerExecutionContext())
{
lock (SyncRoot)
{
if (_study == null)
{
_study = LoadStudy(context.ReadContext);
}
if (_studyStorage == null)
{
_studyStorage = LoadStudyStorage(context.ReadContext);
}
}
}
}
}
private void LoadRelatedEntities()
{
if (_study == null || _studyStorage == null)
{
using (IReadContext context = PersistentStoreRegistry.GetDefaultStore().OpenReadContext())
{
lock (SyncRoot)
{
if (_study == null)
{
_study = LoadStudy(context);
}
if (_studyStorage == null)
{
_studyStorage = LoadStudyStorage(context);
}
}
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="thePartition"></param>
/// <param name="location"></param>
/// <param name="thePatient"></param>
/// <param name="theStudy"></param>
public StudyEditor(ServerPartition thePartition, StudyStorageLocation location, Patient thePatient, Study theStudy, WorkQueue workQueue)
{
FailureReason = string.Empty;
Platform.CheckForNullReference(thePartition, "thePartition");
Platform.CheckForNullReference(location, "location");
Platform.CheckForNullReference(thePatient, "thePatient");
Platform.CheckForNullReference(theStudy, "theStudy");
ServerPartition = thePartition;
StorageLocation = location;
Patient = thePatient;
Study = theStudy;
_workQueue = workQueue;
// Scrub for invalid characters that may cause a failure when the Xml is generated for the history
Patient.PatientId = XmlUtils.XmlCharacterScrub(Patient.PatientId);
Patient.PatientsName = XmlUtils.XmlCharacterScrub(Patient.PatientsName);
Study.StudyDescription = XmlUtils.XmlCharacterScrub(Study.StudyDescription);
Study.ReferringPhysiciansName = XmlUtils.XmlCharacterScrub(Study.ReferringPhysiciansName);
Study.PatientId = XmlUtils.XmlCharacterScrub(Study.PatientId);
Study.PatientsName = XmlUtils.XmlCharacterScrub(Study.PatientsName);
}
static public Study Insert(IUpdateContext update, Study entity)
{
var broker = update.GetBroker <IStudyEntityBroker>();
var updateColumns = new StudyUpdateColumns();
updateColumns.StudyInstanceUid = entity.StudyInstanceUid;
updateColumns.ServerPartitionKey = entity.ServerPartitionKey;
updateColumns.PatientKey = entity.PatientKey;
updateColumns.NumberOfStudyRelatedSeries = entity.NumberOfStudyRelatedSeries;
updateColumns.NumberOfStudyRelatedInstances = entity.NumberOfStudyRelatedInstances;
updateColumns.QCStatusEnum = entity.QCStatusEnum;
updateColumns.QCOutput = entity.QCOutput;
updateColumns.QCUpdateTimeUtc = entity.QCUpdateTimeUtc;
updateColumns.OrderKey = entity.OrderKey;
updateColumns.StudySizeInKB = entity.StudySizeInKB;
updateColumns.ResponsiblePerson = entity.ResponsiblePerson;
updateColumns.ResponsibleOrganization = entity.ResponsibleOrganization;
updateColumns.QueryXml = entity.QueryXml;
updateColumns.SpecificCharacterSet = entity.SpecificCharacterSet;
updateColumns.StudyStorageKey = entity.StudyStorageKey;
updateColumns.PatientsName = entity.PatientsName;
updateColumns.PatientId = entity.PatientId;
updateColumns.IssuerOfPatientId = entity.IssuerOfPatientId;
updateColumns.PatientsBirthDate = entity.PatientsBirthDate;
updateColumns.PatientsAge = entity.PatientsAge;
updateColumns.PatientsSex = entity.PatientsSex;
updateColumns.StudyDate = entity.StudyDate;
updateColumns.StudyTime = entity.StudyTime;
updateColumns.AccessionNumber = entity.AccessionNumber;
updateColumns.StudyId = entity.StudyId;
updateColumns.StudyDescription = entity.StudyDescription;
updateColumns.ReferringPhysiciansName = entity.ReferringPhysiciansName;
Study newEntity = broker.Insert(updateColumns);
return(newEntity);
}
public int GetCountPendingWorkQueueItems(Study study)
{
Platform.CheckForNullReference(study, "Study");
var adaptor = new WorkQueueAdaptor();
var workQueueCriteria = new WorkQueueSelectCriteria();
workQueueCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey);
workQueueCriteria.WorkQueueStatusEnum.In(new [] {WorkQueueStatusEnum.Idle, WorkQueueStatusEnum.InProgress, WorkQueueStatusEnum.Pending});
return adaptor.GetCount(workQueueCriteria);
}
public IList<WorkQueue> GetWorkQueueItems(Study study)
{
Platform.CheckForNullReference(study, "Study");
WorkQueueAdaptor adaptor = new WorkQueueAdaptor();
WorkQueueSelectCriteria workQueueCriteria = new WorkQueueSelectCriteria();
workQueueCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey);
workQueueCriteria.ScheduledTime.SortAsc(0);
return adaptor.Get(workQueueCriteria);
}
/// <summary>
/// Returns a value indicating whether the specified study has been scheduled for delete.
/// </summary>
/// <param name="study"></param>
/// <param name="read"></param>
/// <returns></returns>
public string GetModalitiesInStudy(IPersistenceContext read, Study study)
{
Platform.CheckForNullReference(study, "Study");
IQueryModalitiesInStudy select = read.GetBroker<IQueryModalitiesInStudy>();
ModalitiesInStudyQueryParameters parms = new ModalitiesInStudyQueryParameters { StudyKey = study.Key };
IList<Series> seriesList = select.Find(parms);
List<string> modalities = new List<string>();
foreach (Series series in seriesList)
{
bool found = false;
foreach (string modality in modalities)
if (modality.Equals(series.Modality))
{
found = true;
break;
}
if (!found)
modalities.Add(series.Modality);
}
string modalitiesInStudy = "";
foreach (string modality in modalities)
if (modalitiesInStudy.Length == 0)
modalitiesInStudy = modality;
else
modalitiesInStudy += "\\" + modality;
return modalitiesInStudy;
}
/// <summary>
/// Returns a value indicating whether the specified study has been scheduled for delete.
/// </summary>
/// <param name="study"></param>
/// <param name="workQueueType"></param>
/// <returns></returns>
private static bool IsStudyInWorkQueue(Study study, WorkQueueTypeEnum workQueueType)
{
Platform.CheckForNullReference(study, "Study");
WorkQueueAdaptor adaptor = new WorkQueueAdaptor();
WorkQueueSelectCriteria workQueueCriteria = new WorkQueueSelectCriteria();
workQueueCriteria.WorkQueueTypeEnum.EqualTo(workQueueType);
workQueueCriteria.ServerPartitionKey.EqualTo(study.ServerPartitionKey);
workQueueCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey);
workQueueCriteria.WorkQueueStatusEnum.EqualTo(WorkQueueStatusEnum.Pending);
IList<WorkQueue> list = adaptor.Get(workQueueCriteria);
if (list != null && list.Count > 0)
return true;
workQueueCriteria.WorkQueueStatusEnum.EqualTo(WorkQueueStatusEnum.Idle); // not likely but who knows
list = adaptor.Get(workQueueCriteria);
if (list != null && list.Count > 0)
return true;
return false;
}
public IList<StudyStorageLocation> GetStudyStorageLocation(Study study)
{
Platform.CheckForNullReference(study, "Study");
IQueryStudyStorageLocation select = HttpContext.Current.GetSharedPersistentContext().GetBroker<IQueryStudyStorageLocation>();
StudyStorageLocationQueryParameters parms = new StudyStorageLocationQueryParameters
{StudyStorageKey = study.StudyStorageKey};
IList<StudyStorageLocation> storage = select.Find(parms);
if (storage == null)
{
storage = new List<StudyStorageLocation>();
Platform.Log(LogLevel.Warn, "Unable to find storage location for Study item: {0}",
study.GetKey().ToString());
}
if (storage.Count > 1)
{
Platform.Log(LogLevel.Warn,
"StudyController:GetStudyStorageLocation: multiple study storage found for study {0}",
study.GetKey().Key);
}
return storage;
}
public int GetArchiveQueueCount(Study study)
{
Platform.CheckForNullReference(study, "Study");
ArchiveQueueAdaptor adaptor = new ArchiveQueueAdaptor();
ArchiveQueueSelectCriteria archiveQueueCriteria = new ArchiveQueueSelectCriteria();
archiveQueueCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey);
archiveQueueCriteria.ScheduledTime.SortDesc(0);
return adaptor.GetCount(archiveQueueCriteria);
}
public int GetCountPendingExternalEditWorkQueueItems(Study study)
{
Platform.CheckForNullReference(study, "Study");
var adaptor = new WorkQueueAdaptor();
var workQueueCriteria = new WorkQueueSelectCriteria();
workQueueCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey);
workQueueCriteria.WorkQueueTypeEnum.EqualTo(WorkQueueTypeEnum.ExternalEdit);
return adaptor.GetCount(workQueueCriteria);
}
public bool MoveStudy(Study study, Device device)
{
return MoveStudy(study, device, null);
}
/// <summary>
/// Restore a nearline study.
/// </summary>
/// <param name="study">The <see cref="Study"/> to restore.</param>
/// <returns>true on success, false on failure.</returns>
public bool RestoreStudy(Study study)
{
return _partitionArchiveAdaptor.RestoreStudy(study);
}
public Study LoadStudy(IPersistenceContext context)
{
return(Study.Find(context, StudyInstanceUid, ServerPartition));
}
public IList<FilesystemQueue> GetFileSystemQueueItems(Study study)
{
Platform.CheckForNullReference(study, "Study");
FileSystemQueueAdaptor adaptor = new FileSystemQueueAdaptor();
FilesystemQueueSelectCriteria fileSystemQueueCriteria = new FilesystemQueueSelectCriteria();
fileSystemQueueCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey);
fileSystemQueueCriteria.ScheduledTime.SortAsc(0);
return adaptor.Get(fileSystemQueueCriteria);
}
public void EditStudy(Study study, List<UpdateItem> updateItems, string reason)
{
Platform.Log(LogLevel.Info, String.Format("Editing study {0}", study.StudyInstanceUid));
using (IUpdateContext ctx = PersistentStoreRegistry.GetDefaultStore().OpenUpdateContext(UpdateContextSyncMode.Flush))
{
IList<WorkQueue> entries = StudyEditorHelper.EditStudy(ctx, study.StudyStorageKey, updateItems, reason, ServerHelper.CurrentUserName, EditType.WebEdit);
if (entries!=null)
ctx.Commit();
}
}
public IList<ArchiveStudyStorage> GetArchiveStudyStorage(Study study)
{
Platform.CheckForNullReference(study, "Study");
ArchiveStudyStorageAdaptor adaptor = new ArchiveStudyStorageAdaptor();
ArchiveStudyStorageSelectCriteria archiveStudyStorageCriteria = new ArchiveStudyStorageSelectCriteria();
archiveStudyStorageCriteria.StudyStorageKey.EqualTo(study.StudyStorageKey);
archiveStudyStorageCriteria.ArchiveTime.SortDesc(0);
return adaptor.Get(archiveStudyStorageCriteria);
}
public bool UpdateStudy(Study study, StudyUpdateColumns columns)
{
return _adaptor.Update(study.Key, columns);
}
public StudyStorage GetStudyStorage(Study study)
{
Platform.CheckForNullReference(study, "Study");
return StudyStorage.Load(study.StudyStorageKey);
}
public bool IsScheduledForEdit(Study study)
{
return IsStudyInWorkQueue(study, WorkQueueTypeEnum.WebEditStudy);
}
public bool MoveStudy(Study study, Device device, IList<Series> seriesList)
{
if (seriesList != null)
{
using (
IUpdateContext context = PersistentStoreRegistry.GetDefaultStore().OpenUpdateContext(UpdateContextSyncMode.Flush))
{
ServerPartition partition = ServerPartition.Load(study.ServerPartitionKey);
List<string> seriesUids = new List<string>();
foreach (Series series in seriesList)
{
seriesUids.Add(series.SeriesInstanceUid);
}
IList<WorkQueue> entries = StudyEditorHelper.MoveSeries(context, partition, study.StudyInstanceUid, device.Key, seriesUids);
if(entries != null) context.Commit();
return true;
}
}
WorkQueueAdaptor workqueueAdaptor = new WorkQueueAdaptor();
DateTime time = Platform.Time;
WorkQueueUpdateColumns columns = new WorkQueueUpdateColumns
{
WorkQueueTypeEnum = WorkQueueTypeEnum.WebMoveStudy,
WorkQueueStatusEnum = WorkQueueStatusEnum.Pending,
ServerPartitionKey = study.ServerPartitionKey,
StudyStorageKey = study.StudyStorageKey,
FailureCount = 0,
DeviceKey = device.Key,
ScheduledTime = time,
ExpirationTime = time.AddMinutes(4)
};
workqueueAdaptor.Add(columns);
return true;
}
public bool IsScheduledForDelete(Study study)
{
return IsStudyInWorkQueue(study, WorkQueueTypeEnum.WebDeleteStudy);
}
