protected override OnDemandMetadata PrepareMetadata()
        {
            OnDemandMetadata onDemandMetadata = new OnDemandMetadata(base.ReportDefinition);

            AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot2 = onDemandMetadata.ReportSnapshot = new AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot(base.ReportDefinition, base.PublicProcessingContext.ReportContext.ItemName, base.PublicProcessingContext.Parameters, base.PublicProcessingContext.RequestUserName, this.m_executionTime, base.PublicProcessingContext.ReportContext.HostRootUri, base.PublicProcessingContext.ReportContext.ParentPath, base.PublicProcessingContext.UserLanguage.Name);
            return(onDemandMetadata);
        }
Exemple #2
0
 private void SaveGeneratedReportItemInstance()
 {
     if (this.m_dynamicWidth == null && this.m_dynamicHeight == null)
     {
         OnDemandProcessingContext odpContext = base.RenderingContext.OdpContext;
         AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot = odpContext.OdpMetadata.ReportSnapshot;
         IChunkFactory chunkFactory = odpContext.ChunkFactory;
         if (this.CriDef.RepeatWith == null)
         {
             string text = CustomReportItem.CreateChunkName();
             using (Stream stream = chunkFactory.CreateChunk(text, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.GeneratedReportItems, null))
             {
                 new IntermediateFormatWriter(stream, odpContext.GetActiveCompatibilityVersion()).Write(this.m_generatedReportItem.Instance);
                 stream.Flush();
             }
             reportSnapshot.AddGeneratedReportItemChunkName(this.GetGeneratedInstanceChunkKey(), text);
         }
         else
         {
             ImageInstance imageInstance = (ImageInstance)this.m_generatedReportItem.Instance;
             string        text          = imageInstance.StreamName = ImageHelper.StoreImageDataInChunk(AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.Image, imageInstance.ImageData, imageInstance.MIMEType, base.RenderingContext.OdpContext.OdpMetadata, base.RenderingContext.OdpContext.ChunkFactory);
             reportSnapshot.AddImageChunkName(this.GetGeneratedInstanceChunkKey(), text);
         }
     }
 }
Exemple #3
0
        public static string StoreImageDataInChunk(AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes chunkType, byte[] imageData, string mimeType, OnDemandMetadata odpMetadata, IChunkFactory chunkFactory)
        {
            string         text           = ImageHelper.GenerateImageStreamName();
            ReportSnapshot reportSnapshot = odpMetadata.ReportSnapshot;

            using (Stream stream = chunkFactory.CreateChunk(text, chunkType, mimeType))
            {
                stream.Write(imageData, 0, imageData.Length);
                return(text);
            }
        }
 public RenderingContext(string rendererID, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot, EventInformation eventInfo, OnDemandProcessingContext processingContext)
 {
     this.m_rendererID         = rendererID;
     this.m_isSubReportContext = false;
     this.m_reportSnapshot     = reportSnapshot;
     this.InitEventInfo(eventInfo);
     this.m_odpContext = processingContext;
     if (processingContext.ChunkFactory != null)
     {
         this.m_chunkManager = new RenderingChunkManager(rendererID, processingContext.ChunkFactory);
     }
 }
 public RenderingContext(RenderingContext parentContext, OnDemandProcessingContext onDemandProcessingContext)
 {
     this.m_rendererID         = parentContext.m_rendererID;
     this.m_isSubReportContext = true;
     this.m_pageEvaluation     = null;
     this.m_dynamicInstances   = null;
     this.m_oldReportSnapshot  = parentContext.m_oldReportSnapshot;
     this.m_eventInfo          = parentContext.EventInfo;
     this.m_reportSnapshot     = parentContext.m_reportSnapshot;
     this.m_chunkManager       = parentContext.m_chunkManager;
     this.m_odpContext         = onDemandProcessingContext;
 }
        public bool CanUseExistingDocumentMapChunk(ICatalogItemContext reportContext)
        {
            if (!this.HasDocumentMap)
            {
                return(false);
            }
            if (!this.DocumentMapHasRenderFormatDependency)
            {
                return(true);
            }
            string format = ReportSnapshot.NormalizeRenderFormatForDocumentMap(reportContext);

            return(RenderFormatImpl.IsRenderFormat(format, this.m_documentMapRenderFormat));
        }
