示例#1
0
        public void CreateReport(string reportName, string parentPath, byte[] definition, IEnumerable <string> dataSourcePaths)
        {
            Property[] reportProperties = new Property[1];
            Property   hidden           = new Property();

            hidden.Name         = "Hidden";
            hidden.Value        = reportName.StartsWith("_") ? "true" : "false";
            reportProperties[0] = hidden;
            _reportService.CreateReport(reportName, parentPath, true, definition, reportProperties);

            var sources = new List <DataSource>();

            foreach (var dataSourcePath in dataSourcePaths)
            {
                DataSourceReference dsRef = new DataSourceReference();
                dsRef.Reference = dataSourcePath;
                var ds = new DataSource();
                ds.Item = dsRef;
                sources.Add(ds);
            }
            //DataSourceReference dsRef = new DataSourceReference();
            //	dsRef.Reference = dataSourcePaths;
            //	DataSource[] Sources = _reportService.GetItemDataSources(parentPath + "/" + reportName);
            if (sources != null && sources.Count > 0)
            {
                try
                {
                    _reportService.SetItemDataSources(parentPath + "/" + reportName, sources.ToArray());
                }
                catch (Exception)
                {
                }
            }
        }
示例#2
0
        private void DeployReport(string targetLocation, ReportInfo report, int progress)
        {
            byte[]   reportDef;
            Property propDescr = new Property();

            propDescr.Name  = "Description";
            propDescr.Value = report.Description;
            Property propHidden = new Property();

            propHidden.Name  = "Hidden";
            propHidden.Value = report.Hidden.ToString().ToLower();

            // Don't overwrite if exists
            if (ItemExists(targetLocation + "/" + report.Name, ItemTypeEnum.Report) && !_drd.OverwriteExisting)
            {
                _bgWorker.ReportProgress(progress, String.Format("Skipping report: {0} - Report already exists.", report.Name));
            }
            else
            {
                _bgWorker.ReportProgress(progress, String.Format("Deploying report: {0}...", report.Name));

                using (FileStream stream = File.OpenRead(report.FileName))
                {
                    reportDef = new Byte[stream.Length];
                    stream.Read(reportDef, 0, (int)stream.Length);
                }

                _rs.CreateReport(report.Name, targetLocation, _drd.OverwriteExisting,
                                 reportDef, new Property[] { propDescr, propHidden });
            }
        }
示例#3
0
        private void CreateReport(string folder, string rdlFile, Dictionary <string, DataSourceDefinitionOrReference> dataSources)
        {
            var name           = Path.GetFileNameWithoutExtension(rdlFile);
            var reportContents = File.ReadAllBytes(rdlFile);

            if (!targetFolder.StartsWith("/"))
            {
                folder = "/" + folder;
            }

            var warnings = rs.CreateReport(name, folder, true, reportContents, null);

            if (warnings != null)
            {
                Console.WriteLine("Report: '{0}':", name);
                foreach (var warning in warnings)
                {
                    Console.WriteLine(warning.Message);
                }
            }
            else
            {
                Console.WriteLine("Report: '{0}' created successfully with no warnings", name);
            }

            UpdateReportDataSources(folder, name, dataSources);
        }
        public void CreateReport(string reportName, string parentPath, byte[] definition, string dataSourcePath)
        {
            Property[] reportProperties = new Property[1];
            Property   hidden           = new Property();

            hidden.Name         = "Hidden";
            hidden.Value        = reportName.StartsWith("_") ? "true" : "false";
            reportProperties[0] = hidden;
            _reportService.CreateReport(reportName, parentPath, true, definition, reportProperties);

            DataSourceReference dsRef = new DataSourceReference();

            dsRef.Reference = dataSourcePath;
            DataSource[] Sources = _reportService.GetItemDataSources(parentPath + "/" + reportName);
            if (Sources != null && Sources.Length > 0)
            {
                Sources[0].Item = dsRef;
                try
                {
                    _reportService.SetItemDataSources(parentPath + "/" + reportName, Sources);
                }
                catch (Exception)
                {
                }
            }
        }
示例#5
0
        public static void CreateReport(string reportingServiceUrl, string name, string parent, string[] dataSourcePaths, string definitionFile)
        {
            // Open the definition.

            byte[] definition;
            using (var stream = File.OpenRead(definitionFile))
            {
                definition = new byte[stream.Length];
                stream.Read(definition, 0, (int)stream.Length);
                stream.Close();
            }

            var service = new ReportingService2005
            {
                Url         = reportingServiceUrl,
                Credentials = System.Net.CredentialCache.DefaultCredentials
            };

            var warnings = service.CreateReport(name, parent, true, definition, null);

            // If there are data sources then associate them with the report.

            if (dataSourcePaths != null && dataSourcePaths.Length > 0)
            {
                var dataSources = (from dsp in dataSourcePaths
                                   select new DataSource
                {
                    Item = new DataSourceReference {
                        Reference = dsp
                    },
                    Name = GetName(dsp),
                }).ToArray();
                service.SetItemDataSources(GetPath(name, parent), dataSources);
            }
        }
