public RuntimeDataSourceParameters(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.DataSource dataSource, OnDemandProcessingContext processingContext, int parameterDataSetIndex, ReportParameterDataSetCache aCache)
     : base(report, dataSource, processingContext, false)
 {
     Global.Tracer.Assert(parameterDataSetIndex != -1, "Parameter DataSet index must be specified when processing parameters");
     this.m_parameterDataSetIndex = parameterDataSetIndex;
     this.m_paramDataCache        = aCache;
 }
 public OnDemandMetadata(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report)
 {
     this.m_report                     = report;
     this.m_odpChunkManager            = new AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager();
     this.m_isInitialProcessingRequest = true;
     this.m_metaDataChanged            = true;
     this.m_tablixProcessingComplete   = new Dictionary <string, bool[]>();
 }
		private void InitializeEnvironment()
		{
			this.m_processingContext = base.m_romReport.HeaderFooterRenderingContext.OdpContext;
			AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDef = base.m_romReport.ReportDef;
			AspNetCore.ReportingServices.ReportProcessing.OnDemandReportObjectModel.ObjectModelImpl reportObjectModel = this.m_processingContext.ReportObjectModel;
			if (reportDef.DataSetsNotOnlyUsedInParameters == 1)
			{
				this.m_processingContext.SetupFieldsForNewDataSetPageSection(reportDef.FirstDataSet);
			}
			else
			{
				this.m_processingContext.SetupEmptyTopLevelFields();
			}
			reportObjectModel.VariablesImpl = new VariablesImpl(false);
			if (reportDef.HasVariables)
			{
				AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance currentReportInstance = base.m_romReport.RenderingContext.OdpContext.CurrentReportInstance;
				this.m_processingContext.RuntimeInitializePageSectionVariables(reportDef, (currentReportInstance != null) ? currentReportInstance.VariableValues : null);
			}
			reportObjectModel.LookupsImpl = new LookupsImpl();
			if (reportDef.HasLookups)
			{
				this.m_processingContext.RuntimeInitializeLookups(reportDef);
			}
			AspNetCore.ReportingServices.ReportProcessing.OnDemandReportObjectModel.ReportItemsImpl reportItemsImpl = new AspNetCore.ReportingServices.ReportProcessing.OnDemandReportObjectModel.ReportItemsImpl(false);
			foreach (ReportSection reportSection in base.m_romReport.ReportSections)
			{
				AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSection sectionDef = reportSection.SectionDef;
				reportSection.BodyItemsForHeadFoot = new AspNetCore.ReportingServices.ReportProcessing.OnDemandReportObjectModel.ReportItemsImpl(false);
				reportSection.PageSectionItemsForHeadFoot = new AspNetCore.ReportingServices.ReportProcessing.OnDemandReportObjectModel.ReportItemsImpl(false);
				reportObjectModel.ReportItemsImpl = reportSection.BodyItemsForHeadFoot;
				this.m_processingContext.RuntimeInitializeTextboxObjs(sectionDef.ReportItems, false);
				reportObjectModel.ReportItemsImpl = reportSection.PageSectionItemsForHeadFoot;
				AspNetCore.ReportingServices.ReportIntermediateFormat.Page page = sectionDef.Page;
				if (page.PageHeader != null)
				{
					if (this.m_processingContext.ReportRuntime.ReportExprHost != null)
					{
						page.PageHeader.SetExprHost(this.m_processingContext.ReportRuntime.ReportExprHost, reportObjectModel);
					}
					this.m_processingContext.RuntimeInitializeReportItemObjs(page.PageHeader.ReportItems, false);
					this.m_processingContext.RuntimeInitializeTextboxObjs(page.PageHeader.ReportItems, true);
				}
				if (page.PageFooter != null)
				{
					if (this.m_processingContext.ReportRuntime.ReportExprHost != null)
					{
						page.PageFooter.SetExprHost(this.m_processingContext.ReportRuntime.ReportExprHost, reportObjectModel);
					}
					this.m_processingContext.RuntimeInitializeReportItemObjs(page.PageFooter.ReportItems, false);
					this.m_processingContext.RuntimeInitializeTextboxObjs(page.PageFooter.ReportItems, true);
				}
				reportItemsImpl.AddAll(reportSection.BodyItemsForHeadFoot);
				reportItemsImpl.AddAll(reportSection.PageSectionItemsForHeadFoot);
			}
			reportObjectModel.ReportItemsImpl = reportItemsImpl;
			reportObjectModel.AggregatesImpl = new AspNetCore.ReportingServices.ReportProcessing.OnDemandReportObjectModel.AggregatesImpl(this.m_processingContext);
		}
Beispiel #4
0
		protected override void ProcessReport(ProcessingErrorContext errorContext, ExecutionLogContext executionLogContext, ref UserProfileState userProfileState)
		{
			OnDemandMetadata onDemandMetadata = null;
			AspNetCore.ReportingServices.ReportIntermediateFormat.Report report = default(AspNetCore.ReportingServices.ReportIntermediateFormat.Report);
			GlobalIDOwnerCollection globalIDOwnerCollection = AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager.DeserializeOdpReportSnapshot(base.PublicProcessingContext, (IChunkFactory)null, errorContext, true, true, base.Configuration, ref onDemandMetadata, out report);
			base.m_odpReportSnapshot = onDemandMetadata.ReportSnapshot;
			ProcessReportOdpSnapshot processReportOdpSnapshot = new ProcessReportOdpSnapshot(base.Configuration, base.PublicProcessingContext, report, errorContext, base.PublicRenderingContext.StoreServerParametersCallback, globalIDOwnerCollection, executionLogContext, onDemandMetadata);
			((ProcessReportOdp)processReportOdpSnapshot).Execute(out base.m_odpContext);
		}
