public static Command NextPageCommand <TItem>() where TItem : VText
{
var pagesArgument = new IntegerArgument("pages", Text("The amount of pages you would like to advance"));
void NextPageAction <TItemInner>(Game game, Command command) where TItemInner : VText
{
var element = game.Elements[^ 1] as MultiPageListElement <TItemInner>;
public void WithNotStringArgument_ShouldThrowException()
{
var notStringArgument = new IntegerArgument("4");
var exception = Assert.Throws <ArgumentException>(() => StringArgument.GetValue(notStringArgument));
Assert.Equal(ErrorMessages.IncorrectArgumentTypeError, exception.Message);
}
public void WithCorrectArgument_ShouldReturnValue()
{
var value = 5;
var integerArgument = new IntegerArgument(value.ToString());
var result = IntegerArgument.GetValue(integerArgument);
Assert.Equal(value, result);
}
public void IntegerArgument_ParseShouldFail_BecauseNumberIsTooLow()
{
// Arrange
IntegerArgument argument = new IntegerArgument(minimum: 0);
IStringReader reader = new StringReader("-10");
// Act
ReadResults readResults = argument.Parse(reader, out _);
// Assert
Assert.IsFalse(readResults.Successful);
}
public void WithCorrectNumberValue_ShouldSetValueField()
{
var value = "5";
var integerArgument = new IntegerArgument(value);
var field = integerArgument.GetType().GetField("value", BindingFlags.NonPublic | BindingFlags.Instance);
var expectedValue = int.Parse(value);
var actualValue = (int)field.GetValue(integerArgument);
Assert.Equal(expectedValue, actualValue);
}
public void IntegerArgument_ParseShouldFail_BecauseInvalidInteger()
{
// Arrange
IntegerArgument argument = new IntegerArgument();
IStringReader reader = new StringReader("1.5");
// Act
ReadResults readResults = argument.Parse(reader, out _);
// Assert
Assert.IsFalse(readResults.Successful);
}
public void IntegerResult_ShouldHaveCorrectValue()
{
// Arrange
IntegerArgument argument = new IntegerArgument();
IStringReader reader = new StringReader("123");
// Act
argument.Parse(reader, out int result);
// Assert
Assert.AreEqual(result, 123);
}
public void IntegerArgument_ParseShouldSucceed()
{
// Arrange
IntegerArgument argument = new IntegerArgument();
IStringReader reader = new StringReader("123");
// Act
ReadResults readResults = argument.Parse(reader, out _);
// Assert
Assert.IsTrue(readResults.Successful);
}
public static CommandBuilder WithStandardListAction <TGame, TItem>(this CommandBuilder commandBuilder,
Func <TGame, Command, List <TItem> > source, Action <List <TItem>, TGame, Command> followup,
params Func <TItem, bool>[] filters)
where TGame : Game
where TItem : VText
{
var prefixArgument = new StringArgument("Prefix", Text("the prefix of your search"));
var suffixArgument = new StringArgument("suffix", Text("the suffix of your search"));
var suffixTag = new Tag("-suffix", Text("Allows you to search with a suffix"), new List <Argument> {
suffixArgument
});
var infixArgument = new StringArgument("infix", Text("the infix of your search"));
var infixTag = new Tag("-infix", Text("Allows you to search with an infix"), new List <Argument> {
infixArgument
});
var lengthArgument = new IntegerArgument("Length", Text("the length of your search"));
var lengthTag = new Tag("-length", Text("Allows your to search with a set length"), new List <Argument> {
lengthArgument
});
var minLengthArgument = new IntegerArgument("Minimum Length", Text("the minimum length of your search"));
var minLengthTag = new Tag("-min", Text("Allows your to search with a minimum length"), new List <Argument> {
minLengthArgument
});
var maxLengthArgument = new IntegerArgument("Maximum Length", Text("the maximum length of your search"));
var maxLengthTag = new Tag("-max", Text("Allows your to search with a maximum length"), new List <Argument> {
maxLengthArgument
});
commandBuilder.WithOptionalArguments(prefixArgument);
commandBuilder.WithTags(suffixTag, infixTag, lengthTag, minLengthTag, maxLengthTag);
bool Filter(TItem item)
{
var matchCriteria = new StringMatching.MatchCriteria(
prefixArgument.IsFilled() ? prefixArgument.Content : null,
suffixArgument.IsFilled() ? suffixArgument.Content : null,
infixArgument.IsFilled() ? infixArgument.Content : null,
lengthArgument.IsFilled() ? lengthArgument.Content : -1,
minLengthArgument.IsFilled() ? minLengthArgument.Content : -1,
maxLengthArgument.IsFilled() ? maxLengthArgument.Content : -1,
true);
return(matchCriteria.IsMatch(item.GetContentRaw()));
}
var completeFilters = filters.ToList();
completeFilters.Add(Filter);
return(WithListAction(commandBuilder, source, followup, completeFilters.ToArray()));
}
/// <summary>
/// Gets the value for an <see cref="IntegerArgument"/>.
/// </summary>
/// <param name="argument">The argument.</param>
/// <returns>The value.</returns>
public override int? GetValue(IntegerArgument argument)
{
string value;
if (GetCommandLineArgumentValueAsString(argument.Id, _subArgs, out value))
{
int retval;
if (StaticUtils.TryParseValue(value, null, out retval))
{
return retval;
}
else
{
throw new InvalidOperationArgumentException(argument);
}
}
return null;
}
/// <summary>
/// Typeds the value from entity.
/// </summary>
/// <param name="argument">The argument.</param>
/// <returns>List{TypedValue}.</returns>
/// <exception cref="System.Exception">Unhandled expression result type</exception>
public static List <TypedValue> TypedValueFromEntity(ActivityArgument argument)
{
List <TypedValue> typedValues = new List <TypedValue>();
TypedValue typedValue = new TypedValue();
if (argument == null)
{
typedValue.Type = DatabaseType.UnknownType;
typedValues.Add(typedValue);
}
else if (argument.Is <StringArgument>())
{
typedValue.Type = DatabaseType.StringType;
StringArgument stringArgument = argument.As <StringArgument>();
if (stringArgument.StringParameterValue != null)
{
typedValue.Value = stringArgument.StringParameterValue;
}
typedValues.Add(typedValue);
}
else if (argument.Is <IntegerArgument>())
{
typedValue.Type = DatabaseType.Int32Type;
IntegerArgument integerArgument = argument.As <IntegerArgument>();
if (integerArgument.IntParameterValue.HasValue)
{
typedValue.Value = integerArgument.IntParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <CurrencyArgument>())
{
typedValue.Type = DatabaseType.CurrencyType;
CurrencyArgument currencyArgument = argument.As <CurrencyArgument>();
if (currencyArgument.DecimalParameterValue.HasValue)
{
typedValue.Value = currencyArgument.DecimalParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <DecimalArgument>())
{
typedValue.Type = DatabaseType.DecimalType;
DecimalArgument decimalArgument = argument.As <DecimalArgument>();
if (decimalArgument.DecimalParameterValue.HasValue)
{
typedValue.Value = decimalArgument.DecimalParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <DateArgument>())
{
typedValue.Type = DatabaseType.DateType;
DateArgument dateArgument = argument.As <DateArgument>();
if (dateArgument.DateParameterValue.HasValue)
{
typedValue.Value = dateArgument.DateParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <TimeArgument>())
{
typedValue.Type = DatabaseType.TimeType;
TimeArgument timeArgument = argument.As <TimeArgument>();
if (timeArgument.TimeParameterValue.HasValue)
{
typedValue.Value = timeArgument.TimeParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <DateTimeArgument>())
{
typedValue.Type = DatabaseType.DateTimeType;
DateTimeArgument dateTimeArgument = argument.As <DateTimeArgument>();
if (dateTimeArgument.DateTimeParameterValue.HasValue)
{
typedValue.Value = dateTimeArgument.DateTimeParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <GuidArgument>())
{
typedValue.Type = DatabaseType.GuidType;
GuidArgument guidArgument = argument.As <GuidArgument>();
if (guidArgument.GuidParameterValue.HasValue)
{
typedValue.Value = guidArgument.GuidParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <BoolArgument>())
{
typedValue.Type = DatabaseType.BoolType;
BoolArgument boolArgument = argument.As <BoolArgument>();
if (boolArgument.BoolParameterValue.HasValue)
{
typedValue.Value = boolArgument.BoolParameterValue.Value;
}
typedValues.Add(typedValue);
}
else if (argument.Is <ResourceArgument>())
{
TypedArgument typedArgument = argument.As <TypedArgument>();
if (typedArgument != null && typedArgument.ConformsToType != null)
{
// Interrogate to get it's base type
EntityType type = Entity.Get <EntityType>(typedArgument.ConformsToType.Id);
EntityRef enumType = new EntityRef("core", "enumValue");
if (type.GetAncestorsAndSelf().FirstOrDefault(a => a.Id == enumType.Id) != null)
{
typedValue.Type = DatabaseType.ChoiceRelationshipType;
}
else
{
typedValue.Type = DatabaseType.InlineRelationshipType;
}
}
ResourceArgument resourceArgument = argument.As <ResourceArgument>();
if (resourceArgument.ResourceParameterValue != null)
{
// Is this an enum type (or are any of it's base types an enum type??
var conformsToType = resourceArgument.ConformsToType;
typedValue.SourceEntityTypeId = conformsToType != null ? conformsToType.Id : 0;
typedValue.Value = resourceArgument.ResourceParameterValue.Id;
}
typedValues.Add(typedValue);
}
else if (argument.Is <ResourceListArgument>())
{
TypedArgument typedArgument = argument.As <TypedArgument>();
if (typedArgument != null && typedArgument.ConformsToType != null)
{
// Interrogate to get it's base type
EntityType type = Entity.Get <EntityType>(typedArgument.ConformsToType.Id);
EntityRef enumType = new EntityRef("core", "enumValue");
if (type.GetAncestorsAndSelf().FirstOrDefault(a => a.Id == enumType.Id) != null)
{
typedValue.Type = DatabaseType.ChoiceRelationshipType;
}
else
{
typedValue.Type = DatabaseType.InlineRelationshipType;
}
}
ResourceListArgument resourceList = argument.As <ResourceListArgument>();
if (resourceList.ResourceListParameterValues == null || resourceList.ResourceListParameterValues.Count <= 0)
{
typedValues.Add(typedValue);
}
else
{
typedValues.AddRange(resourceList.ResourceListParameterValues.Select(parameterValue => new TypedValue
{
Type = typedValue.Type, SourceEntityTypeId = resourceList.ConformsToType.Id, Value = parameterValue.Id
}));
}
}
else
{
// Throw as we cannot convert type:(
throw new Exception("Unhandled expression result type");
}
return(typedValues);
}
/// <summary>
/// Method for creating typed values from DatabaseType.
/// Caller must save.
/// </summary>
/// <param name="typedValue"></param>
/// <param name="forceResourceLists"></param>
/// <returns></returns>
public static ActivityArgument CreateTypedValueEntity(TypedValue typedValue, bool forceResourceLists = false)
{
DatabaseType dbType = typedValue.Type;
IEntity result;
if (dbType is UnknownType || dbType == null)
{
return(null);
}
if (dbType is StringType || dbType is XmlType)
{
result = new StringArgument {
StringParameterValue = (string)typedValue.Value
};
}
else if (dbType is Int32Type) // includes autonumber
{
result = new IntegerArgument {
IntParameterValue = (int?)typedValue.Value
};
}
else if (dbType is CurrencyType)
{
result = new CurrencyArgument {
DecimalParameterValue = (decimal?)typedValue.Value
};
}
else if (dbType is DecimalType)
{
result = new DecimalArgument {
DecimalParameterValue = (decimal?)typedValue.Value
};
}
else if (dbType is DateType)
{
result = new DateArgument {
DateParameterValue = (DateTime?)typedValue.Value
};
}
else if (dbType is TimeType)
{
result = new TimeArgument {
TimeParameterValue = (DateTime?)typedValue.Value
};
}
else if (dbType is DateTimeType)
{
result = new DateTimeArgument {
DateTimeParameterValue = (DateTime?)typedValue.Value
};
}
else if (dbType is GuidType)
{
result = new GuidArgument {
GuidParameterValue = (Guid?)typedValue.Value
};
}
else if (dbType is BoolType)
{
result = new BoolArgument {
BoolParameterValue = (bool?)typedValue.Value
};
}
else if (dbType is ChoiceRelationshipType || dbType is InlineRelationshipType || dbType is IdentifierType)
{
// Hmm.. not sure if this is a good idea for identifier types..
long targetId;
if (typedValue.Value == null || !long.TryParse(typedValue.Value.ToString(), out targetId))
{
targetId = 0;
}
IEntity target = targetId > 0 ? Entity.Get(targetId) : null;
if (forceResourceLists)
{
var resourceListArgument = new ResourceListArgument();
if (target != null)
{
resourceListArgument.ResourceListParameterValues.Add(target.As <Resource>());
}
result = resourceListArgument;
}
else
{
var resourceArgument = new ResourceArgument();
if (target != null)
{
resourceArgument.ResourceParameterValue = target.As <Resource>();
}
result = resourceArgument;
}
TypedArgument tResult = result.As <TypedArgument>();
if (typedValue.SourceEntityTypeId > 0)
{
var targetType = Entity.Get <EntityType>(typedValue.SourceEntityTypeId);
tResult.ConformsToType = targetType;
}
}
else
{
// IdentifierType
// BinaryType
// StructureLevelsType
throw new Exception("Unhandled expression result type: " + dbType.GetType().Name);
}
// Caller must save
return(result.As <ActivityArgument>());
}
/// <summary>
/// Method for creating typed values from DatabaseType.
/// Caller must save.
/// </summary>
/// <param name="dbType"></param>
/// <param name="forceResourceLists"></param>
/// <returns></returns>
public static ActivityArgument CreateTypedValueEntity(DatabaseType dbType, bool forceResourceLists = false)
{
IEntity result;
if (dbType is UnknownType || dbType == null)
{
return(null);
}
if (dbType is StringType || dbType is XmlType)
{
result = new StringArgument();
}
else if (dbType is Int32Type) // includes autonumber
{
result = new IntegerArgument();
}
else if (dbType is CurrencyType)
{
result = new CurrencyArgument();
}
else if (dbType is DecimalType)
{
result = new DecimalArgument();
}
else if (dbType is DateType)
{
result = new DateArgument();
}
else if (dbType is TimeType)
{
result = new TimeArgument();
}
else if (dbType is DateTimeType)
{
result = new DateTimeArgument();
}
else if (dbType is GuidType)
{
result = new GuidArgument();
}
else if (dbType is BoolType)
{
result = new BoolArgument();
}
else if (dbType is ChoiceRelationshipType || dbType is InlineRelationshipType || dbType is IdentifierType)
{
// Hmm.. not sure if this is a good idea for identifier types..
if (forceResourceLists)
{
result = new ResourceListArgument();
}
else
{
result = new ResourceArgument();
}
}
else
{
// IdentifierType
// BinaryType
// StructureLevelsType
throw new Exception("Unhandled expression result type: " + dbType.GetType().Name);
}
// Caller must save
return(result.As <ActivityArgument>());
}
public void SimpleCountingLoop( )
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var wf = new Workflow()
{
Name = "Simple Counting " + DateTime.Now
};
wf.AddDefaultExitPoint();
var input = new ResourceListArgument
{
Name = "in"
};
wf.InputArguments.Add(input.As <ActivityArgument>());
var output = new IntegerArgument
{
Name = "out"
};
wf.OutputArguments.Add(output.As <ActivityArgument>());
var employeeType = Entity.Get <EntityType>(new EntityRef("test", "employee"));
wf.AddVariable <IntegerArgument>("Count")
.AddAssignToVar("Assign To Count", "0", "Count")
.AddForEach("foreach1", "in", "test:employee")
.AddAssignToVar("Assign To Count 2", "[Count] + 1", "Count", "foreach1", "Loop")
.AddTransition("Assign To Count 2", "foreach1");
ActivityTestHelper.AddAssignToVar(wf, "AssignOutput", "Count", "out");
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
var createdCount = 15;
var resources = Enumerable.Range(0, createdCount).Select(v => new Person()
{
Name = v.ToString()
}).ToList();
Entity.Save(resources);
var wfInput = new Dictionary <string, object>
{
{
"in", resources
}
};
var run = (RunWorkflow(wf, wfInput));
IDictionary <string, object> outputs = run.GetOutput();
Assert.AreEqual(1, outputs.Count, "There is one output argument");
var result = (int)outputs["out"];
Assert.AreEqual(createdCount, result, "The loop ran the correct number of times");
}
}
public void LoopWithinLoop_bug_17651()
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
var wf = new Workflow()
{
Name = "LoopWithinLoop_bug_17651"
};
wf.AddDefaultExitPoint();
var count = new IntegerArgument()
{
Name = "count"
};
ActivityTestHelper.AddVariableToWorkflow(wf, count.As <ActivityArgument>());
wf.AddExpressionToWorkflowVariable("count", "0");
var foreachX = new ForEachResource()
{
Name = "ForEachX" + DateTime.Now
};
var foreachXAs = foreachX.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, foreachXAs, "List", "all([Workflow Event])");
wf.FirstActivity = foreachXAs;
wf.ContainedActivities.Add(foreachXAs);
var foreachY = new ForEachResource()
{
Name = "ForEachY" + DateTime.Now
};
var foreachYAs = foreachY.As <WfActivity>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, foreachYAs, "List", "all([Event Email Priority Enum])");
wf.ContainedActivities.Add(foreachYAs);
ActivityTestHelper.AddTransition(wf, foreachXAs, foreachYAs, "Loop");
ActivityTestHelper.AddTermination(wf, foreachXAs, "Finished");
var assign = new AssignToVariable()
{
Name = "Assign"
};
var assignAs = assign.As <WfActivity>();
assign.TargetVariable = count.As <ActivityArgument>();
ActivityTestHelper.AddExpressionToActivityArgument(wf, assignAs, "Value", "count + 1");
wf.ContainedActivities.Add(assignAs);
ActivityTestHelper.AddTransition(wf, foreachYAs, assignAs, "Loop");
ActivityTestHelper.AddTransition(wf, foreachYAs, foreachXAs, "Finished");
ActivityTestHelper.AddTransition(wf, assignAs, foreachYAs);
var output = new IntegerArgument()
{
Name = "out"
};
var outputAs = output.As <ActivityArgument>();
wf.OutputArguments.Add(outputAs);
ActivityTestHelper.AddAssignToVar(wf, "Set Output", "count", "out");
ActivityTestHelper.AddMissingExpressionParametersToWorkflow(wf);
wf.Save();
ToDelete.Add(wf.Id);
var run = (RunWorkflow(wf));
var outputs = run.GetOutput();
Assert.AreEqual(1, outputs.Count, "There is one output argument");
var result = (int)outputs["out"];
var triggeredOnCount = Entity.GetInstancesOfType <WorkflowEventEnum>(false).Count();
var runStateCount = Entity.GetInstancesOfType <EventEmailPriorityEnum>(false).Count();
Assert.AreEqual(triggeredOnCount * runStateCount, result, "The nested loops ran the correct number of times.");
}
}
public int GetIntArgument(string argumentName)
{
Validator.ValidateNotNull(argumentName);
Validator.ValidateArgumentName(argumentName, this.namesArguments);
return(IntegerArgument.GetValue(namesArguments[argumentName]));
}
/// <summary> /// Gets the value for an <see cref="IntegerArgument"/>. /// </summary> /// <param name="argument">The argument.</param> /// <returns>The value.</returns> /// <exception cref="InvalidOperationArgumentException"> /// May be thrown if the value for the argument cannot be converted to the appropriate type. /// </exception> public abstract int? GetValue(IntegerArgument argument);
public void WithNullArgument_ShouldThrowException()
{
Assert.Throws <ArgumentNullException>(() => IntegerArgument.GetValue(null));
}
private static void PopulateValueFromArgument(ActivityArgument argument, ReportAnalyserColumn reportColumn)
{
if (argument.Is <StringArgument>())
{
StringArgument stringArgument = argument.As <StringArgument>();
reportColumn.Value = stringArgument.StringParameterValue;
}
else if (argument.Is <IntegerArgument>())
{
IntegerArgument integerArgument = argument.As <IntegerArgument>();
if (integerArgument.IntParameterValue != null)
{
reportColumn.Value = integerArgument.IntParameterValue.ToString();
}
}
else if (argument.Is <CurrencyArgument>())
{
CurrencyArgument currencyArgument = argument.As <CurrencyArgument>();
if (currencyArgument.DecimalParameterValue != null)
{
reportColumn.Value = currencyArgument.DecimalParameterValue.ToString();
}
}
else if (argument.Is <DecimalArgument>())
{
DecimalArgument decimalArgument = argument.As <DecimalArgument>();
if (decimalArgument.DecimalParameterValue != null)
{
reportColumn.Value = decimalArgument.DecimalParameterValue.ToString();
}
}
else if (argument.Is <DateArgument>())
{
DateArgument dateArgument = argument.As <DateArgument>();
if (dateArgument.DateParameterValue != null)
{
//convert the date value to YYYY-MM-DD format
DateTime dateValue = (DateTime)dateArgument.DateParameterValue;
reportColumn.Value = dateValue.ToString("yyyy-MM-dd");
}
}
else if (argument.Is <TimeArgument>())
{
TimeArgument timeArgument = argument.As <TimeArgument>();
if (timeArgument.TimeParameterValue != null)
{
//convert the time value to YYYY-MM-DDTHH:mm:ssZ format
DateTime timeValue = (DateTime)timeArgument.TimeParameterValue;
reportColumn.Value = timeValue.ToString("yyyy-MM-ddTHH:mm:ssZ");
}
}
else if (argument.Is <DateTimeArgument>())
{
DateTimeArgument dateTimeArgument = argument.As <DateTimeArgument>();
if (dateTimeArgument.DateTimeParameterValue != null)
{
//convert the datetime value to YYYY-MM-DDTHH:mm:ssZ format
DateTime dateTimeValue = (DateTime)dateTimeArgument.DateTimeParameterValue;
reportColumn.Value = dateTimeValue.ToString("yyyy-MM-ddTHH:mm:ssZ");
}
}
else if (argument.Is <GuidArgument>())
{
GuidArgument guidArgument = argument.As <GuidArgument>();
if (guidArgument.GuidParameterValue != null)
{
reportColumn.Value = guidArgument.GuidParameterValue.ToString();
}
}
else if (argument.Is <BoolArgument>())
{
BoolArgument boolArgument = argument.As <BoolArgument>();
if (boolArgument.BoolParameterValue != null)
{
reportColumn.Value = boolArgument.BoolParameterValue.ToString();
}
}
else if (argument.Is <TypedArgument>())
{
TypedArgument typedArgument = argument.As <TypedArgument>();
EntityType type = Entity.Get <EntityType>(typedArgument.ConformsToType);
if (type.IsOfType.FirstOrDefault(t => t.Alias == "core:enumType") != null)
{
// A choice field
reportColumn.Type = new ChoiceRelationshipType();
}
else
{
// Is a related resource
reportColumn.Type = new InlineRelationshipType();
}
ResourceListArgument rla = argument.As <ResourceListArgument>();
if (rla.ResourceListParameterValues != null && rla.ResourceListParameterValues.Count > 0)
{
Dictionary <long, string> values = new Dictionary <long, string>();
foreach (Resource resourceListParameterValue in rla.ResourceListParameterValues)
{
values[resourceListParameterValue.Id] = resourceListParameterValue.Name;
}
reportColumn.Values = values;
}
}
}
/// <summary>Given an arg inst and a value create and activityArgument ready for storage.</summary>
/// <param name="activity">The <see cref="WfActivity"/> being run. This cannot be null.</param>
/// <param name="arg">The argument for the activity. This cannot be null.</param>
/// <param name="value">The value of the argument. Its type is determined by <paramref name="arg"/>. This may be null for certain argument types.</param>
/// <returns>The converted value.</returns>
/// <exception cref="ArgumentNullException">Neither <paramref name="activity"/> nor <paramref name="arg"/> can be null.</exception>
/// <exception cref="ArgumentException"><paramref name="arg"/> must be of a supported type.</exception>
public static ActivityArgument ConvertArgInstValue(WfActivity activity, ActivityArgument arg, object value)
{
if (activity == null)
{
throw new ArgumentNullException(nameof(activity));
}
if (arg == null)
{
throw new ArgumentNullException(nameof(arg));
}
ActivityArgument result;
string name = $"{activity.Name ?? "[Unnamed]"}.{arg.Name ?? "[Unnamed]"}";
if (arg.Is <ResourceListArgument>())
{
var list = (IEnumerable <IEntity>)value;
var created = new ResourceListArgument {
Name = name
};
if (list != null)
{
var cleanList = list.Where(e => e != null).Select(e => e.As <Resource>());
created.ResourceListParameterValues.AddRange(cleanList);
}
result = created.As <ActivityArgument>();
}
else if (arg.Is <ResourceArgument>())
{
var res = (IEntity)value;
var created = new ResourceArgument {
Name = name, ResourceParameterValue = res?.As <Resource>()
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <StringArgument>())
{
var created = new StringArgument {
Name = name, StringParameterValue = (string)value
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <BoolArgument>())
{
var created = new BoolArgument {
Name = name, BoolParameterValue = (bool?)value ?? false
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <IntegerArgument>())
{
var created = new IntegerArgument {
Name = name, IntParameterValue = (int?)value ?? 0
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <DecimalArgument>())
{
var created = new DecimalArgument {
Name = name, DecimalParameterValue = (decimal?)value ?? 0
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <CurrencyArgument>())
{
var created = new CurrencyArgument {
Name = name, DecimalParameterValue = (decimal?)value ?? 0
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <DateTimeArgument>())
{
var created = new DateTimeArgument {
Name = name, DateTimeParameterValue = (DateTime?)value
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <DateArgument>())
{
var created = new DateArgument {
Name = name, DateParameterValue = (DateTime?)value
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <TimeArgument>())
{
// ensure that timeparametervalue only ever holds a datetime
var dt = value is TimeSpan?TimeType.NewTime((TimeSpan)value) : (DateTime?)value;
var created = new TimeArgument {
Name = name, TimeParameterValue = dt
};
result = created.As <ActivityArgument>();
}
else if (arg.Is <GuidArgument>())
{
var created = new GuidArgument {
Name = name, GuidParameterValue = (Guid?)value ?? Guid.Empty
};
result = created.As <ActivityArgument>();
}
else
{
throw new ArgumentException($"Unsupported ActivityArgument '{arg.IsOfType.First().Name}' in '{name}'", "arg");
}
return(result);
}
