/// <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); }
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> /// Populates the analyser type for column. /// </summary> /// <param name="report">The report.</param> /// <param name="entityType">The resource type returned if the analyser refers to a resource expression.</param> /// <param name="reportExpression">The report expression.</param> /// <param name="reportAnalyserColumn">The report analyser column.</param> private static void PopulateAnalyserTypeForColumn(Report report, EntityType entityType, ReportExpression reportExpression, ReportAnalyserColumn reportAnalyserColumn) { reportAnalyserColumn.AnalyserType = reportAnalyserColumn.Type.GetDisplayName(); if (reportExpression.Is <StructureViewExpression>()) { reportAnalyserColumn.AnalyserType = StructureLevelsType.DisplayName; reportAnalyserColumn.DefaultOperator = Structured.ConditionType.AnyBelowStructureLevel; var expression = reportExpression.As <StructureViewExpression>(); var resReportNode = expression.StructureViewExpressionSourceNode.As <ResourceReportNode>(); var eType = resReportNode.ResourceReportNodeType; reportAnalyserColumn.TypeId = eType.Id; return; } if (!reportExpression.Is <NodeExpression>()) { return; } NodeExpression nodeExpression = reportExpression.As <NodeExpression>(); if (!nodeExpression.SourceNode.Is <ResourceReportNode>()) { return; } bool isNameColumnForType = false; if (reportExpression.Is <FieldExpression>()) { var fieldExpression = reportExpression.As <FieldExpression>(); if (fieldExpression.FieldExpressionField.Alias != "core:name") { return; } long sourceId = fieldExpression.SourceNode != null ? fieldExpression.SourceNode.Id : 0; long rootId = report.RootNode != null ? report.RootNode.Id : 0; isNameColumnForType = (sourceId == rootId) && (sourceId != 0); } reportAnalyserColumn.IsNameColumnForType = isNameColumnForType; ResourceReportNode resourceReportNode = nodeExpression.SourceNode.As <ResourceReportNode>( ); RelationshipReportNode relationshipReportNode = nodeExpression.SourceNode.As <RelationshipReportNode>( ); if (entityType == null) { // Need to be able accept entityType as an argument, e.g. if it is from a script column // But also need to be able to read it from the node, e.g. if it is the root name column. Messed up. entityType = resourceReportNode.ResourceReportNodeType; if (entityType == null) { return; } } ResourceExpression resourceExpression = reportExpression.As <ResourceExpression>(); // Handle "Type" types //if the resource type is "Type", add current parent node type and descendant types' id as filtered entity ids (bug 24859) //Update: only the forward relationship is "isOfType", the "type" list will be restricted. (bug 27862) if (entityType.Alias == "core:type" && relationshipReportNode?.FollowRelationship?.Alias == "core:isOfType" ) { AggregateReportNode parentAggregatedNode = resourceReportNode.ParentAggregatedNode; ReportNode parentReportNode = parentAggregatedNode != null ? parentAggregatedNode.GroupedNode : resourceReportNode.ParentReportNode; ResourceReportNode parentResourceReportNode = parentReportNode != null?parentReportNode.As <ResourceReportNode>() : null; if (parentResourceReportNode != null && parentResourceReportNode.ResourceReportNodeType != null) { reportAnalyserColumn.FilteredEntityIds = PerTenantEntityTypeCache.Instance.GetDescendantsAndSelf( parentResourceReportNode.ResourceReportNodeType.Id).ToArray(); } } // Handle "User" and "Person" types if (PerTenantEntityTypeCache.Instance.IsDerivedFrom(entityType.Id, "core:person") || PerTenantEntityTypeCache.Instance.IsDerivedFrom(entityType.Id, "core:userAccount")) { // If this is a relationship or calc then make it as a user inline relationship otherwise a simple user string. reportAnalyserColumn.AnalyserType = nodeExpression.SourceNode.Is <FieldExpression>( ) ? "UserString" : "UserInlineRelationship"; return; } // Treat the root 'Name' column like a lookup, so we get the 'Any Of', 'Any Except' options. if (isNameColumnForType) { reportAnalyserColumn.AnalyserType = "InlineRelationship"; reportAnalyserColumn.TypeId = entityType.Id; } }