Beispiel #5
0
        protected override void ProcessReport(ProcessingErrorContext errorContext, ExecutionLogContext executionLogContext, ref UserProfileState userProfileState)
        {
            GlobalIDOwnerCollection globalIDOwnerCollection = default(GlobalIDOwnerCollection);

            AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDefinition = base.GetReportDefinition(out globalIDOwnerCollection);
            ProcessReportDefinitionOnly processReportDefinitionOnly = new ProcessReportDefinitionOnly(base.Configuration, base.PublicProcessingContext, reportDefinition, errorContext, base.PublicRenderingContext.StoreServerParametersCallback, globalIDOwnerCollection, executionLogContext, base.ExecutionTimeStamp);

            base.m_odpReportSnapshot = ((ProcessReportOdp)processReportDefinitionOnly).Execute(out base.m_odpContext);
        }
Beispiel #6
0
 public static bool InitializeSubReports(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, OnDemandProcessingContext odpContext, bool inDataRegion, bool fromCreateSubReportInstance)
 {
     try
     {
         odpContext.IsTopLevelSubReportProcessing = true;
         bool flag = true;
         OnDemandProcessingContext onDemandProcessingContext = odpContext;
         foreach (AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport subReport in report.SubReports)
         {
             if (subReport.ExceededMaxLevel)
             {
                 return(flag);
             }
             IReference <AspNetCore.ReportingServices.ReportIntermediateFormat.SubReportInstance> reference = null;
             try
             {
                 bool flag2 = false;
                 if (subReport.RetrievalStatus != AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport.Status.DefinitionRetrieveFailed)
                 {
                     onDemandProcessingContext = SubReportInitializer.InitializeSubReport(odpContext, subReport, reportInstance, inDataRegion || subReport.InDataRegion, fromCreateSubReportInstance, out flag2);
                     if (!inDataRegion && !subReport.InDataRegion && (!odpContext.SnapshotProcessing || odpContext.ReprocessSnapshot))
                     {
                         reference = subReport.CurrentSubReportInstance;
                     }
                 }
                 if (flag2 && subReport.Report.HasSubReports)
                 {
                     flag &= SubReportInitializer.InitializeSubReports(subReport.Report, (subReport.CurrentSubReportInstance != null) ? subReport.CurrentSubReportInstance.Value().ReportInstance.Value() : null, onDemandProcessingContext, inDataRegion || subReport.InDataRegion, fromCreateSubReportInstance);
                 }
                 if (onDemandProcessingContext.ErrorContext.Messages != null && 0 < onDemandProcessingContext.ErrorContext.Messages.Count)
                 {
                     OnDemandProcessingContext topLevelContext = odpContext.TopLevelContext;
                     topLevelContext.ErrorContext.Register(ProcessingErrorCode.rsWarningExecutingSubreport, Severity.Warning, subReport.ObjectType, subReport.Name, null, onDemandProcessingContext.ErrorContext.Messages);
                 }
                 flag &= flag2;
             }
             catch (Exception e)
             {
                 flag = false;
                 AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.HandleSubReportProcessingError(onDemandProcessingContext.TopLevelContext.ErrorContext, subReport, InstancePathItem.GenerateInstancePathString(subReport.InstancePath), onDemandProcessingContext.ErrorContext, e);
             }
             finally
             {
                 if (reference != null)
                 {
                     reference.Value().InstanceComplete();
                 }
             }
         }
         return(flag);
     }
     finally
     {
         odpContext.IsTopLevelSubReportProcessing = false;
     }
 }
 public Report(AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDef, RenderingContext renderingContext, string reportName, string description)
 {
     this.m_parentDefinitionPath = null;
     this.m_isOldSnapshot        = false;
     this.m_reportDef            = reportDef;
     this.m_reportInstance       = null;
     this.m_renderingContext     = renderingContext;
     this.m_name        = reportName;
     this.m_description = description;
 }
 private void SetupObjectModels(IRIFReportDataScope reportDataScope, int moveNextInstanceIndex)
 {
     AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDefinition = base.m_odpContext.ReportDefinition;
     base.m_odpContext.EnsureCultureIsSetOnCurrentThread();
     this.EnsureScopeIsBound(reportDataScope);
     if (this.m_lastOnDemandScopeInstance != reportDataScope.CurrentStreamingScopeInstance)
     {
         this.SetupEnvironment(reportDataScope, reportDataScope.CurrentStreamingScopeInstance.Value(), reportDataScope.CurrentStreamingScopeInstance);
     }
 }
