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