private static void ApplyProgressFormat(ReportColumn column, IEnumerable <ReportConditionalFormatRule> rules)
{
if (column.ColumnFormattingRule != null)
{
column.ColumnFormattingRule.AsWritable().Delete();
}
ReportConditionalFormatRule rule = rules.First();
decimal min;
if (!decimal.TryParse(rule.PercentageBounds.LowerBounds.ToString(), out min))
{
min = 0;
}
int max;
if (!int.TryParse(rule.PercentageBounds.UpperBounds.ToString(), out max))
{
max = 0;
}
BarFormattingRule formattingRule = new BarFormattingRule
{
BarColor = rule.ForegroundColor != null?rule.ForegroundColor.ToColourString() : null,
BarMinValue = ReportConditionHelper.ArgumentForConditionType(column.ColumnExpression.ReportExpressionResultType, rule.PercentageBounds.LowerBounds.ToString()),
BarMaxValue = ReportConditionHelper.ArgumentForConditionType(column.ColumnExpression.ReportExpressionResultType, rule.PercentageBounds.UpperBounds.ToString())
};
formattingRule.Save();
column.ColumnFormattingRule = formattingRule.As <FormattingRule>();
}
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);
}
/// <summary>
/// Tries to get the rule based on the default condition rules for the choice field column.
/// </summary>
/// <param name="conditionalFormat">The conditional column format.</param>
/// <param name="data">The data.</param>
/// <param name="ruleIndex">Index of the rule.</param>
/// <returns><c>true</c> if XXXX, <c>false</c> otherwise.</returns>
/// <exception cref="System.InvalidOperationException">Predicate has not been set of condition.</exception>
public bool TryGetDefaultRule(ReportColumnConditionalFormat conditionalFormat, object data, out long ruleIndex)
{
if (conditionalFormat != null && conditionalFormat.Rules != null && conditionalFormat.Rules.Count > 0)
{
for (int i = 0; i < conditionalFormat.Rules.Count; i++)
{
ReportConditionalFormatRule rule = conditionalFormat.Rules[i];
if (rule.Values == null || rule.Predicate == null)
{
continue;
}
if (rule.Predicate(data))
{
ruleIndex = i;
return(true);
}
}
}
ruleIndex = -1;
return(false);
}
/// <summary>
/// Builds a list of conditional format rules for the report.
/// </summary>
/// <returns>Dictionary{GuidList{ReportConditionalFormatRule}}.</returns>
public Dictionary <string, ReportColumnConditionalFormat> FormatsForReport(out Dictionary <string, ReportImageScale> imageScaleRules)
{
imageScaleRules = null;
if (_formatRules != null && _formatRules.Count > 0)
{
Dictionary <string, ReportColumnConditionalFormat> formats = new Dictionary <string, ReportColumnConditionalFormat>(_formatRules.Count);
EntityRef imageScale = null;
EntityRef imageSize = null;
ThumbnailSizeEnum thumbnailSizeEnum = null;
foreach (KeyValuePair <string, List <ConditionInfo> > formatRule in _formatRules)
{
ReportColumnConditionalFormat columnFormat = new ReportColumnConditionalFormat();
List <ReportConditionalFormatRule> rules = new List <ReportConditionalFormatRule>();
foreach (ConditionInfo conditionInfo in formatRule.Value)
{
if (rules.Count <= 0)
{
columnFormat.Style = conditionInfo.Style;
columnFormat.ShowValue = conditionInfo.ShowText;
}
ReportConditionalFormatRule rule = new ReportConditionalFormatRule
{
Operator = conditionInfo.Operator,
};
if (conditionInfo.ColorRule != null)
{
if (conditionInfo.ColorRule.ForegroundColor != null)
{
rule.ForegroundColor = new ReportConditionColor
{
Alpha = conditionInfo.ColorRule.ForegroundColor.A,
Blue = conditionInfo.ColorRule.ForegroundColor.B,
Green = conditionInfo.ColorRule.ForegroundColor.G,
Red = conditionInfo.ColorRule.ForegroundColor.R
};
}
if (conditionInfo.ColorRule.BackgroundColor != null)
{
rule.BackgroundColor = new ReportConditionColor
{
Alpha = conditionInfo.ColorRule.BackgroundColor.A,
Blue = conditionInfo.ColorRule.BackgroundColor.B,
Green = conditionInfo.ColorRule.BackgroundColor.G,
Red = conditionInfo.ColorRule.BackgroundColor.R
};
}
}
if (conditionInfo.LowerBounds != null || conditionInfo.Upperbounds != null)
{
rule.PercentageBounds = new ReportPercentageBounds
{
LowerBounds = conditionInfo.LowerBounds,
UpperBounds = conditionInfo.Upperbounds
};
}
if (conditionInfo.IconRule != null && (conditionInfo.IconRule.IconId ?? 0) > 0)
{
if ((conditionInfo.IconRule.CfEntityId ?? 0) > 0)
{
IEntity cfEntity = Entity.Get(conditionInfo.IconRule.CfEntityId.Value);
var cfi = cfEntity.As <ConditionalFormatIcon>();
if (cfi != null)
{
rule.CfEntityId = cfi.Id;
rule.ImageEntityId = cfi.CondFormatImage != null ? cfi.CondFormatImage.Id : -1;
}
}
else
{
IEntity entity = Entity.Get(conditionInfo.IconRule.IconId.Value);
if (entity.Is <IconFileType>())
{
rule.ImageEntityId = conditionInfo.IconRule.IconId.Value;
}
}
if (imageScale == null)
{
imageScale = new EntityRef("core", "scaleImageProportionally");
}
if (imageSize == null)
{
imageSize = new EntityRef("console", "iconThumbnailSize");
}
if (thumbnailSizeEnum == null)
{
thumbnailSizeEnum = Entity.Get <ThumbnailSizeEnum>(imageSize);
}
if (imageScaleRules == null)
{
imageScaleRules = new Dictionary <string, ReportImageScale>();
}
if (!imageScaleRules.ContainsKey(formatRule.Key))
{
ReportImageScale reportImageScale = new ReportImageScale
{
ImageScaleId = imageScale.Id,
ImageSizeId = imageSize.Id,
ImageWidth = thumbnailSizeEnum.ThumbnailWidth ?? 16,
ImageHeight = thumbnailSizeEnum.ThumbnailHeight ?? 16
};
imageScaleRules.Add(formatRule.Key, reportImageScale);
}
}
// Handle the values for the typed value only if this is not an icon as it has relationships
if (conditionInfo.Values != null && conditionInfo.Values.Count > 0)
{
if (conditionInfo.Values[0].Type is ChoiceRelationshipType || conditionInfo.Values[0].Type is InlineRelationshipType || conditionInfo.Values[0].Type is StructureLevelsType)
{
rule.Values = ProcessConditionValues(conditionInfo.Values);
// If there are no values returned then this must be a text string rather than a list of entity identifiers.
if (rule.Values == null)
{
rule.Value = conditionInfo.Values[0].ValueString;
}
}
else
{
DateTime dateTimeValue;
if ((conditionInfo.Values[0].Type is DateTimeType || conditionInfo.Values[0].Type is TimeType || conditionInfo.Values[0].Type is DateType) &&
(DateTime.TryParse(conditionInfo.Values[0].Value.ToString(), out dateTimeValue)))
{
rule.Value = dateTimeValue.ToString("yyyy-MM-ddTHH:mm:ssZ");
}
else
{
rule.Value = conditionInfo.Values[0].ValueString;
}
}
}
rules.Add(rule);
}
columnFormat.Rules = rules;
formats.Add(formatRule.Key, columnFormat);
}
return(formats);
}
return(null);
}