Beispiel #9
0
 public ProcessReportOdp(IConfiguration configuration, ProcessingContext pc, AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext)
 {
     this.m_configuration           = configuration;
     this.m_publicProcessingContext = pc;
     this.m_reportDefinition        = report;
     this.m_errorContext            = errorContext;
     this.m_storeServerParameters   = storeServerParameters;
     this.m_globalIDOwnerCollection = globalIDOwnerCollection;
     this.m_executionLogContext     = executionLogContext;
 }
 protected RuntimeDataSource(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.DataSource dataSource, OnDemandProcessingContext processingContext, bool mergeTransactions)
 {
     this.m_report           = report;
     this.m_dataSource       = dataSource;
     this.m_odpContext       = processingContext;
     this.m_runtimeDataSets  = null;
     this.m_mergeTran        = mergeTransactions;
     this.m_executionMetrics = new DataProcessingMetrics(this.m_odpContext.JobContext, this.m_odpContext.ExecutionLogContext);
     Global.Tracer.Assert(this.m_dataSource.Name != null, "The name of a data source cannot be null.");
 }
 public OnDemandProcessReportParameters(AspNetCore.ReportingServices.ReportIntermediateFormat.Report aReport, OnDemandProcessingContext aContext)
     : base(aContext)
 {
     this.m_report = aReport;
     if (aContext.IsRdlSandboxingEnabled())
     {
         IRdlSandboxConfig rdlSandboxing = aContext.Configuration.RdlSandboxing;
         base.m_maxStringResultLength = rdlSandboxing.MaxStringResultLength;
     }
 }
 public OnDemandMetadata(OnDemandMetadata metadataFromOldSnapshot, AspNetCore.ReportingServices.ReportIntermediateFormat.Report report)
 {
     this.m_isInitialProcessingRequest = true;
     this.m_metaDataChanged            = true;
     this.m_report                 = report;
     this.m_odpChunkManager        = metadataFromOldSnapshot.m_odpChunkManager;
     this.m_subReportInfoMap       = metadataFromOldSnapshot.m_subReportInfoMap;
     this.m_commonSubReportInfoMap = metadataFromOldSnapshot.m_commonSubReportInfoMap;
     this.m_dataChunkMap           = metadataFromOldSnapshot.m_dataChunkMap;
     this.m_lastAssignedGlobalID   = metadataFromOldSnapshot.m_lastAssignedGlobalID;
     this.CommonPrepareForReprocessing();
 }
Beispiel #13
0
        protected override void ProcessReport(ProcessingErrorContext errorContext, ExecutionLogContext executionLogContext, ref UserProfileState userProfileState)
        {
            OnDemandMetadata        onDemandMetadata        = null;
            GlobalIDOwnerCollection globalIDOwnerCollection = new GlobalIDOwnerCollection();

            onDemandMetadata        = AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager.DeserializeOnDemandMetadata(this.m_dataCacheChunks, globalIDOwnerCollection);
            globalIDOwnerCollection = new GlobalIDOwnerCollection();
            AspNetCore.ReportingServices.ReportIntermediateFormat.Report report = ReportProcessing.DeserializeKatmaiReport(base.PublicProcessingContext.ChunkFactory, false, globalIDOwnerCollection);
            ProcessReportOdpWithCachedData processReportOdpWithCachedData       = new ProcessReportOdpWithCachedData(base.Configuration, base.PublicProcessingContext, report, errorContext, base.PublicRenderingContext.StoreServerParametersCallback, globalIDOwnerCollection, executionLogContext, this.m_executionTimeStamp, onDemandMetadata);

            base.m_odpReportSnapshot = ((ProcessReportOdp)processReportOdpWithCachedData).Execute(out base.m_odpContext);
        }
 public Report(IDefinitionPath parentDefinitionPath, AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDef, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, RenderingContext renderingContext, string reportName, string description, bool subreportInSubtotal)
 {
     this.m_parentDefinitionPath = parentDefinitionPath;
     this.m_isOldSnapshot        = false;
     this.m_reportDef            = reportDef;
     this.m_reportInstance       = reportInstance;
     this.m_isOldSnapshot        = false;
     this.m_subreportInSubtotal  = subreportInSubtotal;
     this.m_renderingContext     = renderingContext;
     this.m_name           = reportName;
     this.m_description    = description;
     this.m_pageEvaluation = null;
 }