示例#6
0
        private void UploadReport(ReportItem item)
        {
            _Service.CreateReport(item.Name, item.ParentPath, true, item.ReportDefinition, null);

            var dataSources = GetDataSources(item.DataSources);

            if (dataSources.Length > 0)
            {
                _Service.SetItemDataSources(item.Path, dataSources);
            }
        }
示例#7
0
        private static void CreateReport(ReportingService2005 reportingService, ReportItem report)
        {
            if (reportingService == null)
            {
                throw new ArgumentNullException("reportingService");
            }

            if (report == null)
            {
                throw new ArgumentNullException("report");
            }

            string parent = TesterUtility.GetParentPath(report.Path);

            ReportingService2005TestEnvironment.CreateFolderFromPath(reportingService, parent);

            reportingService.CreateReport(report.Name, parent, true, report.Definition, null);
        }
示例#8
0
        private static void CreateReports(ReportingService2005 reportingService, string path)
        {
            if (reportingService == null)
            {
                throw new ArgumentNullException("reportingService");
            }

            if (string.IsNullOrEmpty(path))
            {
                throw new ArgumentException("path");
            }

            foreach (ReportItem report in SetupReportItems)
            {
                string fullPath = string.Format(report.Path, path);
                string parent   = TesterUtility.GetParentPath(fullPath);

                reportingService.CreateReport(report.Name, parent, true, report.Definition, null);
            }
        }
        public void CreateReport(ReportGroup reportGroup, Report report, int seq)
        {
            byte[] definition = report.Process(reportGroup.TargetFolder, reportGroup.DataSource);
            if (definition == null)
            {
                return;
            }

            Warning[] warnings = _proxy.CreateReport(
                report.Name,
                Util.FormatPath(reportGroup.TargetFolder),
                true,
                definition,
                null);

            if (warnings != null)
            {
                Logger.LogMessage(string.Format("{0} Report:{1} / [{2}] published successfully with some warnings", seq, reportGroup.Name, report.Name));
                //foreach(Warning warning in warnings)
                //{
                //	Logger.LogMessage(warning.Message);
                //}
            }
            else
            {
                Logger.LogMessage(string.Format("{0} Report:{1} / [{2}] published successfully with no warnings", seq, reportGroup.Name, report.Name));
            }

            if (report.CacheOption != null &&
                report.CacheOption.CacheReport &&
                report.CacheOption.ExpirationMinutes != null)
            {
                _proxy.SetCacheOptions(
                    string.Format("{0}/{1}", Util.FormatPath(reportGroup.TargetFolder), report.Name),
                    true,
                    new TimeExpiration()
                {
                    Minutes = report.CacheOption.ExpirationMinutes.Value
                });
            }
        }
示例#10
0
        public string SaveReport(string report, Stream file, string name, bool overwrite, ref Guid id)
        {
            id = Guid.Empty;
            string _report = report.ToLower().Replace(".rdl", "");

            if (this.CheckExist(ItemTypeEnum.Report, WebConfigurationManager.AppSettings["ReportsRootPath"].ToString(), (name == "" ? _report : name)) == true && overwrite == false)
            {
                return("The Report '" + (name == "" ? _report : name) + "' already exists");
            }
            Byte[] definition = null;
            try
            {
                System.IO.BinaryReader br = new System.IO.BinaryReader(file);
                definition = br.ReadBytes((Int32)file.Length);
                //Create Report
                rs.CreateReport((name == string.Empty ? _report : name), WebConfigurationManager.AppSettings["ReportsRootPath"].ToString(), overwrite, definition, null);
                //Set DataSource
                DataSourceReference Item1 = new DataSourceReference();

                DataSource[] datasources = rs.GetItemDataSources(WebConfigurationManager.AppSettings["ReportsRootPath"].ToString() + "/" + (name == "" ? _report : name));



                Item1.Reference = WebConfigurationManager.AppSettings["ReportsRootPath"].ToString() + WebConfigurationManager.AppSettings["MyDataSource"].ToString();

                datasources[0].Item = Item1;

                rs.SetItemDataSources(WebConfigurationManager.AppSettings["ReportsRootPath"].ToString() + "/" + (name == "" ? _report : name), datasources);

                string _id = GetReportID(WebConfigurationManager.AppSettings["ReportsRootPath"].ToString() + "/" + (name == "" ? _report : name));
                id = _id != string.Empty ? new Guid(_id) : Guid.Empty;

                return(string.Format("Report: {0} created successfully", name == "" ? _report : name));
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return(ex.Message);
            }
        }
