private static ParameterValueOrFieldReference[] setPassword(ParameterValueOrFieldReference[] parameterValueOrFieldReference)
{
ParameterValue[] paramVals = new ParameterValue[parameterValueOrFieldReference.Length + 1];
for (int i = 0; i < parameterValueOrFieldReference.Length; i++)
{
paramVals[i] = (ParameterValue)parameterValueOrFieldReference[i];
}
paramVals[parameterValueOrFieldReference.Length] = new ParameterValue();
paramVals[parameterValueOrFieldReference.Length].Name = "PASSWORD";
paramVals[parameterValueOrFieldReference.Length].Value = "pass";
return paramVals;
}
public static DeliverySettings CreateFromParameterValues(ParameterValueOrFieldReference[] objects)
{
if (objects == null) throw new ArgumentNullException();
if (objects.Length == 0) throw new ArgumentException();
if (!(objects[0] is ReportingService.ParameterValue)) throw new ArgumentException();
List<ReportingService.ParameterValue> values = objects.Cast<ReportingService.ParameterValue>().ToList();
// Logic to figure out file share or email
if (values.FirstOrDefault(x => x.Name == "TO") != null)
{
return
new EmailDeliverySettings(new ExtensionSettings
{
ParameterValues = objects,
Extension = EmailDeliverySettings.ExtensionString
});
}
return new FileShareDeliverySettings(new ExtensionSettings
{
ParameterValues = objects,
Extension = FileShareDeliverySettings.ExtensionString
});
}
/// <remarks/>
public void CreateDataDrivenSubscriptionAsync(string Report, ExtensionSettings ExtensionSettings, DataRetrievalPlan DataRetrievalPlan, string Description, string EventType, string MatchData, ParameterValueOrFieldReference[] Parameters) {
this.CreateDataDrivenSubscriptionAsync(Report, ExtensionSettings, DataRetrievalPlan, Description, EventType, MatchData, Parameters, null);
}
public void SetDataDrivenSubscriptionProperties(string DataDrivenSubscriptionID, ExtensionSettings ExtensionSettings, DataRetrievalPlan DataRetrievalPlan, string Description, string EventType, string MatchData, ParameterValueOrFieldReference[] Parameters) {
this.Invoke("SetDataDrivenSubscriptionProperties", new object[] {
DataDrivenSubscriptionID,
ExtensionSettings,
DataRetrievalPlan,
Description,
EventType,
MatchData,
Parameters});
}
/// <remarks/>
public System.IAsyncResult BeginValidateExtensionSettings(string Extension, ParameterValueOrFieldReference[] ParameterValues, string SiteUrl, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("ValidateExtensionSettings", new object[] {
Extension,
ParameterValues,
SiteUrl}, callback, asyncState);
}
public string CreateDataDrivenSubscription(string Report, ExtensionSettings ExtensionSettings, DataRetrievalPlan DataRetrievalPlan, string Description, string EventType, string MatchData, ParameterValueOrFieldReference[] Parameters) {
object[] results = this.Invoke("CreateDataDrivenSubscription", new object[] {
Report,
ExtensionSettings,
DataRetrievalPlan,
Description,
EventType,
MatchData,
Parameters});
return ((string)(results[0]));
}
/// <remarks/>
public void CreateDataDrivenSubscriptionAsync(string report, ExtensionSettings ExtensionSettings,
DataRetrievalPlan DataRetrievalPlan, string Description,
string EventType, string MatchData,
ParameterValueOrFieldReference[] Parameters, object userState)
{
if ((_createDataDrivenSubscriptionOperationCompleted == null))
{
_createDataDrivenSubscriptionOperationCompleted =
new SendOrPostCallback(OnCreateDataDrivenSubscriptionOperationCompleted);
}
InvokeAsync("CreateDataDrivenSubscription", new object[]
{
report,
ExtensionSettings,
DataRetrievalPlan,
Description,
EventType,
MatchData,
Parameters
}, _createDataDrivenSubscriptionOperationCompleted, userState);
}
/// <remarks/>
public System.IAsyncResult BeginSetDataDrivenSubscriptionProperties(string DataDrivenSubscriptionID, ExtensionSettings ExtensionSettings, DataRetrievalPlan DataRetrievalPlan, string Description, string EventType, string MatchData, ParameterValueOrFieldReference[] Parameters, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("SetDataDrivenSubscriptionProperties", new object[] {
DataDrivenSubscriptionID,
ExtensionSettings,
DataRetrievalPlan,
Description,
EventType,
MatchData,
Parameters}, callback, asyncState);
}
private static ParameterValueOrFieldReference[] GetSubscriptionTypeParameters(string[] subscriptionInfoText)
{
ParameterValueOrFieldReference[] extensionParams;
var subscriptionType = GetSubInfoValue(subscriptionInfoText, "subscriptionType", false, "EMAIL").ToUpper();
switch (subscriptionType)
{
case "FILESHARE":
case "CSV":
extensionParams = new ParameterValueOrFieldReference[7];
extensionParams[0] = new ParameterValue
{
Name = "PATH",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionToFile_FilePath", true)
};
//Set the filename to always have a timestamp
extensionParams[1] = new ParameterValue
{
Name = "FILENAME",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionToFile_FileName", true) + "_@timestamp"
};
// Add a file extension always
extensionParams[2] = new ParameterValue {
Name = "FILEEXTN", Value = "True"
};
extensionParams[3] = new ParameterValue
{
Name = "USERNAME",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionToFile_UserName", true)
};
extensionParams[4] = new ParameterValue
{
Name = "PASSWORD",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionToFile_Password", true)
};
extensionParams[5] = new ParameterValue
{
Name = "RENDER_FORMAT",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionRenderFormat", false, "CSV")
};
extensionParams[6] = new ParameterValue {
Name = "WRITEMODE", Value = "Overwrite"
};
break;
case "EMAIL":
extensionParams = new ParameterValueOrFieldReference[10];
extensionParams[0] = new ParameterValue
{
Name = "TO",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionSendTo", true)
};
extensionParams[1] = new ParameterValue
{
Name = "CC",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionCCto", false)
};
extensionParams[2] = new ParameterValue
{
Name = "BCC",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionBCCto", false)
};
extensionParams[3] = new ParameterValue {
Name = "ReplyTo", Value = "*****@*****.**"
};
extensionParams[4] = new ParameterValue {
Name = "IncludeReport", Value = "True"
};
extensionParams[5] = new ParameterValue
{
Name = "RenderFormat",
Value = GetSubInfoValue(subscriptionInfoText, "subscriptionRenderFormat", false, "EXCEL").ToUpper()
};
extensionParams[6] = new ParameterValue
{
Name = "Subject",
Value = GetSubInfoValue(subscriptionInfoText, "subjectPrefix", true) + " - @ReportName executed at @ExecutionTime"
};
extensionParams[7] = new ParameterValue
{
Name = "Comment",
Value = GetSubInfoValue(subscriptionInfoText, "emailBodyText", false)
};
extensionParams[8] = new ParameterValue {
Name = "IncludeLink", Value = "False"
};
extensionParams[9] = new ParameterValue {
Name = "Priority", Value = "NORMAL"
};
break;
default:
throw new Exception($"Unknown report type '{subscriptionType}', supported values: 'EMAIL','CSV','FILESHARE'");
}
return(extensionParams);
}
public string GetDataDrivenSubscriptionProperties(string DataDrivenSubscriptionID, out ExtensionSettings ExtensionSettings, out DataRetrievalPlan DataRetrievalPlan, out string Description, out ActiveState Active, out string Status, out string EventType, out string MatchData, out ParameterValueOrFieldReference[] Parameters) {
object[] results = this.Invoke("GetDataDrivenSubscriptionProperties", new object[] {
DataDrivenSubscriptionID});
ExtensionSettings = ((ExtensionSettings)(results[1]));
DataRetrievalPlan = ((DataRetrievalPlan)(results[2]));
Description = ((string)(results[3]));
Active = ((ActiveState)(results[4]));
Status = ((string)(results[5]));
EventType = ((string)(results[6]));
MatchData = ((string)(results[7]));
Parameters = ((ParameterValueOrFieldReference[])(results[8]));
return ((string)(results[0]));
}
/// <summary>
/// Loads subscription settings into SubscriptionSettings object
/// </summary>
/// <param name="filename">Name of XML file to parse</param>
/// <returns>Collection of Subscription Settings</returns>
/// <remarks>This is the meaty bit</remarks>
public SubscriptionSettings[] LoadSubscriptions(string filename)
{
try
{
// Load XML Document
var xml = XElement.Load(filename);
//// ---------------------------------------------
//// Read XML into Linq monster
//// ---------------------------------------------
var reportSubscriptions = from reportSubscription in xml.Elements("ReportSubscription")
select
new
{
reportName = (string)reportSubscription.Attribute("ReportName"),
subscriptionDescription =
(string)reportSubscription.Attribute("SubscriptionDescription"),
deliveryMethod =
(string)reportSubscription.Attribute("DeliveryMethod"),
dataSource = (string)reportSubscription.Attribute("DataSource"),
itemPath = (string)reportSubscription.Attribute("ItemPath"),
eventType = (string)reportSubscription.Element("EventType"),
queryDefinition = reportSubscription.Element("QueryDefinition"),
scheduleXml = reportSubscription.Element("ScheduleDefinition"),
fields =
from field in reportSubscription.Element("DatasetDefinition").Elements("Fields").Elements()
select field,
extentionParameters =
from extParam in
reportSubscription.Element("ExtensionParameters").Elements()
select extParam,
parameters =
from param in
reportSubscription.Element("Parameters").Elements()
select param,
extensionSetting = (string)reportSubscription.Element("ExtensionSetting")
};
var subSettings = new SubscriptionSettings[reportSubscriptions.Count()];
var subscriptionIndex = 0;
//// ---------------------------------------------
//// Run through each subscription and get values
//// ---------------------------------------------
foreach (var reportSubscription in reportSubscriptions)
{
subSettings[subscriptionIndex] = new SubscriptionSettings();
// Get Subscription Information
subSettings[subscriptionIndex].ReportName = reportSubscription.reportName;
subSettings[subscriptionIndex].SubscriptionDescription = reportSubscription.subscriptionDescription;
subSettings[subscriptionIndex].DeliveryMethod = reportSubscription.deliveryMethod;
subSettings[subscriptionIndex].DataSource = reportSubscription.dataSource;
subSettings[subscriptionIndex].ItemPath = reportSubscription.itemPath;
subSettings[subscriptionIndex].FullReportName = reportSubscription.itemPath + reportSubscription.reportName;
// Get EventType setting
subSettings[subscriptionIndex].EventType = reportSubscription.eventType;
// Get QueryDefinition
subSettings[subscriptionIndex].QueryDefinition = new QueryDefinition
{
CommandText = (string)reportSubscription.queryDefinition.Element("CommandText"),
CommandType = (string)reportSubscription.queryDefinition.Element("CommandType"),
Timeout = (int)reportSubscription.queryDefinition.Element("Timeout"),
TimeoutSpecified = (bool)reportSubscription.queryDefinition.Element("TimeoutSpecified")
};
// Get Schedule Raw XML
subSettings[subscriptionIndex].ScheduleXml = reportSubscription.scheduleXml.ToString();
// Get Fields
var numberOfFields = reportSubscription.fields.Count();
var fieldsList = new Field[numberOfFields];
var fieldIndex = 0;
foreach (var field in reportSubscription.fields)
{
fieldsList[fieldIndex] = new Field
{
Name = (string)field.Element("Name"),
Alias = (string)field.Element("Alias")
};
fieldIndex++;
}
// Dataset Definition
subSettings[subscriptionIndex].DataSetDefinition = new DataSetDefinition
{
AccentSensitivitySpecified = false,
CaseSensitivitySpecified = false,
KanatypeSensitivitySpecified = false,
WidthSensitivitySpecified = false,
Fields = fieldsList
};
// Get Extension Paramters
int numberOfParameterValues = reportSubscription.extentionParameters.Count();
var extensionParams = new ParameterValueOrFieldReference[numberOfParameterValues];
var extParamIndex = 0;
foreach (var extParam in reportSubscription.extentionParameters)
{
switch ((string)extParam.Attribute("Type"))
{
case "ParameterValue":
var pv = new ParameterValue
{
Name = (string)extParam.Element("Name"),
Value = (string)extParam.Element("Value")
};
extensionParams[extParamIndex] = pv;
break;
case "ParameterFieldReference":
var pfr = new ParameterFieldReference
{
ParameterName = (string)extParam.Element("ParameterName"),
FieldAlias = (string)extParam.Element("FieldAlias")
};
extensionParams[extParamIndex] = pfr;
break;
}
extParamIndex++;
}
subSettings[subscriptionIndex].ExtensionParameters = extensionParams;
// Get (Input) Parameters
int numberOfNormalParameterValues = reportSubscription.parameters.Count();
var parameters = new ParameterValueOrFieldReference[numberOfNormalParameterValues];
var paramIndex = 0;
foreach (var param in reportSubscription.parameters)
{
switch ((string)param.Attribute("Type"))
{
case "ParameterValue":
var pv = new ParameterValue
{
Name = (string)param.Element("Name"),
Value = (string)param.Element("Value")
};
parameters[paramIndex] = pv;
break;
case "ParameterFieldReference":
var pfr = new ParameterFieldReference
{
ParameterName = (string)param.Element("ParameterName"),
FieldAlias = (string)param.Element("FieldAlias")
};
parameters[paramIndex] = pfr;
break;
}
paramIndex++;
}
subSettings[subscriptionIndex].Parameters = parameters;
// Get Extension setting
subSettings[subscriptionIndex].ExtensionSettings = new ExtensionSettings
{
Extension = reportSubscription.extensionSetting,
ParameterValues = extensionParams
};
// Set up Dataset Definition
subSettings[subscriptionIndex].DataSetDefinition.Query = subSettings[subscriptionIndex].QueryDefinition;
// Set up Datasource Definition/Reference
subSettings[subscriptionIndex].DataSourceReference = new DataSourceReference
{
Reference = reportSubscription.itemPath + reportSubscription.dataSource
};
// Prepare Query
var preparationResults = new DataSetDefinition();
try
{
bool changed;
string[] paramNames;
preparationResults =
client.PrepareQuery(
new DataSource()
{
Item = subSettings[subscriptionIndex].DataSourceReference,
Name = "Database" // ?
},
subSettings[subscriptionIndex].DataSetDefinition,
out changed,
out paramNames);
}
catch (SoapException e)
{
Console.WriteLine(e.Message);
}
subSettings[subscriptionIndex].DataRetrievalPlan = new DataRetrievalPlan
{
DataSet = preparationResults,
Item = subSettings[subscriptionIndex].DataSourceReference
};
subscriptionIndex++;
}
return subSettings;
}
catch (Exception e)
{
throw new Exception("Error loading subscription settings. Please use absolute path and check XML file is correctly formed.\n\nError Message:\n------------------\n" + e.Message);
}
}
private void syncTreeNodes(string destPath, TreeNodeCollection nodes)
{
foreach (TreeNode node in nodes)
{
if ((bool)node.Tag)
{
if (node.Nodes.Count > 0)
{
var childPath = destPath;
if (node.Checked)
{
if (destPath.Equals(ROOT_FOLDER))
{
childPath = ROOT_FOLDER + node.Text;
}
else
{
childPath = destPath + PATH_SEPERATOR + node.Text;
}
}
syncTreeNodes(childPath, node.Nodes);
}
else
{
if (!existingPaths.Contains(destPath))
{
EnsureDestDir(destPath);
existingPaths.Add(destPath);
}
var itemPath = ROOT_FOLDER + node.FullPath.Replace("\\", PATH_SEPERATOR);
var itemType = sourceRS.GetItemType(itemPath);
if (itemType == ItemTypeEnum.Resource)
{
//Download the resource
string resourceType;
var contents = sourceRS.GetResourceContents(itemPath, out resourceType);
uploadResource(destPath, node.Text, resourceType, contents);
processedNodeCount++;
continue;
}
var reportDef = sourceRS.GetReportDefinition(itemPath);
uploadReport(destPath, node.Text, reportDef);
//Sync subscriptions
ExtensionSettings extSettings;
string desc;
ActiveState active;
string status;
string eventType;
string matchData;
ParameterValue[] values = null;
Subscription[] subscriptions = null;
ParameterValueOrFieldReference[] extensionParams = null;
var destReportPath = destPath;
if (destReportPath.EndsWith("/"))
{
destReportPath += node.Text;
}
else
{
destReportPath += "/" + node.Text;
}
subscriptions = sourceRS.ListSubscriptions(itemPath, txtSourceUser.Text);
foreach (var subscription in subscriptions)
{
sourceRS.GetSubscriptionProperties(subscription.SubscriptionID, out extSettings, out desc, out active, out status, out eventType, out matchData, out values);
if (extSettings.Extension == "Report Server FileShare")
{
ParameterValue para = new ParameterValue();
para.Name = "PASSWORD";
para.Value = txtDestPassword.Text;
ParameterValueOrFieldReference[] exParams = new ParameterValueOrFieldReference[extSettings.ParameterValues.Length + 1];
Array.Copy(extSettings.ParameterValues, exParams, extSettings.ParameterValues.Length);
exParams[extSettings.ParameterValues.Length] = para;
extSettings.ParameterValues = exParams;
}
destRS.CreateSubscription(destReportPath, extSettings, desc, eventType, matchData, values);
}
processedNodeCount++;
bwSync.ReportProgress(processedNodeCount * 100 / selectedNodeCount);
}
}
}
}
private void SyncTreeNodes(string destPath, IEnumerable nodes)
{
foreach (var node in nodes.Cast <TreeNode>().Where(node => (bool)node.Tag))
{
if (node.Nodes.Count > 0)
{
var childPath = destPath;
if (node.Checked)
{
if (destPath.Equals(RootFolder))
{
childPath = RootFolder + node.Text;
}
else
{
childPath = destPath + PathSeperator + node.Text;
}
}
SyncTreeNodes(childPath, node.Nodes);
}
else
{
if (!_existingPaths.Contains(destPath))
{
EnsureDestDir(destPath);
_existingPaths.Add(destPath);
}
var itemPath = RootFolder + node.FullPath.Replace("\\", PathSeperator);
var itemType = _sourceServicesMgmt.ReportingService.GetItemType(itemPath);
if (itemType == ItemTypeEnum.Resource)
{
//Download the resource
string resourceType;
var contents = _sourceServicesMgmt.ReportingService.GetResourceContents(itemPath, out resourceType);
UploadResource(destPath, node.Text, resourceType, contents);
_processedNodeCount++;
continue;
}
var reportDef = _sourceServicesMgmt.ReportingService.GetReportDefinition(itemPath);
UploadReport(destPath, node.Text, reportDef);
//Sync subscriptions
var destReportPath = destPath;
if (destReportPath.EndsWith("/"))
{
destReportPath += node.Text;
}
else
{
destReportPath += "/" + node.Text;
}
var subscriptions = _sourceServicesMgmt.ReportingService.ListSubscriptions(itemPath, tbSourceUser.Text);
foreach (var subscription in subscriptions)
{
ExtensionSettings extSettings;
string desc;
ActiveState active;
string status;
string eventType;
string matchData;
ParameterValue[] values;
_sourceServicesMgmt.ReportingService.GetSubscriptionProperties(subscription.SubscriptionID, out extSettings, out desc, out active, out status, out eventType, out matchData, out values);
if (extSettings.Extension == "Report Server FileShare")
{
var para = new ParameterValue {
Name = "PASSWORD", Value = tbDestPassword.Text
};
var exParams = new ParameterValueOrFieldReference[extSettings.ParameterValues.Length + 1];
Array.Copy(extSettings.ParameterValues, exParams, extSettings.ParameterValues.Length);
exParams[extSettings.ParameterValues.Length] = para;
extSettings.ParameterValues = exParams;
}
_destServicesMgmt.ReportingService.CreateSubscription(destReportPath, extSettings, desc, eventType, matchData, values);
}
_processedNodeCount++;
bwSync.ReportProgress(_processedNodeCount * 100 / _selectedNodeCount);
}
}
}
/// <remarks/>
public void ValidateExtensionSettingsAsync(string Extension, ParameterValueOrFieldReference[] ParameterValues,
object userState)
{
if ((_validateExtensionSettingsOperationCompleted == null))
{
_validateExtensionSettingsOperationCompleted =
new SendOrPostCallback(OnValidateExtensionSettingsOperationCompleted);
}
InvokeAsync("ValidateExtensionSettings", new object[]
{
Extension,
ParameterValues
}, _validateExtensionSettingsOperationCompleted, userState);
}
/// <remarks/>
public IAsyncResult BeginValidateExtensionSettings(string Extension,
ParameterValueOrFieldReference[] ParameterValues,
AsyncCallback callback, object asyncState)
{
return BeginInvoke("ValidateExtensionSettings", new object[]
{
Extension,
ParameterValues
}, callback, asyncState);
}
/// <remarks/>
public void SetDataDrivenSubscriptionPropertiesAsync(string DataDrivenSubscriptionID, ExtensionSettings ExtensionSettings, DataRetrievalPlan DataRetrievalPlan, string Description, string EventType, string MatchData, ParameterValueOrFieldReference[] Parameters) {
this.SetDataDrivenSubscriptionPropertiesAsync(DataDrivenSubscriptionID, ExtensionSettings, DataRetrievalPlan, Description, EventType, MatchData, Parameters, null);
}
/// <remarks/>
public void ValidateExtensionSettingsAsync(string Extension, ParameterValueOrFieldReference[] ParameterValues) {
this.ValidateExtensionSettingsAsync(Extension, ParameterValues, null);
}
/// <remarks/>
public void SetDataDrivenSubscriptionPropertiesAsync(string DataDrivenSubscriptionID, ExtensionSettings ExtensionSettings, DataRetrievalPlan DataRetrievalPlan, string Description, string EventType, string MatchData, ParameterValueOrFieldReference[] Parameters, object userState) {
if ((this.SetDataDrivenSubscriptionPropertiesOperationCompleted == null)) {
this.SetDataDrivenSubscriptionPropertiesOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetDataDrivenSubscriptionPropertiesOperationCompleted);
}
this.InvokeAsync("SetDataDrivenSubscriptionProperties", new object[] {
DataDrivenSubscriptionID,
ExtensionSettings,
DataRetrievalPlan,
Description,
EventType,
MatchData,
Parameters}, this.SetDataDrivenSubscriptionPropertiesOperationCompleted, userState);
}
private void syncTreeNodes(string destPath, TreeNodeCollection nodes)
{
foreach (TreeNode node in nodes)
{
if ((bool)node.Tag)
{
if (node.Nodes.Count > 0)
{
var childPath = destPath;
if (node.Checked)
{
if (destPath.Equals(ROOT_FOLDER))
childPath = ROOT_FOLDER + node.Text;
else
childPath = destPath + PATH_SEPERATOR + node.Text;
}
syncTreeNodes(childPath, node.Nodes);
}
else
{
if (!existingPaths.Contains(destPath))
{
EnsureDestDir(destPath);
existingPaths.Add(destPath);
}
var itemPath = ROOT_FOLDER + node.FullPath.Replace("\\", PATH_SEPERATOR);
var itemType = sourceRS.GetItemType(itemPath);
if (itemType == ItemTypeEnum.Resource)
{
//Download the resource
string resourceType;
var contents = sourceRS.GetResourceContents(itemPath, out resourceType);
uploadResource(destPath, node.Text, resourceType, contents);
processedNodeCount++;
continue;
}
var reportDef = sourceRS.GetReportDefinition(itemPath);
uploadReport(destPath, node.Text, reportDef);
//Sync subscriptions
ExtensionSettings extSettings;
string desc;
ActiveState active;
string status;
string eventType;
string matchData;
ParameterValue[] values = null;
Subscription[] subscriptions = null;
ParameterValueOrFieldReference[] extensionParams = null;
var destReportPath = destPath;
if (destReportPath.EndsWith("/"))
destReportPath += node.Text;
else
destReportPath += "/" + node.Text;
subscriptions = sourceRS.ListSubscriptions(itemPath, txtSourceUser.Text);
foreach (var subscription in subscriptions)
{
sourceRS.GetSubscriptionProperties(subscription.SubscriptionID, out extSettings, out desc, out active, out status, out eventType, out matchData, out values);
if (extSettings.Extension == "Report Server FileShare")
{
ParameterValue para = new ParameterValue();
para.Name = "PASSWORD";
para.Value = txtDestPassword.Text;
ParameterValueOrFieldReference[] exParams = new ParameterValueOrFieldReference[extSettings.ParameterValues.Length + 1];
Array.Copy(extSettings.ParameterValues, exParams, extSettings.ParameterValues.Length);
exParams[extSettings.ParameterValues.Length] = para;
extSettings.ParameterValues = exParams;
}
destRS.CreateSubscription(destReportPath, extSettings, desc, eventType, matchData, values);
}
processedNodeCount++;
bwSync.ReportProgress(processedNodeCount * 100 / selectedNodeCount);
}
}
}
}
public ExtensionParameter[] ValidateExtensionSettings(string Extension, ParameterValueOrFieldReference[] ParameterValues) {
object[] results = this.Invoke("ValidateExtensionSettings", new object[] {
Extension,
ParameterValues});
return ((ExtensionParameter[])(results[0]));
}
/// <remarks/>
public IAsyncResult BeginCreateDataDrivenSubscription(string report, ExtensionSettings ExtensionSettings,
DataRetrievalPlan DataRetrievalPlan, string Description,
string EventType, string MatchData,
ParameterValueOrFieldReference[] Parameters,
AsyncCallback callback, object asyncState)
{
return BeginInvoke("CreateDataDrivenSubscription", new object[]
{
report,
ExtensionSettings,
DataRetrievalPlan,
Description,
EventType,
MatchData,
Parameters
}, callback, asyncState);
}
/// <remarks/>
public void ValidateExtensionSettingsAsync(string Extension, ParameterValueOrFieldReference[] ParameterValues, object userState) {
if ((this.ValidateExtensionSettingsOperationCompleted == null)) {
this.ValidateExtensionSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnValidateExtensionSettingsOperationCompleted);
}
this.InvokeAsync("ValidateExtensionSettings", new object[] {
Extension,
ParameterValues}, this.ValidateExtensionSettingsOperationCompleted, userState);
}
private void SyncTreeNodes(string destPath, IEnumerable nodes)
{
foreach (var node in nodes.Cast<TreeNode>().Where(node => (bool) node.Tag))
{
if (node.Nodes.Count > 0)
{
var childPath = destPath;
if (node.Checked)
{
if (destPath.Equals(RootFolder))
childPath = RootFolder + node.Text;
else
childPath = destPath + PathSeperator + node.Text;
}
SyncTreeNodes(childPath, node.Nodes);
}
else
{
if (!_existingPaths.Contains(destPath))
{
EnsureDestDir(destPath);
_existingPaths.Add(destPath);
}
var itemPath = RootFolder + node.FullPath.Replace("\\", PathSeperator);
var itemType = _sourceServicesMgmt.ReportingService.GetItemType(itemPath);
if (itemType == ItemTypeEnum.Resource)
{
//Download the resource
string resourceType;
var contents = _sourceServicesMgmt.ReportingService.GetResourceContents(itemPath, out resourceType);
UploadResource(destPath, node.Text, resourceType, contents);
_processedNodeCount++;
continue;
}
var reportDef = _sourceServicesMgmt.ReportingService.GetReportDefinition(itemPath);
UploadReport(destPath, node.Text, reportDef);
//Sync subscriptions
var destReportPath = destPath;
if (destReportPath.EndsWith("/"))
destReportPath += node.Text;
else
destReportPath += "/" + node.Text;
var subscriptions = _sourceServicesMgmt.ReportingService.ListSubscriptions(itemPath, tbSourceUser.Text);
foreach (var subscription in subscriptions)
{
ExtensionSettings extSettings;
string desc;
ActiveState active;
string status;
string eventType;
string matchData;
ParameterValue[] values;
_sourceServicesMgmt.ReportingService.GetSubscriptionProperties(subscription.SubscriptionID, out extSettings, out desc, out active, out status, out eventType, out matchData, out values);
if (extSettings.Extension == "Report Server FileShare")
{
var para = new ParameterValue {Name = "PASSWORD", Value = tbDestPassword.Text};
var exParams = new ParameterValueOrFieldReference[extSettings.ParameterValues.Length + 1];
Array.Copy(extSettings.ParameterValues, exParams, extSettings.ParameterValues.Length);
exParams[extSettings.ParameterValues.Length] = para;
extSettings.ParameterValues = exParams;
}
_destServicesMgmt.ReportingService.CreateSubscription(destReportPath, extSettings, desc, eventType, matchData, values);
}
_processedNodeCount++;
bwSync.ReportProgress(_processedNodeCount * 100 / _selectedNodeCount);
}
}
}