Beispiel #15
0
 public static void InitializeSubReportOdpContext(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, OnDemandProcessingContext parentOdpContext)
 {
     foreach (AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport subReport in report.SubReports)
     {
         if (!subReport.ExceededMaxLevel)
         {
             OnDemandProcessingContext parentOdpContext2 = subReport.OdpContext = new OnDemandProcessingContext(parentOdpContext, subReport.ReportContext, subReport);
             if (subReport.RetrievalStatus != AspNetCore.ReportingServices.ReportIntermediateFormat.SubReport.Status.DefinitionRetrieveFailed && subReport.Report.HasSubReports)
             {
                 SubReportInitializer.InitializeSubReportOdpContext(subReport.Report, parentOdpContext2);
             }
         }
     }
 }
 public Report(AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDef, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, RenderingContext renderingContext, string reportName, string description)
 {
     this.m_parentDefinitionPath = null;
     this.m_isOldSnapshot        = false;
     this.m_reportDef            = reportDef;
     this.m_reportInstance       = reportInstance;
     this.m_renderingContext     = renderingContext;
     this.m_name        = reportName;
     this.m_description = description;
     if (reportDef.HasHeadersOrFooters)
     {
         this.m_pageEvaluation = new OnDemandPageEvaluation(this);
         this.m_renderingContext.SetPageEvaluation(this.m_pageEvaluation);
     }
 }
 public AutomaticSubtotalContext(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, List <ICreateSubtotals> createSubtotals, List <AspNetCore.ReportingServices.ReportIntermediateFormat.Grouping> domainScopeGroups, NameValidator reportItemNameValidator, NameValidator scopeNameValidator, NameValidator variableNameValidator, Dictionary <string, AspNetCore.ReportingServices.ReportIntermediateFormat.ISortFilterScope> reportScopes, List <AspNetCore.ReportingServices.ReportIntermediateFormat.ReportItemCollection> reportItemCollections, List <AspNetCore.ReportingServices.ReportIntermediateFormat.IAggregateHolder> aggregateHolders, List <AspNetCore.ReportingServices.ReportIntermediateFormat.IRunningValueHolder> runningValueHolders, Holder <int> variableSequenceIdCounter, Holder <int> textboxSequenceIdCounter, ScopeTree scopeTree)
 {
     this.m_createSubtotals         = createSubtotals;
     this.m_domainScopeGroups       = domainScopeGroups;
     this.m_reportItemNameValidator = reportItemNameValidator;
     this.m_scopeNameValidator      = scopeNameValidator;
     this.m_variableNameValidator   = variableNameValidator;
     this.m_report = report;
     this.m_variableSequenceIdCounter        = variableSequenceIdCounter;
     this.m_textboxSequenceIdCounter         = textboxSequenceIdCounter;
     this.m_dynamicWithStaticPeerEncountered = false;
     this.m_location          = LocationFlags.None;
     this.m_objectName        = null;
     this.m_objectType        = ObjectType.Tablix;
     this.m_currentDataRegion = null;
     this.m_cellLists         = null;
     this.m_tablixColumns     = null;
     this.m_rows                                = null;
     this.m_scopeNameMap                        = new Dictionary <string, string>(StringComparer.Ordinal);
     this.m_reportItemNameMap                   = new Dictionary <string, string>(StringComparer.Ordinal);
     this.m_aggregateMap                        = new Dictionary <string, string>(StringComparer.Ordinal);
     this.m_lookupMap                           = new Dictionary <string, string>(StringComparer.Ordinal);
     this.m_variableNameMap                     = new Dictionary <string, string>(StringComparer.Ordinal);
     this.m_currentScope                        = null;
     this.m_currentScopeBeingCloned             = null;
     this.m_startIndex                          = new Holder <int>();
     this.m_currentIndex                        = new Holder <int>();
     this.m_headerLevel                         = 0;
     this.m_originalColumnCount                 = 0;
     this.m_originalRowCount                    = 0;
     this.m_reportScopes                        = reportScopes;
     this.m_reportItemCollections               = reportItemCollections;
     this.m_aggregateHolders                    = aggregateHolders;
     this.m_runningValueHolders                 = runningValueHolders;
     this.m_expressionsWithReportItemReferences = new List <AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo>();
     this.m_visibilitiesWithToggleToUpdate      = new List <AspNetCore.ReportingServices.ReportIntermediateFormat.Visibility>();
     this.m_reportItemsWithRepeatWithToUpdate   = new List <AspNetCore.ReportingServices.ReportIntermediateFormat.ReportItem>();
     this.m_endUserSortWithTarget               = new List <AspNetCore.ReportingServices.ReportIntermediateFormat.EndUserSort>();
     this.m_scopeNamesToClone                   = new Dictionary <string, IRIFDataScope>(StringComparer.Ordinal);
     this.m_headerLevelHasStaticArray           = null;
     this.m_currentDataRegionClone              = null;
     this.m_currentMapClone                     = null;
     this.m_outerAggregate                      = null;
     this.m_scopeTree                           = scopeTree;
     this.m_currentDataScope                    = null;
     this.m_currentMapVectorLayerClone          = null;
 }
        public void Initialize(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance)
        {
            int size = 0;

            if (report.Parameters != null)
            {
                size = report.Parameters.Count;
            }
            this.m_parameters = new ParametersImpl(size);
            this.InitializeGlobalAndUserCollections();
            this.m_currentFields = new FieldsContext(this);
            this.m_dataSources   = new DataSourcesImpl(report.DataSourceCount);
            this.m_dataSets      = new DataSetsImpl(report.DataSetCount);
            this.InitOrUpdateDataSetCollection(report, reportInstance, true);
            this.m_variables   = new VariablesImpl(false);
            this.m_aggregates  = new AggregatesImpl(false, this.m_odpContext);
            this.m_reportItems = new ReportItemsImpl(false);
            this.m_lookups     = new LookupsImpl();
        }
