public static string JsonSerialize(DataSourceDefinition dataSource)
{
JavaScriptSerializer serializer = new JavaScriptSerializer();
var output = serializer.Serialize(dataSource);
return output;
}
public void SetUp()
{
var rs = GetReportingService();
if (rs.GetItemType("/ReportFolder") == "Folder")
{
rs.DeleteItem("/ReportFolder");
}
rs.CreateFolder("ReportFolder", "/", null);
ProductCatalogPath = FileOnDisk.CreatePhysicalFile("ProductCatalog.rdl", "RsPackage.Testing.Resources.Product Catalog.rdl");
EmployeeSalesSummaryPath = FileOnDisk.CreatePhysicalFile("Employee_Sales_Summary.rdl", "RsPackage.Testing.Resources.Employee_Sales_Summary.rdl");
if (rs.GetItemType("/Data Sources") != "Folder")
{
rs.CreateFolder("Data Sources", "/", null);
}
if (rs.GetItemType("/Data Sources/AdventureWorks") != "DataSource")
{
var ds = new DataSourceDefinition()
{
ConnectString = "Data Source=localhost;Initial Catalog=msdb;Integreted Security=SSPI",
Extension = "SQL"
};
rs.CreateDataSource("AdventureWorks", "/Data Sources", false, ds, null);
}
}
public bool TestConnectForDataSourceDefinition(RSDataSourceDefinition DataSourceDefinition, string UserName, string Password, out string ConnectError)
{
DataSourceDefinition dsDef = (DataSourceDefinition)Converter.Convert(DataSourceDefinition);
bool outval = rs.TestConnectForDataSourceDefinition(dsDef, UserName, Password, out ConnectError);
return(outval);
}
/// <summary>
/// Convert DataSource from old DataSourceDefinition to new DataSourceDefinition. It create temporaryDataSource definition and perform all operations
/// on temporary DataSourcedefinition and return it.
/// </summary>
/// <param name="fromDataSourceDefinition"></param>
/// <param name="toDataSourceDefinition"></param>
/// <returns>Temporary DataSourceDefinition</returns>
private DataSourceDefinition ConvertDataSource(DataSourceDefinition fromDataSourceDefinition, DataSourceDefinition toDataSourceDefinition)
{
Logger.Instance.WriteSupportToLog("convertDataSource():>>>> ", true);
Logger.Instance.WriteSupportToLog(String.Format("convertDataSource(): converting table {0}", fromDataSourceDefinition.Name), true);
GatewayResult result = null;
string temporaryTableName = GetTemporaryTableName(fromDataSourceDefinition.Id);
DataSourceDefinition temporaryDataSourceDefinition = (DataSourceDefinition)toDataSourceDefinition.Clone();
temporaryDataSourceDefinition.Name = temporaryTableName;
// In order to genearte temporary key name for the temporary dbh set magic key mask on the keys.
for (int keyIndex = 0; keyIndex < temporaryDataSourceDefinition.Keys.Count; keyIndex++)
{
DBKey key = temporaryDataSourceDefinition.Keys[keyIndex];
key.SetMask(KeyMasks.MagicKeyMask);
}
// Delete temporary table, if exists
result = GatewayCommandsFactory.CreateFileDeleteCommand(temporaryTableName, temporaryDataSourceDefinition, ClientManager.Instance.LocalManager).Execute();
if (!result.Success && result.ErrorCode != GatewayErrorCode.FileNotExist)
{
throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription);
}
// Open source and temporary table
temporaryDataSourceDefinition.SetMask(DbhMask.CheckExistMask);
result = GatewayCommandsFactory.CreateFileOpenCommand(temporaryTableName, temporaryDataSourceDefinition, Access.Write, ClientManager.Instance.LocalManager).Execute();
if (result.Success)
{
result = GatewayCommandsFactory.CreateFileOpenCommand(fromDataSourceDefinition.Name, fromDataSourceDefinition, Access.Read, ClientManager.Instance.LocalManager).Execute();
}
if (!result.Success)
{
throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription);
}
//Convert values of source table and insert it into temporary table
ConvertAndInsertValues(fromDataSourceDefinition, temporaryDataSourceDefinition);
//Close source and temporary table
result = GatewayCommandsFactory.CreateFileCloseCommand(temporaryDataSourceDefinition, ClientManager.Instance.LocalManager).Execute();
if (result.Success)
{
GatewayCommandsFactory.CreateFileCloseCommand(fromDataSourceDefinition, ClientManager.Instance.LocalManager).Execute();
}
if (!result.Success)
{
throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription);
}
Logger.Instance.WriteSupportToLog("convertDataSource():<<<< ", true);
return(temporaryDataSourceDefinition);
}
/// <summary>
/// Returns RTDataSource according to its definition
/// </summary>
/// <param name="dataSourceDefinition"></param>
/// <returns></returns>
internal RTDataSource GetDataSource(DataSourceDefinition dataSourceDefinition)
{
if (openedDataSources.ContainsKey(dataSourceDefinition))
{
return(openedDataSources[dataSourceDefinition]);
}
return(null);
}
/// <summary>
/// Checks if correspondng table of data source is exist at backend
/// </summary>
/// <param name="dataSourceDefinition"></param>
/// <returns>returns true if table exists</returns>
private bool IsTableExist(DataSourceDefinition dataSourceDefinition)
{
GatewayCommandFileExist fileExistCommand = GatewayCommandsFactory.CreateFileExistCommand(dataSourceDefinition.Name, dataSourceDefinition,
ClientManager.Instance.LocalManager);
GatewayResult result = fileExistCommand.Execute();
return(result.Success);
}
/// <summary>
/// contructor
/// </summary>
/// <param name="dataViewOutputCommand"></param>
public RemoteDataViewToDataSourceCommand(DataViewOutputCommand dataViewOutputCommand)
: base(dataViewOutputCommand)
{
this.dataViewOutputCommand = dataViewOutputCommand;
currTask = (TaskBase)MGDataCollection.Instance.GetTaskByID(dataViewOutputCommand.TaskTag);
ancestorTask = GuiExpressionEvaluator.GetContextTask((TaskBase)currTask, dataViewOutputCommand.Generation);
destinationDataSourceDefinition = ClientManager.Instance.LocalManager.ApplicationDefinitions.DataSourceDefinitionManager.GetDataSourceDefinition(ancestorTask.getCtlIdx(), dataViewOutputCommand.DestinationDataSourceNumber);
}
DataSourceDefinition GetDataSourceDefinition(byte[] dataSourceContent, string name, string guid)
{
var _rptDefinition = new DataSourceDefinition();
var _datasourceStream = this.GetFileToStream(dataSourceContent);
var _umpDefinition = this.DeseralizeObj <DataSourceDefinition>(_datasourceStream);
_rptDefinition = _umpDefinition;
return(_rptDefinition);
}
/// <summary>
/// CTOR - create and activate the parsing process
/// </summary>
/// <param name="dataSourceDefinition"></param>
/// <param name="xmlData"></param>
public DataSourceDefinitionSaxHandler(DataSourceDefinition dataSourceDefinition, DataSourceBuilder dataSourceBuilder,
byte[] xmlData)
{
this.dataSourceDefinition = dataSourceDefinition;
this.dataSourceBuilder = dataSourceBuilder;
MgSAXHandler mgSAXHandler = new MgSAXHandler(this);
mgSAXHandler.parse(xmlData);
}
private void UploadReport(string siteCollectionId, ReportItem report)
{
Warning[] warnings;
if (report.FileName.ToLower().EndsWith(".rdl"))
{
if (dataSources == null)
{
dataSources = client.ListChildren($"/{siteCollectionId}", true).Where(x => x.TypeName == "DataSource").ToList();
}
var catalogItem = client.CreateCatalogItem("Report", report.FileName, $"/{siteCollectionId}/{report.Folder}", true, report.BinaryData, null, out warnings);
var reportDatasources = client.GetItemDataSources(catalogItem.Path);
var itemRefs = new List <ItemReference>();
foreach (DataSource reportDatasource in reportDatasources)
{
if (reportDatasource.Item.GetType() == typeof(InvalidDataSourceReference))
{
var existingDatasource = dataSources.Where(x => x.Name == reportDatasource.Name + ".rsds").First();
var itemRef = new ItemReference()
{
Name = reportDatasource.Name,
Reference = existingDatasource.Path
};
itemRefs.Add(itemRef);
}
}
client.SetItemReferences(catalogItem.Path, itemRefs.ToArray());
}
else if (report.FileName.ToLower().EndsWith(".rsds"))
{
var doc = new XmlDocument();
using (var memoryStream = new MemoryStream(report.BinaryData))
{
doc.Load(memoryStream);
var definition = new DataSourceDefinition()
{
CredentialRetrieval = (CredentialRetrievalEnum)Enum.Parse(typeof(CredentialRetrievalEnum), doc.GetStringValue("/m:DataSourceDefinition/m:CredentialRetrieval")),
ConnectString = doc.GetStringValue("/m:DataSourceDefinition/m:ConnectString"),
Enabled = doc.GetBooleanValue("/m:DataSourceDefinition/m:Enabled"),
Extension = doc.GetStringValue("/m:DataSourceDefinition/m:Extension"),
ImpersonateUser = doc.GetBooleanValue("/m:DataSourceDefinition/m:ImpersonateUser"),
OriginalConnectStringExpressionBased = doc.GetBooleanValue("/m:DataSourceDefinition/m:OriginalConnectStringExpressionBased"),
Prompt = doc.GetStringValue("/m:DataSourceDefinition/m:Prompt"),
UseOriginalConnectString = doc.GetBooleanValue("/m:DataSourceDefinition/m:UseOriginalConnectString"),
WindowsCredentials = doc.GetBooleanValue("/m:DataSourceDefinition/m:WindowsCredentials"),
UserName = "",
Password = ""
};
if (!string.IsNullOrEmpty(report.DatasourceCredentials))
{
var parts = report.DatasourceCredentials.Split(':');
definition.UserName = parts[0].Trim();
definition.Password = parts[1].Trim();
}
client.CreateDataSource(report.FileName, $"/{siteCollectionId}/{report.Folder}", true, definition, null);
}
}
}
public void endElement(string elementName, string elementValue, NameValueCollection attributes)
{
if (elementName.Equals(ConstInterface.MG_TAG_DBH_DATA_ID))
{
DataSourceDefinition dataSourceDefinition = new DataSourceDefinition();
dataSourceDefinitionManager.DataSourceBuilder.SetAttributes(dataSourceDefinition, attributes);
dataSourceDefinitionManager.DataSourceDefinitions.Add(dataSourceDefinition.Id, dataSourceDefinition);
}
}
/// <summary>
/// Create File close command.
/// </summary>
/// <param name="fileName"></param>
/// <param name="dataSourceDefinition"></param>
/// <param name="access"></param>
/// <param name="localManager"></param>
/// <returns></returns>
public static GatewayCommandFileClose CreateFileCloseCommand(DataSourceDefinition dataSourceDefinition, LocalManager localManager)
{
GatewayCommandFileClose fileCloseCommand = new GatewayCommandFileClose();
fileCloseCommand.DataSourceDefinition = dataSourceDefinition;
fileCloseCommand.LocalManager = localManager;
return(fileCloseCommand);
}
public RSCatalogItem CreateDataSource(string DataSource, string Parent, bool Overwrite, RSDataSourceDefinition Definition, RSProperty[] Properties)
{
DataSourceDefinition dsDef = (DataSourceDefinition)Converter.Convert(Definition);
Property[] props = (Property[])Converter.Convert(Properties);
CatalogItem outval = rs.CreateDataSource(DataSource, Parent, Overwrite, dsDef, props);
return((RSCatalogItem)Converter.Convert(outval));
}
/// <summary>
/// Contructor
/// </summary>
/// <param name="updateDataViewToDataSourceCommand"></param>
public LocalUpdateRemoteDataViewToDataSourceCommand(UpdateDataViewToDataSourceEventCommand updateDataViewToDataSourceCommand)
: base(updateDataViewToDataSourceCommand)
{
this.updateDataViewToDataSourceCommand = updateDataViewToDataSourceCommand;
this.destinationColumnList = updateDataViewToDataSourceCommand.DestinationDataSourceFieldsList;
this.sourceVarList = updateDataViewToDataSourceCommand.SourceVarList;
destinationToSourceFieldIndexMapping = new Dictionary <string, int>();
task = (TaskBase)MGDataCollection.Instance.GetTaskByID(updateDataViewToDataSourceCommand.TaskTag);
destinationDataSourceDefinition = ClientManager.Instance.LocalManager.ApplicationDefinitions.DataSourceDefinitionManager.GetDataSourceDefinition(task.getCtlIdx(), updateDataViewToDataSourceCommand.DestDataSource);
}
/// <summary>
///
/// </summary>
/// <param name="attributes"></param>
public void SetAttributes(DataSourceDefinition dataSourceDefinition, NameValueCollection attributes)
{
IEnumerator enumerator = attributes.GetEnumerator();
while (enumerator.MoveNext())
{
String attr = (String)enumerator.Current;
setAttribute(dataSourceDefinition, attr, attributes[attr]);
}
}
/// <summary>
/// Create File Open command.
/// </summary>
/// <param name="fileName"></param>
/// <param name="dataSourceDefinition"></param>
/// <param name="access"></param>
/// <returns></returns>
public static GatewayCommandFileOpen CreateFileOpenCommand(string fileName, DataSourceDefinition dataSourceDefinition, Access access, LocalManager localManager)
{
GatewayCommandFileOpen fileOpenCommand = new GatewayCommandFileOpen();
fileOpenCommand.FileName = fileName;
fileOpenCommand.DataSourceDefinition = dataSourceDefinition;
fileOpenCommand.Access = access;
fileOpenCommand.LocalManager = localManager;
return(fileOpenCommand);
}
/// <summary>
/// Create File Rename Command.
/// </summary>
/// <param name="dataSourceDefinition"></param>
/// <param name="sourceFileName"></param>
/// <param name="destinationFileName"></param>
/// <param name="localManager"></param>
/// <returns></returns>
public static GatewayCommandFileRename CreateFileRenameCommand(DataSourceDefinition sourceDataSourceDefinition, DataSourceDefinition destinationDataSourceDefinition,
LocalManager localManager)
{
GatewayCommandFileRename fileRenameCommand = new GatewayCommandFileRename();
fileRenameCommand.DataSourceDefinition = sourceDataSourceDefinition;
fileRenameCommand.DestinationDataSourceDefinition = destinationDataSourceDefinition;
fileRenameCommand.LocalManager = localManager;
return(fileRenameCommand);
}
public SsrsDataSource MapToSsrsObject(string itemPath, DataSourceDefinition definition)
{
var path = new SsrsObjectPath(itemPath);
return(new SsrsDataSource {
Name = path.Name,
Path = path,
ConnectionString = definition.ConnectString,
Authentication = MapToAuthenticationType(definition)
});
}
private void UploadReportDataSources(ReportingService2010SoapClient reportingServicesClient, TrustedUserHeader userHeader, string artifactsFolderPath)
{
foreach (var dataSourceDefinitionFile in Directory.GetFiles(artifactsFolderPath, String.Format("*{0}", DataSourceFileExtension)))
{
string itemName = Path.GetFileNameWithoutExtension(dataSourceDefinitionFile);
CatalogItem dataSetItem = null;
DataSourceDefinition definition = DataSourceDefinitionParser.Parse(File.OpenRead(dataSourceDefinitionFile));
Console.WriteLine("Uploaded report data source '{0}'", itemName);
reportingServicesClient.CreateDataSource(userHeader, itemName, "/", true, definition, null, out dataSetItem);
}
}
/// <summary>
/// Create Gateway DbDisconnect command.
/// </summary>
/// <param name="localManager"></param>
/// <param name="databaseName"></param>
/// <returns></returns>
public static GatewayCommandDbDisconnect CreateGatewayCommandDbDisconnect(LocalManager localManager, string databaseName)
{
GatewayCommandDbDisconnect dbDisconnectCommand = new GatewayCommandDbDisconnect();
dbDisconnectCommand.LocalManager = localManager;
DataSourceDefinition datasourceDefinition = new DataSourceDefinition();
datasourceDefinition.DBaseName = databaseName.ToUpper();
dbDisconnectCommand.DataSourceDefinition = datasourceDefinition;
return(dbDisconnectCommand);
}
/// <summary>
/// Execute File delete gateway command.
/// </summary>
/// <returns></returns>
internal override ReturnResultBase Execute()
{
ReturnResultBase result = new ReturnResult();
bool exist = false;
int dataSourceNumber = clientDbDelCommand.DataSourceNumber;
string dataSourceName = clientDbDelCommand.DataSourceName;
DataSourceDefinition dataSourceDefintion = ClientManager.Instance.LocalManager.ApplicationDefinitions.DataSourceDefinitionManager.GetDataSourceDefinition(Task.getCtlIdx(), dataSourceNumber);
//If Wrong Data Source Number is Given
if (dataSourceDefintion == null)
{
Logger.Instance.WriteExceptionToLog("ClientDbDel - Invalid Data Source Number");
result = new ReturnResult(MsgInterface.STR_CLIENT_DB_DEL_OPERATION_FAILED);
}
else
{
if (string.IsNullOrEmpty(dataSourceName))
{
dataSourceName = dataSourceDefintion.Name;
}
//Check for Table exist or not.
if (dataSourceDefintion.CheckExist == 'N')
{
exist = true;
}
else
{
GatewayCommandFileExist dbFileExistCommand = GatewayCommandsFactory.CreateFileExistCommand(dataSourceName, dataSourceDefintion, LocalDataviewManager.LocalManager);
result = dbFileExistCommand.Execute();
exist = result.Success;
}
//If Table exists then go for file delete operation.
if (exist)
{
GatewayCommandFileDelete dbDeleteCommand = GatewayCommandsFactory.CreateFileDeleteCommand(dataSourceName, dataSourceDefintion, LocalDataviewManager.LocalManager);
if (!dbDeleteCommand.Execute().Success)
{
Logger.Instance.WriteExceptionToLog("ClientDbDel - Cannot delete Table");
result = new ReturnResult(MsgInterface.STR_CLIENT_DB_DEL_OPERATION_FAILED);
}
}
else
{
Logger.Instance.WriteExceptionToLog(string.Format("ClientDbDel - {0}", result.ErrorDescription));
result = new ReturnResult(MsgInterface.STR_CLIENT_DB_DEL_OPERATION_FAILED);
}
}
return(result);
}
public static DataSourceDefinition Parse(Stream itemDefinitionStream)
{
XDocument definitionDocument = XDocument.Load(itemDefinitionStream);
DataSourceDefinition definition = new DataSourceDefinition()
{
ConnectString = definitionDocument.Root.Descendants("ConnectString").First().Value,
Enabled = bool.Parse(definitionDocument.Root.Descendants("Enabled").First().Value),
Extension = definitionDocument.Root.Descendants("Extension").First().Value,
CredentialRetrieval = (CredentialRetrievalEnum)Enum.Parse(typeof(CredentialRetrievalEnum), definitionDocument.Root.Descendants("CredentialRetrieval").First().Value)
};
return(definition);
}
public static DataSourceDefinition Parse(Stream itemDefinitionStream)
{
XDocument definitionDocument = XDocument.Load(itemDefinitionStream);
DataSourceDefinition definition = new DataSourceDefinition()
{
ConnectString = definitionDocument.Root.Descendants("ConnectString").First().Value,
Enabled = bool.Parse(definitionDocument.Root.Descendants("Enabled").First().Value),
Extension = definitionDocument.Root.Descendants("Extension").First().Value,
CredentialRetrieval = (CredentialRetrievalEnum)Enum.Parse(typeof(CredentialRetrievalEnum), definitionDocument.Root.Descendants("CredentialRetrieval").First().Value)
};
return definition;
}
/// <summary>
/// Checks if table can be deleted, by checking its references in all data sources in repository
/// </summary>
/// <param name="dbName">table name</param>
/// <param name="dataSourceRepository">repository</param>
/// <returns></returns>
private bool CanDeleteTable(String dbName, DataSourceDefinitionManager dataSourceRepository)
{
foreach (KeyValuePair <DataSourceId, DataSourceDefinition> definitionEntry in dataSourceRepository.DataSourceDefinitions)
{
DataSourceDefinition dataSourceDefinition = (DataSourceDefinition)definitionEntry.Value;
if (dataSourceDefinition.Name.Equals(dbName))
{
return(false);
}
}
return(true);
}
private void EditDataSource(TreeView treeView)
{
if ((ItemTypeEnum)(treeView.SelectedNode.Tag) != ItemTypeEnum.DataSource)
{
MessageBox.Show(@"Please choose a Datasource");
return;
}
ReportServerProperties reportServerProperties = new ReportServerProperties(((ReportServerProperties)(treeView.Tag)).ReportsServerInstance.Url);
DataSourceDefinition dataSourceDefinition = reportServerProperties.GetDataSourceDefinition(treeView.SelectedNode.FullPath.Replace(treeView.Nodes[0].Text, string.Empty).Replace(@"\", "/"));
using (var frmDataSourceDetail = new frmDataSourceDetail())
{
string[] connectionString = dataSourceDefinition.ConnectString.Split(';');
foreach (string[] itemDict in connectionString.Select(item => item.Split('=')))
{
if (itemDict[0] == "Data Source")
{
frmDataSourceDetail.SQLServer = itemDict[1];
}
if (itemDict[0] == "Initial Catalog")
{
frmDataSourceDetail.DBName = itemDict[1];
}
}
frmDataSourceDetail.DataSourceName = treeView.SelectedNode.Text;
CatalogItem[] catalogItems = reportServerProperties.ReportsServerInstance.ListDependentItems(treeView.SelectedNode.FullPath.Replace(treeView.Nodes[0].Text, string.Empty).Replace(@"\", "/"));
//frmDataSourceDetail.DependentItems = catalogItems.Select(catalogItem => string.Format("{0}{1}", catalogItem.Path, catalogItem.Name)).ToList();
if (frmDataSourceDetail.ShowDialog() == DialogResult.OK)
{
string folder = treeView.SelectedNode.FullPath.Replace(treeView.Nodes[0].Text, string.Empty).Replace(@"\", "/").Replace(treeView.SelectedNode.Text, string.Empty);
if (ReportServerDestination.DeleteItem(ItemTypeEnum.DataSource, folder.Substring(0, folder.Length - 1), treeView.SelectedNode.Text) &&
ReportServerDestination.CreateDataSource(frmDataSourceDetail.DataSourceName, folder.Substring(0, folder.Length - 1), frmDataSourceDetail.SQLServer, frmDataSourceDetail.DBName))
{
treeView.SelectedNode.Text = frmDataSourceDetail.DataSourceName;
MessageBox.Show("DataSource modified succesfully");
}
else
{
MessageBox.Show("DataSource WASN'T modified");
}
}
}
}
private static void CreateDataSources(ReportingService2010 reportingService, string path)
{
if (reportingService == null)
{
throw new ArgumentNullException("reportingService");
}
if (string.IsNullOrEmpty(path))
{
throw new ArgumentException("path");
}
foreach (DataSourceItem dataSource in SetupDataSourceItems)
{
DataSourceDefinition def = new DataSourceDefinition();
def.ConnectString = dataSource.ConnectString;
switch (dataSource.CredentialsRetrieval)
{
case "Integrated":
def.CredentialRetrieval = CredentialRetrievalEnum.Integrated; break;
case "None":
def.CredentialRetrieval = CredentialRetrievalEnum.None; break;
case "Prompt":
def.CredentialRetrieval = CredentialRetrievalEnum.Prompt; break;
case "Store":
def.CredentialRetrieval = CredentialRetrievalEnum.Store; break;
}
def.Enabled = dataSource.Enabled;
def.EnabledSpecified = dataSource.EnabledSpecified;
def.Extension = dataSource.Extension;
def.ImpersonateUser = dataSource.ImpersonateUser;
def.ImpersonateUserSpecified = dataSource.ImpersonateUserSpecified;
def.OriginalConnectStringExpressionBased = dataSource.OriginalConnectStringExpressionBased;
def.Password = dataSource.Password;
def.Prompt = dataSource.Prompt;
def.UseOriginalConnectString = dataSource.UseOriginalConnectString;
def.UserName = dataSource.UserName;
def.WindowsCredentials = dataSource.WindowsCredentials;
string fullPath = string.Format(dataSource.Path, path);
string parent = TesterUtility.GetParentPath(fullPath);
reportingService.CreateDataSource(dataSource.Name, parent, true, def, null);
}
}
private static void CreateDataSource(ReportingService2010 reportingService, DataSourceItem dataSource)
{
if (reportingService == null)
{
throw new ArgumentNullException("reportingService");
}
if (dataSource == null)
{
throw new ArgumentNullException("dataSource");
}
DataSourceDefinition def = new DataSourceDefinition();
def.ConnectString = dataSource.ConnectString;
switch (dataSource.CredentialsRetrieval)
{
case "Integrated":
def.CredentialRetrieval = CredentialRetrievalEnum.Integrated; break;
case "None":
def.CredentialRetrieval = CredentialRetrievalEnum.None; break;
case "Prompt":
def.CredentialRetrieval = CredentialRetrievalEnum.Prompt; break;
case "Store":
def.CredentialRetrieval = CredentialRetrievalEnum.Store; break;
}
def.Enabled = dataSource.Enabled;
def.EnabledSpecified = dataSource.EnabledSpecified;
def.Extension = dataSource.Extension;
def.ImpersonateUser = dataSource.ImpersonateUser;
def.ImpersonateUserSpecified = dataSource.ImpersonateUserSpecified;
def.OriginalConnectStringExpressionBased = dataSource.OriginalConnectStringExpressionBased;
def.Password = dataSource.Password;
def.Prompt = dataSource.Prompt;
def.UseOriginalConnectString = dataSource.UseOriginalConnectString;
def.UserName = dataSource.UserName;
def.WindowsCredentials = dataSource.WindowsCredentials;
string parent = TesterUtility.GetParentPath(dataSource.Path);
ReportingService2010TestEnvironment.CreateFolderFromPath(reportingService, parent);
reportingService.CreateDataSource(dataSource.Name, parent, true, def, null);
}
public static void SetDataSource(string itemPath, ReportingService2010 report, string userName, string password, int timeExpiry)
{
if (itemPath == null)
{
throw new ArgumentNullException($"itemPath");
}
if (report == null)
{
throw new ArgumentNullException($"report");
}
List <DataSource> lstDs = new List <DataSource>();
foreach (DataSource ds in report.GetItemDataSources(itemPath))
{
DataSourceDefinition tempDef = (DataSourceDefinition)ds.Item;
DataSource dsNew = new DataSource();
DataSourceDefinition dfNew = new DataSourceDefinition();
dfNew.CredentialRetrieval = CredentialRetrievalEnum.Store;
dfNew.UserName = userName;
dfNew.Password = password;
dfNew.Enabled = true;
dfNew.EnabledSpecified = true;
dfNew.Extension = $"SQL";
dfNew.ImpersonateUser = false;
dfNew.ImpersonateUserSpecified = true;
dfNew.OriginalConnectStringExpressionBased = true;
dfNew.UseOriginalConnectString = true;
dfNew.WindowsCredentials = true;
dsNew.Name = ds.Name;
dsNew.Item = dfNew;
lstDs.Add(dsNew);
}
report.SetItemDataSources(itemPath, lstDs.ToArray());
ExpirationDefinition exprDef = new TimeExpiration()
{
Minutes = timeExpiry
};
report.SetCacheOptions(itemPath, true, exprDef);
}
public void UpdateDataSource(DataSourceDefinition dataSourceDefinition)
{
try
{
configurator.UpdateDataSource(dataSourceDefinition);
scheduledJobManager.QueueScheduledJobs(clearExistingScheduledJobInstancesFromWaitingQueue: true);
}
catch (Exception ex)
{
SyncEngineLogger.WriteExceptionToLog(ex, WEB_SERVICE_EXCEPTION_MESSAGE);
throw;
}
}
public DataSourceDefinition createDataSourceDefinition(string connectString)
{
DataSourceDefinition definition = new DataSourceDefinition();
definition.CredentialRetrieval = CredentialRetrievalEnum.Integrated;
definition.ConnectString = connectString; //connection string
definition.Enabled = true;
definition.EnabledSpecified = true;
definition.Extension = "SQL"; //use Sql server
definition.ImpersonateUserSpecified = true; // use Impersonator authentication
//Use the default prompt string.
definition.Prompt = null;
definition.WindowsCredentials = true;//use window authentication
return(definition);
}
/// <summary>
/// Fetech the values from source datasource, convert fetched values and insert values in destination dataSource.
/// </summary>
/// <param name="fromDataSourceDefinition"></param>
/// <param name="toDataSourceDefinition"></param>
private void ConvertAndInsertValues(DataSourceDefinition fromDataSourceDefinition, DataSourceDefinition toDataSourceDefinition)
{
GatewayResult result = null;
MainCursorBuilder cursorBuilder = new MainCursorBuilder(null);
RuntimeCursor fromRuntimeCursor = cursorBuilder.Build(fromDataSourceDefinition, Access.Read);
RuntimeCursor toRuntimeCursor = cursorBuilder.Build(toDataSourceDefinition, Access.Write);
//Prepare and open source and destnation runtime cursor.
PrepareAndOpenCursor(fromRuntimeCursor, true);
PrepareAndOpenCursor(toRuntimeCursor, false);
//Create fetch command
GatewayCommandFetch fetchCommand = GatewayCommandsFactory.CreateCursorFetchCommand(fromRuntimeCursor, ClientManager.Instance.LocalManager);
while (true)
{
//Fetch record from source table
result = fetchCommand.Execute();
if (!result.Success)
{
if (result.ErrorCode == GatewayErrorCode.NoRecord)
{
break;
}
else
{
throw new DataSourceConversionFailedException(fromDataSourceDefinition.Name, result.ErrorDescription);
}
}
//Convert values of fields of source table.
ConvertFields(fromDataSourceDefinition, toDataSourceDefinition, fromRuntimeCursor.RuntimeCursorData.CurrentValues, toRuntimeCursor.RuntimeCursorData.CurrentValues);
for (int i = 0; i < toDataSourceDefinition.Fields.Count; i++)
{
toRuntimeCursor.CursorDefinition.IsFieldUpdated[i] = true;
}
//Insert converted values into temporary table.
result = GatewayCommandsFactory.CreateCursorInsertCommand(toRuntimeCursor, ClientManager.Instance.LocalManager).Execute();
}
// release and close source and destnation runtime cursor.
ReleaseAndCloseCursor(fromRuntimeCursor, true);
ReleaseAndCloseCursor(toRuntimeCursor, false);
}
/// <summary>
/// Take the dataSource objects grabbed from the report server and write them in a file.
/// </summary>
/// <param name="dataSources">array of datasources used.</param>
/// <param name="outputFileName">The path/name of output file.</param>
public void WriteDataSourceContent(DataSource[] dataSources, string outputFileName)
{
XDocument retfile = new XDocument(new XDeclaration("1.0", "utf-8", "yes"), new XElement(DataSourceConstants.DataSources));
string dataSourceContent = string.Empty;
foreach (var dataSource in dataSources)
{
DataSourceDefinition currentDataSource = null;
if (dataSource.Item.GetType().Equals(new DataSourceReference().GetType()))
{
string dataSourcePath = ((DataSourceReference)dataSource.Item).Reference;
currentDataSource = server.GetDataSourceContents(dataSourcePath);
byte[] rawDataSourceContent = server.GetItemDefinition(dataSourcePath);
dataSourceContent = new UTF8Encoding(true).GetString(rawDataSourceContent);
XElement currentDataSourceElement;
using (MemoryStream dataSourceMemoryStream = new MemoryStream(rawDataSourceContent))
{
currentDataSourceElement = XElement.Load(dataSourceMemoryStream);
}
XAttribute nameAttribute = new XAttribute("Name", dataSource.Name);
currentDataSourceElement.Add(nameAttribute);
retfile.Root.Add(currentDataSourceElement);
}
else
{
currentDataSource = (DataSourceDefinition)dataSource.Item;
XAttribute nameAttribute = new XAttribute("Name", dataSource.Name);
XElement currentDataSourceElement = new XElement(DataSourceConstants.DataSourceDefinition, nameAttribute);
PropertyInfo[] properties = typeof(DataSourceDefinition).GetProperties();
foreach (PropertyInfo property in properties)
{
if (property.GetValue(currentDataSource) != null)
{
currentDataSourceElement.Add(new XElement(property.Name, property.GetValue(currentDataSource)));
}
}
retfile.Root.Add(currentDataSourceElement);
}
}
retfile.Save(outputFileName);
}
/// <remarks/>
public void SetDataSourceContentsAsync(string DataSource, DataSourceDefinition Definition, object userState)
{
if ((this.SetDataSourceContentsOperationCompleted == null))
{
this.SetDataSourceContentsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnSetDataSourceContentsOperationCompleted);
}
this.InvokeAsync("SetDataSourceContents", new object[] {
DataSource,
Definition}, this.SetDataSourceContentsOperationCompleted, userState);
}
public CatalogItem CreateDataSource(string DataSource, string Parent, bool Overwrite, DataSourceDefinition Definition, Property[] Properties)
{
object[] results = this.Invoke("CreateDataSource", new object[] {
DataSource,
Parent,
Overwrite,
Definition,
Properties});
return ((CatalogItem)(results[0]));
}
private void CreateDataSource()
{
mvar_ServerName = txtServerName.Text;
mvar_DatabaseName = txtDatabaseName.Text;
mvar_UserID = txtUserName.Text;
mvar_Password = txtPassword.Text;
mvar_DataSourceName = txtDataSourceName.Text;
mvar_DataSourceLocation = txtDataSourceLocation.Text;
try
{
//DataSourceLocation requires '/' at beginning of string
//Sets parent/data source location to root
if (mvar_DataSourceLocation == "/")
{
mvar_DataSourceLocation = @"/";
}
//if "/" + txtDataSourceLocation doesn't exist, add @"/"
//Check if DataSource exists, if !exists, continue, else error
//ReportingService2010.ReportingService2010= new ReportingService2010.ReportingService2010();
//CatalogItem[] items;
//sroot = sroot + "Bin\\V4Web\\SSRS Reports\\"; //V4\\";
//string strItemType = "Report";
//string strReportName = string.Empty;
//string strFilePath = string.Empty;
//string parent = "/V4"; //V4
//mvar_rs.Url = "http://localhost/ReportServer/reportservice2010.asmx"; //WebService url in ReportingServicesConfigurationManager; localhost = server name
//mvar_rs.Credentials = System.Net.CredentialCache.DefaultCredentials;
#region CreateDataSource
// Create DataSource that Report will Use
logger.LogMsg("Begin CreateDataSource: ", Logger.LogLevel.LogIsErr);
WriteLog("Begin CreateDataSource: ");
DataSource dSource = new DataSource();
DataSourceDefinition dDefinition = new DataSourceDefinition();
dSource.Item = dDefinition;
dDefinition.Extension = "SQL";
dDefinition.ConnectString = @"Data Source=" + mvar_ServerName
+ @";Initial Catalog=" + mvar_DatabaseName;
WriteLog(dDefinition.ConnectString.ToString());
dDefinition.ImpersonateUserSpecified = true;
dDefinition.Prompt = null;
dDefinition.WindowsCredentials = false;
dDefinition.UserName = mvar_UserID;
dDefinition.Password = mvar_Password;
dDefinition.CredentialRetrieval = CredentialRetrievalEnum.Store;
dSource.Name = mvar_DataSourceName;
try
{
mvar_rs.CreateDataSource(mvar_DataSourceName, mvar_DataSourceLocation, false,
dDefinition, null);
logger.LogMsg("Create DataSource " + mvar_DataSourceName + ": Success!!", Logger.LogLevel.LogIsErr);
WriteLog("Create DataSource " + mvar_DataSourceName + ": Success!!");
}
catch (System.Web.Services.Protocols.SoapException Err)
{
logger.LogMsg(Err.Detail.InnerXml.ToString(), Logger.LogLevel.LogIsErr);
WriteLog(Err.Detail.InnerXml.ToString());
}
logger.LogMsg("End CreateDataSource", Logger.LogLevel.LogIsErr);
WriteLog("End CreateDataSource");
#endregion CreateDataSource
}
catch (Exception Err)
{
logger.LogMsg(Err.ToString(), Logger.LogLevel.LogIsErr);
WriteLog(Err.ToString());
}
}
public bool TestConnectForDataSourceDefinition(DataSourceDefinition DataSourceDefinition, string UserName, string Password, out string ConnectError)
{
object[] results = this.Invoke("TestConnectForDataSourceDefinition", new object[] {
DataSourceDefinition,
UserName,
Password});
ConnectError = ((string)(results[1]));
return ((bool)(results[0]));
}
/// <remarks/>
public System.IAsyncResult BeginTestConnectForDataSourceDefinition(DataSourceDefinition DataSourceDefinition, string UserName, string Password, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("TestConnectForDataSourceDefinition", new object[] {
DataSourceDefinition,
UserName,
Password}, callback, asyncState);
}
/// <remarks/>
public void CreateDataSourceAsync(string DataSource, string Parent, bool Overwrite, DataSourceDefinition Definition, Property[] Properties, object userState)
{
if ((this.CreateDataSourceOperationCompleted == null))
{
this.CreateDataSourceOperationCompleted = new System.Threading.SendOrPostCallback(this.OnCreateDataSourceOperationCompleted);
}
this.InvokeAsync("CreateDataSource", new object[] {
DataSource,
Parent,
Overwrite,
Definition,
Properties}, this.CreateDataSourceOperationCompleted, userState);
}
/// <remarks/>
public void TestConnectForDataSourceDefinitionAsync(DataSourceDefinition DataSourceDefinition, string UserName, string Password)
{
this.TestConnectForDataSourceDefinitionAsync(DataSourceDefinition, UserName, Password, null);
}
public void CreateDataSource(string DataSource, string Parent, bool Overwrite, DataSourceDefinition Definition, Property[] Properties)
{
this.Invoke("CreateDataSource", new object[] {
DataSource,
Parent,
Overwrite,
Definition,
Properties});
}
/// <remarks/>
public void CreateDataSourceAsync(string DataSource, string Parent, bool Overwrite, DataSourceDefinition Definition, Property[] Properties)
{
this.CreateDataSourceAsync(DataSource, Parent, Overwrite, Definition, Properties, null);
}
/// <remarks/>
public System.IAsyncResult BeginSetDataSourceContents(string DataSource, DataSourceDefinition Definition, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("SetDataSourceContents", new object[] {
DataSource,
Definition}, callback, asyncState);
}
/// <remarks/>
public System.IAsyncResult BeginCreateDataSource(string DataSource, string Parent, bool Overwrite, DataSourceDefinition Definition, Property[] Properties, System.AsyncCallback callback, object asyncState)
{
return this.BeginInvoke("CreateDataSource", new object[] {
DataSource,
Parent,
Overwrite,
Definition,
Properties}, callback, asyncState);
}
/// <remarks/>
public void TestConnectForDataSourceDefinitionAsync(DataSourceDefinition DataSourceDefinition, string UserName, string Password, object userState)
{
if ((this.TestConnectForDataSourceDefinitionOperationCompleted == null))
{
this.TestConnectForDataSourceDefinitionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnTestConnectForDataSourceDefinitionOperationCompleted);
}
this.InvokeAsync("TestConnectForDataSourceDefinition", new object[] {
DataSourceDefinition,
UserName,
Password}, this.TestConnectForDataSourceDefinitionOperationCompleted, userState);
}
/// <remarks/>
public void SetDataSourceContentsAsync(string DataSource, DataSourceDefinition Definition)
{
this.SetDataSourceContentsAsync(DataSource, Definition, null);
}
public void SetDataSourceContents(string DataSource, DataSourceDefinition Definition)
{
this.Invoke("SetDataSourceContents", new object[] {
DataSource,
Definition});
}
