private ExprType CalcExpressionType(ActivityArgument arg) { ExprType result; var resArg = arg.As <ResourceArgument>(); if (resArg != null) { var resType = resArg.ConformsToType ?? Resource.Resource_Type; result = ExprTypeHelper.EntityOfType(resType); } else { var resListArg = arg.As <ResourceListArgument>(); if (resListArg != null) { var resType = resListArg.ConformsToType ?? Resource.Resource_Type; result = ExprType.EntityList.Clone(); result.EntityType = resType; } else { var argType = arg.GetArgumentType(); result = ArgTypeAliasToExprType[argType.Alias]; } } return(result); }
/// <summary> /// Gets the database type represented by a typed value. /// (Avoids unnecessarily attempting to resolve values). /// </summary> /// <param name="argument">The argument.</param> /// <returns>Database type.</returns> /// <exception cref="System.Exception">Unhandled expression result type</exception> public static DatabaseType GetDatabaseType(ActivityArgument argument) { if (argument == null) { return(DatabaseType.UnknownType); } else if (argument.Is <StringArgument>( )) { return(DatabaseType.StringType); } else if (argument.Is <IntegerArgument>( )) { return(DatabaseType.Int32Type); } else if (argument.Is <CurrencyArgument>( )) { return(DatabaseType.CurrencyType); } else if (argument.Is <DecimalArgument>( )) { return(DatabaseType.DecimalType); } else if (argument.Is <DateArgument>( )) { return(DatabaseType.DateType); } else if (argument.Is <TimeArgument>( )) { return(DatabaseType.TimeType); } else if (argument.Is <DateTimeArgument>( )) { return(DatabaseType.DateTimeType); } else if (argument.Is <GuidArgument>( )) { return(DatabaseType.GuidType); } else if (argument.Is <BoolArgument>( )) { return(DatabaseType.BoolType); } else if (argument.Is <ResourceArgument>( ) || 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) { return(DatabaseType.ChoiceRelationshipType); } } return(DatabaseType.InlineRelationshipType); } throw new Exception("Result type is not of a recognised type."); }
/// <summary> /// Update any arguments on the workflow with the resolved expressions /// </summary> private void UpdateWorkflowArguments(IRunState context, Dictionary <WfExpression, object> resolvedExpressions) { foreach (var kvp in resolvedExpressions) { var expression = kvp.Key; ActivityArgument arg = context.Metadata.GetArgumentPopulatedByExpression(expression); context.SetArgValue(arg, kvp.Value); } }
private ExprType GetExpressionType(ActivityArgument arg) { ExprType result; if (!_expressionArgumentTypeCache.TryGetValue(arg.Id, out result)) { throw new ArgumentException("Tried to get an expression type for an uncached expression."); } return(result); }
/// <summary> /// Returns a new activity argument describing the argument type based on the column expression type and condition. /// </summary> /// <param name="reportColumnExpressionType">Type of the report column expression.</param> /// <param name="conditionType">Type of the condition.</param> /// <returns>ActivityArgument.</returns> public static ActivityArgument ArgumentForConditionType(ActivityArgument reportColumnExpressionType, ConditionType conditionType) { switch (conditionType) { case ConditionType.Equal: case ConditionType.NotEqual: case ConditionType.Contains: case ConditionType.StartsWith: case ConditionType.EndsWith: if (reportColumnExpressionType.Is <ResourceArgument>() || reportColumnExpressionType.Is <ResourceListArgument>()) { return(new StringArgument().As <ActivityArgument>()); } return(reportColumnExpressionType); case ConditionType.LastNDays: case ConditionType.LastNDaysTillNow: case ConditionType.NextNDaysFromNow: case ConditionType.NextNDays: case ConditionType.LastNWeeks: case ConditionType.NextNWeeks: case ConditionType.LastNMonths: case ConditionType.NextNMonths: case ConditionType.LastNQuarters: case ConditionType.NextNQuarters: case ConditionType.LastNYears: case ConditionType.NextNYears: case ConditionType.LastNFinancialYears: case ConditionType.NextNFinancialYears: return(new IntegerArgument().As <ActivityArgument>()); case ConditionType.DateEquals: return(new DateArgument().As <ActivityArgument>()); case ConditionType.FullTextSearch: return(new StringArgument().As <ActivityArgument>()); case ConditionType.AnyOf: case ConditionType.AnyExcept: case ConditionType.CurrentUser: if (reportColumnExpressionType.Is <ResourceArgument>() || reportColumnExpressionType.Is <ResourceListArgument>()) { return(reportColumnExpressionType); } return(new StringArgument().As <ActivityArgument>()); case ConditionType.Unspecified: return(new StringArgument().As <ActivityArgument>()); default: return(new StringArgument().As <ActivityArgument>()); } }
/// <summary> /// Create a variable to be used within a windows activity based upon a model variable. /// </summary> /// <param name="argument"></param> /// <returns></returns> public static Variable CreateVariable(ActivityArgument argument) { Variable result; var argumentTypes = argument.IsOfType.Select(t => t.Id); // This is ugly, but it works if (argumentTypes.Contains(StringArgument.StringArgument_Type.Id)) { result = new Variable <string>(); } else if (argumentTypes.Contains(IntegerArgument.IntegerArgument_Type.Id)) { result = new Variable <int>(); } else if (argumentTypes.Contains(BoolArgument.BoolArgument_Type.Id)) { result = new Variable <bool>(); } else if (argumentTypes.Contains(DecimalArgument.DecimalArgument_Type.Id)) { result = new Variable <decimal>(); } else if (argumentTypes.Contains(CurrencyArgument.CurrencyArgument_Type.Id)) { result = new Variable <decimal>(); } else if (argumentTypes.Contains(ResourceArgument.ResourceArgument_Type.Id)) { result = new Variable <EntityRef>(); } else if (argumentTypes.Contains(ObjectArgument.ObjectArgument_Type.Id)) { result = new Variable <object>(); } else { throw new ArgumentException(string.Format("Unsupported result type ")); } result.Name = argument.Name; //TODO: Add in default values return(result); }
private static ReportCondition ReportConditionFromRule(ReportConditionalFormatRule rule, ReportColumn column) { ReportCondition reportCondition = new ReportCondition(); if (rule.Operator.HasValue && rule.Operator != ConditionType.Unspecified) { string alias = "oper" + rule.Operator.ToString(); reportCondition.Operator = Entity.Get <OperatorEnum>(new EntityRef(alias)); } Parameter parameter = reportCondition.ConditionParameter != null?reportCondition.ConditionParameter.AsWritable <Parameter>() : new Parameter(); // Clear the old parameter if (parameter.ParamTypeAndDefault != null) { parameter.ParamTypeAndDefault.AsWritable().Delete(); } // Force entity resource list for argument if we have entities ActivityArgument activityArgument = null; if (rule.Values != null && rule.Values.Count > 0) { ResourceListArgument resourceList = new ResourceListArgument(); foreach (KeyValuePair <long, string> valuePair in rule.Values) { Resource resource = Entity.Get <Resource>(valuePair.Key); if (resource != null) { resourceList.ResourceListParameterValues.Add(resource); } } TypedArgument argumentType = column.ColumnExpression.ReportExpressionResultType.As <TypedArgument>(); resourceList.ConformsToType = argumentType.ConformsToType; activityArgument = resourceList.As <ActivityArgument>(); activityArgument.Save(); } else if (rule.Operator.HasValue) { int operatorCount = ConditionTypeHelper.GetArgumentCount(rule.Operator.Value); if (operatorCount > 0) { activityArgument = ReportConditionHelper.ArgumentForConditionType(column.ColumnExpression.ReportExpressionResultType, rule.Operator.Value, rule.Value); activityArgument.Save(); } } parameter.ParamTypeAndDefault = activityArgument; parameter.Save(); reportCondition.ConditionParameter = parameter; return(reportCondition); }
public WfExpression GetPopulatedBy(WfActivity activity, ActivityArgument argument) { WfExpression result; var key = new Tuple <long, long>(activity.Id, argument.Id); if (_populatedByCache.TryGetValue(key, out result)) { return(result); } else { return(null); } }
/// <summary> /// Add an expression parameter, return the parameters substitution name /// </summary> /// <param name="wf"></param> /// <param name="from"></param> /// <param name="argument"></param> /// <returns></returns> public static string CreateArgumentInstance(Workflow wf, WfActivity from, ActivityArgument argument) { var uniqueName = GeneratetUniqueNameForExpressionParameter(wf, from, argument); var sourceInstance = new WfArgumentInstance { Name = uniqueName, ArgumentInstanceActivity = @from, ArgumentInstanceArgument = argument }; if (@from.IsReadOnly) { @from = @from.AsWritable <WfActivity>(); } @from.ArgumentInstanceFromActivity.Add(sourceInstance); wf.ExpressionParameters.Add(sourceInstance); return(uniqueName); }
private static ActivityArgument CloneArgument(ActivityArgument arg) { var newArg = Entity.Create(arg.TypeIds).As <ActivityArgument>(); newArg.Name = arg.Name; newArg.Description = arg.Description; // deal with type specific info. var resArg = arg.As <ResourceArgument>(); if (resArg != null) { newArg.As <ResourceArgument>().ConformsToType = resArg.ConformsToType; } return(newArg); }
public WfArgumentInstance GetArgInstance(ActivityArgument targetArg, WfActivity activity) { WfArgumentInstance targetArgInst = null; var key = new Tuple <long, long>(activity.Id, targetArg.Id); if (_argInstCache.TryGetValue(key, out targetArgInst)) { return(targetArgInst); } targetArgInst = targetArg.GetArgInstance(activity); _argInstCache.Add(key, targetArgInst); return(targetArgInst); }
public static WfArgumentInstance GetArgInstance(this ActivityArgument targetArg, WfActivity activity) { WfArgumentInstance targetArgInst = null; var key = new Tuple <long, long>(activity.Id, targetArg.Id); targetArgInst = activity.ArgumentInstanceFromActivity.First(ai => ai.ArgumentInstanceArgument.Id == targetArg.Id); //var targetArgInst = // targetArg.ArgumentInstanceFromArgument.First(ai => ai.ArgumentInstanceActivity.Id == activity.Id); // this is probably less efficient return(targetArgInst); }
/// <summary> /// Defaults the type of the operator for. /// </summary> /// <param name="dataType">Type of the data.</param> /// <returns>ConditionType.</returns> private static Structured.ConditionType DefaultOperatorForType(ActivityArgument dataType) { Structured.ConditionType conditionType = Structured.ConditionType.Contains; if (dataType.Is <BoolArgument>()) { conditionType = Structured.ConditionType.Unspecified; } else if (dataType.Is <DateArgument>()) { conditionType = Structured.ConditionType.GreaterThan; } else if (dataType.Is <DateTimeArgument>()) { conditionType = Structured.ConditionType.GreaterThan; } else if (dataType.Is <DecimalArgument>()) { conditionType = Structured.ConditionType.GreaterThan; } else if (dataType.Is <IntegerArgument>()) { conditionType = Structured.ConditionType.GreaterThan; } else if (dataType.Is <CurrencyArgument>()) { conditionType = Structured.ConditionType.GreaterThan; } else if (dataType.Is <StringArgument>()) { conditionType = Structured.ConditionType.Contains; } else if (dataType.Is <TimeArgument>()) { conditionType = Structured.ConditionType.GreaterThan; } else if (dataType.Is <TypedArgument>()) { conditionType = Structured.ConditionType.AnyOf; } return(conditionType); }
/// <summary> /// Get the type of an argument. /// </summary> public static EntityType GetArgumentType(this ActivityArgument argument) { var argumentType = new List <EntityType> { StringArgument.StringArgument_Type, IntegerArgument.IntegerArgument_Type, BoolArgument.BoolArgument_Type, DecimalArgument.DecimalArgument_Type, CurrencyArgument.CurrencyArgument_Type, ResourceArgument.ResourceArgument_Type, DateTimeArgument.DateTimeArgument_Type, DateArgument.DateArgument_Type, TimeArgument.TimeArgument_Type, ObjectArgument.ObjectArgument_Type, ResourceListArgument.ResourceListArgument_Type, GuidArgument.GuidArgument_Type }; EntityType result = null; var resultTypes = argument.IsOfType.Intersect(argumentType, new EntityIdComparer()).ToList(); if (resultTypes.Count == 0) { throw new ArgumentException("Was asked to evaluate an expression with an argument that can not be evaluated. This should never occur."); } if (resultTypes.Count > 1) { throw new ArgumentException("Was asked to evaluate and expression with more than one argument type. This should never occur."); } result = resultTypes[0]; return(result); }
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> /// Interrogates the expression instance populating the report column that is exposed to the Report API service. /// </summary> /// <param name="argument">The argument.</param> /// <param name="reportColumn">The report column.</param> /// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns> private static bool PopulateTypeFromArgument(ActivityArgument argument, out DatabaseType type, out EntityType resourceType) { resourceType = null; if (argument.Is <StringArgument>()) { type = new StringType(); } else if (argument.Is <IntegerArgument>()) { type = new Int32Type(); } else if (argument.Is <CurrencyArgument>()) { type = new CurrencyType(); } else if (argument.Is <DecimalArgument>()) { type = new DecimalType(); } else if (argument.Is <DateArgument>()) { type = new DateType(); } else if (argument.Is <TimeArgument>()) { type = new TimeType(); } else if (argument.Is <DateTimeArgument>()) { type = new DateTimeType(); } else if (argument.Is <GuidArgument>()) { type = new GuidType(); } else if (argument.Is <BoolArgument>()) { type = new BoolType(); } else if (argument.Is <TypedArgument>()) { TypedArgument rla = argument.As <TypedArgument>(); resourceType = Entity.Get <EntityType>(rla.ConformsToType); if (resourceType == null) { type = null; return(false); } if (resourceType.IsOfType.FirstOrDefault(t => t.Alias == "core:enumType") != null) { // A choice field type = new ChoiceRelationshipType(); } else { // Is a related resource type = new InlineRelationshipType(); } } else { type = null; return(false); } return(true); }
/// <summary> /// Analysers the column for condition. /// </summary> /// <param name="report">The report.</param> /// <param name="reportCondition">The report condition.</param> /// <returns> /// ReportAnalyserColumn. /// </returns> internal static ReportAnalyserColumn AnalyserColumnForCondition(Report report, ReportCondition reportCondition) { if (reportCondition.ConditionIsHidden ?? false) { // Do not include analyser conditions when they are hidden return(null); } ReportAnalyserColumn reportAnalyserColumn = new ReportAnalyserColumn { Title = reportCondition.Name, Ordinal = reportCondition.ConditionDisplayOrder ?? 0, IsConditionLocked = reportCondition.ConditionIsLocked ?? false }; if (reportCondition.Operator != null && reportCondition.Operator.ToString().Length > 4) { string[] conditionOperatorParts = reportCondition.Operator.Alias.Split(':'); string operatorString = conditionOperatorParts.Length == 2 ? conditionOperatorParts[1].Substring(4) : conditionOperatorParts[0].Substring(4); Structured.ConditionType conditionType; reportAnalyserColumn.Operator = Enum.TryParse(operatorString, true, out conditionType) ? conditionType : Structured.ConditionType.Unspecified; } else { reportAnalyserColumn.Operator = Structured.ConditionType.Unspecified; } if (reportCondition.ColumnForCondition != null) { reportAnalyserColumn.ReportColumnId = reportCondition.ColumnForCondition.Id; } if (reportCondition.ConditionExpression == null) { return(null); } // Get the argument ActivityArgument reportExpressionResultType = reportCondition.ConditionExpression.Is <ColumnReferenceExpression>() ? reportCondition.ConditionExpression.As <ColumnReferenceExpression>().ExpressionReferencesColumn.ColumnExpression.ReportExpressionResultType : reportCondition.ConditionExpression.ReportExpressionResultType; // Process the expression result associated to this condition DatabaseType type; // scalar type of analyser expression EntityType resourceType; // resource type of analyser expression if (reportExpressionResultType == null || !PopulateTypeFromArgument(reportExpressionResultType, out type, out resourceType)) { return(null); } reportAnalyserColumn.Type = type; if (resourceType != null) { reportAnalyserColumn.TypeId = resourceType.Id; } reportAnalyserColumn.DefaultOperator = DefaultOperatorForType(reportExpressionResultType); // Get the column expression for the analysable field. If this is a referenced column then use it's referenced column's expression. ReportExpression reportExpression = reportCondition.ConditionExpression.Is <ColumnReferenceExpression>() ? reportCondition.ConditionExpression.As <ColumnReferenceExpression>().ExpressionReferencesColumn.ColumnExpression : reportCondition.ConditionExpression; // Track current user for a 'core:UserAccount' or any derivatives and 'core:Person' or any derivatives and if the source node // is one of these and the report expression's field type is 'core:name' then fudge the analyser type to be 'UserString' which includes all // string analyser operator definitions in addition to the 'Current User' operator. PopulateAnalyserTypeForColumn(report, resourceType, reportExpression, reportAnalyserColumn); // Process any values associated to this condition. if (reportCondition.ConditionParameter != null && reportCondition.ConditionParameter.ParamTypeAndDefault != null) { ActivityArgument activityArgument = reportCondition.ConditionParameter.ParamTypeAndDefault; PopulateValueFromArgument(activityArgument, reportAnalyserColumn); } // resource picker for condition parameter if (reportCondition.ConditionParameterPicker != null) { reportAnalyserColumn.ConditionParameterPickerId = reportCondition.ConditionParameterPicker.Id; } return(reportAnalyserColumn); }
public override void SetArgValue(WfActivity activity, ActivityArgument targetArg, object value) { _storage[GetKey(activity, targetArg)] = value; }
/// <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); }
public override T GetArgValue <T>(ActivityArgument targetArg) { return((T)_storage[GetKey(null, targetArg)]); }
public override void SetArgValue(ActivityArgument targetArg, object value) { _storage[GetKey(null, targetArg)] = value; }
private Tuple <long, long, string> GetKey(WfActivity activity, ActivityArgument targetArg) { return(new Tuple <long, long, string>(activity != null ? activity.Id : 0, targetArg.Id, targetArg.Name)); }
public override T GetArgValue <T>(WfActivity activity, ActivityArgument targetArg) { return((T)_storage[GetKey(activity, targetArg)]); }
public abstract T GetArgValue <T>(ActivityArgument targetArg);
public abstract void SetArgValue(ActivityArgument targetArg, object value);
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>()); }
public static Workflow AddUpdateExpressionToArgument(this Workflow wf, WfActivity activity, ActivityArgument arg, string expressionString, bool isTemplate) { if (isTemplate) { expressionString = ConvertTemplateToExpressionString(expressionString); } if (expressionString == null) { throw new ArgumentNullException("expressionString"); } var exp = activity.ExpressionMap.FirstOrDefault(x => x.ArgumentToPopulate?.Id == arg.Id); if (exp == null) { var newExp = new WfExpression() { ExpressionString = expressionString, ArgumentToPopulate = arg, ExpressionInActivity = activity, IsTemplateString = false }; activity.ExpressionMap.Add(newExp.As <WfExpression>()); } else { var wrExp = exp.AsWritable <WfExpression>(); wrExp.ExpressionString = expressionString; wrExp.Save(); } return(wf); }
/// <summary> /// Returns a new activity argument describing the argument type based on the column expression type and condition. /// Also populates the value for the argument prior to returning. /// </summary> /// <param name="reportColumnExpressionType">Type of the report column expression.</param> /// <param name="conditionType">Type of the condition.</param> /// <param name="value">The value.</param> /// <returns>ActivityArgument.</returns> public static ActivityArgument ArgumentForConditionType(ActivityArgument reportColumnExpressionType, ConditionType conditionType, string value) { ActivityArgument targetArgumentType = ArgumentForConditionType(reportColumnExpressionType, conditionType); return(ArgumentForConditionType(targetArgumentType, value)); }
public static Workflow AddUpdateEntityExpression(this Workflow wf, WfActivity activity, ActivityArgument arg, EntityRef entityRef) { var exp = activity.ExpressionMap.FirstOrDefault(x => x.ArgumentToPopulate?.Id == arg.Id); var r = Entity.Get(entityRef).As <Resource>(); var expName = r.Id.ToString(); if (!string.IsNullOrEmpty(r.Name)) { expName = r.Name; } if (exp == null) { exp = new WfExpression { ArgumentToPopulate = arg, ExpressionInActivity = activity, ExpressionString = string.Format("[{0}]", expName) }; exp.WfExpressionKnownEntities.Add(new NamedReference { Name = expName, ReferencedEntity = r }); activity.ExpressionMap.Add(exp); } else { var wrExp = exp.AsWritable <WfExpression>(); wrExp.ExpressionString = string.Format("[{0}]", expName); wrExp.WfExpressionKnownEntities.Clear(); wrExp.WfExpressionKnownEntities.Add(new NamedReference { Name = expName, ReferencedEntity = r }); wrExp.Save(); } return(wf); }
/// <summary> /// Update the provided run with the cached values in the runstate /// </summary> /// <param name="writableRun"></param> public void SyncToRun(WorkflowRun writableRun) { using (Profiler.Measure("RunStateBase.SyncToRun")) { writableRun.WorkflowRunExitPoint = ExitPointId != null?Entity.Get <ExitPoint>(ExitPointId) : null; writableRun.HasTimeout = HasTimeout; writableRun.PendingActivity = PendingActivity; writableRun.RunStepCounter = writableRun.RunStepCounter.HasValue ? writableRun.RunStepCounter.Value + StepsTakenInSession : StepsTakenInSession; writableRun.TotalTimeMs = (writableRun.TotalTimeMs.HasValue ? writableRun.TotalTimeMs.Value : 0) + (int)TimeTakenInSession.ElapsedMilliseconds; writableRun.WorkflowRunStatus_Enum = RunStatus; writableRun.RunCompletedAt = CompletedAt; StepsTakenInSession = 0; TimeTakenInSession.Reset(); var stateInfo = writableRun.StateInfo; var deleteList = stateInfo.Select(e => e.Id).ToList(); stateInfo.Clear(); Entity.Delete(deleteList); // write a message to the log var sb = new StringBuilder(); sb.AppendLine("Saving state to workflow run. Values: "); foreach (var cacheValue in GetArgValues()) { WfActivity activity = cacheValue.Item1; ActivityArgument arg = cacheValue.Item2; object value = cacheValue.Item3; ActivityArgument valueArg = ActivityArgumentHelper.ConvertArgInstValue(activity, arg, value); stateInfo.Add(new StateInfoEntry { Name = valueArg.Name, StateInfoActivity = activity.Id != writableRun.WorkflowBeingRun.Id ? activity : null, // Don't store the workflow as an activity StateInfoArgument = arg, StateInfoValue = valueArg }); sb.Append(valueArg.Name); sb.Append(": \t"); if (value is IEntity) { sb.AppendFormat("Resource {0}\n", ((IEntity)value).Id); } else if (value == null) { sb.AppendLine("[Null]"); } else { sb.AppendLine(value.ToString()); } } EventLog.Application.WriteInformation(sb.ToString()); } }