Beispiel #19
0
        public static void DumpTablixes(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report)
        {
            StreamWriter streamWriter = new StreamWriter(new FileStream("TablixDump.html", FileMode.Create));

            streamWriter.WriteLine("<html><body>");
            for (int i = 0; i < report.ReportSections.Count; i++)
            {
                ReportSection reportSection = report.ReportSections[i];
                for (int j = 0; j < reportSection.ReportItems.Count; j++)
                {
                    if (reportSection.ReportItems[j].ObjectType == ObjectType.Tablix)
                    {
                        SupportabilityRIFVisualizer.DumpTablix((AspNetCore.ReportingServices.ReportIntermediateFormat.Tablix)reportSection.ReportItems[j], streamWriter);
                    }
                }
            }
            streamWriter.WriteLine("</body></html>");
            streamWriter.Flush();
            streamWriter.Close();
        }
Beispiel #20
0
        public static bool PreProcessTablixes(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, OnDemandProcessingContext odpContext, bool onlyWithSubReports)
        {
            bool result = false;

            foreach (AspNetCore.ReportingServices.ReportIntermediateFormat.DataSource dataSource in report.DataSources)
            {
                if (dataSource.DataSets != null)
                {
                    foreach (AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet dataSet in dataSource.DataSets)
                    {
                        DataSetInstance dataSetInstance = odpContext.CurrentReportInstance.GetDataSetInstance(dataSet, odpContext);
                        if (dataSetInstance != null && dataSet.DataRegions.Count != 0 && !odpContext.IsTablixProcessingComplete(dataSet.IndexInCollection) && (!onlyWithSubReports || dataSet.HasSubReports || (odpContext.InSubreport && odpContext.HasUserSortFilter)))
                        {
                            result = true;
                            Merge.TablixDataProcessing(odpContext, dataSet);
                        }
                    }
                }
            }
            return(result);
        }
        private int InitOrUpdateDataSetCollection(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, bool initialize)
        {
            int result = 0;

            for (int i = 0; i < report.DataSourceCount; i++)
            {
                AspNetCore.ReportingServices.ReportIntermediateFormat.DataSource dataSource = report.DataSources[i];
                if (initialize && !dataSource.IsArtificialForSharedDataSets)
                {
                    this.m_dataSources.Add(dataSource);
                }
                if (dataSource.DataSets != null)
                {
                    for (int j = 0; j < dataSource.DataSets.Count; j++)
                    {
                        this.InitDataSet(reportInstance, dataSource.DataSets[j], ref result);
                    }
                }
            }
            return(result);
        }
        public DataProcessingController(OnDemandProcessingContext odpContext, AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet dataSet, DataSetInstance dataSetInstance)
        {
            this.m_odpContext      = odpContext;
            this.m_dataSet         = dataSet;
            this.m_dataSetInstance = dataSetInstance;
            this.m_report          = odpContext.ReportDefinition;
            this.m_odpContext.EnsureScalabilitySetup();
            UserSortFilterContext userSortFilterContext = this.m_odpContext.UserSortFilterContext;

            if (!this.m_odpContext.InSubreportInDataRegion)
            {
                userSortFilterContext.ResetContextForTopLevelDataSet();
            }
            this.m_hasSortFilterInfo = this.m_odpContext.PopulateRuntimeSortFilterEventInfo(this.m_dataSet);
            if (-1 == userSortFilterContext.DataSetGlobalId)
            {
                userSortFilterContext.DataSetGlobalId = this.m_dataSet.GlobalID;
            }
            Global.Tracer.Assert(this.m_odpContext.ReportObjectModel != null && this.m_odpContext.ReportRuntime != null);
            this.m_odpContext.SetupFieldsForNewDataSet(this.m_dataSet, this.m_dataSetInstance, true, true);
            this.m_dataSet.SetFilterExprHost(this.m_odpContext.ReportObjectModel);
            this.m_dataSetObj = new RuntimeOnDemandDataSetObj(this.m_odpContext, this.m_dataSet, this.m_dataSetInstance);
        }
 public ProcessReportOdpStreaming(IConfiguration configuration, ProcessingContext pc, AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, DateTime executionTime, IAbortHelper abortHelper)
     : base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext, executionTime)
 {
     this.m_abortHelper = abortHelper;
 }
Beispiel #24
0
 public DataSetCollection(AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDef, RenderingContext renderingContext)
 {
     this.m_reportDef       = reportDef;
     this.m_rendringContext = renderingContext;
 }
