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