Exemple #7
0
        private bool LoadGeneratedReportItemDefinition()
        {
            AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot = base.RenderingContext.OdpContext.OdpMetadata.ReportSnapshot;
            string chunkName = default(string);

            if (!reportSnapshot.TryGetGeneratedReportItemChunkName(this.GetGeneratedDefinitionChunkKey(), out chunkName))
            {
                return(false);
            }
            IChunkFactory chunkFactory = base.RenderingContext.OdpContext.ChunkFactory;
            string        text         = default(string);
            Stream        chunk        = chunkFactory.GetChunk(chunkName, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.GeneratedReportItems, ChunkMode.Open, out text);

            if (chunk == null)
            {
                return(false);
            }
            using (chunk)
            {
                IntermediateFormatReader intermediateFormatReader = new IntermediateFormatReader(chunk, new ProcessingRIFObjectCreator((AspNetCore.ReportingServices.ReportIntermediateFormat.IDOwner)base.m_reportItemDef.ParentInstancePath, base.m_reportItemDef.Parent));
                AspNetCore.ReportingServices.ReportIntermediateFormat.ReportItem reportItem = (AspNetCore.ReportingServices.ReportIntermediateFormat.ReportItem)intermediateFormatReader.ReadRIFObject();
                Global.Tracer.Assert(!intermediateFormatReader.HasReferences, "!reader.HasReferences");
                reportItem.GlobalID = -this.CriDef.GlobalID;
                if (reportItem.StyleClass != null)
                {
                    reportItem.StyleClass.InitializeForCRIGeneratedReportItem();
                }
                reportItem.Visibility = base.m_reportItemDef.Visibility;
                AspNetCore.ReportingServices.ReportProcessing.ObjectType objectType = reportItem.ObjectType;
                if (objectType == AspNetCore.ReportingServices.ReportProcessing.ObjectType.Image)
                {
                    Image image = new Image(this.ParentScope, base.ParentDefinitionPath, this.m_indexIntoParentCollectionDef, (AspNetCore.ReportingServices.ReportIntermediateFormat.Image)reportItem, base.RenderingContext);
                    image.CriOwner             = this;
                    image.CriGenerationPhase   = CriGenerationPhases.None;
                    this.m_generatedReportItem = image;
                }
                else
                {
                    Global.Tracer.Assert(false, "Unexpected CRI generated report item type: " + reportItem.ObjectType);
                }
            }
            return(true);
        }
 public RenderingContext(RenderingContext parentContext, bool hasReportItemReferences)
 {
     this.m_rendererID         = parentContext.m_rendererID;
     this.m_isSubReportContext = true;
     this.m_pageEvaluation     = null;
     this.m_dynamicInstances   = null;
     this.m_eventInfo          = parentContext.EventInfo;
     this.m_reportSnapshot     = parentContext.m_reportSnapshot;
     this.m_oldReportSnapshot  = parentContext.m_oldReportSnapshot;
     this.m_chunkManager       = parentContext.m_chunkManager;
     if (this.m_oldReportSnapshot != null)
     {
         this.m_odpContext = parentContext.OdpContext;
     }
     else
     {
         this.m_odpContext = new OnDemandProcessingContext(parentContext.m_odpContext, hasReportItemReferences, this.m_reportSnapshot.Report);
     }
 }
Exemple #9
0
 private bool LoadGeneratedReportItemInstance()
 {
     Global.Tracer.Assert(this.m_generatedReportItem != null && this.m_generatedReportItem.Instance != null, "m_generatedReportItem != null && m_generatedReportItem.Instance != null");
     if (this.m_dynamicWidth == null && this.m_dynamicHeight == null)
     {
         AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot = base.RenderingContext.OdpContext.OdpMetadata.ReportSnapshot;
         string text = default(string);
         if (this.CriDef.RepeatWith != null)
         {
             if (!reportSnapshot.TryGetImageChunkName(this.GetGeneratedInstanceChunkKey(), out text))
             {
                 return(false);
             }
             ((ImageInstance)this.m_generatedReportItem.Instance).StreamName = text;
             return(true);
         }
         if (!reportSnapshot.TryGetGeneratedReportItemChunkName(this.GetGeneratedInstanceChunkKey(), out text))
         {
             return(false);
         }
         IChunkFactory chunkFactory = base.RenderingContext.OdpContext.ChunkFactory;
         string        text2        = default(string);
         Stream        chunk        = chunkFactory.GetChunk(text, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.GeneratedReportItems, ChunkMode.Open, out text2);
         if (chunk == null)
         {
             return(false);
         }
         using (chunk)
         {
             ROMInstanceObjectCreator rOMInstanceObjectCreator = new ROMInstanceObjectCreator(this.m_generatedReportItem.Instance);
             IntermediateFormatReader intermediateFormatReader = new IntermediateFormatReader(chunk, rOMInstanceObjectCreator, rOMInstanceObjectCreator);
             IPersistable             persistable = intermediateFormatReader.ReadRIFObject();
             Global.Tracer.Assert(persistable is ReportItemInstance, "reportItemInstance is ReportItemInstance");
             Global.Tracer.Assert(!intermediateFormatReader.HasReferences, "!reader.HasReferences");
         }
         return(true);
     }
     return(false);
 }
