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