/// <summary>
/// Add a new custom activity to the workflow instance
/// </summary>
/// <param name="instance"></param>
private static void AddNewActivity(WorkflowInstance instance)
{
//create a workflow changes object
WorkflowChanges wfChanges = new WorkflowChanges(
instance.GetWorkflowDefinition());
//find the SequenceActivity that is a placeholder
//for new activities
CompositeActivity placeholder
= wfChanges.TransientWorkflow.GetActivityByName(
"sequencePlaceholder") as CompositeActivity;
if (placeholder != null)
{
//create an instance of the new activity
NewFunctionActivity newActivity
= new NewFunctionActivity();
//bind the TestNumber property of the activity
//to the TestNumber property of the workflow
#if UPDATES_RESTRICTED
newActivity.SetBinding(
NewFunctionActivity.TestNumberProperty,
new ActivityBind("DynamicRestrictedWorkflow", "TestNumber"));
#else
newActivity.SetBinding(
NewFunctionActivity.TestNumberProperty,
new ActivityBind("DynamicWorkflow", "TestNumber"));
#endif
//add the new custom activity to the workflow
placeholder.Activities.Add(newActivity);
//apply the changes
ValidateAndApplyChanges(instance, wfChanges);
}
}
void ShowState(object activity)
{
if (activity is System.Workflow.ComponentModel.CompositeActivity)
{
CompositeActivity Workflow = activity as CompositeActivity;
foreach (var v in Workflow.EnabledActivities)
{
var ee = new Element();
ee.类型 = "节";
ee.说明 = v.Description;
ee.Name = v.Name;
ee.X坐标 = 0;
ee.Y坐标 = 0;
ee.分支集合 = new List <string>();
if (v is StateActivity)
{
StateActivity sta = v as StateActivity;
foreach (var c in sta.EnabledActivities)
{
foreach (var cc in ((CompositeActivity)c).EnabledActivities)
{
if (cc is wxwinter.wf.WFLib.等待提交)
{
wxwinter.wf.WFLib.等待提交 waitsubmit = cc as wxwinter.wf.WFLib.等待提交;
WaitControlData wd = new WaitControlData();
wd.办理查看业务表单 = waitsubmit.办理查看业务表单;
wd.办理人员 = waitsubmit.办理人员;
wd.办理时限 = waitsubmit.办理时限;
wd.办理提交选项 = waitsubmit.办理提交选项;
wd.办理添写业务表单 = waitsubmit.办理添写业务表单;
wd.处理方式 = waitsubmit.处理方式;
wd.接件部门 = waitsubmit.接件部门;
wd.接件职能 = waitsubmit.接件职能;
wd.启动窗体 = waitsubmit.启动窗体;
wd.说明 = waitsubmit.Description;
ee.结点数据 = wd;
}
if (cc is wxwinter.wf.WFLib.条件容器)
{
wxwinter.wf.WFLib.条件容器 ic = cc as wxwinter.wf.WFLib.条件容器;
foreach (var fz in ic.EnabledActivities)
{
wxwinter.wf.WFLib.条件分支 ifz = fz as wxwinter.wf.WFLib.条件分支;
ee.分支集合.Add(ifz.条件);
}
}
}
}
}
ElementList.Add(ee);
}
}
}
private static bool ValidateParent(CompositeActivity parentActivity)
{
if (parentActivity == null)
{
return(false);
}
return(SetStateValidator.IsValidContainer(parentActivity) || ValidateParent(parentActivity.Parent));
}
internal static bool IsActivitySourceInOrder(Activity request, Activity response)
{
if (request.Parent == null)
{
return(true);
}
List <Activity> responsePath = new List <Activity>();
responsePath.Add(response);
Activity responseParent = response is CompositeActivity ? (CompositeActivity)response : response.Parent;
while (responseParent != null)
{
responsePath.Add(responseParent);
responseParent = responseParent.Parent;
}
Activity requestChild = request;
CompositeActivity requestParent = request is CompositeActivity ? (CompositeActivity)request : request.Parent;
while (requestParent != null && !responsePath.Contains(requestParent))
{
requestChild = requestParent;
requestParent = requestParent.Parent;
}
if (requestParent == requestChild)
{
return(true);
}
bool incorrectOrder = false;
int index = (responsePath.IndexOf(requestParent) - 1);
index = (index < 0) ? 0 : index; //sometimes parent gets added to the collection twice which causes index to be -1
Activity responseChild = responsePath[index];
if (requestParent == null || Helpers.IsAlternateFlowActivity(requestChild) || Helpers.IsAlternateFlowActivity(responseChild))
{
incorrectOrder = true;
}
else
{
for (int i = 0; i < requestParent.EnabledActivities.Count; i++)
{
if (requestParent.EnabledActivities[i] == requestChild)
{
break;
}
else if (requestParent.EnabledActivities[i] == responseChild)
{
incorrectOrder = true;
break;
}
}
}
return(!incorrectOrder);
}
internal static Activity ParseActivity(Activity parsingContext, string activityName)
{
if (parsingContext == null)
{
throw new ArgumentNullException("parsingContext");
}
if (activityName == null)
{
throw new ArgumentNullException("activityName");
}
string id = activityName;
string str2 = string.Empty;
int index = activityName.IndexOf(".");
if (index != -1)
{
id = activityName.Substring(0, index);
str2 = activityName.Substring(index + 1);
if (str2.Length == 0)
{
return(null);
}
}
Activity containerActivity = GetActivity(parsingContext, id);
if (containerActivity == null)
{
return(null);
}
if (str2.Length > 0)
{
if (!(containerActivity is CompositeActivity) || !IsCustomActivity(containerActivity as CompositeActivity))
{
return(null);
}
string[] strArray = str2.Split(new char[] { '.' });
for (int i = 0; i < strArray.Length; i++)
{
Activity activity = GetActivity(containerActivity, strArray[i]);
if ((activity == null) || !IsActivityLocked(activity))
{
return(null);
}
CompositeActivity declaringActivity = GetDeclaringActivity(activity);
if (containerActivity != declaringActivity)
{
return(null);
}
containerActivity = activity;
}
return(containerActivity);
}
if (IsActivityLocked(containerActivity) && !IsDeclaringActivityMatchesContext(containerActivity, parsingContext))
{
return(null);
}
return(containerActivity);
}
internal void ValidateDefinition(Activity root, bool isNewType, ITypeProvider typeProvider)
{
if (this.validateOnCreate)
{
ValidationErrorCollection errors = new ValidationErrorCollection();
if (typeProvider == null)
{
typeProvider = WorkflowRuntime.CreateTypeProvider(root);
}
if (!isNewType)
{
if (!string.IsNullOrEmpty(root.GetValue(WorkflowMarkupSerializer.XClassProperty) as string))
{
errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasClassName, 0x61c));
}
Queue queue = new Queue();
queue.Enqueue(root);
while (queue.Count > 0)
{
Activity activity = queue.Dequeue() as Activity;
if (activity.GetValue(WorkflowMarkupSerializer.XCodeProperty) != null)
{
errors.Add(new ValidationError(ExecutionStringManager.XomlWorkflowHasCode, 0x61d));
}
CompositeActivity activity2 = activity as CompositeActivity;
if (activity2 != null)
{
foreach (Activity activity3 in activity2.EnabledActivities)
{
queue.Enqueue(activity3);
}
}
}
}
ServiceContainer serviceProvider = new ServiceContainer();
serviceProvider.AddService(typeof(ITypeProvider), typeProvider);
ValidationManager manager = new ValidationManager(serviceProvider);
using (WorkflowCompilationContext.CreateScope(manager))
{
foreach (Validator validator in manager.GetValidators(root.GetType()))
{
foreach (ValidationError error in validator.Validate(manager, root))
{
if (!error.UserData.Contains(typeof(Activity)))
{
error.UserData[typeof(Activity)] = root;
}
errors.Add(error);
}
}
}
if (errors.HasErrors)
{
throw new WorkflowValidationFailedException(ExecutionStringManager.WorkflowValidationFailure, errors);
}
}
}
private static RuleDefinitions GetRuleDefinitions(Activity activity, out CompositeActivity declaringActivity)
{
declaringActivity = Helpers.GetDeclaringActivity(activity);
if (declaringActivity == null)
{
declaringActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
}
return(ConditionHelper.Load_Rules_RT(declaringActivity));
}
/// <summary>
/// Gets the business process info.
/// </summary>
/// <param name="workflowId">The workflow id.</param>
/// <returns></returns>
public static BusinessProcessInfo GetBusinessProcessInfo(Guid workflowId)
{
BusinessProcessInfo retVal = new BusinessProcessInfo();
using (WorkflowChangesScope scope = WorkflowChangesScope.Create(workflowId))
{
// Step 1. Fill BusinessProcessInfo
retVal.PrimaryKeyId = (PrimaryKeyId)workflowId;
retVal.Name = scope.WorkflowEntity.Properties.GetValue <string>(WorkflowInstanceEntity.FieldName);
if (scope.WorkflowEntity.Properties.Contains(WorkflowInstanceEntity.FieldState))
{
retVal.State = (BusinessProcessState)scope.WorkflowEntity.Properties.GetValue <int>(WorkflowInstanceEntity.FieldState);
}
else
{
retVal.State = BusinessProcessState.Pending;
}
retVal.PlanFinishDate = scope.WorkflowEntity.Properties.GetValue <DateTime?>(WorkflowInstanceEntity.FieldPlanFinishDate);
retVal.PlanDuration = scope.WorkflowEntity.Properties.GetValue <int?>(WorkflowInstanceEntity.FieldPlanDuration);
if (scope.WorkflowEntity.Properties.Contains(WorkflowInstanceEntity.FieldActualStartDate))
{
retVal.ActualStartDate = scope.WorkflowEntity.Properties.GetValue <DateTime?>(WorkflowInstanceEntity.FieldActualStartDate);
}
if (scope.WorkflowEntity.Properties.Contains(WorkflowInstanceEntity.FieldActualFinishDate))
{
retVal.ActualFinishDate = scope.WorkflowEntity.Properties.GetValue <DateTime?>(WorkflowInstanceEntity.FieldActualFinishDate);
}
if (scope.WorkflowEntity.Properties.Contains(WorkflowInstanceEntity.FieldExecutionResult))
{
retVal.ExecutionResult = (BusinessProcessExecutionResult?)scope.WorkflowEntity.Properties.GetValue <int?>(WorkflowInstanceEntity.FieldExecutionResult);
}
// Step 2. Fill ActivityInfo Recursion
CompositeActivity activity = scope.TransientWorkflow as CompositeActivity;
if (activity != null)
{
EntityObject[] assignments = BusinessManager.List(AssignmentEntity.ClassName, new FilterElement[] { FilterElement.EqualElement(AssignmentEntity.FieldWorkflowInstanceId, (PrimaryKeyId)workflowId) });
CreateBusinessProcessActivityInfo(retVal, scope, assignments, activity, retVal.Activities);
// Fill Plan Finish Date
if (retVal.PlanFinishDate.HasValue && retVal.State == BusinessProcessState.Active)
{
FillPlanFinishDate(retVal.Activities);
}
}
}
return(retVal);
}
public virtual int MapToIndex()
{
CompositeActivity activity = this.activityDesigner.Activity as CompositeActivity;
if (activity != null)
{
return(activity.Activities.Count);
}
return(0);
}
static internal IEventActivity GetEventActivity(EventDrivenActivity eventDriven)
{
CompositeActivity sequenceActivity = eventDriven as CompositeActivity;
Debug.Assert(eventDriven.EnabledActivities.Count > 0);
IEventActivity eventActivity = sequenceActivity.EnabledActivities[0] as IEventActivity;
Debug.Assert(eventActivity != null);
return(eventActivity);
}
public override ValidationErrorCollection Validate(ValidationManager manager, object obj)
{
CompositeActivity compositeActivity = obj as CompositeActivity;
if (compositeActivity == null)
{
throw new ArgumentException(SR.GetString(SR.Error_UnexpectedArgumentType, typeof(CompositeActivity).FullName), "obj");
}
if (Helpers.IsActivityLocked(compositeActivity))
{
return(new ValidationErrorCollection());
}
ValidationErrorCollection validationErrors = base.Validate(manager, obj);
// check if more than one cancellation handler or compensation or fault handlers are specified
int cancelHandlerCount = 0;
int exceptionHandlersCount = 0;
int compensationHandlerCount = 0;
foreach (Activity activity in ((ISupportAlternateFlow)compositeActivity).AlternateFlowActivities)
{
cancelHandlerCount += (activity is CancellationHandlerActivity) ? 1 : 0;
exceptionHandlersCount += (activity is FaultHandlersActivity) ? 1 : 0;
compensationHandlerCount += (activity is CompensationHandlerActivity) ? 1 : 0;
}
// check cancellation handlers
if (cancelHandlerCount > 1)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_MoreThanOneCancelHandler, compositeActivity.GetType().Name), ErrorNumbers.Error_ScopeMoreThanOneEventHandlersDecl));
}
// check exception handlers
if (exceptionHandlersCount > 1)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_MoreThanOneFaultHandlersActivityDecl, compositeActivity.GetType().Name), ErrorNumbers.Error_ScopeMoreThanOneFaultHandlersActivityDecl));
}
// check compensation handlers
if (compensationHandlerCount > 1)
{
validationErrors.Add(new ValidationError(SR.GetString(SR.Error_MoreThanOneCompensationDecl, compositeActivity.GetType().Name), ErrorNumbers.Error_ScopeMoreThanOneCompensationDecl));
}
if (manager.ValidateChildActivities)
{
foreach (Activity childActivity in Helpers.GetAllEnabledActivities(compositeActivity))
{
validationErrors.AddRange(ValidationHelpers.ValidateActivity(manager, childActivity));
}
}
return(validationErrors);
}
/// <summary>
/// Calculates the current assignment count.
/// </summary>
/// <returns></returns>
private int CalculateCurrentAssignmentCount()
{
CompositeActivity parent = this.Parent;
if (parent is BlockActivity)
{
return(((BlockActivity)parent).Activities.Count);
}
return(1);
}
private static bool IsPreBuiltActivity(Activity activity)
{
for (CompositeActivity activity2 = activity.Parent; activity2 != null; activity2 = activity2.Parent)
{
if (Helpers.IsCustomActivity(activity2))
{
return(true);
}
}
return(false);
}
private static bool IsDeclaringActivityMatchesContext(Activity currentActivity, Activity context)
{
CompositeActivity compositeActivity = context as CompositeActivity;
CompositeActivity declaringActivity = GetDeclaringActivity(currentActivity);
if (IsActivityLocked(context) && ((compositeActivity == null) || !IsCustomActivity(compositeActivity)))
{
compositeActivity = GetDeclaringActivity(context);
}
return(compositeActivity == declaringActivity);
}
private void OnStatusPaste(object sender, EventArgs e)
{
MenuCommand command = (MenuCommand)sender;
command.Enabled = false;
object primarySelection = this.selectionService.PrimarySelection;
CompositeActivityDesigner parentDesigner = ActivityDesigner.GetDesigner(primarySelection as Activity) as CompositeActivityDesigner;
if (parentDesigner == null)
{
parentDesigner = ActivityDesigner.GetParentDesigner(primarySelection);
}
if ((parentDesigner != null) && parentDesigner.IsEditable)
{
IDesignerHost host = this.serviceProvider.GetService(typeof(IDesignerHost)) as IDesignerHost;
IToolboxService service = (IToolboxService)this.serviceProvider.GetService(typeof(IToolboxService));
IDataObject dataObject = Clipboard.GetDataObject();
if (((dataObject != null) && (host != null)) && ((dataObject.GetDataPresent("CF_WINOEDESIGNERCOMPONENTS") || (service == null)) || service.IsSupported(dataObject, host)))
{
System.Workflow.ComponentModel.Design.HitTestInfo insertLocation = null;
if (primarySelection is System.Workflow.ComponentModel.Design.HitTestInfo)
{
insertLocation = (System.Workflow.ComponentModel.Design.HitTestInfo)primarySelection;
}
else if (primarySelection is CompositeActivity)
{
insertLocation = new System.Workflow.ComponentModel.Design.HitTestInfo(parentDesigner, HitTestLocations.Designer);
}
else if (primarySelection is Activity)
{
Activity item = primarySelection as Activity;
CompositeActivity parent = item.Parent;
CompositeActivityDesigner designer = ActivityDesigner.GetDesigner(parent) as CompositeActivityDesigner;
if (designer != null)
{
insertLocation = new ConnectorHitTestInfo(designer, HitTestLocations.Designer, parent.Activities.IndexOf(item) + 1);
}
}
ICollection activities = null;
try
{
activities = CompositeActivityDesigner.DeserializeActivitiesFromDataObject(this.serviceProvider, dataObject);
}
catch (CheckoutException exception)
{
if (exception != CheckoutException.Canceled)
{
throw exception;
}
}
command.Enabled = ((activities != null) && (insertLocation != null)) && parentDesigner.CanInsertActivities(insertLocation, new List <Activity>(Helpers.GetTopLevelActivities(activities)).AsReadOnly());
}
}
}
internal static bool IsActivitySourceInOrder(Activity request, Activity response)
{
if (request.Parent == null)
{
return(true);
}
List <Activity> list = new List <Activity> {
response
};
for (Activity activity = (response is CompositeActivity) ? ((CompositeActivity)response) : response.Parent; activity != null; activity = activity.Parent)
{
list.Add(activity);
}
Activity activity2 = request;
CompositeActivity item = (request is CompositeActivity) ? ((CompositeActivity)request) : request.Parent;
while ((item != null) && !list.Contains(item))
{
activity2 = item;
item = item.Parent;
}
if (item == activity2)
{
return(true);
}
bool flag = false;
int num = list.IndexOf(item) - 1;
num = (num < 0) ? 0 : num;
Activity activity4 = list[num];
if (((item == null) || Helpers.IsAlternateFlowActivity(activity2)) || Helpers.IsAlternateFlowActivity(activity4))
{
flag = true;
}
else
{
for (int i = 0; i < item.EnabledActivities.Count; i++)
{
if (item.EnabledActivities[i] == activity2)
{
break;
}
if (item.EnabledActivities[i] == activity4)
{
flag = true;
break;
}
}
}
return(!flag);
}
public override ValidationError ValidateActivityChange(Activity activity, ActivityChangeAction action)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (action == null)
{
throw new ArgumentNullException("action");
}
AddedActivityAction addedAction = action as AddedActivityAction;
if (addedAction != null)
{
//Check existence of nested PersistOnClose/ICompensatable/SupportsTransaction nested anywhere
//in the added activity branch
System.Collections.Generic.Queue <Activity> childrenQueue = new System.Collections.Generic.Queue <Activity>();
childrenQueue.Enqueue(addedAction.AddedActivity);
while (childrenQueue.Count != 0)
{
Activity childActivity = childrenQueue.Dequeue();
if (childActivity.SupportsTransaction)
{
return(new ValidationError(SR.GetString(SR.Error_AtomicScopeNestedInNonLRT), ErrorNumbers.Error_AtomicScopeNestedInNonLRT));
}
if (childActivity.PersistOnClose)
{
return(new ValidationError(SR.GetString(SR.Error_NestedPersistOnClose, activity.QualifiedName), ErrorNumbers.Error_NestedPersistOnClose));
}
if (childActivity is ICompensatableActivity)
{
return(new ValidationError(SR.GetString(SR.Error_NestedCompensatableActivity, activity.QualifiedName), ErrorNumbers.Error_NestedCompensatableActivity));
}
CompositeActivity compositeActivity = childActivity as CompositeActivity;
if (compositeActivity != null)
{
foreach (Activity grandChild in compositeActivity.EnabledActivities)
{
childrenQueue.Enqueue(grandChild);
}
}
}
}
return(base.ValidateActivityChange(activity, action));
}
private CompositeActivity GetRootWorkflow(CompositeActivity activity)
{
if (activity.Parent != null)
{
CompositeActivity workflow = GetRootWorkflow(activity.Parent);
return(workflow);
}
else
{
return(activity);
}
}
internal TransitionInfo(SetStateActivity setState, CompositeActivity eventHandler)
{
if (setState == null)
{
throw new ArgumentNullException("setState");
}
if (eventHandler == null)
{
throw new ArgumentNullException("eventHandler");
}
_setState = setState;
_eventHandler = eventHandler;
}
void IIdentifierCreationService.ValidateIdentifier(Activity activity, string identifier)
{
if (identifier == null)
{
throw new ArgumentNullException("identifier");
}
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (!activity.Name.ToLowerInvariant().Equals(identifier.ToLowerInvariant()))
{
if (this.Provider != null)
{
SupportedLanguages supportedLanguage = CompilerHelpers.GetSupportedLanguage(this.serviceProvider);
if ((((supportedLanguage == SupportedLanguages.CSharp) && identifier.StartsWith("@", StringComparison.Ordinal)) || (((supportedLanguage == SupportedLanguages.VB) && identifier.StartsWith("[", StringComparison.Ordinal)) && identifier.EndsWith("]", StringComparison.Ordinal))) || !this.Provider.IsValidIdentifier(identifier))
{
throw new Exception(SR.GetString("Error_InvalidLanguageIdentifier", new object[] { identifier }));
}
}
StringDictionary dictionary = new StringDictionary();
CompositeActivity rootActivity = Helpers.GetRootActivity(activity) as CompositeActivity;
if (rootActivity != null)
{
foreach (string str in Helpers.GetIdentifiersInCompositeActivity(rootActivity))
{
dictionary[str] = str;
}
}
Type rootActivityType = this.GetRootActivityType(this.serviceProvider);
if (rootActivityType != null)
{
foreach (MemberInfo info in rootActivityType.GetMembers(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance))
{
Type c = null;
if (info is FieldInfo)
{
c = ((FieldInfo)info).FieldType;
}
if ((c == null) || !typeof(Activity).IsAssignableFrom(c))
{
dictionary[info.Name] = info.Name;
}
}
}
if (dictionary.ContainsKey(identifier))
{
throw new ArgumentException(SR.GetString("DuplicateActivityIdentifier", new object[] { identifier }));
}
}
}
public override bool Evaluate(Activity activity, IServiceProvider provider)
{
if (activity == null)
{
throw new ArgumentNullException("activity");
}
if (string.IsNullOrEmpty(this._condition))
{
throw new InvalidOperationException(SR.GetString(SR.Error_MissingConditionName, activity.Name));
}
RuleDefinitions defs = null;
if (string.IsNullOrEmpty(this.declaringActivityId))
{
// No Runtime Initialization.
CompositeActivity declaringActivity = null;
defs = RuleConditionReference.GetRuleDefinitions(activity, out declaringActivity);
}
else
{
// Runtime Initialized.
defs = (RuleDefinitions)activity.GetActivityByName(declaringActivityId).GetValue(RuleDefinitions.RuleDefinitionsProperty);
}
if ((defs == null) || (defs.Conditions == null))
{
throw new InvalidOperationException(SR.GetString(SR.Error_MissingRuleConditions));
}
RuleCondition conditionDefinitionToEvaluate = defs.Conditions[this._condition];
if (conditionDefinitionToEvaluate != null)
{
Activity contextActivity = System.Workflow.Activities.Common.Helpers.GetEnclosingActivity(activity);
RuleValidation validation = new RuleValidation(contextActivity);
if (!conditionDefinitionToEvaluate.Validate(validation))
{
string message = string.Format(CultureInfo.CurrentCulture, Messages.ConditionValidationFailed, this._condition);
throw new InvalidOperationException(message);
}
RuleExecution context = new RuleExecution(validation, contextActivity, provider as ActivityExecutionContext);
return(conditionDefinitionToEvaluate.Evaluate(context));
}
else
{
// no condition, so defaults to true
return(true);
}
}
/// <summary>
/// Recursively get a collection of all child activities
/// </summary>
/// <param name="composite"></param>
/// <param name="children"></param>
private static void GetChildActivities(
CompositeActivity composite, List <Activity> children)
{
foreach (Activity activity in composite.Activities)
{
children.Add(activity);
if (activity is CompositeActivity)
{
//make recursive call
GetChildActivities(
activity as CompositeActivity, children);
}
}
}
public override bool CanInsertActivities(HitTestInfo insertLocation, ReadOnlyCollection <Activity> activitiesToInsert)
{
CompositeActivity activity = base.Activity as CompositeActivity;
if ((activity != null) && (activity.EnabledActivities.Count > 0))
{
return(false);
}
if (activitiesToInsert.Count > 1)
{
return(false);
}
return(base.CanInsertActivities(insertLocation, activitiesToInsert));
}
internal static IList GetIdentifiersInCompositeActivity(CompositeActivity compositeActivity)
{
ArrayList list = new ArrayList();
if (compositeActivity != null)
{
list.Add(compositeActivity.Name);
foreach (Activity activity in GetAllNestedActivities(compositeActivity))
{
list.Add(activity.Name);
}
}
return(ArrayList.ReadOnly(list));
}
/// <summary>
/// Add a new custom activity to this workflow instance
/// </summary>
/// <param name="instance"></param>
private void AddNewActivity()
{
//create an instance of the specified new activity
if (NewActivityType != null && NumberProperty != null)
{
//create a workflow changes object
WorkflowChanges wfChanges = new WorkflowChanges(this);
//find the SequenceActivity that is a placeholder
//for new activities
CompositeActivity placeholder
= wfChanges.TransientWorkflow.GetActivityByName(
"sequencePlaceholder") as CompositeActivity;
if (placeholder == null)
{
return;
}
//construct an instance of the activity
//using reflection
ConstructorInfo ctor
= NewActivityType.GetConstructor(Type.EmptyTypes);
Activity newActivity = ctor.Invoke(null) as Activity;
//bind the TestNumber property of the activity
//to the TestNumber property of the workflow
newActivity.SetBinding(NumberProperty,
new ActivityBind(this.Name, "TestNumber"));
//add the new custom activity to the workflow
placeholder.Activities.Add(newActivity);
//validate the structural changes before applying them
ValidationErrorCollection errors = wfChanges.Validate();
if (errors.Count == 0)
{
//apply the changes to the workflow instance
this.ApplyWorkflowChanges(wfChanges);
}
else
{
//the proposed changes are not valid
foreach (ValidationError error in errors)
{
Console.WriteLine(error.ToString());
}
}
}
}
private void OnAddBranch(object sender, EventArgs e)
{
CompositeActivity activity = this.OnCreateNewBranch();
CompositeActivity activity2 = base.Activity as CompositeActivity;
if ((activity2 != null) && (activity != null))
{
int count = this.ContainedDesigners.Count;
CompositeActivityDesigner.InsertActivities(this, new ConnectorHitTestInfo(this, HitTestLocations.Designer, activity2.Activities.Count), new List <Activity>(new Activity[] { activity }).AsReadOnly(), DR.GetString("AddingBranch", new object[] { activity.GetType().Name }));
if ((this.ContainedDesigners.Count > count) && (this.ContainedDesigners.Count > 0))
{
this.ContainedDesigners[this.ContainedDesigners.Count - 1].EnsureVisible();
}
}
}
protected override void InitializeProperties()
{
lock (this.syncLock)
{
if (!this._runtimeInitialized)
{
CompositeActivity declaringActivity = null;
Activity parentDependencyObject = base.ParentDependencyObject as Activity;
GetRuleDefinitions(parentDependencyObject, out declaringActivity).OnRuntimeInitialized();
this.declaringActivityId = declaringActivity.QualifiedName;
base.InitializeProperties();
this._runtimeInitialized = true;
}
}
}
private static IList GetIdentifiersInCompositeActivity(CompositeActivity compositeActivity)
{
ArrayList identifiers = new ArrayList();
if (compositeActivity != null)
{
identifiers.Add(compositeActivity.Name);
IList <Activity> allChildren = GetAllNestedActivities(compositeActivity);
foreach (Activity activity in allChildren)
{
identifiers.Add(activity.Name);
}
}
return(ArrayList.ReadOnly(identifiers));
}
protected override void OnLayoutPosition(ActivityDesignerLayoutEventArgs e)
{
base.OnLayoutPosition(e);
// Draw a connector between the first and second activities contained in
// the sequence activity used by this designer
if (this.IsRootDesigner)
{
CompositeActivity parentActivity = (CompositeActivity)this.Activity;
ConnectionPoint sourcePoint = GetConnectionPoint(parentActivity.Activities[0], 1, DesignerEdges.Bottom);
ConnectionPoint targetPoint = GetConnectionPoint(parentActivity.Activities[1], 0, DesignerEdges.Top);
this.AddConnector(sourcePoint, targetPoint);
}
}
internal static bool IsChildActivity(CompositeActivity parent, Activity activity)
{
foreach (Activity activity2 in parent.Activities)
{
if (activity == activity2)
{
return(true);
}
if ((activity2 is CompositeActivity) && IsChildActivity(activity2 as CompositeActivity, activity))
{
return(true);
}
}
return(false);
}
private ActivityUnInitializeMethodCaller GetActivityUnInitializeMethodCaller(
string methodName, CompositeActivity compositeActivity)
{
if (methodName.StartsWith(PREFIX_REFTOROOT))
{
methodName = methodName.Substring(PREFIX_REFTOROOTLEN);
return new ActivityUnInitializeMethodCaller(methodName, Scheme.RootActivity);
}
return new ActivityUnInitializeMethodCaller(methodName, compositeActivity);
}
private void InitEventHandlerActivity(
EventHandlerActivity activity, StringDictionary atts, CompositeActivity parentActivity)
{
var activityName = atts[ATT_NAME];
var eventAttValue = atts[ATT_EVENT];
var handlerAttValue = atts[ATT_HANDLER];
var nextActivityAttValue = atts[ATT_NEXTACTIVITY];
if (activityName == null)
throw new WorkflowSchemeParserException("Не задано имя действия", this);
if (eventAttValue == null)
throw new WorkflowSchemeParserException("Не задано событие", this);
if (handlerAttValue == null)
throw new WorkflowSchemeParserException("Не задано действие-обработчик события", this);
activity.Name = CreateFullActivityName(activityName, parentActivity);
AddActivityToScheme(activity);
parentActivity.Activities.Add(activity);
activity.Parent = parentActivity;
activity.Event = GetEventHolder(activity, eventAttValue);
activity.Handler = GetEventHandlerActivity(handlerAttValue, parentActivity);
if (!string.IsNullOrEmpty(nextActivityAttValue))
AddNextActivity(activity, Scheme.DefaultNextActivityKey.Name, nextActivityAttValue);
}
private void InitMonitorActivity(MonitorActivity activity, CompositeActivity parentActivity)
{
var atts = ReadAttributes(new[] { ATT_NAME, ATT_LOCKNAME, ATT_NEXTACTIVITY });
var activityName = atts[ATT_NAME];
var lockName = atts[ATT_LOCKNAME];
var nextActivityAttValue = atts[ATT_NEXTACTIVITY];
if (activityName == null)
throw new WorkflowSchemeParserException("Не задано имя действия", this);
if (lockName == null)
throw new WorkflowSchemeParserException("Не задано имя блокировки", this);
activity.Name = CreateFullActivityName(activityName, parentActivity);
activity.LockName = lockName;
AddActivityToScheme(activity);
parentActivity.Activities.Add(activity);
activity.Parent = parentActivity;
if (!string.IsNullOrEmpty(nextActivityAttValue))
AddNextActivity(activity, Scheme.DefaultNextActivityKey.Name, nextActivityAttValue);
}
private Activity ReadActivity(CompositeActivity parentActivity)
{
var activity = new Activity();
string activityExecutionMethod;
ReadActivityCommon(activity, parentActivity, out activityExecutionMethod);
activity.ExecutionMethodCaller = GetActivityExecutionMethodCaller(
activityExecutionMethod, parentActivity);
return activity;
}
private void ReadActivityCommon(
Activity activity, CompositeActivity parentActivity, out string activityExecutionMethod)
{
NameValueCollection nextActivitiesAtts;
var atts = ReadAllAttributes(
new[] {
ATT_NAME,
ATT_INITIALIZE,
ATT_UNINITIALIZE,
ATT_EXECUTE,
ATT_PRIORITY,
ATT_PARAMETERS,
ATT_NEXTACTIVITIES,
ATT_DEFAULTNEXTACTIVITY,
ATT_TRACKING },
out nextActivitiesAtts);
var activityName = atts[ATT_NAME];
var activityInitializeMethod = atts[ATT_INITIALIZE];
var activityUninitializeMethod = atts[ATT_UNINITIALIZE];
activityExecutionMethod = atts[ATT_EXECUTE];
var parametersAttValue = atts[ATT_PARAMETERS];
var nextActivitiesAttValue = atts[ATT_NEXTACTIVITIES];
var defaultNextActivityAttValue = atts[ATT_DEFAULTNEXTACTIVITY];
var tracking = GetTrackingAttValue(atts);
if (activityName == null)
throw new WorkflowSchemeParserException("Не задано имя действия", this);
if (activityExecutionMethod == null)
throw new WorkflowSchemeParserException("Не задан метод, реализующий логику действия", this);
activity.Name = CreateFullActivityName(activityName, parentActivity);
if (activityInitializeMethod != null)
activity.InitializeMethodCaller =
GetActivityUnInitializeMethodCaller(activityInitializeMethod, parentActivity);
if (activityUninitializeMethod != null)
activity.UninitializeMethodCaller =
GetActivityUnInitializeMethodCaller(activityUninitializeMethod, parentActivity);
SetPriority(activity, atts[ATT_PRIORITY]);
activity.Tracking = tracking;
AddActivityToScheme(activity);
parentActivity.Activities.Add(activity);
activity.Parent = parentActivity;
if (parametersAttValue != null)
ReadActivityParametersFromAttValue(activity, parametersAttValue);
if (nextActivitiesAttValue != null)
{
ReadNameAndValueString(
nextActivitiesAttValue,
(name, value) => AddNextActivity(activity, name, value));
}
for (int i = 0; i < nextActivitiesAtts.Count; i++)
{
var attName = nextActivitiesAtts.GetKey(i);
var attValue = nextActivitiesAtts.Get(i);
AddNextActivity(activity, attName, attValue);
}
if (defaultNextActivityAttValue != null)
{
AddNextActivity(activity, NextActivityKey.DefaultNextActivityKey, defaultNextActivityAttValue);
}
ReadActivityInnerElements(activity);
}
private CompositeActivity CreateCompositeActivity()
{
CompositeActivity activity;
var atts = ReadAttributes(new[] { ATT_NAME, ATT_CLASS, ATT_TRACKING });
var activityName = atts[ATT_NAME];
var activityClassTypeName = atts[ATT_CLASS];
var tracking = GetTrackingAttValue(atts);
if (activityName == null)
throw new WorkflowSchemeParserException("Не задано имя составного действия", this);
if (activityClassTypeName != null)
{
Type activityType;
try
{
activityType = Type.GetType(activityClassTypeName, true);
}
catch (Exception ex)
{
throw new WorkflowSchemeParserException(string.Format(
"Ошибка загрузки типа класса действия. Имя типа класса = {0}", activityClassTypeName),
ex, this);
}
if (activityType == null)
throw new WorkflowSchemeParserException(string.Format(
"Тип класса действия с именем {0} не найден", activityClassTypeName), this);
if (!activityType.IsInheritedFromType(typeof(CompositeActivity)))
throw new WorkflowSchemeParserException(string.Format(
"Класс '{0}' должен быть унаследован от CompositeActivity", activityClassTypeName), this);
if (activityType.GetConstructor(new Type[] { }) == null)
throw new WorkflowSchemeParserException(string.Format(
"Для класса '{0}' не найден конструктор", activityClassTypeName), this);
try
{
activity = (CompositeActivity)Activator.CreateInstance(activityType);
}
catch (Exception ex)
{
throw new WorkflowSchemeParserException(string.Format(
"Ошибка создания экземпляра класса действия. Имя типа класса = {0}", activityClassTypeName),
ex, this);
}
}
else
{
activity = new CompositeActivity();
}
activity.Name = activityName;
activity.Tracking = tracking;
return activity;
}
internal static void ReplaceChildActivities(CompositeActivity instanceActivity, CompositeActivity xomlActivity)
{
ArrayList activities = new ArrayList();
foreach (Activity activity1 in (xomlActivity as CompositeActivity).Activities)
{
activities.Add(activity1);
}
try
{
// Clear the activities
instanceActivity.CanModifyActivities = true;
xomlActivity.CanModifyActivities = true;
instanceActivity.Activities.Clear();
xomlActivity.Activities.Clear();
foreach (Activity activity in activities)
{
instanceActivity.Activities.Add(activity);
}
}
finally
{
instanceActivity.CanModifyActivities = false;
xomlActivity.CanModifyActivities = false;
}
if (!instanceActivity.UserData.Contains(UserDataKeys.CustomActivity))
instanceActivity.UserData[UserDataKeys.CustomActivity] = (instanceActivity.Activities.Count > 0);
}
private ReferenceActivity ReadReferenceActivity(CompositeActivity parentActivity)
{
var activity = new ReferenceActivity();
string activityExecutionMethod;
ReadActivityCommon(activity, parentActivity, out activityExecutionMethod);
activity.ActivityForExecute = GetReferencedActivity(activityExecutionMethod);
return activity;
}
private void AddDummyActivity(CompositeActivity parentActivity, Type activityType)
{
IDesignerHost host = this.surface.GetService(typeof(IDesignerHost)) as IDesignerHost;
Debug.Assert(host != null);
if (host == null)
return;
Activity dummyActivity = Activator.CreateInstance(activityType) as Activity;
Debug.Assert(dummyActivity != null);
if (dummyActivity == null)
return;
parentActivity.Activities.Add(dummyActivity);
EnsureUniqueId(dummyActivity);
WorkflowDesignerLoader.AddActivityToDesigner(this.surface, dummyActivity);
}
private UnsubscribeFromEventActivity ReadUnsubscribeFromEventActivity(
CompositeActivity parentActivity)
{
var activity = new UnsubscribeFromEventActivity();
var atts = ReadAttributes(new[] { ATT_NAME, ATT_EVENT, ATT_HANDLER, ATT_NEXTACTIVITY });
InitEventHandlerActivity(activity, atts, parentActivity);
return activity;
}
private Activity GetEventHandlerActivity(string handlerActivityName, CompositeActivity compositeActivity)
{
return Scheme.Activities.ContainsKey(handlerActivityName)
? Scheme.Activities[handlerActivityName]
: new UnevaluatedActivity(handlerActivityName, compositeActivity);
}
private MonitorExitActivity ReadMonitorExitActivity(CompositeActivity parentActivity)
{
var activity = new MonitorExitActivity();
InitMonitorActivity(activity, parentActivity);
return activity;
}
private SubscribeToEventActivity ReadSubscribeToEventActivity(CompositeActivity parentActivity)
{
var activity = new SubscribeToEventActivity();
var atts = ReadAttributes(new[] { ATT_NAME, ATT_EVENT, ATT_HANDLER, ATT_HANDLINGTYPE, ATT_NEXTACTIVITY });
InitEventHandlerActivity(activity, atts, parentActivity);
activity.HandlingType = GetEventHandlingType(atts[ATT_HANDLINGTYPE]);
return activity;
}
