private static void addUniqueItemToDependencyList(NCatalogItemCollection dependencyList, NCatalogItem catalogItem) { bool isUnique = true; foreach (NCatalogItem ci in dependencyList) { if (ci.Path == catalogItem.Path) { isUnique = false; break; } } if (isUnique) { dependencyList.Add(catalogItem); } }
public NCatalogItemCollection GetCatalogItems(bool recursive, bool useHttpClient, bool target) { NCatalogItemCollection catalog = new NCatalogItemCollection(); // Retrieve the full list of catalog items from SRS CatalogItem[] catalogItems = null; if (target) { //Get Target SRS if (useHttpClient) { catalogItems = this.ReportingTargetServiceClient.ListChildren(@"/", recursive); } else { catalogItems = this.ReportingTargetServiceNonHttpClient.ListChildren(@"/", recursive); } } else { //Get Source SRS if (useHttpClient) { catalogItems = this.ReportingSourceServiceClient.ListChildren(@"/", recursive); } else { catalogItems = this.ReportingSourceServiceNonHttpClient.ListChildren(@"/", recursive); } } foreach (CatalogItem item in catalogItems) { NCatalogItem nItem = NCatalogItem.CreateNRCatalogItem(item); catalog.Add(nItem); } return catalog; }
/// <summary> /// Build the CatalogItemCollection structure from SRS /// </summary> public NCatalogItemCollection LookupCatalogItems(string itemPath, bool recursive, bool useHttpClient, ReportingServiceClient srsClient) { NCatalogItemCollection catalogItemCollection = new NCatalogItemCollection(); // If no ItemPath is specified, use the Root if (itemPath == null) { itemPath = "/"; } // Retrieve the full list of catalog items from SRS CatalogItem[] unsecureCatalogItems = null; if (srsClient != null) { unsecureCatalogItems = srsClient.ListChildren(itemPath, recursive); } else { if (useHttpClient) { unsecureCatalogItems = this.ReportingServiceClient.ListChildren(itemPath, recursive); } else { unsecureCatalogItems = this.ReportingServiceNonHttpClient.ListChildren(itemPath, recursive); } } // Secure the list List<CatalogItem> secureCatalogList = buildSecureCatalogList(unsecureCatalogItems); foreach (CatalogItem item in secureCatalogList) { NCatalogItem nItem = NCatalogItem.CreateNRCatalogItem(item); // TODO: Still not decided if it's wise to get all the parameters upon login // Supply the parameters /* if (nItem.ItemType.Equals(Constants.CatalogItemTypes.Report)) { try { nItem.ReportParameters = GetReportParameters(nItem.Path, null); } catch { //TODO: Prepare an error display for this //Error retrieving the parameters. nItem.ReportParameters = null; } } */ catalogItemCollection.Add(nItem); } /* // Create a map between SRS folders and Nodes collections in the tree Hashtable folderMapTable = new Hashtable(); if (itemPath == "/") { folderMapTable.Add("", catalogItemCollection); } else { folderMapTable.Add(itemPath, catalogItemCollection); } foreach (CatalogItem item in secureCatalogList) { // Get the path to the current item's folder string folderPath = item.Path.Substring(0, item.Path.LastIndexOf("/", StringComparison.OrdinalIgnoreCase)); // Get the node collection associated with that folder path NCatalogItemCollection nodes = folderMapTable[folderPath] as NCatalogItemCollection; if (nodes != null) { NCatalogItem nci = NCatalogItem.CreateNRCatalogItem(item); nodes.Add(nci); if (nci.ItemType == Constants.CatalogItemTypes.Folder) { if (folderMapTable.ContainsKey(nci.Path)) { throw new InvalidCatalogStructureException("Folder already exists"); } NFolder nf = nci as NFolder; folderMapTable.Add(nf.Path, nf.ChildCatalogItems); } } } */ return catalogItemCollection; }
public NCatalogItemCollection BuildDependencyList(string catalogItemPath) { NCatalogItemCollection dependencyList = new NCatalogItemCollection(); // Get a list of any child dependentancy items NCatalogItemCollection childCatalogItemList = null; // Get the ItemType so we can behave appropriately string itemType = LookupItemType(catalogItemPath, true); if (itemType == Constants.CatalogItemTypes.Folder) { childCatalogItemList = LookupCatalogItems(catalogItemPath, true, true, null); } else { childCatalogItemList = LookupCatalogItems(null, true, true, null); } addDependencies(dependencyList, catalogItemPath, itemType, childCatalogItemList); return dependencyList; }
private void addDependenciesForReport(NCatalogItemCollection dependencyList, string path, NCatalogItemCollection childCatalogItemList) { // Walk through the catalog looking for linked reports foreach (NCatalogItem catalogItem in childCatalogItemList) { if (catalogItem.ItemType == Constants.CatalogItemTypes.LinkedReport) { string sourcePath = this.ReportingServiceClient.GetReportLink(catalogItem.Path); if (sourcePath == path) { addUniqueItemToDependencyList(dependencyList, catalogItem); } } else if (catalogItem.ItemType == Constants.CatalogItemTypes.Folder) { // Recurse through this item looking for any other dependencies NFolder nf = catalogItem as NFolder; if (nf != null) { addDependenciesForReport(dependencyList, path, nf.ChildCatalogItems); } } } }
private void addDependenciesForFolder(NCatalogItemCollection dependencyList, string path) { NCatalogItemCollection folderCatalogItems = LookupCatalogItems(path, true, true, null); foreach (NCatalogItem catalogItem in folderCatalogItems) { bool interestingType = false; switch (catalogItem.ItemType) { case Constants.CatalogItemTypes.MSAccess: case Constants.CatalogItemTypes.MSExcel: case Constants.CatalogItemTypes.LinkedReport: case Constants.CatalogItemTypes.Report: case Constants.CatalogItemTypes.DataSource: interestingType = true; break; } if (interestingType) { // This item is referenced addUniqueItemToDependencyList(dependencyList, catalogItem); // Recurse through this item looking for any other dependencies NFolder nf = catalogItem as NFolder; if (nf != null) { addDependencies(dependencyList, nf.Path, nf.ItemType, nf.ChildCatalogItems); } } } }
private void addDependenciesForDataSource(NCatalogItemCollection dependencyList, string path, NCatalogItemCollection childCatalogItemList) { if (!string.IsNullOrEmpty(path)) { // Step through the catalog to see if the datasource it uses matches the path foreach (NCatalogItem catalogItem in childCatalogItemList) { string dataSourcePath = string.Empty; try { if (catalogItem.ItemType == Constants.CatalogItemTypes.Report) { // Get all DataSources referenced by this Report DataSource[] referencedDataSourceList = this.ReportingServiceClient.GetItemDataSources(catalogItem.Path); foreach (DataSource dataSource in referencedDataSourceList) { // We only care about DataSourceReference types, otherwise the // DataSource isn't defined as an object in the catalog, it is // defined inside the Report itself. DataSourceReference dataSourceReference = dataSource.Item as DataSourceReference; if (dataSourceReference != null) { dataSourcePath = dataSourceReference.Reference; } } } else if (catalogItem.ItemType == Constants.CatalogItemTypes.Folder) { // Recurse through this item looking for any other dependencies NFolder nf = catalogItem as NFolder; if (nf != null) { addDependenciesForDataSource(dependencyList, path, nf.ChildCatalogItems); } } } catch //( Exception ex ) { // Something failed when trying to retrieve the DataSource path for this // catalog item don't stop looking, but this item will not be included in // the link list //Debug.WriteLine( ex.Message ); } if (dataSourcePath == path) { // This item is referenced addUniqueItemToDependencyList(dependencyList, catalogItem); // Recurse through this item looking for any other dependencies addDependencies(dependencyList, catalogItem.Path, catalogItem.ItemType, childCatalogItemList); } } } }
private void addDependencies(NCatalogItemCollection dependencyList, string catalogItemPath, string itemType, NCatalogItemCollection childCatalogItemList) { switch (itemType) { case Constants.CatalogItemTypes.DataSource: addDependenciesForDataSource(dependencyList, catalogItemPath, childCatalogItemList); break; case Constants.CatalogItemTypes.Report: addDependenciesForReport(dependencyList, catalogItemPath, childCatalogItemList); break; case Constants.CatalogItemTypes.Folder: addDependenciesForFolder(dependencyList, catalogItemPath); break; } }