public void ResourceVarWithEntityExpressionTest( )
{
using (new WorkflowRunContext {
RunTriggersInCurrentThread = true
})
{
Workflow workflow = CreateLoggingWorkflow("The workflow is {{TestResourceArg}}");
var resArg = new ResourceArgument
{
Name = "TestResourceArg"
};
ActivityTestHelper.AddVariableToWorkflow(workflow, resArg.Cast <ActivityArgument>());
workflow.AddEntityExpressionToVariable("TestResourceArg", workflow);
workflow.Save();
ToDelete.Add(workflow.Id);
var run = (RunWorkflow(workflow));
Assert.IsTrue(run.WorkflowRunStatus_Enum == WorkflowRunState_Enumeration.WorkflowRunCompleted, "Run Completed");
}
}
public void Check_StructuredQuery_Invalidation_On_ReportInterface( )
{
using (CacheManager.EnforceCacheHitRules(false))
{
Report report;
ResourceReportNode rootNode;
ResourceArgument exprType;
// Create report
using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true))
{
report = new EntityModel.Report();
rootNode = new ResourceReportNode();
var reportType = EntityModel.Entity.Get <EntityType>("test:person");;
rootNode.ResourceReportNodeType = reportType;
report.RootNode = rootNode.As <ReportNode>();
var column = new EntityModel.ReportColumn( );
exprType = new ResourceArgument();
exprType.ConformsToType = reportType;
var expr = new EntityModel.ResourceExpression();
expr.ReportExpressionResultType = exprType.As <ActivityArgument>();
expr.SourceNode = rootNode.As <ReportNode>();
column.ColumnExpression = expr.As <ReportExpression>();
report.ReportColumns.Add(column);
report.Save();
ctx.CommitTransaction();
}
ReportingInterface ri = new ReportingInterface( );
var settings = new ReportSettings
{
InitialRow = 0,
PageSize = 1,
RequireFullMetadata = true,
RequireBasicMetadata = true
};
// Run and expect 1 column
var result = ri.RunReport(report.Id, settings);
Assert.AreEqual(1, result.ReportQueryColumns.Count);
// Add column
using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true))
{
var column2 = new EntityModel.ReportColumn();
var expr2 = new EntityModel.ResourceExpression();
expr2.SourceNode = rootNode.As <ReportNode>();
expr2.ReportExpressionResultType = exprType.As <ActivityArgument>();
column2.ColumnExpression = expr2.As <ReportExpression>();
report.ReportColumns.Add(column2);
report.Save();
ctx.CommitTransaction();
}
// Run and expect 2 columns
result = ri.RunReport(report.Id, settings);
Assert.AreEqual(2, result.ReportQueryColumns.Count);
}
}
public void ThatTheReplyWorflowRunsAndHasCorrectInput(bool workflowHasInput)
{
var dummyrunner = new DummyWorkflowRunner();
using (var scope = Factory.Current.BeginLifetimeScope(builder =>
{
builder.Register(ctx => dummyrunner).As <IWorkflowRunner>();
}))
using (Factory.SetCurrentScope(scope))
{
var workflow = new Workflow {
WorkflowRunAsOwner = true
};
if (workflowHasInput)
{
var inputArg = new ResourceArgument {
Name = "myInput", ConformsToType = ReplyRecord.ReplyRecord_Type
};
workflow.InputArguments.Add(inputArg.As <ActivityArgument>());
}
var notification = new Notification();
notification.NReplyMapCopy.Add(new ReplyMapEntry {
Name = "Reply", RmeWorkflow = workflow
});
var send = new SendRecord();
notification.SendRecords.Add(send);
notification.Save();
int runs = 0;
var reply = new ReplyRecord {
RrToSend = send, RrReply = "Reply to anything", RrReplyDate = DateTime.UtcNow
};
dummyrunner.StartWorkflowAsyncFn = (startEvent) => {
runs++;
if (workflowHasInput)
{
Assert.That(startEvent.Arguments.Keys, Has.Member("myInput"));
Assert.That(startEvent.Arguments["myInput"] is IEntity, Is.True);
Assert.That(((IEntity)startEvent.Arguments["myInput"]).Id, Is.EqualTo(reply.Id));
}
return("1");
};
reply.Save();
Assert.That(runs, Is.EqualTo(1));
}
}
protected Workflow CreateEditNameWorkflow()
{
var workflow = new Workflow
{
Name = "Test Edit Name Workflow " + DateTime.Now
};
var input = new ResourceArgument
{
Name = "in",
ConformsToType = Resource.Resource_Type
};
var inputAs = input.As <ActivityArgument>();
workflow.InputArguments.Add(inputAs);
workflow.InputArgumentForAction = inputAs;
workflow
.AddDefaultExitPoint()
.AddUpdate("update", "in", new string[] { "in.Name", "in.Name + '1'" })
;
return(workflow);
}
public static ActivityArgument ArgumentForConditionType(ActivityArgument reportColumnExpressionType, string value)
{
IEntity result;
if (reportColumnExpressionType.Is <StringArgument>())
{
result = new StringArgument {
StringParameterValue = value
};
}
else if (reportColumnExpressionType.Is <IntegerArgument>())
{
int intValue;
result = !int.TryParse(value, out intValue) ? new IntegerArgument() : new IntegerArgument {
IntParameterValue = intValue
};
}
else if (reportColumnExpressionType.Is <CurrencyArgument>())
{
decimal currencyValue;
result = !decimal.TryParse(value, out currencyValue) ? new CurrencyArgument() : new CurrencyArgument {
DecimalParameterValue = currencyValue
};
}
else if (reportColumnExpressionType.Is <DecimalArgument>())
{
decimal decimalValue;
result = !decimal.TryParse(value, out decimalValue) ? new DecimalArgument() : new DecimalArgument {
DecimalParameterValue = decimalValue
};
}
else if (reportColumnExpressionType.Is <DateArgument>())
{
DateTime dateValue;
result = !DateTime.TryParse(value, out dateValue) ? new DateArgument() : new DateArgument {
DateParameterValue = dateValue
};
}
else if (reportColumnExpressionType.Is <TimeArgument>())
{
DateTime timeValue;
result = !DateTime.TryParse(value, out timeValue) ? new TimeArgument() : new TimeArgument {
TimeParameterValue = timeValue
};
}
else if (reportColumnExpressionType.Is <DateTimeArgument>())
{
DateTime dateTimeValue;
result = !DateTime.TryParse(value, out dateTimeValue) ? new DateTimeArgument() : new DateTimeArgument {
DateTimeParameterValue = dateTimeValue
};
}
else if (reportColumnExpressionType.Is <GuidArgument>())
{
Guid guidValue;
result = !Guid.TryParse(value, out guidValue) ? new GuidArgument() : new GuidArgument {
GuidParameterValue = guidValue
};
}
else if (reportColumnExpressionType.Is <BoolArgument>())
{
bool boolValue;
result = !bool.TryParse(value, out boolValue) ? new BoolArgument() : new BoolArgument {
BoolParameterValue = boolValue
};
}
else if (reportColumnExpressionType.Is <ResourceArgument>())
{
// Convert the value to an entityId
TypedArgument tResult = reportColumnExpressionType.As <TypedArgument>();
long entityId;
result = new ResourceArgument
{
ResourceParameterValue = long.TryParse(value, out entityId) ? Entity.Get(entityId).As <Resource>() : new Resource(),
ConformsToType = tResult.ConformsToType
};
}
else if (reportColumnExpressionType.Is <ResourceListArgument>())
{
TypedArgument tResult = reportColumnExpressionType.As <TypedArgument>();
long entityId;
result = new ResourceListArgument
{
ResourceListParameterValues = new EntityCollection <Resource>
{
long.TryParse(value, out entityId) ? Entity.Get(entityId).As <Resource>() : new Resource()
},
ConformsToType = tResult.ConformsToType
};
}
else
{
throw new Exception("Unhandled expression result type");
}
// Caller must save
return(result.As <ActivityArgument>());
}
/// <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 PassingValuesBetweenActivities( )
{
// This test creates a person with an age of ten and a workflow that takes the persons resource id as inputs, reads that persons age and writes it out to the log embedded in a message.
// Testing:
// Mapping workflow input arguments.
// Mapping an output argument to a variable.
// Using an expression that contains an input parameter.
var personType = CodeNameResolver.GetTypeByName("AA_Person").As <EntityType>();
var ageField = personType.Fields.First(f => f.Name == "Age");
var peter = Entity.Create(personType).As <Resource>();
peter.Name = "Peter" + DateTime.Now;
peter.SetField(ageField, 10);
peter.Save( );
ToDelete.Add(peter.Id);
var workflow = new Workflow
{
Name = "Wf" + DateTime.Now
};
workflow.AddDefaultExitPoint( );
var resourceIdArg = new ResourceArgument
{
Name = "ResourceId",
ConformsToType = personType
};
var resourceIdArgAs = resourceIdArg.As <ActivityArgument>( );
workflow.InputArguments.Add(resourceIdArg.As <ActivityArgument>( ));
//workflow.Save( );
var workflowAs = workflow.As <WfActivity>( );
// log activity
var log = new LogActivity
{
Name = "log" + DateTime.Now
};
var logAs = log.As <WfActivity>( );
workflow.ContainedActivities.Add(logAs);
workflow.FirstActivity = logAs;
ActivityTestHelper.AddExpressionToActivityArgument(workflow, logAs, "Message", "'Peters age is ' + ResourceId.Age", false);
ActivityTestHelper.AddTermination(workflow, logAs);
workflow.Save( );
ToDelete.Add(workflow.Id);
ActivityImplementationBase nextActivity = workflow.Cast <WfActivity>( ).CreateWindowsActivity( );
var input = new Dictionary <string, object>
{
{
"ResourceId", peter
}
};
var run = (RunWorkflow(workflow, input));
Assert.AreEqual(WorkflowRunState_Enumeration.WorkflowRunCompleted, run.WorkflowRunStatus_Enum, "The workflow run and completed without error");
//RunActivity( nextActivity, input );
}
/// <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);
}