Exemple #10
0
 protected virtual OnDemandProcessingContext CreateOnDemandContext(OnDemandMetadata odpMetadata, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot, UserProfileState initialUserDependency)
 {
     return(new OnDemandProcessingContext(this.PublicProcessingContext, this.ReportDefinition, odpMetadata, this.m_errorContext, reportSnapshot.ExecutionTime, this.SnapshotProcessing, this.ReprocessSnapshot, this.ProcessWithCachedData, this.m_storeServerParameters, initialUserDependency, this.m_executionLogContext, this.Configuration, this.OnDemandProcessingMode, this.GetAbortHelper()));
 }
Exemple #11
0
 protected override void PreProcessSnapshot(OnDemandProcessingContext odpContext, Merge odpMerge, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot)
 {
     base.SetupInitialOdpState(odpContext, reportInstance, reportSnapshot);
     if (base.ReportDefinition.HasSubReports)
     {
         SubReportInitializer.InitializeSubReportOdpContext(base.ReportDefinition, odpContext);
         SubReportInitializer.InitializeSubReports(base.ReportDefinition, reportInstance, odpContext, false, false);
     }
     this.PreProcessTablices(odpContext, reportSnapshot);
     reportInstance.CalculateAndStoreReportVariables(odpContext);
     odpContext.OdpMetadata.SetUpdatedVariableValues(odpContext, reportInstance);
 }
Exemple #12
0
        private void GenerateReportItemDefinition()
        {
            this.m_generatedReportItem = null;
            ICustomReportItem controlInstance = base.RenderingContext.OdpContext.CriProcessingControls.GetControlInstance(this.CriDef.Type, base.RenderingContext.OdpContext.ExtFactory);

            if (controlInstance != null)
            {
                try
                {
                    controlInstance.GenerateReportItemDefinition(this);
                }
                catch (Exception ex)
                {
                    base.RenderingContext.ErrorContext.Register(ProcessingErrorCode.rsCRIProcessingError, Severity.Warning, this.Name, this.Type);
                    Global.Tracer.TraceException(TraceLevel.Error, RPRes.rsCRIProcessingError(this.Name, this.Type) + " " + ex.ToString());
                    return;
                }
                if (this.m_generatedReportItem == null)
                {
                    base.RenderingContext.ErrorContext.Register(ProcessingErrorCode.rsCRIRenderItemNull, Severity.Warning, this.CriDef.ObjectType, this.Name, this.Type);
                }
                else
                {
                    this.m_generatedReportItem.ConstructReportItemDefinition();
                    this.m_generatedReportItem.CriGenerationPhase = CriGenerationPhases.None;
                    string text = CustomReportItem.CreateChunkName();
                    OnDemandProcessingContext odpContext = base.RenderingContext.OdpContext;
                    AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot = odpContext.OdpMetadata.ReportSnapshot;
                    IChunkFactory chunkFactory = odpContext.ChunkFactory;
                    using (Stream stream = chunkFactory.CreateChunk(text, AspNetCore.ReportingServices.ReportProcessing.ReportProcessing.ReportChunkTypes.GeneratedReportItems, null))
                    {
                        IntermediateFormatWriter intermediateFormatWriter = new IntermediateFormatWriter(stream, odpContext.GetActiveCompatibilityVersion());
                        AspNetCore.ReportingServices.ReportIntermediateFormat.Visibility visibility = this.m_generatedReportItem.ReportItemDef.Visibility;
                        this.m_generatedReportItem.ReportItemDef.Visibility = null;
                        intermediateFormatWriter.Write(this.m_generatedReportItem.ReportItemDef);
                        this.m_generatedReportItem.ReportItemDef.Visibility = visibility;
                        stream.Flush();
                    }
                    reportSnapshot.AddGeneratedReportItemChunkName(this.GetGeneratedDefinitionChunkKey(), text);
                }
            }
        }
