/// <summary>
/// Writes the condition to the specified XML writer using the specified XML element name.
/// </summary>
/// <param name="elementName">The XML element name that will contain the serialized condition.</param>
/// <param name="condition">The condition to serialize.</param>
/// <param name="xmlWriter">The XML writer used to write the image to.</param>
public static void WriteConditionXml(string elementName, Condition condition, XmlWriter xmlWriter)
{
if (string.IsNullOrEmpty(elementName))
{
throw new ArgumentNullException("elementName");
}
if (condition == null)
{
throw new ArgumentNullException("condition");
}
if (xmlWriter == null)
{
throw new ArgumentNullException("xmlWriter");
}
xmlWriter.WriteStartElement(elementName);
xmlWriter.WriteElementString("operator", condition.Operator.ToString());
xmlWriter.WriteElementString("columnName", condition.ColumnName ?? string.Empty);
condition.ColumnType.ToXml(xmlWriter);
xmlWriter.WriteStartElement("arguments");
if (condition.Arguments != null)
{
foreach (TypedValue arg in condition.Arguments)
{
TypedValueHelper.WriteTypedValueXml("argument", arg, xmlWriter);
}
}
xmlWriter.WriteEndElement(); // arguments
xmlWriter.WriteEndElement(); //elementName
}
/// <summary>
/// Builds the script expression.
/// </summary>
/// <param name="scriptExpression">The script expression.</param>
/// <returns>ScriptExpression.</returns>
private static ScriptExpression BuildScriptExpression(Model.ScriptExpression scriptExpression)
{
DatabaseType castType = TypedValueHelper.GetDatabaseType(scriptExpression.ReportExpressionResultType);
return(new ScriptExpression {
Script = scriptExpression.ReportScript, ResultType = castType
});
}
/// <summary>
/// Writes the bar formatting rule to the specified XML writer.
/// </summary>
/// <param name="barFormattingRule">The bar formatting rule to serialize.</param>
/// <param name="xmlWriter">The XML writer used to write the image to.</param>
private static void WriteBarFormattingRuleXml(BarFormattingRule barFormattingRule, XmlWriter xmlWriter)
{
xmlWriter.WriteStartElement("barFormattingRule");
ColorInfoHelper.WriteColorInfoXml("color", barFormattingRule.Color, xmlWriter);
TypedValueHelper.WriteTypedValueXml("minimum", barFormattingRule.Minimum, xmlWriter);
TypedValueHelper.WriteTypedValueXml("maximum", barFormattingRule.Maximum, xmlWriter);
xmlWriter.WriteEndElement(); // barFormattingRule
}
private static Formatting.FormattingRule BuildColumnFormatRule(Model.FormattingRule formattingRule, DatabaseType columnType, IReportToQueryContext context)
{
var converter = Factory.Current.Resolve <IReportToQueryPartsConverter>( );
if (formattingRule.Is <Model.BarFormattingRule>())
{
Model.BarFormattingRule barRule = formattingRule.As <Model.BarFormattingRule>();
Formatting.BarFormattingRule barFormattingRule = new Formatting.BarFormattingRule()
{
Color = ColourFromString(barRule.BarColor)
};
List <TypedValue> value = TypedValueHelper.TypedValueFromEntity(barRule.BarMinValue);
if (value != null && value.Count > 0)
{
barFormattingRule.Minimum = value[0];
}
value = TypedValueHelper.TypedValueFromEntity(barRule.BarMaxValue);
if (value != null && value.Count > 0)
{
barFormattingRule.Maximum = value[0];
}
return(barFormattingRule);
}
if (formattingRule.Is <Model.ColorFormattingRule>())
{
Model.ColorFormattingRule modelColourRule = formattingRule.As <Model.ColorFormattingRule>();
List <ColorRule> colourRules = modelColourRule.ColorRules.Count > 0 ?
modelColourRule.ColorRules.OrderBy(rule => rule.RulePriority ?? 0).Select(colorRule => new ColorRule
{
BackgroundColor = ColourFromString(colorRule.ColorRuleBackground),
ForegroundColor = ColourFromString(colorRule.ColorRuleForeground),
Condition = converter.ConvertCondition(colorRule.RuleCondition, columnType, context)
}).ToList()
: null;
Formatting.ColorFormattingRule colourFormattingRule = new Formatting.ColorFormattingRule
{
Rules = colourRules
};
return(colourFormattingRule);
}
if (formattingRule.Is <Model.IconFormattingRule>())
{
Model.IconFormattingRule modelIconFormattingRule = formattingRule.As <Model.IconFormattingRule>();
return(new Formatting.IconFormattingRule
{
Rules = modelIconFormattingRule.IconRules.OrderBy(rule => rule.RulePriority ?? 0).Select(rule => new Formatting.IconRule
{
CfEntityId = rule.IconRuleCFIcon != null ? rule.IconRuleCFIcon.Id: -1,
IconId = GetIconId(rule),
Condition = converter.ConvertCondition(rule.RuleCondition, columnType, context)
}).ToList()
});
}
return(null);
}
public static void CheckLegacyLoad <T>(TypedValue expectedValue, string legacyXml) where T : IComparable
{
const string namespaces = @"xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns=""http://enterprisedata.com.au/readinow/v2/query/2.0""";
string legacyXml2 = legacyXml.Replace("<TypedValue", "<TypedValue " + namespaces);
TypedValue actualValue = TypedValueHelper.FromXml(legacyXml2);
T expectedData = (T)expectedValue.Value;
T actualData = (T)actualValue.Value;
Assert.AreEqual(expectedValue.Type.GetType(), actualValue.Type.GetType(), "Check type");
Assert.IsTrue(expectedData.CompareTo(actualData) == 0, "Check Data");
Assert.AreEqual(expectedValue.SourceEntityTypeId, actualValue.SourceEntityTypeId, "Check SourceEntityTypeId");
}
public static void CheckRoundTrip <T>(TypedValue expectedValue, string expectedXml) where T : IComparable
{
// Verify serialize
string actualXml = TypedValueHelper.ToXml(expectedValue);
string actualXml2 = RemoveNamespaces(actualXml);
Assert.AreEqual(expectedXml, actualXml2, "Check XML");
// Attempt deserialize
TypedValue actualValue = TypedValueHelper.FromXml(actualXml);
// Verify type
Assert.AreEqual(expectedValue.Type.GetType(), actualValue.Type.GetType(), "Check type");
// Verify data
if (expectedValue.Value == null)
{
Assert.IsNull(actualValue.Value, "Check null data");
}
else
{
T expectedData = (T)expectedValue.Value;
T actualData = (T)actualValue.Value;
Assert.IsTrue(expectedData.CompareTo(actualData) == 0, "Check Data");
}
Assert.AreEqual(expectedValue.SourceEntityTypeId, actualValue.SourceEntityTypeId,
"Check SourceEntityTypeId");
// Attempt alternate deserialize
XmlDocument doc = new XmlDocument();
doc.LoadXml(actualXml);
TypedValue actualValue2 = TypedValueHelper.FromXml(doc.DocumentElement);
// Verify type2
Assert.AreEqual(expectedValue.Type.GetType(), actualValue2.Type.GetType(), "Check type2");
// Verify data2
if (expectedValue.Value == null)
{
Assert.IsNull(actualValue2.Value, "Check null data2");
}
else
{
T expectedData = (T)expectedValue.Value;
T actualData = (T)actualValue2.Value;
Assert.IsTrue(expectedData.CompareTo(actualData) == 0, "Check Data2");
}
Assert.AreEqual(expectedValue.SourceEntityTypeId, actualValue2.SourceEntityTypeId,
"Check SourceEntityTypeId2");
}
protected override ScalarExpression OnBuildQuery(QueryBuilderContext context)
{
if (ResultType.IsList)
{
throw new InvalidOperationException();
}
var result = new LiteralExpression
{
Value = TypedValueHelper.FromDataType(ResultType.Type, Value)
};
return(result);
}
/// <summary>
/// Returns a tree node that is representative of an entity or.
/// </summary>
/// <param name="context">Context information about this query building session, including the target structured query object.</param>
/// <param name="allowReuse">A dedicated node should be returned because the caller intends on disturbing it.</param>
/// <returns>A query node that can be used within the query.</returns>
public override SQ.Entity OnBuildQueryNode(QueryBuilderContext context, bool allowReuse)
{
IEntity instance = Instance.Entity;
long typeId = instance.TypeIds.First( );
if (context.ParentNode == null)
{
throw new Exception("No context.");
}
// Look for an existing relationship node in the tree that we can reuse
SQ.CustomJoinNode result = !allowReuse ? null :
context.ParentNode
.RelatedEntities
.OfType <SQ.CustomJoinNode>( )
.FirstOrDefault(cj => IsMatch(cj, Instance.Id) && cj.EntityTypeId.Id == typeId);
// New node
if (result == null)
{
result = new SQ.CustomJoinNode
{
EntityTypeId = typeId,
JoinPredicateScript = "true"
};
SQ.ScalarExpression predicate = new SQ.ComparisonExpression
{
Operator = SQ.ComparisonOperator.Equal,
Expressions =
{
new SQ.IdExpression
{
NodeId = result.NodeId
},
new SQ.LiteralExpression
{
Value = TypedValueHelper.FromDataType(ResultType.Type, Instance.Id)
}
}
};
result.Conditions = new List <SQ.ScalarExpression> {
predicate
};
}
context.ParentNode.RelatedEntities.Add(result);
AddChildNodes(context, result, allowReuse);
return(result);
}
public static void CheckLegacyConditionalFormat <T>(TypedValue expectedValue, string legacyXml) where T : IComparable
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(legacyXml);
TypedValue actualValue = TypedValueHelper.ReadTypedValueXml(doc.DocumentElement, "whatever");
T expectedData = (T)expectedValue.Value;
T actualData = (T)actualValue.Value;
Assert.AreEqual(expectedValue.Type.GetType(), actualValue.Type.GetType(), "Check type");
Assert.IsTrue(expectedData.CompareTo(actualData) == 0, "Check Data");
Assert.AreEqual(expectedValue.SourceEntityTypeId, actualValue.SourceEntityTypeId, "Check SourceEntityTypeId");
}
/// <summary>
/// Reconstructs a bar formatting rule from the specified XML image.
/// </summary>
/// <param name="node">The node containing the bar formatting rule XML.</param>
/// <returns>The bar formatting rule.</returns>
private static BarFormattingRule ReadBarFormattingRuleXml(XmlNode node)
{
BarFormattingRule formattingRule = new BarFormattingRule();
if (XmlHelper.EvaluateSingleNode(node, "barFormattingRule"))
{
XmlNode barFormattingRuleNode = XmlHelper.SelectSingleNode(node, "barFormattingRule");
if (barFormattingRuleNode != null)
{
formattingRule.Color = ColorInfoHelper.ReadColorInfoXml(barFormattingRuleNode, "color");
formattingRule.Minimum = TypedValueHelper.ReadTypedValueXml(barFormattingRuleNode, "minimum");
formattingRule.Maximum = TypedValueHelper.ReadTypedValueXml(barFormattingRuleNode, "maximum");
}
}
return(formattingRule);
}
/// <summary>
/// Builds the field expression.
/// </summary>
/// <param name="fieldExpression">The field expression.</param>
/// <param name="context"></param>
/// <returns>ResourceDataColumn.</returns>
private static ResourceDataColumn BuildFieldExpression(Model.FieldExpression fieldExpression, FromEntityContext context)
{
DatabaseType castType = TypedValueHelper.GetDatabaseType(fieldExpression.ReportExpressionResultType);
if (fieldExpression.FieldExpressionField == null)
{
EventLog.Application.WriteWarning(context.DebugInfo + "field was null");
return(null);
}
ResourceDataColumn rdc = new ResourceDataColumn
{
FieldId = fieldExpression.FieldExpressionField,
CastType = castType, ExpressionId = Guid.NewGuid(),
SourceNodeEntityId = fieldExpression.As <NodeExpression>().SourceNode.Id
};
return(rdc);
}
/// <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>
/// Builds the column format rules for the report columns.
/// </summary>
/// <param name="reportColumns">The report columns.</param>
/// <param name="context">The context.</param>
/// <returns>
/// List{ColumnFormatting}.
/// </returns>
internal static List <ColumnFormatting> BuildColumnFormats(IEntityCollection <ReportColumn> reportColumns, IReportToQueryContext context)
{
List <ColumnFormatting> reportColumnFormats = new List <ColumnFormatting>();
foreach (ReportColumn reportColumn in reportColumns)
{
ColumnFormatting columnFormatting = null;
if (reportColumn.ColumnDisplayFormat != null && reportColumn.ColumnExpression != null)
{
Formatting.ImageFormattingRule imageFormattingRule = null;
if (reportColumn.ColumnDisplayFormat.FormatImageScale != null &&
reportColumn.ColumnDisplayFormat.FormatImageSize != null)
{
imageFormattingRule = new Formatting.ImageFormattingRule
{
ThumbnailSizeId = new Model.EntityRef(reportColumn.ColumnDisplayFormat.FormatImageSize.Id),
ThumbnailScaleId = new Model.EntityRef(reportColumn.ColumnDisplayFormat.FormatImageScale.Id),
};
}
columnFormatting = new ColumnFormatting
{
EntityId = reportColumn.Id,
ColumnName = reportColumn.Name,
DecimalPlaces = reportColumn.ColumnDisplayFormat.FormatDecimalPlaces ?? 0,
ShowText = reportColumn.ColumnDisplayFormat.ColumnShowText ?? false,
DisableDefaultFormat = reportColumn.ColumnDisplayFormat.DisableDefaultFormat ?? false,
Prefix = reportColumn.ColumnDisplayFormat.FormatPrefix,
Suffix = reportColumn.ColumnDisplayFormat.FormatSuffix,
Lines = reportColumn.ColumnDisplayFormat.MaxLineCount ?? 0,
FormattingRule = imageFormattingRule ?? null
};
// Column Type
columnFormatting.ColumnType = TypedValueHelper.GetDatabaseType(reportColumn.ColumnExpression.ReportExpressionResultType);
DisplayFormat displayFormat = reportColumn.ColumnDisplayFormat;
// Format String
if (displayFormat.DateColumnFormat != null)
{
columnFormatting.DateFormat = displayFormat.DateColumnFormat;
}
if (displayFormat.DateTimeColumnFormat != null)
{
columnFormatting.DateTimeFormat = displayFormat.DateTimeColumnFormat;
}
if (displayFormat.TimeColumnFormat != null)
{
columnFormatting.TimeFormat = displayFormat.TimeColumnFormat;
}
// Text Alignment
if (displayFormat.FormatAlignment != null)
{
columnFormatting.Alignment = displayFormat.FormatAlignment;
}
if (displayFormat.EntityListColumnFormat != null)
{
columnFormatting.EntityListColumnFormat = displayFormat.EntityListColumnFormat;
}
}
// Formatting Rule
if (reportColumn.ColumnFormattingRule != null && reportColumn.ColumnExpression != null)
{
if (columnFormatting == null)
{
columnFormatting = new ColumnFormatting
{
EntityId = reportColumn.Id,
ColumnName = reportColumn.Name,
}
}
;
columnFormatting.FormattingRule = BuildColumnFormatRule(reportColumn.ColumnFormattingRule, columnFormatting.ColumnType, context);
}
if (columnFormatting != null && reportColumn.ColumnExpression != null)
{
reportColumnFormats.Add(columnFormatting);
}
}
return(reportColumnFormats);
}
/// <summary>
/// Reconstructs the condition object from the specified XML node and XML element name.
/// </summary>
/// <param name="node">The XML node containing the condition XML.</param>
/// <param name="elementName">The name of the XML element containing the condition data.</param>
/// <returns>The condition object.</returns>
public static Condition ReadConditionXml(XmlNode node, string elementName)
{
if (node == null)
{
throw new ArgumentNullException("node");
}
if (string.IsNullOrEmpty(elementName))
{
throw new ArgumentNullException("elementName");
}
var condition = new Condition();
if (XmlHelper.EvaluateSingleNode(node, elementName))
{
XmlNode conditionNode = XmlHelper.SelectSingleNode(node, elementName);
condition.Operator = (ConditionType)XmlHelper.ReadElementEnum(conditionNode, "operator", typeof(ConditionType), ConditionType.Unspecified);
condition.ColumnName = XmlHelper.ReadElementString(conditionNode, "columnName", string.Empty);
//database type
condition.ColumnType = DatabaseType.UnknownType;
if (XmlHelper.EvaluateSingleNode(conditionNode, "type"))
{
XmlNode typeNode = XmlHelper.SelectSingleNode(conditionNode, "type");
condition.ColumnType = DatabaseType.FromXml(typeNode);
}
if (DatabaseTypeHelper.IsTypeRelationshipField(condition.ColumnType))
{
XmlNode argumentsNode = XmlHelper.SelectSingleNode(conditionNode, "arguments");
foreach (XmlNode argumentNode in argumentsNode.ChildNodes)
{
TypedValue argument = TypedValueHelper.FromXml(argumentNode);
if (argument != null)
{
condition.Arguments.Add(argument);
if (argument.Value != null)
{
string strArgumentValue = argument.Value.ToString();
long longArgumentValue;
if (long.TryParse(strArgumentValue, out longArgumentValue))
{
Resource resource = Model.Entity.Get <Resource>(new EntityRef(longArgumentValue));
ConvertArgumentValue(strArgumentValue, resource == null ? "Missing" : resource.Name);
}
}
}
}
}
else
{
XmlNodeList argumentNodes = XmlHelper.SelectNodes(conditionNode, "arguments");
foreach (TypedValue argument in argumentNodes.Cast <XmlNode>().Select(argumentNode => TypedValueHelper.ReadTypedValueXml(argumentNode, "argument")).Where(argument => argument != null))
{
condition.Arguments.Add(argument);
}
}
}
return(condition);
}
