public override void Initialize() { base.Initialize(); Radius = 37.0; StartAngle = 20.0; SweepAngle = 320.0; }
public override void Initialize() { base.Initialize(); this.StartMargin = 8.0; this.EndMargin = 8.0; this.Position = 50.0; }
public override void Initialize() { base.Initialize(); this.Left = 0.0; this.Top = 0.0; this.Unit = MapUnits.Percentage; }
public override void Initialize() { base.Initialize(); Left = 0.0; Top = 0.0; Unit = MapUnits.Percentage; }
public override void Initialize() { base.Initialize(); StartMargin = 8.0; EndMargin = 8.0; Position = 50.0; }
public override void Initialize() { base.Initialize(); this.ScaleFactor = 1.0; this.ShowLabel = MapAutoBools.Auto; this.LabelPlacement = MapPolygonLabelPlacements.MiddleCenter; }
/// <summary> /// Builds the condition parameter. /// </summary> /// <param name="reportCondition">The report condition.</param> /// <param name="queryCondition">The query condition.</param> /// <param name="context"></param> internal static void BuildConditionParameter([NotNull] ReportCondition reportCondition, QueryCondition queryCondition, FromEntityContext context) { if (reportCondition == null) { throw new ArgumentNullException(nameof(reportCondition)); } ActivityArgument activityArgument; // 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; if (reportExpression != null && reportExpression.Is <ColumnReferenceExpression>()) { reportExpression = reportCondition.ConditionExpression.As <ColumnReferenceExpression>() .ExpressionReferencesColumn.ColumnExpression; } if (reportCondition.ConditionParameter?.ParamTypeAndDefault != null) { activityArgument = reportCondition.ConditionParameter.ParamTypeAndDefault; } else if (reportExpression?.ReportExpressionResultType != null) { activityArgument = reportCondition.ConditionExpression.ReportExpressionResultType; } else { EventLog.Application.WriteWarning(context.DebugInfo + "condition parameter could not be processed"); return; } List <TypedValue> typedValues = TypedValueHelper.TypedValueFromEntity(activityArgument); foreach (TypedValue typedValue in typedValues) { queryCondition.Arguments.Add(typedValue); } }
/// <summary> /// To check column is valid, /// if field or relationship is removed from object. /// </summary> /// <param name="expression">report column expression</param> /// <remarks> /// the report column expression must be exists, when field is removed from node object, /// the column expression will be deleted, on this case, it is not valid column /// the the column expression is resourceexpression, check the relationship exists or not /// if the relationship is removed, the followRelationship property will be null, current /// column is invalid column /// </remarks> /// <returns></returns> internal static bool IsValidExpression(ReportExpression expression) { if (expression == null) { return(false); } bool isValid = true; //resourceExpression reportnode's followRelationship must not be null Model.ResourceExpression resourceExpression = expression.As <Model.ResourceExpression>(); if (resourceExpression != null) { RelationshipReportNode relationshipReportNode = resourceExpression.SourceNode.As <RelationshipReportNode>(); if (relationshipReportNode != null) { if (relationshipReportNode.FollowRelationship == null) { isValid = false; } } } //if aggregated grouped expression is resourceExpression reportnode's followRelationship must not be null Model.AggregateExpression aggregateExpression = expression.As <Model.AggregateExpression>(); if (aggregateExpression != null) { if (!IsValidExpression(aggregateExpression.AggregatedExpression)) { isValid = false; } } return(isValid); }
public override void Initialize() { base.Initialize(); Palette = MapPalettes.Random; }
public override void Initialize() { base.Initialize(); this.LabelPosition = MapLabelPositions.Near; }
/// <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; } }
public override void Initialize() { base.Initialize(); PivotX = 50.0; PivotY = 50.0; }
/// <summary> /// Builds the expression. /// </summary> /// <param name="reportExpression">The report expression.</param> /// <param name="context">The context.</param> /// <returns>ScalarExpression.</returns> internal static ScalarExpression BuildExpression(ReportExpression reportExpression, FromEntityContext context) { if (reportExpression == null) { EventLog.Application.WriteWarning(context.DebugInfo + "reportExpression was null"); return(null); } // Verify that there is a valid node - prior to converting expressions (invalid nodes may be only partially loaded) // Update the reference table for expressions of interest ignoring anything that is a column expression long nodeId = 0; NodeExpression nodeExpression = reportExpression.As <NodeExpression>( ); if (nodeExpression != null) { nodeId = nodeExpression.SourceNode.Id; // Check that we have a valid node for it if (!context.ReportNodeToEntityMap.ContainsKey(nodeId)) { EventLog.Application.WriteWarning(context.DebugInfo + "expression node could not be found"); return(null); } } // Convert specific expression types ScalarExpression scalarExpression; if (context.InstanceExpressionMap.TryGetValue(reportExpression.Id, out scalarExpression)) { return(scalarExpression); } if (reportExpression.Is <Model.IdExpression>()) { scalarExpression = BuildIdExpression(reportExpression.As <Model.IdExpression>()); } else if (reportExpression.Is <Model.ResourceExpression>()) { scalarExpression = BuildResourceExpression(reportExpression.As <Model.ResourceExpression>(), context); } else if (reportExpression.Is <Model.FieldExpression>()) { scalarExpression = BuildFieldExpression(reportExpression.As <Model.FieldExpression>(), context); } else if (reportExpression.Is <Model.ScriptExpression>()) { scalarExpression = BuildScriptExpression(reportExpression.As <Model.ScriptExpression>()); } else if (reportExpression.Is <Model.AggregateExpression>()) { return(BuildAggregateExpression(reportExpression.As <Model.AggregateExpression>(), context)); } else if (reportExpression.Is <Model.ColumnReferenceExpression>()) { return(BuildColumnReferenceExpression(reportExpression.As <ColumnReferenceExpression>(), context)); } else if (reportExpression.Is <Model.StructureViewExpression>()) { return(BuildStructureViewExpression(reportExpression.As <Model.StructureViewExpression>(), context)); } // Final book keeping if (scalarExpression != null) { if (nodeExpression != null) { Guid key = Guid.NewGuid( ); context.ReportExpressionMap[key] = nodeId; scalarExpression.ExpressionId = key; scalarExpression.EntityId = nodeExpression.Id; } context.InstanceExpressionMap[reportExpression.Id] = scalarExpression; } ApplyExpressionClustering(scalarExpression, reportExpression, context); return(scalarExpression); }
/// <summary> /// Detect expressions that are being clustered (grouped by month, etc) and convert them to clustering expressions. /// </summary> /// <param name="scalarExpression"></param> /// <param name="reportExpression"></param> /// <param name="context"></param> /// <returns></returns> private static void ApplyExpressionClustering(ScalarExpression scalarExpression, ReportExpression reportExpression, FromEntityContext context) { if (reportExpression == null || scalarExpression == null) { return; } var reportColumn = reportExpression.ExpressionForColumn; var displayFormat = reportColumn?.ColumnDisplayFormat; if (displayFormat == null) { return; } ClusterOperation oper = ClusterOperation.None; if (displayFormat.DateColumnFormat_Enum != null) { switch (displayFormat.DateColumnFormat_Enum) { case DateColFmtEnum_Enumeration.DateDayMonth: oper = ClusterOperation.Day | ClusterOperation.Month; break; case DateColFmtEnum_Enumeration.DateMonth: oper = ClusterOperation.Month; break; case DateColFmtEnum_Enumeration.DateMonthYear: oper = ClusterOperation.Month | ClusterOperation.Year; break; case DateColFmtEnum_Enumeration.DateQuarter: oper = ClusterOperation.Quarter; break; case DateColFmtEnum_Enumeration.DateQuarterYear: oper = ClusterOperation.Quarter | ClusterOperation.Year; break; case DateColFmtEnum_Enumeration.DateYear: oper = ClusterOperation.Year; break; case DateColFmtEnum_Enumeration.DateWeekday: oper = ClusterOperation.Weekday; break; case DateColFmtEnum_Enumeration.DateLong: case DateColFmtEnum_Enumeration.DateShort: default: oper = ClusterOperation.None; break; } } if (displayFormat.TimeColumnFormat_Enum != null) { switch (displayFormat.TimeColumnFormat_Enum) { case TimeColFmtEnum_Enumeration.TimeHour: oper = ClusterOperation.Hour; break; default: oper = ClusterOperation.None; break; } } if (displayFormat.DateTimeColumnFormat_Enum != null) { switch (displayFormat.DateTimeColumnFormat_Enum) { case DateTimeColFmtEnum_Enumeration.DateTimeDayMonth: oper = ClusterOperation.Day | ClusterOperation.Month; break; case DateTimeColFmtEnum_Enumeration.DateTimeMonth: oper = ClusterOperation.Month; break; case DateTimeColFmtEnum_Enumeration.DateTimeMonthYear: oper = ClusterOperation.Month | ClusterOperation.Year; break; case DateTimeColFmtEnum_Enumeration.DateTimeQuarter: oper = ClusterOperation.Quarter; break; case DateTimeColFmtEnum_Enumeration.DateTimeQuarterYear: oper = ClusterOperation.Quarter | ClusterOperation.Year; break; case DateTimeColFmtEnum_Enumeration.DateTimeYear: oper = ClusterOperation.Year; break; case DateTimeColFmtEnum_Enumeration.DateTimeWeekday: oper = ClusterOperation.Weekday; break; case DateTimeColFmtEnum_Enumeration.DateTimeDate: oper = ClusterOperation.Year | ClusterOperation.Month | ClusterOperation.Day; break; case DateTimeColFmtEnum_Enumeration.DateTimeTime: oper = ClusterOperation.Hour | ClusterOperation.Minute | ClusterOperation.Second; break; case DateTimeColFmtEnum_Enumeration.DateTimeHour: oper = ClusterOperation.Hour; break; case DateTimeColFmtEnum_Enumeration.DateTime24Hour: case DateTimeColFmtEnum_Enumeration.DateTimeDayMonthTime: case DateTimeColFmtEnum_Enumeration.DateTimeLong: case DateTimeColFmtEnum_Enumeration.DateTimeShort: case DateTimeColFmtEnum_Enumeration.DateTimeSortable: default: oper = ClusterOperation.None; break; } } scalarExpression.ClusterOperation = oper; }
public override void Initialize() { base.Initialize(); Color = Constants.DefaultEmptyColor; }
public override void Initialize() { this.Default = Constants.DefaultEmptyColor; }
public override void Initialize() { base.Initialize(); Width = 26.0; }
public override void Initialize() { base.Initialize(); this.MapBorderSkinType = MapBorderSkinTypes.None; }
public override void Initialize() { base.Initialize(); this.CenterX = 50.0; this.CenterY = 50.0; }
public override void Initialize() { base.Initialize(); ZIndex = 0; }
/// <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 Initialize() { base.Initialize(); Unit = MapUnits.Percentage; }