/// <summary>
/// Set filename with prefix to local variable
/// </summary>
/// <param name="variableDispenser"></param>
/// <param name="componentEvents"></param>
private void SetPrefixFilename(VariableDispenser variableDispenser, IDTSComponentEvents componentEvents)
{
try
{
if (PrefixFilename != null && PrefixFilename != "Choose a Variable")
{
Variables vars = null;
variableDispenser.LockOneForWrite(PrefixFilename, ref vars);
vars[PrefixFilename].Value = TypeConverter(_localname, vars[0].DataType);
vars.Unlock();
variableDispenser.Reset();
componentEvents.FireInformation(0, "ReportGenerator", "Variable " + PrefixFilename + " set to " + _localname, string.Empty, 0, ref _refire);
}
}
catch (Exception exc)
{
componentEvents.FireError(0, "ReportGenerator", "Task Errored: " + exc, "", -1);
}
}
public override object Execute(Package package, DtsContainer container)
{
object returnValue;
CommandParentType commandParentType = GetCommandParentType();
try
{
OnCommandStarted(new CommandStartedEventArgs(DateTime.Now, CommandName, null, null, commandParentType));
Variables vars = null;
VariableDispenser dispenser = container.VariableDispenser;
string varName = VariableName;
if (Operation == VariableOperation.Get)
{
dispenser.LockOneForRead(varName, ref vars);
returnValue = vars[varName].Value;
vars.Unlock();
}
else
{
// writing to the variable
object varValue = Value;
dispenser.LockOneForWrite(varName, ref vars);
vars[varName].Value = Convert.ChangeType(varValue, vars[varName].DataType);
vars.Unlock();
returnValue = varValue;
}
OnCommandCompleted(new CommandCompletedEventArgs(DateTime.Now, CommandName, null, null, string.Format("The {0} command has completed.", CommandName), commandParentType));
}
catch (Exception ex)
{
OnCommandFailed(new CommandFailedEventArgs(DateTime.Now, CommandName, null, null, ex.Message, commandParentType));
throw;
}
return(returnValue);
}
public override void ProcessInput(int inputID, PipelineBuffer buffer)
{
base.ProcessInput(inputID, buffer);
while (buffer.NextRow())
{
var dataRow = DataTable.NewRow();
foreach (var columnMapping in _bufferColumnMapping)
{
// TODO: Update to use the correct data type methods
if (buffer.IsNull(columnMapping.Value))
{
dataRow[columnMapping.Key] = DBNull.Value;
}
else
{
dataRow[columnMapping.Key] = buffer[columnMapping.Value];
}
}
DataTable.Rows.Add(dataRow);
}
if (buffer.EndOfRowset)
{
var xml = SaveDataTableToXml(DataTable);
var property = ComponentMetaData.CustomPropertyCollection[DataTablePropertyName];
property.Value = xml;
string variableName = ComponentMetaData.CustomPropertyCollection[VariablePropertyName].Value.ToString();
if (!string.IsNullOrEmpty(variableName))
{
IDTSVariables variables = null;
VariableDispenser.LockOneForWrite(variableName, ref variables);
variables[variableName].Value = xml;
variables.Unlock();
}
}
}
/// <summary>
/// Generate SSRS Report
/// </summary>
/// <param name="variableDispenser"></param>
/// <param name="componentEvents"></param>
private void GenerateServerReport(VariableDispenser variableDispenser, IDTSComponentEvents componentEvents)
{
var fi = new FileInfo(Filename);
Variables vars = null;
// Create a new proxy to the web service
var rs = new ReportService2010.ReportingService2010();
var rsExec = new ReportExecution2005.ReportExecutionService();
// Assign the URL of the Web service
rs.Url = ReportServer + "/ReportService2010.asmx";
rsExec.Url = ReportServer + "/ReportExecution2005.asmx";
// Authenticate to the Web service using Windows credentials
if (WindowsAuthorization)
{
rs.Credentials = CredentialCache.DefaultCredentials;
rsExec.Credentials = CredentialCache.DefaultCredentials;
}
else
{
rs.CookieContainer = new CookieContainer();
rs.LogonUser(String.Format("{0}\\{1}", Domain, Username), Password, ReportServer);
rsExec.CookieContainer = new CookieContainer();
rsExec.LogonUser(String.Format("{0}\\{1}", Domain, Username), Password, ReportServer);
}
rs.Timeout = TimeOut;
rsExec.Timeout = TimeOut;
componentEvents.FireInformation(0, "ReportGenerator", String.Format("WebService timeout is set to {0} milliseconds.", TimeOut), string.Empty, 0, ref _refire);
componentEvents.FireInformation(0, "ReportGenerator", "Report Server:" + ReportServer, string.Empty, 0, ref _refire);
if (Snapshot)
{
try
{
ReportService2010.Warning[] warn;
rs.CreateItemHistorySnapshot(Reportname, out warn);
componentEvents.FireInformation(0, "ReportGenerator", "A snapshot was created.", string.Empty, 0, ref _refire);
}
catch (Exception ex)
{
componentEvents.FireWarning(0, "ReportGeneratorTask", "A snapshot could not be created. Exception: " + ex.Message, "", 0);
}
}
// Prepare Render arguments
var renderExtensions = new RenderExtensions();
var renderExtension = renderExtensions.Get(fi.Extension);
if (renderExtension == null)
{
throw new Exception("Not supported render type (GenerateServerReport): " + fi.Extension);
}
string format = renderExtension.Name;
// fire render arguments
componentEvents.FireInformation(0, "ReportGenerator", "Reportname: " + Reportname, string.Empty, 0, ref _refire);
componentEvents.FireInformation(0, "ReportGenerator", "Filename: " + _localname, string.Empty, 0, ref _refire);
componentEvents.FireInformation(0, "ReportGenerator", "Format: " + format, string.Empty, 0, ref _refire);
try
{
// Prepare report parameter.
//DataTable dt = (DataTable)ReportGenerator.DeserializeObject(_Reportparameter.ToString());
var dt = GetParameterDataTable(Reportparameter);
var param = new List <ParameterValue>();
// set paramter for server report
//foreach (var row in dt.Rows.Cast<DataRow>().Where(row => !string.IsNullOrEmpty(row[0].ToString()) && row[0].ToString() != "Choose a Variable"))
foreach (DataRow row in dt.Rows)
{
if (!string.IsNullOrEmpty(row[0].ToString()) && row[0].ToString() != "Choose a Variable")
{
variableDispenser.LockForRead(row[0].ToString());
variableDispenser.GetVariables(ref vars);
var variableValue = vars[row[0].ToString()].Value.ToString();
var multiValue = Convert.ToBoolean(row[2]) ? variableValue.Split(';') : new[] { variableValue };
foreach (var value in multiValue)
{
param.Add(new ReportExecution2005.ParameterValue
{
Name = row[1].ToString(),
Value = value
});
componentEvents.FireInformation(0, "ReportGenerator",
row[1] + " --> " + row[0] + " --> " + value, string.Empty, 0, ref _refire);
}
}
}
//componentEvents.FireInformation(0, "ReportGenerator", iParams.ToString(), string.Empty, 0, ref _refire);
// Load the selected report
var ei = rsExec.LoadReport(Reportname, null);
// Set the parameters
if (param.Count > 0)
{
rsExec.SetExecutionParameters(param.ToArray(), "en-EN");
}
// Render the report
string[] streamIDs;
ReportExecution2005.Warning[] warnings;
string encoding;
string mimeType;
string extension;
var results = rsExec.Render(format, null, out extension, out encoding, out mimeType, out warnings, out streamIDs);
var execInfo = rsExec.GetExecutionInfo();
componentEvents.FireInformation(0, "ReportGenerator", string.Format("ExecutionDateTime: {0}", execInfo.ExecutionDateTime.ToLongDateString()), string.Empty, 0, ref _refire);
if (!string.IsNullOrEmpty(ExecutionDateTime) && ExecutionDateTime != "Choose a Variable")
{
variableDispenser.LockOneForWrite(ExecutionDateTime, ref vars);
if (vars[ExecutionDateTime].DataType == TypeCode.DateTime)
{
vars[ExecutionDateTime].Value = execInfo.ExecutionDateTime;
vars.Unlock();
componentEvents.FireInformation(0, "ReportGenerator", String.Format("ExecutionDateTime: {0}", execInfo.ExecutionDateTime.ToLongDateString()), string.Empty, 0, ref _refire);
}
else
{
componentEvents.FireWarning(0, "ReportGenerator", "Incorrect DataType for ExecutionDateTime", null, 0);
}
}
if (!string.IsNullOrEmpty(ExecutionId) && ExecutionId != "Choose a Variable")
{
variableDispenser.LockOneForWrite(ExecutionId, ref vars);
if (vars[ExecutionId].DataType == TypeCode.String)
{
vars[ExecutionId].Value = String.IsNullOrEmpty(execInfo.ExecutionID) ? "" : execInfo.ExecutionID;
vars.Unlock();
componentEvents.FireInformation(0, "ReportGenerator", string.Format("ExecutionId: {0}", execInfo.ExecutionID), string.Empty, 0, ref _refire);
}
else
{
componentEvents.FireWarning(0, "ReportGenerator", "Incorrect DataType for ExecutionId", null, 0);
}
}
if (!string.IsNullOrEmpty(ExpirationDateTime) && ExpirationDateTime != "Choose a Variable")
{
variableDispenser.LockOneForWrite(ExpirationDateTime, ref vars);
if (vars[ExpirationDateTime].DataType == TypeCode.DateTime)
{
vars[ExpirationDateTime].Value = execInfo.ExpirationDateTime;
vars.Unlock();
componentEvents.FireInformation(0, "ReportGenerator",
String.Format("ExpirationDateTime: {0}", execInfo.ExpirationDateTime.ToLongDateString()),
string.Empty, 0, ref _refire);
}
else
{
componentEvents.FireWarning(0, "ReportGenerator", "Incorrect DataType for ExpirationDateTime", null, 0);
}
}
if (!string.IsNullOrEmpty(HistoryId) && HistoryId != "Choose a Variable")
{
variableDispenser.LockOneForWrite(HistoryId, ref vars);
if (vars[HistoryId].DataType == TypeCode.String)
{
vars[HistoryId].Value = String.IsNullOrEmpty(execInfo.HistoryID) ? "" : execInfo.HistoryID;
vars.Unlock();
componentEvents.FireInformation(0, "ReportGenerator", String.Format("HistoryId: {0}", execInfo.HistoryID), string.Empty, 0, ref _refire);
}
else
{
componentEvents.FireWarning(0, "ReportGenerator", "Incorrect DataType for HistoryId", null, 0);
}
}
if (!string.IsNullOrEmpty(NumPages) && NumPages != "Choose a Variable")
{
variableDispenser.LockOneForWrite(NumPages, ref vars);
if (vars[NumPages].DataType == TypeCode.Int16 || vars[NumPages].DataType == TypeCode.Int32 ||
vars[NumPages].DataType == TypeCode.Int64)
{
vars[NumPages].Value = execInfo.NumPages;
vars.Unlock();
componentEvents.FireInformation(0, "ReportGenerator",
String.Format("NumPages: {0}", execInfo.NumPages), string.Empty, 0, ref _refire);
}
else
{
componentEvents.FireWarning(0, "ReportGenerator", "Incorrect DataType for NumPages", null, 0);
}
}
if (File.Exists(_localname))
{
File.Delete(_localname);
}
//// Create a file stream and write the report to it
using (var stream = File.OpenWrite(_localname))
{
stream.Write(results, 0, results.Length);
}
componentEvents.FireInformation(0, "ReportGenerator", "Report was generated.", string.Empty, 0, ref _refire);
// open ReportViewerUI in debugmode
if (DebugMode)
{
componentEvents.FireInformation(0, "ReportGenerator", "Show Report in Debugmode.", string.Empty, 0, ref _refire);
var localReport = new ReportViewerUi
{
Reportserver = ReportServer,
Reportname = Reportname,
WindowsAuthorization = WindowsAuthorization,
Username = Username,
Password = Password,
Domain = Domain,
ReportType = ReportType
};
//set parameter for localreport
if (param.Count > 0)
{
var parameter = new List <ReportParameter>(); //[iParams];
//foreach (var row in dt.Rows.Cast<DataRow>().Where(row => !String.IsNullOrEmpty(row[0].ToString())))
foreach (DataRow row in dt.Rows)
{
if (!string.IsNullOrEmpty(row[0].ToString()))
{
variableDispenser.LockForRead(row[0].ToString());
variableDispenser.GetVariables(ref vars);
var varValue = vars[row[0].ToString()].Value.ToString();
var multiValue = Convert.ToBoolean(row[2]) ? varValue.Split(';') : new[] { varValue };
foreach (var value in multiValue)
{
var localparam = new ReportParameter {
Name = row[1].ToString()
};
localparam.Values.Add(value);
parameter.Add(localparam);
}
}
}
localReport.Reportparameter = parameter.ToArray();
}
localReport.ShowDialog();
}
}
catch (Exception ex)
{
componentEvents.FireError(0, "ReportGenerator", ex.ToString(), "", 0);
componentEvents.FireError(0, "ReportGenerator", fi.Extension.ToString(), "", 0);
}
}
/// <summary>
/// Validates the Task
/// </summary>
/// <param name="connections"></param>
/// <param name="variableDispenser"></param>
/// <param name="componentEvents"></param>
/// <param name="log"></param>
/// <returns></returns>
public override DTSExecResult Validate(Connections connections, VariableDispenser variableDispenser, IDTSComponentEvents componentEvents, IDTSLogging log)
{
Debug.Print("Validation Started");
string xmlVariableQualifiedName = string.Empty;
//Check XmlVariables
if (string.IsNullOrEmpty(_xmlVariable))
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorXmlVariableEmpty, string.Empty, 0);
return(DTSExecResult.Failure);
}
else if (!variableDispenser.Contains(_xmlVariable)) //Check Variable exists
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, string.Format(Resources.ErrorXmlVariableNotExists, _xmlVariable), string.Empty, 0);
return(DTSExecResult.Failure);
}
else
{
Variables vars = null;
try
{
variableDispenser.Reset();
variableDispenser.LockOneForWrite(_xmlVariable, ref vars);
if (vars == null || vars.Locked == false) //Check if wariable is writable
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, string.Format(Resources.ErrorLockingXmlVariable, _xmlVariable), string.Empty, 0);
return(DTSExecResult.Failure);
}
else
{
Variable v = vars[0];
TypeCode dataType = v.DataType;
xmlVariableQualifiedName = v.QualifiedName;
if (v.Namespace != "User") //Check namespace. Vaiabe should be writable in the user name space
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorXmlVariableNotUser, string.Empty, 0);
return(DTSExecResult.Failure);
}
if (v.DataType != TypeCode.String && v.DataType != TypeCode.Object) //Variable has to be string or object data type to be able to store XML
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorXmlVaraibleNotString, string.Empty, 0);
return(DTSExecResult.Failure);
}
if (v.EvaluateAsExpression == true) //Variable cannot be expression to be writable
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorXmlVariableCannotHaveExpression, string.Empty, 0);
return(DTSExecResult.Failure);
}
}
}
finally
{
if (vars != null && vars.Locked)
{
vars.Unlock();
}
}
}
//Check VariableElementName
if (string.IsNullOrEmpty(_variableElementName)) //Variable element has to be specified
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorVariableElementEmpty, string.Empty, 0);
return(DTSExecResult.Failure);
}
else
{
try
{
XElement element = new XElement(_variableElementName); //Check the VariableElementName is proper name for XmlElement
}
catch
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, string.Format(Resources.ErrorNotValidElementName, _rootElementName), string.Empty, 0);
return(DTSExecResult.Failure);
}
}
//Check RootElementName
if (string.IsNullOrEmpty(_rootElementName)) //Che that RootElementName is specified
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorRootXmlElementCannotBeEmpty, string.Empty, 0);
return(DTSExecResult.Failure);
}
else
{
try
{
XElement element = new XElement(_rootElementName); //Check that RootElementName is valid XmlElement name
}
catch
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, string.Format(Resources.ErrorNotValidElementName, _rootElementName), string.Empty, 0);
return(DTSExecResult.Failure);
}
}
//Check ExportVaraibles
if (_exportVariables.Count > 0)
{
Variables vars = null;
try
{
variableDispenser.Reset();
foreach (string var in _exportVariables)
{
if (!variableDispenser.Contains(var)) //Check that all variables to be exported exists
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorInvalidVariables, string.Empty, 0);
return(DTSExecResult.Failure);
}
variableDispenser.LockForRead(var);
}
variableDispenser.GetVariables(ref vars);
if (vars == null || vars.Locked == false) //Check that all varaibles to be exported are readable
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorLockingReadVariables, string.Empty, 0);
return(DTSExecResult.Failure);
}
else
{
foreach (Variable v in vars)
{
if (v.QualifiedName == xmlVariableQualifiedName) //Check that XmlVariable is not present int he Export Variable list. (Cannot export and write to the same variable)
{
componentEvents.FireError(0, Resources.VariablesToXmlTaskName, Resources.ErrorXmlVariableCannotBeExported, string.Empty, 0);
}
}
}
}
finally
{
if (vars != null && vars.Locked)
{
vars.Unlock();
}
variableDispenser.Reset();
}
}
Debug.Print("Validation Finished Successfully");
return(base.Validate(connections, variableDispenser, componentEvents, log));
}
