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