/// <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);
}
}
private void ReadVariables(VariableDispenser variableDispenser)
{
variableDispenser.LockForRead("System::StartTime");
variableDispenser.LockForRead("System::PackageName");
variableDispenser.LockForRead("System::SourceName");
variableDispenser.LockForRead("System::MachineName");
variableDispenser.LockForRead("System::ExecutionInstanceGUID");
variableDispenser.LockForRead("System::EventHandlerStartTime");
variableDispenser.LockForRead("User::UID");
bool includesError = variableDispenser.Contains("System::ErrorCode");
if (includesError)
{
variableDispenser.LockForRead("System::ErrorCode");
variableDispenser.LockForRead("System::ErrorDescription");
}
Variables vars = null;
variableDispenser.GetVariables(ref vars);
DateTime startTime = (DateTime)vars["System::StartTime"].Value;
_packageDuration = DateTime.Now.Subtract(startTime).TotalSeconds;
_packageName = vars["System::PackageName"].Value.ToString();
_taskName = vars["System::SourceName"].Value.ToString();
_machineName = vars["System::MachineName"].Value.ToString();
_executionid = vars["System::ExecutionInstanceGUID"].Value.ToString();
_handlerdatetime = (DateTime)vars["System::EventHandlerStartTime"].Value;
_uid = vars["User::UID"].Value.ToString();
if (includesError)
{
_errorCode = vars["System::ErrorCode"].Value.ToString();
_errorDescription = vars["System::ErrorDescription"].Value.ToString();
}
// release the variable locks.
vars.Unlock();
// reset the dispenser
variableDispenser.Reset();
}
/// <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));
}