Exemple #13
0
 protected virtual void PreProcessTablices(OnDemandProcessingContext odpContext, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot)
 {
 }
 public override bool TryGetDatabaseImage(string uniqueName, out string streamName)
 {
     AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot = base.m_odpMetadata.ReportSnapshot;
     return(reportSnapshot.TryGetImageChunkName(uniqueName, out streamName));
 }
 protected override void PreProcessTablices(OnDemandProcessingContext odpContext, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot)
 {
     Merge.PreProcessTablixes(base.ReportDefinition, odpContext, false);
     reportSnapshot.SortFilterEventInfo = odpContext.NewSortFilterEventInfo;
 }
 protected override void PreProcessSnapshot(OnDemandProcessingContext odpContext, Merge odpMerge, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot)
 {
     base.SetupInitialOdpState(odpContext, reportInstance, reportSnapshot);
 }
Exemple #17
0
        public AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot Execute(out OnDemandProcessingContext odpContext)
        {
            ReportProcessingCompatibilityVersion.TraceCompatibilityVersion(this.m_configuration);
            odpContext = null;
            OnDemandMetadata onDemandMetadata = this.PrepareMetadata();

            onDemandMetadata.GlobalIDOwnerCollection = this.m_globalIDOwnerCollection;
            AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot = onDemandMetadata.ReportSnapshot;
            Global.Tracer.Assert(reportSnapshot != null, "ReportSnapshot object must exist");
            try
            {
                UserProfileState userProfileState = UserProfileState.None;
                if (this.PublicProcessingContext.Parameters != null)
                {
                    userProfileState |= this.PublicProcessingContext.Parameters.UserProfileState;
                }
                odpContext = this.CreateOnDemandContext(onDemandMetadata, reportSnapshot, userProfileState);
                this.CompleteOdpContext(odpContext);
                Merge odpMerge = default(Merge);
                AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance = this.CreateReportInstance(odpContext, onDemandMetadata, reportSnapshot, out odpMerge);
                this.PreProcessSnapshot(odpContext, odpMerge, reportInstance, reportSnapshot);
                odpContext.SnapshotProcessing = true;
                odpContext.IsUnrestrictedRenderFormatReferenceMode = true;
                this.ResetEnvironment(odpContext, reportInstance);
                if (odpContext.ThreadCulture != null)
                {
                    Thread.CurrentThread.CurrentCulture = odpContext.ThreadCulture;
                }
                this.UpdateUserProfileLocation(odpContext);
                return(reportSnapshot);
            }
            finally
            {
                this.CleanupAbortHandler(odpContext);
                if (odpContext != null && odpContext.GlobalDataSourceInfo != null && odpContext.GlobalDataSourceInfo.Values != null)
                {
                    foreach (ReportProcessing.DataSourceInfo value in odpContext.GlobalDataSourceInfo.Values)
                    {
                        if (value.TransactionInfo != null)
                        {
                            if (value.TransactionInfo.RollbackRequired)
                            {
                                if (Global.Tracer.TraceInfo)
                                {
                                    Global.Tracer.Trace(TraceLevel.Info, "Data source '{0}': Rolling back transaction.", value.DataSourceName.MarkAsModelInfo());
                                }
                                try
                                {
                                    value.TransactionInfo.Transaction.Rollback();
                                }
                                catch (Exception innerException)
                                {
                                    throw new ReportProcessingException(ErrorCode.rsErrorRollbackTransaction, innerException, value.DataSourceName.MarkAsModelInfo());
                                }
                            }
                            else
                            {
                                if (Global.Tracer.TraceVerbose)
                                {
                                    Global.Tracer.Trace(TraceLevel.Verbose, "Data source '{0}': Committing transaction.", value.DataSourceName.MarkAsModelInfo());
                                }
                                try
                                {
                                    value.TransactionInfo.Transaction.Commit();
                                }
                                catch (Exception innerException2)
                                {
                                    throw new ReportProcessingException(ErrorCode.rsErrorCommitTransaction, innerException2, value.DataSourceName.MarkAsModelInfo());
                                }
                            }
                        }
                        if (value.Connection != null)
                        {
                            try
                            {
                                odpContext.CreateAndSetupDataExtensionFunction.CloseConnection(value.Connection, value.ProcDataSourceInfo, value.DataExtDataSourceInfo);
                            }
                            catch (Exception innerException3)
                            {
                                throw new ReportProcessingException(ErrorCode.rsErrorClosingConnection, innerException3, value.DataSourceName.MarkAsModelInfo());
                            }
                        }
                    }
                }
            }
        }
 protected override void PreProcessSnapshot(OnDemandProcessingContext odpContext, Merge odpMerge, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot)
 {
     if (base.ReportDefinition.HasSubReports)
     {
         ReportProcessing.FetchSubReports(base.ReportDefinition, odpContext.ChunkFactory, odpContext.ErrorContext, odpContext.OdpMetadata, odpContext.ReportContext, odpContext.SubReportCallback, 0, odpContext.SnapshotProcessing, odpContext.ProcessWithCachedData, base.GlobalIDOwnerCollection, base.PublicProcessingContext.QueryParameters);
         SubReportInitializer.InitializeSubReportOdpContext(base.ReportDefinition, odpContext);
     }
 }
 protected override AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance CreateReportInstance(OnDemandProcessingContext odpContext, OnDemandMetadata odpMetadata, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot, out Merge odpMerge)
 {
     odpMerge = null;
     return(null);
 }
        protected override OnDemandProcessingContext CreateOnDemandContext(OnDemandMetadata odpMetadata, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot, UserProfileState initialUserDependency)
        {
            OnDemandProcessingContext onDemandProcessingContext = new OnDemandProcessingContext(base.PublicProcessingContext, base.ReportDefinition, odpMetadata, base.ErrorContext, reportSnapshot.ExecutionTime, base.StoreServerParameters, initialUserDependency, base.ExecutionLogContext, base.Configuration, this.GetAbortHelper());

            onDemandProcessingContext.ReportObjectModel.Initialize(base.PublicProcessingContext.Parameters);
            return(onDemandProcessingContext);
        }
 protected override void PreProcessSnapshot(OnDemandProcessingContext odpContext, Merge odpMerge, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot)
 {
     if (base.ReportDefinition.HasSubReports)
     {
         ReportProcessing.FetchSubReports(base.ReportDefinition, odpContext.ChunkFactory, odpContext.ErrorContext, odpContext.OdpMetadata, odpContext.ReportContext, odpContext.SubReportCallback, 0, odpContext.SnapshotProcessing, odpContext.ProcessWithCachedData, base.GlobalIDOwnerCollection, base.PublicProcessingContext.QueryParameters);
         SubReportInitializer.InitializeSubReportOdpContext(base.ReportDefinition, odpContext);
     }
     odpMerge.FetchData(reportInstance, false);
     reportInstance.CalculateAndStoreReportVariables(odpContext);
     if (base.ReportDefinition.HasSubReports)
     {
         SubReportInitializer.InitializeSubReports(base.ReportDefinition, reportInstance, odpContext, false, false);
     }
     base.SetupInitialOdpState(odpContext, reportInstance, reportSnapshot);
     if (!base.ReportDefinition.HasSubReports)
     {
         if (base.ReportDefinition.DeferVariableEvaluation)
         {
             return;
         }
         if (!base.ReportDefinition.HasVariables)
         {
             return;
         }
     }
     Merge.PreProcessTablixes(base.ReportDefinition, odpContext, true);
 }
