/// <summary> /// Create an argument wrapper for a property /// </summary> /// <param name="prop"></param> /// <returns></returns> private ArgumentViewModel CreateArgument(DynamicActivityProperty prop) { Type innerType = prop.Type.GetGenericArguments().FirstOrDefault() ?? prop.Type; if (innerType == typeof(bool)) { return new BooleanArgumentViewModel() { Title = prop.Name, Property = prop } } ; if (innerType == typeof(DateTime)) { return new DateTimeArgumentViewModel() { Title = prop.Name, Property = prop } } ; if (innerType == typeof(int)) { return new IntArgumentViewModel() { Title = prop.Name, Property = prop } } ; return(new TextArgumentViewModel() { Title = prop.Name + " (" + innerType.Name + ")", Property = prop }); }
public static Activity CreateSalutationRules(List <SalutationAssignmentRule> rules) { var inProperty = new DynamicActivityProperty { Name = "Person", Type = typeof(InArgument <Person>) }; var activity = new DynamicActivity() { Properties = { inProperty } }; Common.AddVbSetting(activity); var sequence = new Sequence(); activity.Implementation = () => sequence; // Sort descending - those added first are lowest priority var sortedRules = rules.OrderByDescending(p => p.Priority).ToList(); // Convert to if-activities and add to sequence foreach (var inRule in sortedRules) { var outRule = RuleConverter.ToIfActivity(inRule); sequence.Activities.Add(outRule); } return(activity); }
/// <summary> /// Validates the arguments in ChildArguments property against the arguments of specified dynamicActivity instance by adding a validation error /// to supplied metadata if the argument is wrong type, direction or does not exist. /// </summary> /// <param name="metadata">The metadata.</param> /// <param name="dynamicActivity">The dynamic activity.</param> private void Validate(NativeActivityMetadata metadata, DynamicActivity dynamicActivity) { foreach (string argumentKey in this.ChildArguments.Keys) { if (dynamicActivity.Properties.Contains(argumentKey)) { DynamicActivityProperty dynamicActivityProperty = dynamicActivity.Properties[argumentKey]; Argument arg = this.ChildArguments[argumentKey]; if (dynamicActivityProperty.Type.GetGenericTypeDefinition() == typeof(InArgument <>) && arg.Direction != ArgumentDirection.In) { metadata.AddValidationError(new ValidationError(string.Format(Resources.InvalidInArgumentDirectionValidationErrorText, argumentKey))); } else if (dynamicActivityProperty.Type.GetGenericTypeDefinition() == typeof(OutArgument <>) && arg.Direction != ArgumentDirection.Out) { metadata.AddValidationError(new ValidationError(string.Format(Resources.InvalidOutArgumentDirectionValidationErrorText, argumentKey))); } else if (dynamicActivityProperty.Type.GetGenericTypeDefinition() == typeof(InOutArgument <>) && arg.Direction != ArgumentDirection.InOut) { metadata.AddValidationError(new ValidationError(string.Format(Resources.InvalidInOutArgumentDirectionValidationErrorText, argumentKey))); } if (dynamicActivityProperty.Type.GetGenericArguments()[0] != arg.ArgumentType) { metadata.AddValidationError(new ValidationError(string.Format(Resources.InvalidIArgumentTypeValidationErrorText, argumentKey, dynamicActivityProperty.Type.GetGenericArguments()[0]))); } } else { metadata.AddValidationError(new ValidationError(string.Format(Resources.InvalidIArgumentValidationErrorText, argumentKey))); } } }
internal static Variable GetVariableFromProperty(DynamicActivityProperty property) { Type variableType = null; Variable autoVariable = null; if (property.Type != null) { Type propertyType = property.Type; // if the property is an Argument<T> create a variable of type T if (propertyType != null && typeof(Argument).IsAssignableFrom(propertyType)) { if (propertyType.IsGenericType) { variableType = propertyType.GetGenericArguments()[0]; } else { variableType = typeof(object); } } } if (variableType != null) { autoVariable = Variable.Create(property.Name, variableType, VariableModifiers.None); Argument argument = property.Value as Argument; if (argument != null) { autoVariable.Default = argument.Expression; } } return(autoVariable); }
public static Activity CreateSalutationRules() { var inProperty = new DynamicActivityProperty { Name = "Person", Type = typeof(InArgument <Person>) }; var activity = new DynamicActivity() { Properties = { inProperty } }; Common.AddVbSetting(activity); var sequence = new Sequence(); activity.Implementation = () => sequence; // First rule var condition1 = new VisualBasicValue <bool>("Person.Gender = \"Male\""); var if1 = new If(new InArgument <bool>(condition1)); if1.Then = new Assign <string> { To = new OutArgument <string>(new VisualBasicReference <string>("Person.Salutation")), Value = new InArgument <string>("Mr") }; if1.Else = new Assign <string> { To = new OutArgument <string>(new VisualBasicReference <string>("Person.Salutation")), Value = new InArgument <string>("Miss") }; // Second rule var condition2 = new VisualBasicValue <bool>("Person.Gender = \"Female\" AND Person.Married"); var if2 = new If(new InArgument <bool>(condition2)); if2.Then = new Assign <string> { To = new OutArgument <string>(new VisualBasicReference <string>("Person.Salutation")), Value = new InArgument <string>("Mrs") }; // Third rule var condition3 = new VisualBasicValue <bool>("Person.Minor"); var if3 = new If(new InArgument <bool>(condition3)); if3.Then = new Assign <string> { To = new OutArgument <string>(new VisualBasicReference <string>("Person.Salutation")), Value = new InArgument <string>("To the parents of") }; // Priority is implicitly defined by the order in which we add the IF-activites sequence.Activities.Add(if1); sequence.Activities.Add(if2); sequence.Activities.Add(if3); return(activity); }
internal static Variable GetVariableFromProperty(DynamicActivityProperty property) { Type variableType = null; Variable autoVariable = null; if (property.Type != null) { Type propertyType = property.Type; // if the property is an Argument<T> create a variable of type T if (propertyType != null && typeof(Argument).IsAssignableFrom(propertyType)) { if (propertyType.IsGenericType) { variableType = propertyType.GetGenericArguments()[0]; } else { variableType = typeof(object); } } } if (variableType != null) { autoVariable = Variable.Create(property.Name, variableType, VariableModifiers.None); Argument argument = property.Value as Argument; if (argument != null) { autoVariable.Default = argument.Expression; } } return autoVariable; }
public void UpdateDropDownItems() { if (this.IsUpdatingDropDownItems) { return; } List <DynamicActivityProperty> list = new List <DynamicActivityProperty>(); bool currentSelectionFound = false; if (this.Properties != null) { foreach (ModelItem modelItem in this.Properties) { DynamicActivityProperty property = modelItem.GetCurrentValue() as DynamicActivityProperty; if (property != null) { if (this.Filter == null || this.Filter(property)) { DynamicActivityProperty clone = new DynamicActivityProperty(); clone.Name = property.Name; clone.Type = property.Type; list.Add(clone); if (StringComparer.Ordinal.Equals(this.SelectedPropertyName, property.Name)) { currentSelectionFound = true; } } } } } string savedSelectedPropertyName = this.SelectedPropertyName; if (!currentSelectionFound) { if (!string.IsNullOrEmpty(this.SelectedPropertyName)) { DynamicActivityProperty unresolvedProperty = new DynamicActivityProperty(); unresolvedProperty.Name = this.SelectedPropertyName; list.Add(unresolvedProperty); } } list.Sort(new DynamicaActivityPropertyComparer()); this.IsUpdatingDropDownItems = true; this.DropDownItems = new ReadOnlyCollection <DynamicActivityProperty>(list); this.SelectedPropertyName = savedSelectedPropertyName; this.IsUpdatingDropDownItems = false; }
public static DynamicActivityProperty Find(ModelItemCollection properties, string propertyName) { foreach (ModelItem entry in properties) { DynamicActivityProperty property = (DynamicActivityProperty)entry.GetCurrentValue(); if (StringComparer.Ordinal.Equals(property.Name, propertyName)) { return(property); } } return(null); }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { DynamicActivityProperty property = value as DynamicActivityProperty; if (property == null) { return(null); } if (property.Type == null) { return(string.Format(CultureInfo.CurrentUICulture, SR.PropertyReferenceNotResolved, property.Name)); } else { return(TypeNameHelper.GetDisplayName(property.Type, false)); } }
private void FillArguments() { string propertyName = PropertyReferenceUtilities.GetPropertyReference(this.ModelItem.GetCurrentValue(), DelegatePropertyName); if (string.IsNullOrEmpty(propertyName)) { return; } ModelTreeManager manager = this.Context.Services.GetService <ModelTreeManager>(); DynamicActivityProperty property = DynamicActivityPropertyUtilities.Find(manager.Root.Properties["Properties"].Collection, propertyName); if (property == null || !property.Type.IsSubclassOf(typeof(ActivityDelegate))) { return; } ActivityDelegateMetadata metadata = ActivityDelegateUtilities.GetMetadata(property.Type); ModelItemCollection collection = this.ModelItem.Properties[DelegateArgumentsPropertyName].Value.Properties["ItemsCollection"].Collection; Type underlyingArgumentType = this.ModelItem.Properties[DelegateArgumentsPropertyName].Value.GetCurrentValue().GetType().GetGenericArguments()[1]; if (!typeof(Argument).IsAssignableFrom(underlyingArgumentType)) { return; } if (collection.Count == 0) { using (ModelEditingScope change = collection.BeginEdit(SR.FillDelegateArguments)) { Type dictionaryEntryType = typeof(ModelItemKeyValuePair <,>).MakeGenericType(new Type[] { typeof(string), underlyingArgumentType }); foreach (ActivityDelegateArgumentMetadata arg in metadata) { Argument argument = Argument.Create(arg.Type, arg.Direction == ActivityDelegateArgumentDirection.In ? ArgumentDirection.In : ArgumentDirection.Out); object mutableKVPair = Activator.CreateInstance(dictionaryEntryType, new object[] { arg.Name, argument }); ModelItem argumentKVPair = collection.Add(mutableKVPair); } change.Complete(); } } }
public static ActivityBuilder ToBuilder(DynamicActivity dynamicActivity) { var activityBuilder = new ActivityBuilder { Implementation = dynamicActivity.Implementation != null?dynamicActivity.Implementation() : null, Name = dynamicActivity.Name }; foreach (var item in dynamicActivity.Attributes) { activityBuilder.Attributes.Add(item); } foreach (var item in dynamicActivity.Constraints) { activityBuilder.Constraints.Add(item); } foreach (var item in dynamicActivity.Properties) { var property = new DynamicActivityProperty { Name = item.Name, Type = item.Type, Value = null }; foreach (var attribute in item.Attributes) { property.Attributes.Add(attribute); } activityBuilder.Properties.Add(property); } VisualBasic.SetSettings(activityBuilder, VisualBasic.GetSettings(dynamicActivity)); return(activityBuilder); }
private void populateDynamicActivity() { //get the list of rules from repository var rules = ObjectFactory .Container .GetInstance <IRuleRepository>() .Rules .ToList(); //Declare a dynamic property as the view model var inProperty = new DynamicActivityProperty { Name = "Model", Type = typeof(InArgument <HomeIndexViewModel>) }; _dynamicActivity = new DynamicActivity() { Properties = { inProperty } }; //Import references Common.AddVbSetting(activity); var sequence = new Sequence(); activity.Implementation = () => sequence //Sort Descending - those added first are lowest priority var sortedRules = rules.OrderBy(x => x.Priority).ToList(); foreach (var inRule in rules) { var outRule = RuleConverter.ToIfActivity(inRule); sequence.Activities.Add(outRule); } }
public bool CreateNewArgumentWrapper() { bool result = false; if (null != this.ActivitySchema) { DynamicActivityProperty property = new DynamicActivityProperty() { Name = this.GetDefaultName(), Type = this.GetDefaultType(), }; DesignTimeArgument wrapper = null; using (ModelEditingScope scope = this.ActivitySchema.BeginEdit((string)this.FindResource("addNewArgumentDescription"))) { ModelItem argument = this.GetArgumentCollection().Add(property); wrapper = new DesignTimeArgument(argument, this); this.argumentWrapperCollection.Add(wrapper); scope.Complete(); result = true; } this.dgHelper.BeginRowEdit(wrapper); } return result; }
private static bool IsActivityDelegate(DynamicActivityProperty instance) { return(instance.Type == typeof(ActivityDelegate) || instance.Type.IsSubclassOf(typeof(ActivityDelegate))); }
protected override void Execute(NativeActivityContext context) { StringBuilder errorBuilder = new StringBuilder(); InvokeDelegate activity = this.Activity.Get(context); string reference = PropertyReferenceUtilities.GetPropertyReference(activity, "Delegate"); if (reference != null) { DynamicActivityProperty property = null; ModelTreeManager manager = this.EditingContext.Services.GetService <ModelTreeManager>(); if (manager.Root.ItemType == typeof(ActivityBuilder)) { property = DynamicActivityPropertyUtilities.Find(manager.Root.Properties["Properties"].Collection, reference); } if (property == null) { this.EmitValidationError(context, string.Format(CultureInfo.CurrentUICulture, SR.PropertyReferenceNotResolved, reference)); return; } if (property.Type == typeof(ActivityDelegate)) { this.EmitValidationWarning(context, string.Format(CultureInfo.CurrentUICulture, SR.PropertyIsNotAConcreteActivityDelegate, reference)); return; } if (!property.Type.IsSubclassOf(typeof(ActivityDelegate))) { this.EmitValidationError(context, string.Format(CultureInfo.CurrentUICulture, SR.PropertyIsNotAnActivityDelegate, reference)); return; } if (property.Type.IsAbstract) { this.EmitValidationWarning(context, string.Format(CultureInfo.CurrentUICulture, SR.PropertyIsNotAConcreteActivityDelegate, reference)); return; } ActivityDelegateMetadata metadata = ActivityDelegateUtilities.GetMetadata(property.Type); if (activity.DelegateArguments.Count != metadata.Count) { this.EmitValidationWarning(context, SR.WrongNumberOfArgumentsForActivityDelegate); return; } foreach (ActivityDelegateArgumentMetadata expectedArgument in metadata) { Argument delegateArgument = null; if (activity.DelegateArguments.TryGetValue(expectedArgument.Name, out delegateArgument)) { if ((expectedArgument.Direction == ActivityDelegateArgumentDirection.In && delegateArgument.Direction != ArgumentDirection.In) || (expectedArgument.Direction == ActivityDelegateArgumentDirection.Out && delegateArgument.Direction != ArgumentDirection.Out)) { errorBuilder.AppendFormat(CultureInfo.CurrentUICulture, SR.DelegateArgumentsDirectionalityMismatch, expectedArgument.Name, delegateArgument.Direction, expectedArgument.Direction); } if (delegateArgument.ArgumentType != expectedArgument.Type) { if (expectedArgument.Direction == ActivityDelegateArgumentDirection.In) { if (!TypeHelper.AreTypesCompatible(delegateArgument.ArgumentType, expectedArgument.Type)) { errorBuilder.AppendFormat(CultureInfo.CurrentUICulture, SR.DelegateInArgumentTypeMismatch, expectedArgument.Name, expectedArgument.Type, delegateArgument.ArgumentType); } } else { if (!TypeHelper.AreTypesCompatible(expectedArgument.Type, delegateArgument.ArgumentType)) { errorBuilder.AppendFormat(CultureInfo.CurrentUICulture, SR.DelegateOutArgumentTypeMismatch, expectedArgument.Name, expectedArgument.Type, delegateArgument.ArgumentType); } } } } else { errorBuilder.AppendFormat(CultureInfo.CurrentUICulture, SR.DelegateArgumentMissing, expectedArgument.Name); } } if (errorBuilder.Length > 0) { this.EmitValidationWarning(context, errorBuilder.ToString()); } } }
private object TransformAndGetPropertySourceLocation(XamlReader reader, SourceTextScanner sourceTextScanner, SourceLocationFoundCallback sourceLocationFoundCallback) { // <property name, value's start location> Dictionary <string, SourceLocation> propertyValueLocationMapping = new Dictionary <string, SourceLocation>(); object deserializedObject = null; object earlyResult = null; UsingXamlWriter( new XamlObjectWriter(reader.SchemaContext), delegate(XamlObjectWriter objectWriter) { if (this.XamlSchemaContext.HasLocalAssembly) { this.CopyNamespacesAndAddLocalAssembly(reader, objectWriter); } if (!(reader is IXamlLineInfo)) { XamlServices.Transform(reader, objectWriter); earlyResult = objectWriter.Result; return; } XamlType dynamicActivityPropertyType = this.XamlSchemaContext.GetXamlType(typeof(DynamicActivityProperty)); while (reader.Read()) { // read SubTree will moves the reader pointed to // element after its EO. So, we need to use a while while (!reader.IsEof && reader.NodeType == XamlNodeType.StartObject && dynamicActivityPropertyType == reader.Type) { KeyValuePair <string, SourceLocation> nameSourceLocation = this.TransformDynamicActivityProperty(reader.ReadSubtree(), objectWriter, sourceTextScanner); if (nameSourceLocation.Key != null && nameSourceLocation.Value != null && !propertyValueLocationMapping.ContainsKey(nameSourceLocation.Key)) { propertyValueLocationMapping.Add(nameSourceLocation.Key, nameSourceLocation.Value); } } if (!reader.IsEof) { objectWriter.WriteNode(reader); } } deserializedObject = objectWriter.Result; }); if (earlyResult != null) { return(earlyResult); } ActivityBuilder activityBuilder = deserializedObject as ActivityBuilder; if (activityBuilder == null) { return(deserializedObject); } foreach (KeyValuePair <string, SourceLocation> propertyValueLocation in propertyValueLocationMapping) { string propertyName = propertyValueLocation.Key; SourceLocation propertyLocation = propertyValueLocation.Value; if (!activityBuilder.Properties.Contains(propertyName)) { SharedFx.Assert(string.Format(CultureInfo.CurrentCulture, "no such property:{0}", propertyName)); continue; } DynamicActivityProperty property = activityBuilder.Properties[propertyName]; if (property == null || property.Value == null) { SharedFx.Assert(string.Format(CultureInfo.CurrentCulture, "no such property value:{0}", propertyName)); continue; } object expression = (property.Value is Argument) ? ((Argument)property.Value).Expression : null; if (expression != null) { sourceLocationFoundCallback(expression, propertyLocation); } else { sourceLocationFoundCallback(property.Value, propertyLocation); } } return(deserializedObject); }
private void menuRun_Click(object sender, RoutedEventArgs e) { #if RUNWF try { wd.Flush(); Activity activity = null; using (StringReader reader = new StringReader(wd.Text)) { activity = ActivityXamlServices.Load(reader); } if (activity != null) { #if LISTARGS //list any defined arguments messageListBox.Items.Clear(); ModelService ms = wd.Context.Services.GetService <ModelService>(); ModelItemCollection items = ms.Root.Properties["Properties"].Collection; foreach (var item in items) { if (item.ItemType == typeof(DynamicActivityProperty)) { DynamicActivityProperty prop = item.GetCurrentValue() as DynamicActivityProperty; if (prop != null) { Argument arg = prop.Value as Argument; if (arg != null) { messageListBox.Items.Add(String.Format( "Name={0} Type={1} Direction={2} Exp={3}", prop.Name, arg.ArgumentType, arg.Direction, arg.Expression)); } } } } #endif StringBuilder sb = new StringBuilder(); using (StringWriter writer = new StringWriter(sb)) { Console.SetOut(writer); try { WorkflowInvoker.Invoke(activity); } catch (Exception exception) { MessageBox.Show(this, exception.Message, "Exception", MessageBoxButton.OK, MessageBoxImage.Error); } finally { MessageBox.Show(this, sb.ToString(), "Results", MessageBoxButton.OK, MessageBoxImage.Information); } } StreamWriter standardOutput = new StreamWriter(Console.OpenStandardOutput()); Console.SetOut(standardOutput); } } catch (Exception exception) { MessageBox.Show(this, exception.Message, "Outer Exception", MessageBoxButton.OK, MessageBoxImage.Error); } #endif }