public void Check_StructuredQuery_Invalidation_On_ReportInterface( )
{
using (CacheManager.EnforceCacheHitRules(false))
{
Report report;
ResourceReportNode rootNode;
ResourceArgument exprType;
// Create report
using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true))
{
report = new EntityModel.Report();
rootNode = new ResourceReportNode();
var reportType = EntityModel.Entity.Get <EntityType>("test:person");;
rootNode.ResourceReportNodeType = reportType;
report.RootNode = rootNode.As <ReportNode>();
var column = new EntityModel.ReportColumn( );
exprType = new ResourceArgument();
exprType.ConformsToType = reportType;
var expr = new EntityModel.ResourceExpression();
expr.ReportExpressionResultType = exprType.As <ActivityArgument>();
expr.SourceNode = rootNode.As <ReportNode>();
column.ColumnExpression = expr.As <ReportExpression>();
report.ReportColumns.Add(column);
report.Save();
ctx.CommitTransaction();
}
ReportingInterface ri = new ReportingInterface( );
var settings = new ReportSettings
{
InitialRow = 0,
PageSize = 1,
RequireFullMetadata = true,
RequireBasicMetadata = true
};
// Run and expect 1 column
var result = ri.RunReport(report.Id, settings);
Assert.AreEqual(1, result.ReportQueryColumns.Count);
// Add column
using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true))
{
var column2 = new EntityModel.ReportColumn();
var expr2 = new EntityModel.ResourceExpression();
expr2.SourceNode = rootNode.As <ReportNode>();
expr2.ReportExpressionResultType = exprType.As <ActivityArgument>();
column2.ColumnExpression = expr2.As <ReportExpression>();
report.ReportColumns.Add(column2);
report.Save();
ctx.CommitTransaction();
}
// Run and expect 2 columns
result = ri.RunReport(report.Id, settings);
Assert.AreEqual(2, result.ReportQueryColumns.Count);
}
}
public void Import_Nested_SimplifiedReport( )
{
IEntityRepository repository = Factory.EntityRepository;
IEntityXmlImporter importer = Factory.EntityXmlImporter;
EntityXmlImportResult result;
string xml;
long entityId;
Report report;
// Import
using (RunAsImportExportRole( ))
using (Stream stream = GetStream("SimplifiedReport.xml"))
using (StreamReader reader = new StreamReader(stream))
{
xml = reader.ReadToEnd( );
result = importer.ImportXml(xml, EntityXmlImportSettings.Default);
}
// Check
Assert.That(result, Is.Not.Null);
Assert.That(result.RootEntities, Is.Not.Null);
entityId = result.RootEntities.Single( );
report = repository.Get <Report>(entityId);
try
{
Assert.That(report, Is.Not.Null);
Assert.That(report.Name, Is.EqualTo("Simple herb"));
ResourceReportNode rootNode = report.RootNode?.As <ResourceReportNode>( );
Assert.That(rootNode, Is.Not.Null, "Root node");
Assert.That(rootNode.ResourceReportNodeType, Is.Not.Null);
Assert.That(rootNode.ResourceReportNodeType.Alias, Is.EqualTo("test:herb"));
Assert.That(report.ReportColumns, Has.Count.EqualTo(1), "ReportColumns");
ReportColumn column = report.ReportColumns.First( );
Assert.That(column, Is.Not.Null, "Column");
Assert.That(column.Name, Is.EqualTo("AA_Herb"));
Assert.That(column.ColumnIsHidden == true, Is.True, "ColumnIsHidden");
FieldExpression fieldExpr = column.ColumnExpression?.As <FieldExpression>( );
Assert.That(fieldExpr, Is.Not.Null, "FieldExpression");
Assert.That(fieldExpr.FieldExpressionField.Alias, Is.EqualTo("core:name"));
Assert.That(fieldExpr.SourceNode?.Id, Is.EqualTo(rootNode?.Id), "SourceNode");
Assert.That(column.ColumnGrouping, Has.Count.EqualTo(1), "ColumnGrouping");
ReportRowGroup grouping = column.ColumnGrouping.First( );
Assert.That(grouping, Is.Not.Null, "ColumnGrouping");
Assert.That(grouping.GroupingPriority, Is.EqualTo(1), "GroupingPriority");
}
finally
{
Entity.Delete(entityId);
}
}
/// <summary>
/// Builds the resource report node.
/// </summary>
/// <param name="reportNode">The report node.</param>
/// <param name="context">The context.</param>
/// <returns>ResourceEntity.</returns>
private static ResourceEntity BuildResourceReportNode(ResourceReportNode reportNode, FromEntityContext context)
{
ResourceEntity resourceEntity = new ResourceEntity
{
ExactType = reportNode.ExactType ?? false
};
if (reportNode.ResourceReportNodeType != null)
{
resourceEntity.EntityTypeId = reportNode.ResourceReportNodeType.Id;
}
Guid nodeId;
if (!context.ReportNodeMap.TryGetValue(reportNode.Id, out nodeId))
{
nodeId = Guid.NewGuid();
context.ReportNodeMap[reportNode.Id] = nodeId;
}
resourceEntity.NodeId = nodeId;
resourceEntity.EntityId = reportNode.Id;
return(resourceEntity);
}
/// <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;
}
}