Exemple #22
0
 protected virtual AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance CreateReportInstance(OnDemandProcessingContext odpContext, OnDemandMetadata odpMetadata, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot, out Merge odpMerge)
 {
     odpMerge = new Merge(this.ReportDefinition, odpContext);
     AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager.EnsureGroupTreeStorageSetup(odpMetadata, odpContext.ChunkFactory, odpMetadata.GlobalIDOwnerCollection, false, odpContext.GetActiveCompatibilityVersion(), odpContext.ProhibitSerializableValues);
     AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance2 = odpContext.CurrentReportInstance = odpMerge.PrepareReportInstance(odpMetadata);
     AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance4 = reportSnapshot.ReportInstance = reportInstance2;
     AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance5 = reportInstance4;
     odpMerge.Init(this.PublicProcessingContext.Parameters);
     this.SetupReportLanguage(odpMerge, reportInstance5);
     odpMerge.SetupReport(reportInstance5);
     return(reportInstance5);
 }
Exemple #23
0
 protected abstract void PreProcessSnapshot(OnDemandProcessingContext odpContext, Merge odpMerge, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot);
 public void SetRenderFormatDependencyInDocumentMap(OnDemandProcessingContext odpContext)
 {
     this.m_cachedDataChanged       = true;
     this.m_documentMapRenderFormat = ReportSnapshot.NormalizeRenderFormatForDocumentMap(odpContext.TopLevelContext.ReportContext);
 }
