/// <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; }