Beispiel #25
0
 public Merge(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, OnDemandProcessingContext odpContext)
 {
     this.m_report           = report;
     this.m_odpContext       = odpContext;
     this.m_retrievalManager = new RetrievalManager(report, odpContext);
 }
        private void SetupObjectModels(OnDemandMode mode, bool needDeepCopyPath, int moveNextInstanceIndex, string scopeName)
        {
            AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegionInstance dataRegionInstance = null;
            IMemberHierarchy memberHierarchy         = null;
            int                     num              = -1;
            ScopeInstance           scopeInstance    = base.m_odpContext.CurrentReportInstance;
            List <InstancePathItem> lastInstancePath = this.m_lastInstancePath;
            List <InstancePathItem> list             = null;
            int                     num2             = 0;

            AspNetCore.ReportingServices.ReportIntermediateFormat.Report reportDefinition = base.m_odpContext.ReportDefinition;
            ObjectModelImpl reportObjectModel = base.m_odpContext.ReportObjectModel;
            bool            flag  = false;
            bool            flag2 = false;
            int             num3  = 0;

            try
            {
                if (this.m_lastRIFObject.InstancePath != null)
                {
                    list = this.m_lastRIFObject.InstancePath;
                    num2 = list.Count;
                }
                if (mode != OnDemandMode.InScope)
                {
                    base.m_odpContext.EnsureCultureIsSetOnCurrentThread();
                }
                if (mode != OnDemandMode.InScope || 1 != reportDefinition.DataSetsNotOnlyUsedInParameters || !this.InScopeCompare(reportDefinition.FirstDataSet.Name, scopeName))
                {
                    int num4 = 0;
                    if (base.m_odpContext.InSubreport)
                    {
                        num4 = InstancePathItem.GetParentReportIndex(this.m_lastRIFObject.InstancePath, this.m_lastRIFObject.InstancePathItem.Type == InstancePathItemType.SubReport);
                    }
                    bool flag3           = default(bool);
                    int  sharedPathIndex = InstancePathItem.GetSharedPathIndex(num4, lastInstancePath, list, reportObjectModel.AllFieldsCleared, out flag3);
                    for (int i = this.m_specialLastGroupingValues.Count; i < num4; i++)
                    {
                        this.m_specialLastGroupingValues.Add(null);
                    }
                    for (int j = num4; j < num2; j++)
                    {
                        InstancePathItem instancePathItem = list[j];
                        bool             flag4            = false;
                        if (mode != OnDemandMode.InScope)
                        {
                            flag4 = (j <= sharedPathIndex);
                        }
                        if (!flag4 && mode == OnDemandMode.FullSetup)
                        {
                            if (this.m_specialLastGroupingValues.Count < num2)
                            {
                                this.m_specialLastGroupingValues.Add(null);
                            }
                            else
                            {
                                this.m_specialLastGroupingValues[j] = null;
                            }
                        }
                        switch (instancePathItem.Type)
                        {
                        case InstancePathItemType.SubReport:
                            if (scopeInstance.SubreportInstances != null && instancePathItem.IndexInCollection < scopeInstance.SubreportInstances.Count)
                            {
                                IReference <AspNetCore.ReportingServices.ReportIntermediateFormat.SubReportInstance> reference = scopeInstance.SubreportInstances[instancePathItem.IndexInCollection];
                                using (reference.PinValue())
                                {
                                    AspNetCore.ReportingServices.ReportIntermediateFormat.SubReportInstance subReportInstance = reference.Value();
                                    subReportInstance.SubReportDef.CurrentSubReportInstance = reference;
                                    if (mode != OnDemandMode.InScope && !subReportInstance.Initialized)
                                    {
                                        if (base.m_odpContext.IsTablixProcessingMode || base.m_odpContext.IsTopLevelSubReportProcessing)
                                        {
                                            return;
                                        }
                                        SubReportInitializer.InitializeSubReport(subReportInstance.SubReportDef);
                                        reference.PinValue();
                                    }
                                    Global.Tracer.Assert(j == num2 - 1, "SubReport not last in instance path.");
                                }
                            }
                            goto default;

                        case InstancePathItemType.DataRegion:
                            if (scopeInstance is AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance && (scopeInstance.DataRegionInstances == null || scopeInstance.DataRegionInstances.Count <= instancePathItem.IndexInCollection || scopeInstance.DataRegionInstances[instancePathItem.IndexInCollection] == null || scopeInstance.DataRegionInstances[instancePathItem.IndexInCollection].Value() == null))
                            {
                                Global.Tracer.Assert(instancePathItem.IndexInCollection < reportDefinition.TopLevelDataRegions.Count, "(newItem.IndexInCollection < m_reportDefinition.TopLevelDataRegions.Count)");
                                AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegion dataRegion = reportDefinition.TopLevelDataRegions[instancePathItem.IndexInCollection];
                                AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet    dataSet    = dataRegion.GetDataSet(reportDefinition);
                                if (mode == OnDemandMode.InScope && this.InScopeCompare(dataSet.Name, scopeName))
                                {
                                    return;
                                }
                                this.PerformOnDemandTablixProcessing(dataSet);
                            }
                            scopeInstance      = scopeInstance.DataRegionInstances[instancePathItem.IndexInCollection].Value();
                            flag               = (this.m_inRecursiveColumnHierarchy = false);
                            flag2              = (this.m_inRecursiveRowHierarchy = false);
                            num                = -1;
                            dataRegionInstance = (scopeInstance as AspNetCore.ReportingServices.ReportIntermediateFormat.DataRegionInstance);
                            memberHierarchy    = dataRegionInstance;
                            if (mode == OnDemandMode.InScope && this.InScopeCompare(dataRegionInstance.DataRegionDef.Name, scopeName))
                            {
                                return;
                            }
                            if (dataRegionInstance.DataSetIndexInCollection >= 0 && base.m_odpContext.CurrentDataSetIndex != dataRegionInstance.DataSetIndexInCollection && mode != OnDemandMode.InScope)
                            {
                                if (!flag4)
                                {
                                    AspNetCore.ReportingServices.ReportIntermediateFormat.DataSetInstance dataSetInstance = base.m_odpContext.CurrentReportInstance.GetDataSetInstance(dataRegionInstance.DataSetIndexInCollection, base.m_odpContext);
                                    if (dataSetInstance != null)
                                    {
                                        dataSetInstance.SetupEnvironment(base.m_odpContext, true);
                                        num3 = 0;
                                    }
                                }
                                else
                                {
                                    num3 = j + 1;
                                }
                            }
                            if (mode != OnDemandMode.InScope)
                            {
                                if (!flag4)
                                {
                                    dataRegionInstance.SetupEnvironment(base.m_odpContext);
                                    num3 = 0;
                                    if (!dataRegionInstance.NoRows)
                                    {
                                        dataRegionInstance.DataRegionDef.NoRows = false;
                                        goto default;
                                    }
                                    dataRegionInstance.DataRegionDef.NoRows = true;
                                    dataRegionInstance.DataRegionDef.ResetTopLevelDynamicMemberInstanceCount();
                                    return;
                                }
                                num3 = j + 1;
                            }
                            goto default;

                        case InstancePathItemType.ColumnMemberInstanceIndexTopMost:
                            scopeInstance = dataRegionInstance;
                            goto default;

                        case InstancePathItemType.Cell:
                        {
                            if (-1 == num)
                            {
                                num = 0;
                            }
                            IList <AspNetCore.ReportingServices.ReportIntermediateFormat.DataCellInstance> cellInstances = memberHierarchy.GetCellInstances(num);
                            if (cellInstances == null)
                            {
                                if (flag2 && flag)
                                {
                                    reportObjectModel.ResetFieldValues();
                                }
                            }
                            else if (cellInstances.Count > instancePathItem.IndexInCollection)
                            {
                                AspNetCore.ReportingServices.ReportIntermediateFormat.DataCellInstance dataCellInstance = cellInstances[instancePathItem.IndexInCollection];
                                if (dataCellInstance != null)
                                {
                                    scopeInstance = dataCellInstance;
                                    if (!flag4)
                                    {
                                        dataCellInstance.SetupEnvironment(base.m_odpContext, base.m_odpContext.CurrentDataSetIndex);
                                        num3 = 0;
                                    }
                                    else
                                    {
                                        num3 = j + 1;
                                    }
                                }
                            }
                            goto default;
                        }

                        default:
                            if (instancePathItem.IsDynamicMember)
                            {
                                IList <DataRegionMemberInstance> childMemberInstances = ((IMemberHierarchy)scopeInstance).GetChildMemberInstances(instancePathItem.Type == InstancePathItemType.RowMemberInstanceIndex, instancePathItem.IndexInCollection);
                                if (childMemberInstances == null)
                                {
                                    reportObjectModel.ResetFieldValues();
                                    return;
                                }
                                int num5 = (j != num2 - 1 || moveNextInstanceIndex < 0 || moveNextInstanceIndex >= childMemberInstances.Count) ? ((instancePathItem.InstanceIndex >= 0) ? instancePathItem.InstanceIndex : 0) : moveNextInstanceIndex;
                                if (num5 >= childMemberInstances.Count)
                                {
                                    instancePathItem.ResetContext();
                                    num5 = 0;
                                }
                                DataRegionMemberInstance dataRegionMemberInstance = childMemberInstances[num5];
                                if (mode == OnDemandMode.FullSetup)
                                {
                                    dataRegionMemberInstance.MemberDef.InstanceCount      = childMemberInstances.Count;
                                    dataRegionMemberInstance.MemberDef.CurrentMemberIndex = num5;
                                }
                                scopeInstance             = dataRegionMemberInstance;
                                this.m_lastRecursiveLevel = dataRegionMemberInstance.RecursiveLevel;
                                AspNetCore.ReportingServices.ReportIntermediateFormat.ReportHierarchyNode memberDef = dataRegionMemberInstance.MemberDef;
                                if (mode == OnDemandMode.InScope && this.InScopeCompare(memberDef.Grouping.Name, scopeName))
                                {
                                    return;
                                }
                                if (instancePathItem.Type == InstancePathItemType.RowMemberInstanceIndex)
                                {
                                    memberHierarchy = dataRegionMemberInstance;
                                    flag2           = true;
                                }
                                else
                                {
                                    num  = dataRegionMemberInstance.MemberInstanceIndexWithinScopeLevel;
                                    flag = true;
                                }
                                if (mode == OnDemandMode.FullSetup && !flag4)
                                {
                                    dataRegionMemberInstance.SetupEnvironment(base.m_odpContext, base.m_odpContext.CurrentDataSetIndex);
                                    num3 = 0;
                                    AspNetCore.ReportingServices.ReportIntermediateFormat.Grouping grouping = memberDef.Grouping;
                                    if (grouping.Parent != null)
                                    {
                                        if (memberDef.IsColumn)
                                        {
                                            this.m_inRecursiveColumnHierarchy = true;
                                        }
                                        else
                                        {
                                            this.m_inRecursiveRowHierarchy = true;
                                        }
                                        if (memberDef.IsTablixMember)
                                        {
                                            memberDef.SetMemberInstances(childMemberInstances);
                                            memberDef.SetRecursiveParentIndex(dataRegionMemberInstance.RecursiveParentIndex);
                                            memberDef.SetInstanceHasRecursiveChildren(dataRegionMemberInstance.HasRecursiveChildren);
                                        }
                                    }
                                    else if (memberDef.IsColumn)
                                    {
                                        this.m_inRecursiveColumnHierarchy = false;
                                    }
                                    else
                                    {
                                        this.m_inRecursiveRowHierarchy = false;
                                    }
                                    grouping.RecursiveLevel = this.m_lastRecursiveLevel;
                                    grouping.SetGroupInstanceExpressionValues(dataRegionMemberInstance.GroupExprValues);
                                    if (mode == OnDemandMode.FullSetup && grouping != null && grouping.GroupExpressions != null && grouping.GroupExpressions.Count > 0)
                                    {
                                        AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo expressionInfo = grouping.GroupExpressions[0];
                                        if (expressionInfo.Type == AspNetCore.ReportingServices.ReportIntermediateFormat.ExpressionInfo.Types.Field)
                                        {
                                            AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet dataSet2 = memberDef.DataRegionDef.GetDataSet(reportDefinition);
                                            AspNetCore.ReportingServices.ReportIntermediateFormat.Field   field    = dataSet2.Fields[expressionInfo.IntValue];
                                            if (field.DataField != null)
                                            {
                                                string dataField = field.DataField;
                                                object second    = dataRegionMemberInstance.GroupExprValues[0];
                                                PairObj <string, object> pairObj = this.m_specialLastGroupingValues[j];
                                                if (pairObj == null)
                                                {
                                                    pairObj = new PairObj <string, object>(dataField, second);
                                                    this.m_specialLastGroupingValues[j] = pairObj;
                                                }
                                                else
                                                {
                                                    pairObj.First  = dataField;
                                                    pairObj.Second = second;
                                                }
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    num3 = j + 1;
                                }
                            }
                            break;

                        case InstancePathItemType.None:
                            break;
                        }
                    }
                    if (mode == OnDemandMode.FullSetup && !flag3 && scopeInstance != null && num3 > 0)
                    {
                        while (num3 < this.m_lastInstancePath.Count)
                        {
                            if (!this.m_lastInstancePath[num3].IsScope)
                            {
                                num3++;
                                continue;
                            }
                            scopeInstance.SetupFields(base.m_odpContext, base.m_odpContext.CurrentDataSetIndex);
                            break;
                        }
                    }
                    if (mode == OnDemandMode.FullSetup && !base.m_odpContext.IsTablixProcessingMode && base.m_odpContext.CurrentReportInstance != null && dataRegionInstance == null && reportDefinition.DataSetsNotOnlyUsedInParameters == 1)
                    {
                        AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet         firstDataSet     = reportDefinition.FirstDataSet;
                        AspNetCore.ReportingServices.ReportIntermediateFormat.DataSetInstance dataSetInstance2 = base.m_odpContext.CurrentReportInstance.GetDataSetInstance(firstDataSet, base.m_odpContext);
                        if (dataSetInstance2 != null)
                        {
                            bool flag5 = true;
                            if (!base.m_odpContext.IsTablixProcessingComplete(firstDataSet.IndexInCollection))
                            {
                                this.PerformOnDemandTablixProcessing(firstDataSet);
                                flag5 = false;
                            }
                            if (base.m_odpContext.CurrentOdpDataSetInstance == dataSetInstance2)
                            {
                                flag5 = false;
                            }
                            if (flag5)
                            {
                                dataSetInstance2.SetupEnvironment(base.m_odpContext, true);
                            }
                            else if (!dataSetInstance2.NoRows)
                            {
                                dataSetInstance2.SetupFields(base.m_odpContext, dataSetInstance2);
                            }
                        }
                    }
                }
            }
            finally
            {
                if (needDeepCopyPath)
                {
                    InstancePathItem.DeepCopyPath(list, ref this.m_lastInstancePath);
                }
            }
        }
 public ScopeTree(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report)
     : this()
 {
     this.m_report = report;
 }
Beispiel #28
0
 public ProcessReportOdpWithCachedData(IConfiguration configuration, ProcessingContext pc, AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, ErrorContext errorContext, ReportProcessing.StoreServerParameters storeServerParameters, GlobalIDOwnerCollection globalIDOwnerCollection, ExecutionLogContext executionLogContext, DateTime executionTime, OnDemandMetadata odpMetadataFromDataCache)
     : base(configuration, pc, report, errorContext, storeServerParameters, globalIDOwnerCollection, executionLogContext, executionTime)
 {
     Global.Tracer.Assert(odpMetadataFromDataCache != null, "Must provide existing metadata to process with cached data");
     this.m_odpMetadataFromDataCache = odpMetadataFromDataCache;
 }
 protected RuntimeIncrementalDataSource(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.DataSet dataSet, OnDemandProcessingContext odpContext)
     : base(report, dataSet.DataSource, odpContext, false)
 {
     this.m_dataSet = dataSet;
 }
Beispiel #30
0
 protected RuntimeAtomicDataSource(AspNetCore.ReportingServices.ReportIntermediateFormat.Report report, AspNetCore.ReportingServices.ReportIntermediateFormat.DataSource dataSource, OnDemandProcessingContext processingContext, bool mergeTransactions)
     : base(report, dataSource, processingContext, mergeTransactions)
 {
 }