Exemple #25
0
 protected void SetupInitialOdpState(OnDemandProcessingContext odpContext, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportInstance reportInstance, AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot reportSnapshot)
 {
     reportSnapshot.HasUserSortFilter = this.ReportDefinition.ReportOrDescendentHasUserSortFilter;
     odpContext.SetupEnvironment(reportInstance);
 }
Exemple #26
0
 public StreamingOnDemandProcessingResult(AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot newOdpSnapshot, AspNetCore.ReportingServices.ReportIntermediateFormat.Persistence.ChunkManager.OnDemandProcessingManager chunkManager, bool newOdpSnapshotChanged, IChunkFactory createChunkFactory, ParameterInfoCollection parameters, int autoRefresh, int numberOfPages, ProcessingMessageList warnings, bool eventInfoChanged, EventInformation newEventInfo, PaginationMode updatedPaginationMode, ReportProcessingFlags updatedProcessingFlags, UserProfileState usedUserProfileState, ExecutionLogContext executionLogContext)
     : base(createChunkFactory, newOdpSnapshot.DefinitionTreeHasDocumentMap, newOdpSnapshot.HasShowHide || newOdpSnapshot.HasUserSortFilter, parameters, autoRefresh, numberOfPages, warnings, eventInfoChanged, newEventInfo, updatedPaginationMode, updatedProcessingFlags, usedUserProfileState, executionLogContext)
 {
 }
        public virtual void Deserialize(IntermediateFormatReader reader)
        {
            reader.RegisterDeclaration(OnDemandMetadata.m_Declaration);
            while (reader.NextMember())
            {
                switch (reader.CurrentMember.MemberName)
                {
                case MemberName.CommonSubReportInfos:
                    this.m_commonSubReportInfoMap = reader.ReadStringRIFObjectDictionary <CommonSubReportInfo>();
                    break;

                case MemberName.SubReportInfos:
                    this.m_subReportInfoMap = reader.ReadStringRIFObjectDictionary <SubReportInfo>();
                    break;

                case MemberName.ReportSnapshot:
                    this.m_reportSnapshot = (AspNetCore.ReportingServices.ReportIntermediateFormat.ReportSnapshot)reader.ReadRIFObject();
                    break;

                case MemberName.GroupTreePartitionOffsets:
                {
                    List <long> list = reader.ReadListOfPrimitives <long>();
                    if (list != null)
                    {
                        this.m_groupTreePartitions = new TreePartitionManager(list);
                    }
                    break;
                }

                case MemberName.DataChunkMap:
                    this.m_dataChunkMap = reader.ReadStringRIFObjectDictionary <DataSetInstance>();
                    break;

                case MemberName.CachedExternalImages:
                    this.m_cachedExternalImages = reader.ReadStringRIFObjectDictionary <AspNetCore.ReportingServices.ReportIntermediateFormat.ImageInfo>();
                    break;

                case MemberName.CachedShapefiles:
                    this.m_cachedShapefiles = reader.ReadStringRIFObjectDictionary <ShapefileInfo>();
                    break;

                case MemberName.TransparentImageChunkName:
                    this.m_transparentImageChunkName = reader.ReadString();
                    break;

                case MemberName.GroupTreeRootOffset:
                    this.m_groupTreeRootOffset = reader.ReadInt64();
                    break;

                case MemberName.TablixProcessingComplete:
                    this.m_tablixProcessingComplete = reader.ReadStringBoolArrayDictionary();
                    break;

                case MemberName.GroupTreePartitions:
                    this.m_groupTreePartitions = (TreePartitionManager)reader.ReadRIFObject();
                    break;

                case MemberName.LookupPartitions:
                    this.m_lookupPartitions = (TreePartitionManager)reader.ReadRIFObject();
                    break;

                case MemberName.LastAssignedGlobalID:
                    this.m_lastAssignedGlobalID = reader.ReadInt32();
                    break;

                case MemberName.UpdatedVariableValues:
                    this.m_updatedVariableValues = reader.ReadStringRIFObjectDictionary <UpdatedVariableValues>();
                    break;

                default:
                    Global.Tracer.Assert(false);
                    break;
                }
            }
        }