示例#11
0
        private void uploadReport(string destinationPath, string reportName, byte[] reportDef)
        {
            try
            {
                //Create report
                destRS.CreateReport(reportName, destinationPath, true, reportDef, null);

                //Link datasources
                var reportPath = destinationPath;
                if (reportPath.EndsWith("/"))
                {
                    reportPath += reportName;
                }
                else
                {
                    reportPath += "/" + reportName;
                }
                var reportDss = destRS.GetItemDataSources(reportPath);
                List <DataSource> dataSources = new List <DataSource>();
                foreach (var reportDs in reportDss)
                {
                    if (destDS.ContainsKey(reportDs.Name))
                    {
                        DataSourceReference reference = new DataSourceReference();
                        reference.Reference = destDS[reportDs.Name];
                        var ds = new DataSource();
                        ds.Item = (DataSourceDefinitionOrReference)reference;
                        ds.Name = reportDs.Name;
                        dataSources.Add(ds);
                    }
                }
                destRS.SetItemDataSources(reportPath, dataSources.ToArray());
            }
            catch (Exception e)
            {
                MessageBox.Show("Upload " + reportName + " failed." + e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
        private void browseFile_Click(object sender, EventArgs e)
        {
            // Get the full pathname from the treeview control
            string pathName = ssrsFolders.SelectedNode.FullPath;

            if (pathName == "Root")
            {
                pathName = "/";
            }
            else
            {
                // Strip off the Root name from the path and correct the path separators for use with SRS
                pathName = pathName.Substring(4, pathName.Length - 4);
                pathName = pathName.Replace(@"\", "/");
            }

            byte[]    definition = null;
            Warning[] warnings   = null;
            string    warningMsg = String.Empty;

            OpenFileDialog openFileDialog = new OpenFileDialog();

            openFileDialog.Filter      = "RDL files (*.rdl)|*.rdl|All files (*.*)|*.*";
            openFileDialog.FilterIndex = 1;
            if (openFileDialog.ShowDialog() == DialogResult.OK)
            {
                try
                {
                    // Read the file and put it into a byte array to pass to SRS
                    FileStream stream = File.OpenRead(openFileDialog.FileName);
                    definition = new byte[stream.Length];
                    stream.Read(definition, 0, (int)(stream.Length));
                    stream.Close();
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message);
                }

                // We are going to use the name of the rdl file as the name of our report
                string reportName = Path.GetFileNameWithoutExtension(openFileDialog.FileName);
                reportFile.Text = reportName;

                // Now lets use this information to publish the report
                try
                {
                    warnings = rs.CreateReport(reportName, pathName, true, definition, null);
                    if (warnings != null)
                    {
                        foreach (Warning warning in warnings)
                        {
                            warningMsg += warning.Message + "\n";
                        }
                        MessageBox.Show("Report creation failed with the following warnings:\n" + warningMsg);
                    }
                    else
                    {
                        MessageBox.Show(String.Format("Report: {0} created successfully with no warnings", reportName));
                    }
                }
                catch (SoapException ex)
                {
                    MessageBox.Show(ex.Detail.InnerXml.ToString());
                }
            }
        }
示例#13
0
        private string DeployReport(string localPath, string serverPath, string dataSourcePath, string dataSourceName)
        {
            byte[]    definition = null;
            Warning[] warnings   = null;
            string    retRes     = String.Empty;

            try
            {
                // Read the file and put it into a byte array to pass to SRS
                FileStream stream = File.OpenRead(localPath);
                definition = new byte[stream.Length];
                stream.Read(definition, 0, (int)(stream.Length));
                stream.Close();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }

            // We are going to use the name of the rdl file as the name of our report
            string reportName = Path.GetFileNameWithoutExtension(localPath);


            // Now lets use this information to publish the report
            try
            {
                warnings = rs.CreateReport(reportName, serverPath, true, definition, null);

                if (warnings != null)
                {
                    retRes = String.Format("Report {0} created with warnings :\n", reportName);
                    foreach (Warning warning in warnings)
                    {
                        retRes += warning.Message + "\n";
                    }
                }
                else
                {
                    retRes = String.Format("Report {0} created successfully with no warnings\n", reportName);
                }

                // check xml datasource
                var isXmlProvider = IsXmlDataProvider(localPath);
                if (isXmlProvider)
                {
                    return(retRes);
                }

                //set the datasource
                DataSourceReference dsr = new DataSourceReference();
                dsr.Reference = dataSourcePath + "/" + dataSourceName;


                DataSource[] dsarray = rs.GetItemDataSources(serverPath + "/" + reportName);
                DataSource   ds      = new DataSource();
                if (dsarray.Length > 0)
                {
                    ds      = dsarray[0];
                    ds.Item = (DataSourceReference)dsr;
                    rs.SetItemDataSources(serverPath + "/" + reportName, dsarray);
                    retRes += String.Format("Data source succesfully set to {0}\n", dsr.Reference);
                }
            }
            catch (SoapException ex)
            {
                return(String.Format("Report {0} failed with exception {1}\n", reportName, ex.Detail.InnerXml.ToString()));
            }

            return(retRes);
        }
示例#14
0
        public ReportWarning[] CreateReport(string filename, string destination, bool overwrite, Byte[] definition, string properties)
        {
            var warnings = webserviceProxy.CreateReport(Path.GetFileNameWithoutExtension(filename), destination, overwrite, definition, null);

            return(warnings != null?Array.ConvertAll(warnings, ConvertSPWarningToReportWarning) : null);
        }