public BookmarkCollection Import(string path)
{
var bookmarksTxt = TxtToListConverter.Convert(path);
bookmarksTxt.RemoveAll(x => BadTexts(x));
var result = new BookmarkCollection
{
FullPath = path,
Bookmarks = new List <Bookmark>()
};
for (int bookmarksTxtIndex = 0; bookmarksTxtIndex < bookmarksTxt.Count - 1; bookmarksTxtIndex += 2)
{
var bookmarkTxt = bookmarksTxt[bookmarksTxtIndex];
if (!IsMetadataLine(bookmarkTxt))
{
throw new InvalidOperationException($"{bookmarkTxt} wasn't metadata.");
}
BookmarkMetadata metadata = VoiceBookmarkMetadataConverter.Convert(bookmarkTxt);
bookmarkTxt = bookmarksTxt[bookmarksTxtIndex + 1];
result.Bookmarks.Add(new Bookmark
{
Text = bookmarkTxt,
Metadata = metadata
});
}
return(result);
}
public bool AddBookmark(Type viewModelType, string uniqueName, BookmarkMetadata metadata, IDictionary <string, string> navigationArgs)
{
if (HasBookmark(uniqueName))
{
return(UpdateBookmark(uniqueName, metadata));
}
var liveTileData = ToTileData(metadata);
var navigationUri =
this.GetService <IMvxWindowsPhoneViewModelRequestTranslator>().GetXamlUriFor(new MvxShowViewModelRequest(viewModelType, navigationArgs, false, MvxRequestedBy.Bookmark));
// we sneak in an extra parameter here - our unique name
var navigationUri2 = new Uri(
string.Format("{0}{1}{2}={3}",
navigationUri.ToString(),
navigationUri.ToString().Contains("?") ? "&" : "?",
UniqueIdParameterName,
uniqueName),
UriKind.Relative);
ShellTile.Create(navigationUri2, liveTileData);
return(true);
}
public BookmarkCollection Import(string path)
{
var bookmarksTxt = TxtToListConverter.Convert(path);
var result = new BookmarkCollection
{
FullPath = path,
Bookmarks = new List <Bookmark>()
};
for (int bookmarksTxtIndex = 0; bookmarksTxtIndex < bookmarksTxt.Count - 1; bookmarksTxtIndex += 1)
{
var bookmarkTxt = bookmarksTxt[bookmarksTxtIndex];
BookmarkMetadata metadata = new BookmarkMetadata
{
Colour = HighlightType.Color1,
Text = bookmarkTxt
};
result.Bookmarks.Add(new Bookmark
{
Text = bookmarkTxt,
Metadata = metadata
});
}
return(result);
}
protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
{
var method = System.Reflection.MethodBase.GetCurrentMethod().Name;
pCancelBookmarkCreation = false;
_logger.Log(EventSeverity.Debug, method,
string.Format("[{0}] Enter: Processing UnitId: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
Thread.CurrentThread.ManagedThreadId,
PlanUid.Get(context), BookmarkName, _processDose.ConstructedBy));
var metadata = _processDose.BuildReferencedPlanMonitorMetadata(PlanUid.Get(context));
//
// If the dataset we are planning to wait is already available
// skip the bookmark creation and proceed to next activity.
//
if (_waitDataWrapper.IsDataAvailable(metadata))
{
pCancelBookmarkCreation = true;
var dcmInstanceId = _processDose.GetReferencePlanDcmInstanceId(PlanUid.Get(context));
OutRTPlanUnitId.Set(context, dcmInstanceId);
}
else
{
BookmarkMetadata.Set(context, metadata.ToString());
_waitDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing UnitId: [{1}], Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, PlanUid.Get(context), BookmarkName));
}
public bool UpdateBookmark(string uniqueName, BookmarkMetadata metadata)
{
var tile = FindShellTileFor(uniqueName);
if (tile == null)
{
return(false);
}
tile.Update(ToTileData(metadata));
return(true);
}
protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
{
var method = System.Reflection.MethodBase.GetCurrentMethod().Name;
bool validRefForSequenceInSS = true;
pCancelBookmarkCreation = false;
_logger.Log(EventSeverity.Debug, method,
string.Format("[{0}] Enter: Processing UnitId: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
Thread.CurrentThread.ManagedThreadId,
UnitId.Get(context), BookmarkName, _processSS.ConstructedBy));
var refStudyInfo = _processSS.GetReferencedStudyInfo(Int32.Parse(UnitId.Get(context)));
foreach (var tuple in refStudyInfo)
{
string refForUid = _processSS.GetReferencedFrameOfRefUid(Int32.Parse(UnitId.Get(context)));
var metadata = _processSS.BuildMonitorMetadata(tuple.Item2, tuple.Item3, refForUid);
//
// If the dataset we are planning to wait is already available
// skip the bookmark creation and proceed to next activity.
//
if (_waitSetDataWrapper.IsDataAvailable(metadata))
{
pCancelBookmarkCreation = true;
OutUnitId.Set(context, UnitId.Get(context));
//if (!base._useQueryNotificationFor3DWorkflows)
//{
// if (!String.IsNullOrEmpty(metadata.DataMonitoringEventId))
// {
// WaitEventManager.TryRemoveEvent(metadata.DataMonitoringEventId);
// }
//}
}
else
{
BookmarkMetadata.Set(context, metadata.ToString());
if (base._useQueryNotificationFor3DWorkflows)
{
_waitSetDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
else
{
_waitSetDataWrapper.InitiateWaitForDataEvent(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
}
}
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing UnitId: [{1}], Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), BookmarkName));
}
protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
{
var method = System.Reflection.MethodBase.GetCurrentMethod().Name;
pCancelBookmarkCreation = false;
_logger.Log(EventSeverity.Debug, method,
string.Format("[{0}] Enter: Processing RPSUid: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
Thread.CurrentThread.ManagedThreadId,
RPSUid.Get(context), BookmarkName, _processSpatialRegistrationObject.ConstructedBy));
var metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForRPSData(RPSUid.Get(context));
//
// If the dataset we are planning to wait is already available
// skip the bookmark creation and proceed to next activity.
//
if (_waitDataWrapper.IsDataAvailable(metadata))
{
pCancelBookmarkCreation = true;
var dcmInstanceId = _processSpatialRegistrationObject.GetRPSDcmInstanceId(RPSUid.Get(context));
OutRPSUnitId.Set(context, dcmInstanceId);
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] IsDataAvailable(): Processing RPSUid: [{1}], Bookmark name: [{2}], RPS already available : Id [{3}]",
Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), BookmarkName, dcmInstanceId));
//if (!base._useQueryNotificationFor3DWorkflows)
//{
// if (!String.IsNullOrEmpty(metadata.DataMonitoringEventId))
// {
// WaitEventManager.TryRemoveEvent(metadata.DataMonitoringEventId);
// }
//}
}
else
{
BookmarkMetadata.Set(context, metadata.ToString());
if (base._useQueryNotificationFor3DWorkflows)
{
_waitDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
else
{
_waitDataWrapper.InitiateWaitForDataEvent(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
}
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing RPSUid: [{1}], Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, RPSUid.Get(context), BookmarkName));
}
private static StandardTileData ToTileData(BookmarkMetadata metadata)
{
var liveTileData = new StandardTileData
{
BackgroundImage = metadata.BackgroundImageUri,
Title = metadata.Title,
BackTitle = metadata.BackTitle,
BackContent = metadata.BackContent,
BackBackgroundImage = metadata.BackBackgroundImageUri,
Count = metadata.Count
};
return(liveTileData);
}
protected override void OnAddToWorklist(NativeActivityContext context, Guid instanceId)
{
var method = System.Reflection.MethodBase.GetCurrentMethod().Name;
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Enter: Processing UnitId: [{1}], Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), BookmarkName));
var bookmarkManager = context.GetExtension <IQWorklistManager>();
string bookmarkDesc = BookmarkDesc.Get(context);
bookmarkDesc = String.IsNullOrEmpty(bookmarkDesc) ? String.Empty : bookmarkDesc.Trim();
bookmarkManager.AddWorklistItem(BookmarkName, IQBookmarkType.DBMonitor, bookmarkDesc, BookmarkMetadata.Get(context));
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing UnitId: [{1}], Context Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), BookmarkName));
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="pCancelBookmarkCreation"></param>
protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
{
var method = System.Reflection.MethodBase.GetCurrentMethod().Name;
pCancelBookmarkCreation = false;
_logger.Log(EventSeverity.Debug, method,
string.Format("[{0}] Enter: Processing UnitId: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
Thread.CurrentThread.ManagedThreadId,
UnitId.Get(context), BookmarkName, _processSpatialRegistrationObject.ConstructedBy));
string verificationForUid = _processSpatialRegistrationObject.GetReferencedFrameOfReferenceInfo(Int32.Parse(UnitId.Get(context)));
var metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForStructureSetData(verificationForUid);
//
// If the dataset we are planning to wait is already available
// skip the bookmark creation and proceed to next activity.
//
if (_waitDataWrapper.IsDataAvailable(metadata))
{
pCancelBookmarkCreation = true;
string referencedSiteId = _processSpatialRegistrationObject.GetReferencedSiteId(Int32.Parse(UnitId.Get(context)));
if (referencedSiteId != "")
{
//get DcmInstanceId of planning structure set. The verification FrameofRefUid is
//passed as an argument but is redundant. (confusing also)
var tmpList = _processSpatialRegistrationObject.GetReferenceStructureSetDcmInstances(verificationForUid, referencedSiteId, Int32.Parse(UnitId.Get(context)));
foreach (string rtssId in tmpList)
{
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Found structure set id: [{2}]",
Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), rtssId));
}
OutStructureSetIds.Set(context, tmpList);
OutUnitId.Set(context, UnitId.Get(context));
//if (!base._useQueryNotificationFor3DWorkflows)
//{
// if (!String.IsNullOrEmpty(metadata.DataMonitoringEventId))
// {
// WaitEventManager.TryRemoveEvent(metadata.DataMonitoringEventId);
// }
//}
}
}
else
{
BookmarkMetadata.Set(context, metadata.ToString());
if (base._useQueryNotificationFor3DWorkflows)
{
_waitDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
else
{
_waitDataWrapper.InitiateWaitForDataEvent(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
}
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing UnitId: [{1}], Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), BookmarkName));
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="pCancelBookmarkCreation"></param>
protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
{
var method = System.Reflection.MethodBase.GetCurrentMethod().Name;
pCancelBookmarkCreation = false;
_logger.Log(EventSeverity.Debug, method,
string.Format("[{0}] Enter: Processing UnitId: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
Thread.CurrentThread.ManagedThreadId,
UnitId.Get(context), BookmarkName, _processSpatialRegistrationObject.ConstructedBy));
var registrationType = SpatialRegistrationObjectType.Get(context);
var planningSopInstanceUids = PlanningImageSopInstanceValues.Get(context);
switch (registrationType)
{
case "2D":
var ref2DImageInfo = _processSpatialRegistrationObject.GetReferenced2DImageInfo(Int32.Parse(UnitId.Get(context)), planningSopInstanceUids);
foreach (var tuple in ref2DImageInfo)
{
foreach (string refSopInstanceUid in tuple.Item2)
{
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Looking for IMG with SOP Instance: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), refSopInstanceUid));
}
var metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForReferencedImageData(tuple.Item1, tuple.Item2);
IList <int> imageIds = new List <int>();
//
// If the dataset we are planning to wait is already available
// skip the bookmark creation and proceed to next activity.
//
if (_waitSetDataWrapper.IsDataAvailable(metadata))
{
pCancelBookmarkCreation = true;
_processSpatialRegistrationObject.GetReferencedImageIds(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
if (imageIds.Count > 0)
{
foreach (int image_id in imageIds)
{
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Found Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), image_id.ToString()));
}
}
if (imageIds.Count == 0)
{
_logger.Log(EventSeverity.Error, method, string.Format("[{0}] Processing UnitId: [{1}], Image Id list was not set correctly", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context)));
ActivityStatus.Set(context, "FAILED");
}
else
{
ActivityStatus.Set(context, "SUCCESS");
}
VerificationImageIds.Set(context, imageIds);
OutUnitId.Set(context, UnitId.Get(context));
}
else
{
// Perform manual processing to see which images are currently available
// This needs to handle 1-N cases
_processSpatialRegistrationObject.GetReferencedImageIds(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
// based on that result set, set the bookmark if we are still missing some data
if (imageIds.Count < VerificationImageSopInstanceValues.Get(context).Count)
{
BookmarkMetadata.Set(context, metadata.ToString());
_waitSetDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
metadata,
_waitHandlersRepository.Get("WorkQueueElement"));
}
}
}
break;
case "3D":
var ref3DImageInfo = _processSpatialRegistrationObject.GetReferenced3DImageInfo(Int32.Parse(UnitId.Get(context)), planningSopInstanceUids);
int i = 0;
foreach (var tuple in ref3DImageInfo)
{
if (tuple.Item2.Count == 0)
{
continue;
}
foreach (string refSopInstanceUid in tuple.Item3)
{
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Looking for DCM SOP Instance: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), refSopInstanceUid));
}
string verForUid = string.Empty;
if (!base._useQueryNotificationFor3DWorkflows)
{
verForUid = _processSpatialRegistrationObject.GetReferencedFrameOfReferenceInfo(Int32.Parse(UnitId.Get(context)));
}
var metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForReferencedDicomData(tuple.Item1, tuple.Item2[i], verForUid, tuple.Item3);
//
// If the dataset we are planning to wait is already available
// skip the bookmark creation and proceed to next activity.
//
if (_waitSetDataWrapper.IsDataAvailable(metadata))
{
pCancelBookmarkCreation = true;
IList <int> imageIds = new List <int>();
_processSpatialRegistrationObject.GetReferencedImageIdsFromSOPInstanceUIDs(Int32.Parse(UnitId.Get(context)), VerificationImageSopInstanceValues.Get(context), ref imageIds);
foreach (int image_id in imageIds)
{
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing UnitId: [{1}], Found Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), image_id.ToString()));
}
if (imageIds.Count == 0)
{
_logger.Log(EventSeverity.Error, method, string.Format("[{0}] Processing UnitId: [{1}], Image Id list was not set correctly", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context)));
ActivityStatus.Set(context, "FAILED");
}
else
{
ActivityStatus.Set(context, "SUCCESS");
}
VerificationImageIds.Set(context, imageIds);
OutUnitId.Set(context, UnitId.Get(context));
//if (!base._useQueryNotificationFor3DWorkflows)
//{
// if (!String.IsNullOrEmpty(metadata.DataMonitoringEventId))
// {
// WaitEventManager.TryRemoveEvent(metadata.DataMonitoringEventId);
// }
//}
}
else
{
BookmarkMetadata.Set(context, metadata.ToString());
if (base._useQueryNotificationFor3DWorkflows)
{
_waitSetDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
else
{
_waitSetDataWrapper.InitiateWaitForDataEvent(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
}
i++;
}
break;
}
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing UnitId: [{1}], Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), BookmarkName));
}
/// <summary>
///
/// </summary>
/// <param name="context"></param>
/// <param name="pCancelBookmarkCreation"></param>
protected override void OnBeforeCreateBookmark(NativeActivityContext context, out bool pCancelBookmarkCreation)
{
var method = System.Reflection.MethodBase.GetCurrentMethod().Name;
pCancelBookmarkCreation = false;
_logger.Log(EventSeverity.Debug, method,
string.Format("[{0}] Enter: Processing SRO UnitId: [{1}], Bookmark name: [{2}], Extension Recorded Id:[{3}]",
Thread.CurrentThread.ManagedThreadId,
UnitId.Get(context), BookmarkName, _processSpatialRegistrationObject.ConstructedBy));
var planningSopInstanceUids = PlanningImageSopInstanceUidValues.Get(context);
var verificationSopInstanceUids = VerificationImageSopInstanceUidValues.Get(context);
// we want to wait for both planning and verification instances
//IList<string> instanceUidsToWaitFor =
// planningSopInstanceUids.Concat(verificationSopInstanceUids).ToList();
string verForUid = string.Empty;
if (!base._useQueryNotificationFor3DWorkflows)
{
verForUid = _processSpatialRegistrationObject.GetLocalizationFrameOfRefFromXVISRO(Int32.Parse(UnitId.Get(context)));
}
var metadata = _processSpatialRegistrationObject.BuildMonitorMetadataForXVI5xReferencedDicomData(verForUid, verificationSopInstanceUids);
//
// If the dataset we are planning to wait for is already available
// skip the bookmark creation and proceed to next activity.
//
if (_waitSetDataWrapper.IsDataAvailable(metadata))
{
pCancelBookmarkCreation = true;
// get the Image IDs for the Verification and Planning images
IList <int> verifImageIds = new List <int>();
_processSpatialRegistrationObject.GetReferencedImageIdsFromSOPInstanceUIDs(Int32.Parse(UnitId.Get(context)),
VerificationImageSopInstanceUidValues.Get(context), ref verifImageIds);
IList <int> planningImageIds = new List <int>();
_processSpatialRegistrationObject.GetReferencedImageIdsFromSOPInstanceUIDs(Int32.Parse(UnitId.Get(context)),
PlanningImageSopInstanceUidValues.Get(context), ref planningImageIds);
// (NB for an XVI 5x SRO we only expect a single Planning image & a single Verification image
if (verifImageIds.Count != 1 || planningImageIds.Count != 1)
{
_logger.Log(EventSeverity.Error, method, string.Format("[{0}] Processing UnitId: [{1}], Verification and/or Planning Image Ids were not correctly found", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context)));
ActivityStatus.Set(context, "FAILED");
}
else
{
ActivityStatus.Set(context, "SUCCESS");
}
foreach (int imageId in verifImageIds)
{
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing SRO UnitId: [{1}], Found Verification Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), imageId.ToString()));
}
foreach (int imageId in planningImageIds)
{
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Processing SRO UnitId: [{1}], Found Planning Image ID: [{2}]", Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), imageId.ToString()));
}
PlanningImageIds.Set(context, planningImageIds);
VerificationImageIds.Set(context, verifImageIds);
OutUnitId.Set(context, UnitId.Get(context));
//if (!base._useQueryNotificationFor3DWorkflows)
//{
// if (!String.IsNullOrEmpty(metadata.DataMonitoringEventId))
// {
// WaitEventManager.TryRemoveEvent(metadata.DataMonitoringEventId);
// }
//}
}
else
{
BookmarkMetadata.Set(context, metadata.ToString());
if (base._useQueryNotificationFor3DWorkflows)
{
_waitSetDataWrapper.InitiateWaitForData(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
else
{
_waitSetDataWrapper.InitiateWaitForDataEvent(context.WorkflowInstanceId, BookmarkName,
metadata, _waitHandlersRepository.Get("WorkQueueElement"));
}
}
_logger.Log(EventSeverity.Debug, method, string.Format("[{0}] Exit: Processing SRO UnitId: [{1}], Bookmark name: [{2}]",
Thread.CurrentThread.ManagedThreadId, UnitId.Get(context), BookmarkName));
}
