// Token: 0x06001655 RID: 5717 RVA: 0x00027364 File Offset: 0x00026364
protected void OnStatusChanged(ActivityExecutionStatus status)
{
if (this.StatusChanged != null)
{
this.StatusChanged(this, status);
}
}
/// <summary>
/// Defines the processing procedure when the subscribed-to event occurs.
/// </summary>
/// <param name="sender">The object that raised the event.</param>
/// <param name="e">The previously typed event arguments.</param>
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e)
{
ActivityExecutionContext ctx = sender as ActivityExecutionContext;
if (ctx != null &&
this.ExecutionStatus == ActivityExecutionStatus.Executing)
{
try
{
ActivityExecutionStatus status = ProcessQueueElement(ctx);
if (status == ActivityExecutionStatus.Closed)
{
UnsubscribeFromQueueItemAvailable(ctx);
ctx.CloseActivity();
}
else if (status == ActivityExecutionStatus.Canceling)
{
UnsubscribeFromQueueItemAvailable(ctx);
ctx.CloseActivity();
throw new CustomWorkflowTerminateException(BusinessProcessExecutionResult.Declined);
}
}
finally
{
}
}
}
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException(SR.Error_SenderMustBeActivityExecutionContext, "sender");
}
if (e.ExecutionStatus == ActivityExecutionStatus.Closed)
{
// Remove status change subscription.
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
// Do it again if there are any more.
ActivityExecutionStatus status = CompensateTargetActivity(context);
if (status == ActivityExecutionStatus.Closed)
{
context.CloseActivity();
}
}
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
try
{
ActivityExecutionStatus result = base.Execute(executionContext);
// Pick off the last segment of the URL
string existingWebUrl;
string newWebUrl;
GetSiteAndWeb(SiteUrl, out existingWebUrl, out newWebUrl);
using (SPSite site = new SPSite(existingWebUrl))
{
using (SPWeb web = site.OpenWeb())
{
using (SPWeb newWeb = web.Webs.Add(newWebUrl, SiteTitle, SiteDescription, (uint)LocaleID, SiteTemplateId, UseUniquePermissions, ConvertIfExists))
{
// Make sure the new web is disposed if created
}
}
}
return(result);
}
catch (Exception e)
{
ISharePointService service = executionContext.GetService <ISharePointService>();
if (service != null)
{
service.LogToHistoryList(executionContext.ContextGuid, SPWorkflowHistoryEventType.WorkflowError, 0, TimeSpan.Zero, "Exception", "An exception occured in the Create Sub Site activity", e.ToString());
}
throw;
}
}
internal ActivityExecutionStatusChangedEventArgs(ActivityExecutionStatus executionStatus, ActivityExecutionResult executionResult, System.Workflow.ComponentModel.Activity activity)
{
this.status = executionStatus;
this.activityExecutionResult = executionResult;
this.activityQualifiedName = activity.QualifiedName;
this.stateId = activity.ContextActivity.ContextId;
}
public void ExecuteEmptyTopLevelSiteRelativeUrlTest()
{
SPSite fakeSite = Isolate.Fake.Instance <SPSite>(Members.ReturnRecursiveFakes);
Isolate.Swap.NextInstance <SPSite>().With(fakeSite);
SPWeb fakeWeb = fakeSite.RootWeb.Webs.Add("", "", "", uint.MinValue, "", false, false);
Isolate.WhenCalled(() => fakeWeb.Url).WillReturn("http://localhost/unittest");
SPPropertyBag fakePropertyBag = fakeWeb.Properties;
CreateSubSiteActivity_Accessor target = new CreateSubSiteActivity_Accessor();
target.BusinessEvent = "unittest";
target.BusinessEventId = "1";
target.BusinessEventIdKey = "unittestid";
target.SiteCollectionUrl = "http://localhost";
target.SiteTemplateName = "testtemplate";
ActivityExecutionContext executionContext = null;
ActivityExecutionStatus expected = new ActivityExecutionStatus();
expected = ActivityExecutionStatus.Closed;
ActivityExecutionStatus actual;
actual = target.Execute(executionContext);
Isolate.Verify.WasCalledWithAnyArguments(() => fakeSite.RootWeb.Webs.Add("", "", "", uint.MinValue, "", false, false));
Isolate.Verify.WasCalledWithExactArguments(() => fakePropertyBag["unittestid"] = "1");
Isolate.Verify.WasCalledWithAnyArguments(() => fakePropertyBag.Update());
Assert.AreEqual(target.SubSiteUrl, "http://localhost/unittest");
Assert.AreEqual(expected, actual);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
ActivityExecutionStatus result = base.Execute(executionContext);
try
{
// Get Web Application
SPWebApplication webApp = null;//GetWebApplicationForUrl(SiteUrl);
Uri siteUri = new Uri("SiteUrl");
// Create Site
using (SPSite newSite = webApp.Sites.Add(siteUri.PathAndQuery, "SiteTitle", "SiteDescription", (uint)123, "1234", OwnerLogon, OwnerName, OwnerEmail))
{
// Set Quota
if (!string.IsNullOrEmpty(QuotaName))
{
newSite.Quota = SPWebService.ContentService.QuotaTemplates[QuotaName];
}
}
}
catch (Exception e)
{
ISharePointService service = executionContext.GetService <ISharePointService>();
if (service != null)
{
service.LogToHistoryList(executionContext.ContextGuid, SPWorkflowHistoryEventType.WorkflowError, 0, TimeSpan.Zero, "Exception", "An exception occurred in the Create Site Collection activity", e.ToString());
}
throw;
}
return(result);
}
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
ActivityExecutionStatus status = ExecuteForActivity(executionContext, this.InterfaceType, this.MethodName);
if (status == ActivityExecutionStatus.Closed)
{
UnsubscribeForActivity(executionContext);
executionContext.CloseActivity();
return(status);
}
// cannot resolve queue name or message not available
// hence subscribe for message arrival
if (!this.ActivitySubscribed)
{
this.ActivitySubscribed = CorrelationService.Subscribe(executionContext, this, this.InterfaceType, this.MethodName, this, this.WorkflowInstanceId);
}
return(ActivityExecutionStatus.Executing);
}
internal bool TryTrackActivityEvent(Activity activity, ActivityExecutionStatus status, IServiceProvider provider, ActivityTrackingRecord record)
{
List <ActivityTrackPointCacheItem> points;
//
// Check the match caches.
if (TryGetCacheItems(activity, out points))
{
bool ret = false;
foreach (ActivityTrackPointCacheItem item in points)
{
if (item.HasLocationConditions)
{
if (!item.Point.IsMatch(activity, status))
{
continue;
}
}
if (item.Events.Contains(status))
{
ret = true;
item.Point.Track(activity, provider, record.Body);
record.Annotations.AddRange(item.Point.Annotations);
}
}
return(ret);
}
return(false);
}
internal ActivityExecutionStatusChangedEventArgs(ActivityExecutionStatus executionStatus, ActivityExecutionResult executionResult, Activity activity)
{
this.status = executionStatus;
this.activityExecutionResult = executionResult;
this.activityQualifiedName = activity.QualifiedName;
this.stateId = activity.ContextActivity.ContextId;
}
public ActivityExecutionStatusEvent ExecuteNewEventForActivity(ActivityExecutionStatus newExecutionStatus, User currentUser, string comments, DateTime?contextDate, string contextCode)
{
//if (CurrentActivity.CurrentStatus.Description == newExecutionStatus.Description) { return null; };
var activityExecutionStatusEvent = CurrentActivity.ExecuteEvent(newExecutionStatus, currentUser, comments, contextDate, contextCode);
switch (newExecutionStatus.Description)
{
case "CONFIRMED":
CheckIfAbleToChangeFromConfirmationActivity();
MoveToNextActivity(WorkFlow, currentUser);
break;
case "CAUSALITYCONFIRMED":
MoveToNextActivity(WorkFlow, currentUser);
AddCausalityConfirmedDomainEvent();
break;
case "E2BGENERATED":
AddE2BGeneratedDomainEvent();
break;
case "E2BSUBMITTED":
AddE2BSubmittedDomainEvent();
break;
default:
break;
}
return(activityExecutionStatusEvent);
}
internal ActivityExecutionStatusChangedEventArgs(ActivityExecutionStatus executionStatus, ActivityExecutionResult executionResult, System.Workflow.ComponentModel.Activity activity)
{
this.status = executionStatus;
this.activityExecutionResult = executionResult;
this.activityQualifiedName = activity.QualifiedName;
this.stateId = activity.ContextActivity.ContextId;
}
internal ActivityExecutionStatusChangedEventArgs(ActivityExecutionStatus executionStatus, ActivityExecutionResult executionResult, Activity activity)
{
this.status = executionStatus;
this.activityExecutionResult = executionResult;
this.activityQualifiedName = activity.QualifiedName;
this.stateId = activity.ContextActivity.ContextId;
}
internal bool IsMatch(Activity activity, ActivityExecutionStatus status)
{
bool flag = false;
foreach (ActivityTrackingLocation location in this._match)
{
if (location.Match(activity, false) && location.ExecutionStatusEvents.Contains(status))
{
flag = true;
break;
}
}
if (!flag)
{
return(false);
}
foreach (ActivityTrackingLocation location2 in this._exclude)
{
if (location2.Match(activity, false) && location2.ExecutionStatusEvents.Contains(status))
{
return(false);
}
}
return(flag);
}
/// <exclude />
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
_instanceId = WorkflowEnvironment.WorkflowInstanceId;
ActivityExecutionStatus activityExecutionStatus = base.Execute(executionContext);
return(activityExecutionStatus);
}
public ActivityExecutionStatusEvent ExecuteEvent(ActivityExecutionStatus newExecutionStatus, User currentUser, string comments, DateTime?contextDate, string contextCode)
{
var newExecutionStatusEvent = new ActivityExecutionStatusEvent(newExecutionStatus, currentUser, comments, contextCode, contextDate);
CurrentStatus = newExecutionStatus;
_executionEvents.Add(newExecutionStatusEvent);
return(newExecutionStatusEvent);
}
protected override ActivityExecutionStatus HandleFault(ActivityExecutionContext executionContext, Exception exception)
{
base.SetValue(SequenceFaultingProperty, true);
ActivityExecutionStatus status = base.HandleFault(executionContext, exception);
if (status == ActivityExecutionStatus.Closed)
{
base.RemoveProperty(SequenceFaultingProperty);
}
return(status);
}
public ActivityTrackingRecord(Type activityType, string qualifiedName, Guid contextGuid, Guid parentContextGuid, ActivityExecutionStatus executionStatus, DateTime eventDateTime, int eventOrder, EventArgs eventArgs)
{
_activityType = activityType;
_qualifiedID = qualifiedName;
_status = executionStatus;
_eventDateTime = eventDateTime;
_contextGuid = contextGuid;
_parentContextGuid = parentContextGuid;
_eventOrder = eventOrder;
_args = eventArgs;
}
public ActivityTrackingRecord(Type activityType, string qualifiedName, Guid contextGuid, Guid parentContextGuid, ActivityExecutionStatus executionStatus, DateTime eventDateTime, int eventOrder, EventArgs eventArgs)
{
_activityType = activityType;
_qualifiedID = qualifiedName;
_status = executionStatus;
_eventDateTime = eventDateTime;
_contextGuid = contextGuid;
_parentContextGuid = parentContextGuid;
_eventOrder = eventOrder;
_args = eventArgs;
}
// Token: 0x060016B2 RID: 5810 RVA: 0x00027B8C File Offset: 0x00026B8C
protected void OnStatusChanged(ActivityExecutionContext context, ActivityExecutionStatus status)
{
if (status == ActivityExecutionStatus.Closed)
{
this.Abort();
if (this.Completed != null)
{
this.Completed(this, null);
}
Console.WriteLine(string.Format("Workflow Instance Completed: {0}", this.element));
}
}
public void OnEvent(object sender, EventArgs e)
{
ActivityExecutionContext context = (ActivityExecutionContext)sender;
// only if activity is still executing, then run it
if (context.Activity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
ActivityExecutionStatus newStatus = ExecuteActivityNow(context);
if (newStatus == ActivityExecutionStatus.Closed)
{
context.CloseActivity();
}
}
}
void IActivityEventListener <EventArgs> .OnEvent(object sender, EventArgs e)
{
ActivityExecutionContext context = (ActivityExecutionContext)sender;
// only if activity is still executing, then run it
if (context.Activity.ExecutionStatus == ActivityExecutionStatus.Executing)
{
ActivityExecutionStatus newStatus = TransactedContextFilter.ExecuteActivity(context.Activity, context, true);
if (newStatus == ActivityExecutionStatus.Closed)
{
context.CloseActivity();
}
}
}
public ActivityExecutionStatusEvent(ActivityExecutionStatus newStatus, User currentUser, string comments, string contextCode, DateTime?contextDateTime)
{
_attachments = new List <Attachment>();
EventCreatedById = currentUser.Id;
EventCreatedBy = currentUser;
ExecutionStatusId = newStatus.Id;
ExecutionStatus = newStatus;
Comments = comments;
ContextCode = contextCode;
ContextDateTime = contextDateTime;
EventDateTime = DateTime.Now;
}
/// <summary>
/// Toggles whether the specified activity status is tracked
/// </summary>
/// <param name="activity"></param>
/// <param name="status"></param>
internal void ToggleEventStatus(Activity activity, ActivityExecutionStatus status)
{
ActivityTrackPoint trackPoint = GetTrackPointForActivity(activity);
if (trackPoint != null)
{
if (trackPoint.MatchingLocations[0].ExecutionStatusEvents.Contains(status))
{
trackPoint.MatchingLocations[0].ExecutionStatusEvents.Remove(status);
}
else
{
trackPoint.MatchingLocations[0].ExecutionStatusEvents.Add(status);
}
}
}
public ActivityTrackingRecord(Type activityType, string qualifiedName, Guid contextGuid, Guid parentContextGuid, ActivityExecutionStatus executionStatus, DateTime eventDateTime, int eventOrder, System.EventArgs eventArgs)
{
this._body = new List<TrackingDataItem>();
this._contextGuid = Guid.Empty;
this._parentContextGuid = Guid.Empty;
this._eventDateTime = DateTime.MinValue;
this._eventOrder = -1;
this._annotations = new TrackingAnnotationCollection();
this._activityType = activityType;
this._qualifiedID = qualifiedName;
this._status = executionStatus;
this._eventDateTime = eventDateTime;
this._contextGuid = contextGuid;
this._parentContextGuid = parentContextGuid;
this._eventOrder = eventOrder;
this._args = eventArgs;
}
public ActivityTrackingRecord(Type activityType, string qualifiedName, Guid contextGuid, Guid parentContextGuid, ActivityExecutionStatus executionStatus, DateTime eventDateTime, int eventOrder, System.EventArgs eventArgs)
{
this._body = new List <TrackingDataItem>();
this._contextGuid = Guid.Empty;
this._parentContextGuid = Guid.Empty;
this._eventDateTime = DateTime.MinValue;
this._eventOrder = -1;
this._annotations = new TrackingAnnotationCollection();
this._activityType = activityType;
this._qualifiedID = qualifiedName;
this._status = executionStatus;
this._eventDateTime = eventDateTime;
this._contextGuid = contextGuid;
this._parentContextGuid = parentContextGuid;
this._eventOrder = eventOrder;
this._args = eventArgs;
}
protected sealed override ActivityExecutionStatus HandleFault(ActivityExecutionContext executionContext, Exception exception)
{
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
if (exception == null)
{
throw new ArgumentNullException("exception");
}
ActivityExecutionStatus status = this.Cancel(executionContext);
if (status == ActivityExecutionStatus.Canceling)
{
return(ActivityExecutionStatus.Faulting);
}
return(status);
}
// Token: 0x06001652 RID: 5714 RVA: 0x00027240 File Offset: 0x00026240
private void OnDependencyStatusChanged(ActivityExecutionContext context, ActivityExecutionStatus status)
{
if (status == ActivityExecutionStatus.Closed)
{
this.scheduled.Remove(context);
this.children.Remove(context.element);
context.StatusChanged = (StatusChangedHandler)Delegate.Remove(context.StatusChanged, new StatusChangedHandler(this.OnDependencyStatusChanged));
context.Faulted = (FaultCallback)Delegate.Remove(context.Faulted, new FaultCallback(this.OnDependencyFaulted));
this.OnCompletion(context.element);
}
else if (status == ActivityExecutionStatus.Faulted || status == ActivityExecutionStatus.Canceled)
{
this.scheduled.Remove(context);
this.children.Remove(context.element);
context.StatusChanged = (StatusChangedHandler)Delegate.Remove(context.StatusChanged, new StatusChangedHandler(this.OnDependencyStatusChanged));
context.Faulted = (FaultCallback)Delegate.Remove(context.Faulted, new FaultCallback(this.OnDependencyFaulted));
}
this.CheckClosed();
}
public void ExecuteTest()
{
SharePointServiceLocator.ReplaceCurrentServiceLocator(new ActivatingServiceLocator().RegisterTypeMapping <IBusinessEventTypeConfigurationRepository, MockBusinessEventTypeConfigurationRepository>());
ResolveSiteTemplateActivity_Accessor target = new ResolveSiteTemplateActivity_Accessor();
target.BusinessEventName = "unittest";
ActivityExecutionContext executionContext = null;
ActivityExecutionStatus expected = ActivityExecutionStatus.Closed;
ActivityExecutionStatus actual;
actual = target.Execute(executionContext);
Assert.AreEqual(expected, actual);
Assert.AreEqual("unittesttemplate", target.SiteTemplateName);
Assert.AreEqual("unittestkey", target.BusinessEventIdKey);
Assert.AreEqual("/unittest", target.TopLevelSiteRelativeUrl);
}
void IActivityEventListener <QueueEventArgs> .OnEvent(object sender, QueueEventArgs e)
{
ActivityExecutionContext context = (ActivityExecutionContext)sender;
WebServiceInputActivity activity = context.Activity as WebServiceInputActivity;
// if activity is not scheduled for execution do not dequeue the message
if (activity.ExecutionStatus != ActivityExecutionStatus.Executing)
{
return;
}
ActivityExecutionStatus status = ExecuteForActivity(context, activity.InterfaceType, activity.MethodName);
if (status == ActivityExecutionStatus.Closed)
{
UnsubscribeForActivity(context);
context.CloseActivity();
}
}
void IActivityEventListener <ActivityExecutionStatusChangedEventArgs> .OnEvent(object sender, ActivityExecutionStatusChangedEventArgs e)
{
if (sender == null)
{
throw new ArgumentNullException("sender");
}
if (e == null)
{
throw new ArgumentNullException("e");
}
ActivityExecutionContext context = sender as ActivityExecutionContext;
if (context == null)
{
throw new ArgumentException("Sender must be ActivityExecutionContext", "sender");
}
BlockActivity activity = context.Activity as BlockActivity;
e.Activity.UnregisterForStatusChange(Activity.ClosedEvent, this);
ActivityExecutionStatus result = ActivityExecutionStatus.Initialized;
switch (this.Type)
{
case BlockActivityType.All:
result = ProcessClosedEvenForAllActivities(context, e.Activity);
break;
case BlockActivityType.Any:
result = ProcessClosedEvenForAnyActivities(context, e.Activity);
break;
default:
throw new ArgumentOutOfRangeException("Unknown Type");
}
if (result == ActivityExecutionStatus.Closed)
{
context.CloseActivity();
}
}
internal bool IsMatch(Activity activity, ActivityExecutionStatus status)
{
//
// Do matches first
bool included = false;
foreach (ActivityTrackingLocation location in _match)
{
if (location.Match(activity, false))
{
if (location.ExecutionStatusEvents.Contains(status))
{
included = true;
break;
}
}
}
//
// If no includes matched this trackpoint
// doesn't match this activity
if (!included)
{
return(false);
}
//
// Check the excludes
foreach (ActivityTrackingLocation location in _exclude)
{
//
// If any exclude matches this trackpoint
// doesn't match this activity
if (location.Match(activity, false))
{
if (location.ExecutionStatusEvents.Contains(status))
{
return(false);
}
}
}
return(included);
}
protected override ActivityExecutionStatus Cancel(ActivityExecutionContext executionContext)
{
ActivityExecutionStatus __status = ActivityExecutionStatus.Closed;
foreach (IfElseBranchActivityCustom branch in this.EnabledActivities)
{
if (branch.ExecutionStatus == ActivityExecutionStatus.Executing)
{
__status = ActivityExecutionStatus.Canceling;
executionContext.CancelActivity(branch);
break;
}
if ((branch.ExecutionStatus == ActivityExecutionStatus.Canceling) || (branch.ExecutionStatus == ActivityExecutionStatus.Faulting))
{
__status = ActivityExecutionStatus.Canceling;
break;
}
}
return(__status);
}
protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
ActivityExecutionStatus __status = ActivityExecutionStatus.Closed;
if (executionContext == null)
{
throw new ArgumentNullException("executionContext");
}
foreach (IfElseBranchActivityCustom branch in this.EnabledActivities)
{
if ((branch.Condition == null) || (branch.Condition.Evaluate(branch, executionContext)))
{
__status = ActivityExecutionStatus.Executing;
branch.RegisterForStatusChange(Activity.ClosedEvent, this);
executionContext.ExecuteActivity(branch);
break;
}
}
return(__status);
}
internal bool IsMatch(Activity activity, ActivityExecutionStatus status)
{
bool flag = false;
foreach (ActivityTrackingLocation location in this._match)
{
if (location.Match(activity, false) && location.ExecutionStatusEvents.Contains(status))
{
flag = true;
break;
}
}
if (!flag)
{
return false;
}
foreach (ActivityTrackingLocation location2 in this._exclude)
{
if (location2.Match(activity, false) && location2.ExecutionStatusEvents.Contains(status))
{
return false;
}
}
return flag;
}
internal bool TryTrackActivityEvent(Activity activity, ActivityExecutionStatus status, IServiceProvider provider, ActivityTrackingRecord record)
{
List<ActivityTrackPointCacheItem> list;
if (!this.TryGetCacheItems(activity, out list))
{
return false;
}
bool flag = false;
foreach (ActivityTrackPointCacheItem item in list)
{
if ((!item.HasLocationConditions || item.Point.IsMatch(activity, status)) && item.Events.Contains(status))
{
flag = true;
item.Point.Track(activity, provider, record.Body);
record.Annotations.AddRange(item.Point.Annotations);
}
}
return flag;
}
/// <summary>
/// Toggles whether the specified activity status is tracked
/// </summary>
/// <param name="activity"></param>
/// <param name="status"></param>
internal void ToggleEventStatus(Activity activity, ActivityExecutionStatus status)
{
ActivityTrackPoint trackPoint = GetTrackPointForActivity(activity);
if (trackPoint != null)
{
if (trackPoint.MatchingLocations[0].ExecutionStatusEvents.Contains(status))
{
trackPoint.MatchingLocations[0].ExecutionStatusEvents.Remove(status);
}
else
{
trackPoint.MatchingLocations[0].ExecutionStatusEvents.Add(status);
}
}
}
private void ProcessExecutionStatus(ActivityExecutionStatus executionStatus)
{
this.completed = executionStatus == ActivityExecutionStatus.Closed;
}
internal bool TryTrackActivityEvent(Activity activity, ActivityExecutionStatus status, IServiceProvider provider, ActivityTrackingRecord record)
{
List<ActivityTrackPointCacheItem> points;
//
// Check the match caches.
if (TryGetCacheItems(activity, out points))
{
bool ret = false;
foreach (ActivityTrackPointCacheItem item in points)
{
if (item.HasLocationConditions)
{
if (!item.Point.IsMatch(activity, status))
continue;
}
if (item.Events.Contains(status))
{
ret = true;
item.Point.Track(activity, provider, record.Body);
record.Annotations.AddRange(item.Point.Annotations);
}
}
return ret;
}
return false;
}
internal bool IsMatch(Activity activity, ActivityExecutionStatus status)
{
//
// Do matches first
bool included = false;
foreach (ActivityTrackingLocation location in _match)
{
if (location.Match(activity, false))
{
if (location.ExecutionStatusEvents.Contains(status))
{
included = true;
break;
}
}
}
//
// If no includes matched this trackpoint
// doesn't match this activity
if (!included)
return false;
//
// Check the excludes
foreach (ActivityTrackingLocation location in _exclude)
{
//
// If any exclude matches this trackpoint
// doesn't match this activity
if (location.Match(activity, false))
{
if (location.ExecutionStatusEvents.Contains(status))
return false;
}
}
return included;
}
